From 8367ae01d219d82253148c378180b4b82798a31e Mon Sep 17 00:00:00 2001 From: Kim Gert Nielsen Date: Sun, 25 Feb 2024 19:10:26 +0100 Subject: [PATCH] refactor: split into smaller files - rewrite tests to fix new structure --- .github/workflows/format.yml | 26 +++++ .github/workflows/lint.yml | 18 +++ lua/agrolens/core.lua | 206 +++++++++++++++++++++++++++++++++++ tests/c_spec.lua | 90 +++++++++------ tests/cpp_spec.lua | 71 ++++++++---- tests/glsl_spec.lua | 67 ++++++------ tests/go_spec.lua | 60 ++++++---- tests/lua_spec.lua | 70 ++++++------ tests/make_spec.lua | 33 +++--- tests/markdown_spec.lua | 30 +++-- tests/php_spec.lua | 69 ++++++------ tests/python_spec.lua | 88 +++++++-------- tests/ruby_spec.lua | 83 +++++++------- tests/rust_spec.lua | 96 +++++++--------- tests/toml_spec.lua | 32 ++++-- tests/utils_spec.lua | 33 ++++++ tests/yaml_spec.lua | 46 ++++---- 17 files changed, 741 insertions(+), 377 deletions(-) create mode 100644 .github/workflows/format.yml create mode 100644 .github/workflows/lint.yml create mode 100644 lua/agrolens/core.lua create mode 100644 tests/utils_spec.lua diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml new file mode 100644 index 0000000..136e557 --- /dev/null +++ b/.github/workflows/format.yml @@ -0,0 +1,26 @@ +name: Format + +on: [push, pull_request] + +jobs: + format: + name: Stylua + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - run: date +%W > weekly + + - name: Restore cache + id: cache + uses: actions/cache@v4 + with: + path: | + ~/.cargo/bin + key: ${{ runner.os }}-cargo-${{ hashFiles('weekly') }} + + - name: Install + if: steps.cache.outputs.cache-hit != 'true' + run: cargo install stylua + + - name: Format + run: stylua --check lua/ --config-path=.stylua.toml diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..4e5069f --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,18 @@ +name: Lint + +on: [push, pull_request] + +jobs: + lint: + name: Luacheck + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Setup + run: | + sudo apt-get update + sudo apt-get install luarocks + sudo luarocks install luacheck + + - name: Lint + run: luacheck lua/ --globals vim diff --git a/lua/agrolens/core.lua b/lua/agrolens/core.lua new file mode 100644 index 0000000..4312a17 --- /dev/null +++ b/lua/agrolens/core.lua @@ -0,0 +1,206 @@ +local M = {} + +local ppath = require("plenary.path") +local utils = require("telescope._extensions.utils") + +M.create_entry = function(filename, matches, iter_query, bufnr, capture_name) + local entry = {} + entry.filename = filename + entry.bufnr = bufnr + + for i, _ in pairs(matches) do + local curr_capture_name = iter_query.captures[i] + local lnum, from, torow, to = matches[i]:range() + local line_text = + vim.api.nvim_buf_get_lines(bufnr, lnum, lnum + 1, false)[1] + + -- if multiline and its the capture line just include the line + if to ~= torow and curr_capture_name == "agrolens.scope" then + from = 0 + to = -1 + end + + if not entry[curr_capture_name] then + entry[curr_capture_name] = {} + end + + entry[curr_capture_name].match = string.sub(line_text, from + 1, to) + entry[curr_capture_name].capture = capture_name + + entry.lnum = lnum + 1 + entry.col = from + + (string.len(line_text) - string.len(utils.ltrim(line_text))) + entry.line = line_text + end + return entry +end + +M.does_match = function(opts, entry) + -- no matches defined + if not opts.matches then + return true + end + + for _, match in ipairs(opts.matches) do + local n = "agrolens." .. match.name + if entry[n] then + -- only one has to match (or and not and) + if match.word == entry[n].match then + return true + end + end + end + + return false +end + +M.add_entries = function( + opts, + entries, + capture_names, + bufnr, + filename, + filetype +) + local ts = vim.treesitter + local dublicates = {} + local ok, tsparser = pcall(ts.get_parser, bufnr, filetype) + if ok and tsparser and type(tsparser) ~= "string" then + local trees = tsparser:parse() + local root = trees[1]:root() + + for _, capture_name in ipairs(capture_names) do + local iter_query = + vim.treesitter.query.get(filetype, "agrolens." .. capture_name) + if iter_query then + for _, matches, _ in iter_query:iter_matches(root, bufnr) do + local entry = M.create_entry( + filename, + matches, + iter_query, + bufnr, + capture_name + ) + + if opts.disable_indentation then + entry.line = utils.all_trim(entry.line) + end + + local formated_entry = utils.format_entry(entry) + if not dublicates[formated_entry] then + dublicates[formated_entry] = true + if M.does_match(opts, entry) then + table.insert(entries, entry) + end + end + end + end + end + end + return entries +end + +M.get_captures = function(opts) + local entries = {} + + for _, bufnr in ipairs(opts.bufids) do + local buffilename = vim.api.nvim_buf_get_name(bufnr) + local relpath = ppath:new(buffilename):make_relative(opts.cwd) + local filetype = vim.filetype.match({ buf = bufnr }) + + if filetype and filetype ~= "" then + entries = M.add_entries( + opts, + entries, + opts.queries, + bufnr, + relpath, + filetype + ) + end + end + return entries +end + +M.generate_jump_list = function(opts) + local entries = {} + local ts = vim.treesitter + local capture_names = opts.queries + local bufnr = 0 + local filetype = vim.filetype.match({ buf = bufnr }) + if filetype and filetype ~= "" then + local ok, tsparser = pcall(ts.get_parser, bufnr, filetype) + if ok and tsparser and type(tsparser) ~= "string" then + local trees = tsparser:parse() + local root = trees[1]:root() + + for _, capture_name in ipairs(capture_names) do + local iter_query = vim.treesitter.query.get( + filetype, + "agrolens." .. capture_name + ) + if iter_query then + for _, matches, _ in iter_query:iter_matches(root, bufnr) do + for i, _ in pairs(matches) do + local curr_capture_name = iter_query.captures[i] + local lnum, _, _, _ = matches[i]:range() + if curr_capture_name == "agrolens.scope" then + entries[lnum + 1] = true + end + end + end + end + end + end + end + + return utils.hash_keys_to_list(entries) +end + +M.sanitize_opts = function(opts, telescope_opts, telescope_config) + opts.queries = {} + + opts = vim.tbl_deep_extend( + "force", + telescope_opts, + opts or {}, + telescope_config + ) + + opts.query = opts.aliases[opts.query] or opts.query + + if opts.query then + for query in opts.query:gmatch("[^,%s]+") do + table.insert(opts.queries, query) + end + end + + local matches = {} + if opts.match then + local current_word = utils.get_word_at_cursor() + + for match in opts.match:gmatch("[^,%s]+") do + local elements = utils.split(match, "=") + + if vim.tbl_count(elements) == 1 then + table.insert(elements, current_word) + end + + local entry = {} + entry.name = elements[1] + entry.word = elements[2] + + table.insert(matches, entry) + end + end + + opts.disable_indentation = telescope_config.disable_indentation or false + + if not vim.tbl_isempty(matches) then + opts.matches = matches + end + + return opts +end + +return M diff --git a/tests/c_spec.lua b/tests/c_spec.lua index a1106c9..ccd26d8 100644 --- a/tests/c_spec.lua +++ b/tests/c_spec.lua @@ -1,51 +1,77 @@ describe("c", function() - - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/c/test.c") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) + + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries={"functions"}, bufids=buffers}) + -- make sure buffer has content + eq(string.match(content[1], "include"), "include") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({queries={"functions"}, bufids=buffers}) + local entries = + core.get_captures({ queries = { "functions" }, bufids = buffers }) - assert.equals(#entries, 5) + eq(#entries, 5) - assert.equals('tests/c/test.c:16:0:int days_since_birth(struct Person *p) {', entries[1]) - assert.equals('tests/c/test.c:45:0:int basic_calc(struct Person *p) {', entries[2]) - assert.equals('tests/c/test.c:55:0:void print_person(struct Person *p, format_func func) {', entries[3]) - assert.equals('tests/c/test.c:65:0:char **do_nothing(char **argv) {', entries[4]) - assert.equals('tests/c/test.c:69:0:int main(int argc, char **argv) {', entries[5]) + eq(entries[1].filename, "tests/c/test.c") + eq(entries[1].lnum, 16) + eq(entries[1].col, 0) + eq(entries[1].line, "int days_since_birth(struct Person *p) {") + eq(entries[2].line, "int basic_calc(struct Person *p) {") + eq( + entries[3].line, + "void print_person(struct Person *p, format_func func) {" + ) + eq(entries[4].line, "char **do_nothing(char **argv) {") + eq(entries[5].line, "int main(int argc, char **argv) {") end) it("callings", function() - local entries = lens._get_captures({queries={"callings"}, bufids=buffers}) - assert.equals(#entries, 10) - - assert.equals('tests/c/test.c:23:2: if (sscanf(p->born, "%d-%d-%d", &day, &month, &year) != EOF) {', entries[1]) - assert.equals('tests/c/test.c:25:4: now = time(0);', entries[2]) - assert.equals('tests/c/test.c:29:4: parsedDate = localtime(&now);', entries[3]) - assert.equals('tests/c/test.c:34:4: time_t born = mktime(parsedDate);', entries[4]) - assert.equals('tests/c/test.c:49:2: return days_since_birth(p);', entries[5]) - assert.equals('tests/c/test.c:60:2: int age = (*func)(p);', entries[6]) - assert.equals('tests/c/test.c:62:2: printf("%s is %d days old\\n", p->name, (*func)(p));', entries[7]) - assert.equals('tests/c/test.c:73:2: strncpy(donald.name, "Donald Duck", MAXNAME);', entries[8]) - assert.equals('tests/c/test.c:74:2: strncpy(donald.born, "07-09-1934", MAXDATE);', entries[9]) - assert.equals('tests/c/test.c:77:2: print_person(&donald, basic_calc);', entries[10]) + local entries = + core.get_captures({ queries = { "callings" }, bufids = buffers }) + eq(#entries, 10) + + eq(entries[1].filename, "tests/c/test.c") + eq(entries[1].lnum, 23) + eq(entries[1].col, 2) + + eq( + entries[1].line, + ' if (sscanf(p->born, "%d-%d-%d", &day, &month, &year) != EOF) {' + ) + eq(entries[2].line, " now = time(0);") + eq(entries[3].line, " parsedDate = localtime(&now);") + eq(entries[4].line, " time_t born = mktime(parsedDate);") + eq(entries[5].line, " return days_since_birth(p);") + eq(entries[6].line, " int age = (*func)(p);") + eq( + entries[7].line, + ' printf("%s is %d days old\\n", p->name, (*func)(p));' + ) + eq(entries[8].line, ' strncpy(donald.name, "Donald Duck", MAXNAME);') + eq(entries[9].line, ' strncpy(donald.born, "07-09-1934", MAXDATE);') + eq(entries[10].line, " print_person(&donald, basic_calc);") end) it("comments", function() - local entries = lens._get_captures({queries={"comments"}, bufids=buffers}) - assert.equals(#entries, 4) + local entries = + core.get_captures({ queries = { "comments" }, bufids = buffers }) + eq(#entries, 4) - assert.equals('tests/c/test.c:52:0:/*', entries[1]) - assert.equals('tests/c/test.c:59:2: // not used', entries[2]) - assert.equals('tests/c/test.c:71:2: // Create Donald', entries[3]) - assert.equals('tests/c/test.c:76:2: // Print Donald', entries[4]) - end) + eq(entries[1].filename, "tests/c/test.c") + eq(entries[1].lnum, 52) + eq(entries[1].col, 0) + eq(entries[1].line, "/*") + eq(entries[2].line, " // not used") + eq(entries[3].line, " // Create Donald") + eq(entries[4].line, " // Print Donald") + end) end) diff --git a/tests/cpp_spec.lua b/tests/cpp_spec.lua index 5a7d0a3..15201d0 100644 --- a/tests/cpp_spec.lua +++ b/tests/cpp_spec.lua @@ -1,43 +1,68 @@ describe("cpp", function() - - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/cpp/main.cc") buffers = vim.api.nvim_list_bufs() + eq(#buffers, 1) + + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "include"), "include") - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries={"functions"}, bufids=buffers}) + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({queries={"functions"}, bufids=buffers}) + local entries = + core.get_captures({ queries = { "functions" }, bufids = buffers }) - assert.equals(#entries, 4) - assert.equals('tests/cpp/main.cc:18:0:Person::Person(std::string name, std::string born) {', entries[1]) - assert.equals('tests/cpp/main.cc:25:0:int sec_to_days(time_t now, time_t born) { ', entries[2]) - assert.equals('tests/cpp/main.cc:28:0:int days_since_birth(const Person &p, conv_func func) {', entries[3]) - assert.equals('tests/cpp/main.cc:61:0:int main() {', entries[4]) + eq(#entries, 4) + eq(entries[1].filename, "tests/cpp/main.cc") + eq(entries[1].lnum, 18) + eq(entries[1].col, 0) + + eq( + entries[1].line, + "Person::Person(std::string name, std::string born) {" + ) + eq(entries[2].line, "int sec_to_days(time_t now, time_t born) { ") + eq( + entries[3].line, + "int days_since_birth(const Person &p, conv_func func) {" + ) + eq(entries[4].line, "int main() {") end) it("callings", function() - local entries = lens._get_captures({queries={"callings"}, bufids=buffers}) - - assert.equals(#entries, 5) - assert.equals('tests/cpp/main.cc:36:4: time_t now = time(0);', entries[1]) - assert.equals('tests/cpp/main.cc:39:4: parsedDate = localtime(&now);', entries[2]) - assert.equals('tests/cpp/main.cc:44:4: time_t born = mktime(parsedDate);', entries[3]) - assert.equals('tests/cpp/main.cc:46:4: int age = (*func)(now, born);', entries[4]) - assert.equals('tests/cpp/main.cc:56:2: out << p.name << " is " << days_since_birth(p, sec_to_days) << " days old";', entries[5]) + local entries = + core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 5) + eq(entries[1].filename, "tests/cpp/main.cc") + eq(entries[1].lnum, 36) + eq(entries[1].col, 4) + + eq(entries[1].line, ' time_t now = time(0);') + eq(entries[2].line, ' parsedDate = localtime(&now);') + eq(entries[3].line, ' time_t born = mktime(parsedDate);') + eq(entries[4].line, ' int age = (*func)(now, born);') + eq(entries[5].line, ' out << p.name << " is " << days_since_birth(p, sec_to_days) << " days old";') end) it("comments", function() - local entries = lens._get_captures({queries={"comments"}, bufids=buffers}) + local entries = + core.get_captures({ queries = { "comments" }, bufids = buffers }) - assert.equals(#entries, 3) - assert.equals('tests/cpp/main.cc:23:0:/* basic seconds to days', entries[1]) - assert.equals('tests/cpp/main.cc:63:2: // Create Donald', entries[2]) - assert.equals('tests/cpp/main.cc:66:2: // Print Donald', entries[3]) + eq(#entries, 3) + eq(entries[1].filename, "tests/cpp/main.cc") + eq(entries[1].lnum, 23) + eq(entries[1].col, 0) + eq(entries[1].line, '/* basic seconds to days') + eq(entries[2].line, ' // Create Donald') + eq(entries[3].line, ' // Print Donald') end) end) diff --git a/tests/glsl_spec.lua b/tests/glsl_spec.lua index ea5c9d4..7317f2c 100644 --- a/tests/glsl_spec.lua +++ b/tests/glsl_spec.lua @@ -1,55 +1,52 @@ describe("glsl", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals vim.filetype.add({extension = {frag = "glsl", vert = "glsl"}}) it("load", function() vim.cmd.edit("tests/glsl/default.frag") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "version"), "version") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({ - queries = {"functions"}, - bufids = buffers - }) + local entries = core.get_captures({ queries = { "functions" }, bufids = buffers }) -- functions - assert.equals(#entries, 4) - assert.equals("tests/glsl/default.frag:26:0:vec4 pointLight()", - entries[1]) - assert.equals("tests/glsl/default.frag:55:0:vec4 direcLight()", - entries[2]) - assert.equals("tests/glsl/default.frag:75:0:vec4 spotLight()", - entries[3]) - assert.equals("tests/glsl/default.frag:104:0:void main()", entries[4]) + eq(#entries, 4) + eq(entries[1].filename, "tests/glsl/default.frag") + eq(entries[1].lnum, 26) + eq(entries[1].col, 0) + eq(entries[1].line, "vec4 pointLight()") + eq(entries[2].line, "vec4 direcLight()") + eq(entries[3].line, "vec4 spotLight()") + eq(entries[4].line, "void main()") end) it("callings", function() - local entries = lens._get_captures({ - queries = {"callings"}, - bufids = buffers - }) - - assert.equals(#entries, 1) - assert.equals( - "tests/glsl/default.frag:107:2: FragColor = spotLight();", - entries[1]) + local entries = core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 1) + eq(entries[1].filename, "tests/glsl/default.frag") + eq(entries[1].lnum, 107) + eq(entries[1].col, 2) + eq(entries[1].line, " FragColor = spotLight();") end) it("comments", function() - local entries = lens._get_captures({ - queries = {"comments"}, - bufids = buffers - }) - assert.equals(#entries, 23) - assert.equals("tests/glsl/default.frag:3:0:// Outputs colors in RGBA", - entries[1]) - assert.equals( - "tests/glsl/default.frag:106:2: /* outputs final color */", - entries[23]) + local entries = core.get_captures({ queries = { "comments" }, bufids = buffers }) + eq(#entries, 23) + eq(entries[1].filename, "tests/glsl/default.frag") + eq(entries[1].lnum, 3) + eq(entries[1].col, 0) + eq(entries[1].line, "// Outputs colors in RGBA") + eq(entries[23].line, " /* outputs final color */") end) end) diff --git a/tests/go_spec.lua b/tests/go_spec.lua index 679303a..e40fa75 100644 --- a/tests/go_spec.lua +++ b/tests/go_spec.lua @@ -1,45 +1,59 @@ describe("go", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/go/main.go") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "package"), "package") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({queries = {"functions"}, bufids = buffers}) + local entries = core.get_captures({ queries = { "functions" }, bufids = buffers }) - assert.equals(#entries, 4) + eq(#entries, 4) + eq(entries[1].filename, "tests/go/main.go") + eq(entries[1].lnum, 15) + eq(entries[1].col, 0) - assert.equals("tests/go/main.go:15:0:func (p *Person) GetName() string {", entries[1]) - assert.equals("tests/go/main.go:19:0:func print_person(p Person, fn format_func) {", entries[2]) - assert.equals("tests/go/main.go:23:0:func main() {", entries[3]) - assert.equals("tests/go/main.go:29:1:\tformat_func := func(p Person) string {", entries[4]) + eq(entries[1].line, "func (p *Person) GetName() string {") + eq(entries[2].line, "func print_person(p Person, fn format_func) {") + eq(entries[3].line, "func main() {") + eq(entries[4].line, "\tformat_func := func(p Person) string {") end) it("callings", function() - local entries = lens._get_captures({queries = {"callings"}, bufids = buffers}) - - assert.equals(#entries, 10) - - assert.equals("tests/go/main.go:20:2:\tfmt.Println(fn(p))", entries[1]) - assert.equals("tests/go/main.go:20:1:\tfmt.Println(fn(p))", entries[2]) - assert.equals('tests/go/main.go:30:15:\t\ttt, err := time.Parse("01-02-2006", p.Born)', entries[3]) - assert.equals("tests/go/main.go:32:13:\t\t\treturn err.Error()", entries[4]) - assert.equals("tests/go/main.go:35:19:\t\tcurrentTime := time.Now()", entries[5]) + local entries = core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 10) + eq(entries[1].filename, "tests/go/main.go") + eq(entries[1].lnum, 20) + eq(entries[1].col, 2) + + eq(entries[1].line, "\tfmt.Println(fn(p))") + eq(entries[2].line, "\tfmt.Println(fn(p))") + eq(entries[3].line, '\t\ttt, err := time.Parse("01-02-2006", p.Born)') + eq(entries[4].line, "\t\t\treturn err.Error()") + eq(entries[5].line, "\t\tcurrentTime := time.Now()") end) it("comments", function() - local entries = lens._get_captures({queries = {"comments"}, bufids = buffers}) + local entries = core.get_captures({ queries = { "comments" }, bufids = buffers }) - assert.equals(#entries, 2) + eq(#entries, 2) + eq(entries[1].filename, "tests/go/main.go") + eq(entries[1].lnum, 26) + eq(entries[1].col, 1) - assert.equals("tests/go/main.go:26:1:\t/*", entries[1]) - assert.equals("tests/go/main.go:41:1:\t// Print Donald", entries[2]) + eq(entries[1].line, "\t/*") + eq(entries[2].line, "\t// Print Donald") end) end) diff --git a/tests/lua_spec.lua b/tests/lua_spec.lua index a4a661f..c258f69 100644 --- a/tests/lua_spec.lua +++ b/tests/lua_spec.lua @@ -1,52 +1,54 @@ describe("lua", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/lua/test.lua") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "hello1"), "hello1") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({ - queries = {"functions"}, - bufids = buffers - }) - - -- functions - assert.equals(#entries, 5) - assert.equals("tests/lua/test.lua:1:0:local hello1 = function()", - entries[1]) - assert.equals("tests/lua/test.lua:5:0:hello2 = function()", entries[2]) - assert.equals("tests/lua/test.lua:9:0:function hello3()", entries[3]) - assert.equals("tests/lua/test.lua:19:0:M.hello4 = function()", - entries[4]) - assert.equals("tests/lua/test.lua:23:0:function M.hello5()", entries[5]) + local entries = + core.get_captures({ queries = { "functions" }, bufids = buffers }) + + eq(#entries, 5) + eq(entries[1].lnum, 1) + eq(entries[1].col, 0) + eq(entries[1].line, "local hello1 = function()") + eq(entries[2].line, "hello2 = function()") + eq(entries[3].line, "function hello3()") + eq(entries[4].line, "M.hello4 = function()") + eq(entries[5].line, "function M.hello5()") end) it("callings", function() - local entries = lens._get_captures({ - queries = {"callings"}, - bufids = buffers - }) - - assert.equals(#entries, 10) - assert.equals('tests/lua/test.lua:2:4: print("hello1")', entries[1]) - assert.equals('tests/lua/test.lua:6:4: print("hello2")', entries[2]) + local entries = + core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 10) + eq(entries[1].lnum, 2) + eq(entries[1].col, 4) + eq(entries[1].line, ' print("hello1")') + eq(entries[2].line, ' print("hello2")') end) it("comments", function() - local entries = lens._get_captures({ - queries = {"comments"}, - bufids = buffers - }) - - assert.equals(#entries, 2) - assert.equals("tests/lua/test.lua:13:0:-- Local object", entries[1]) - assert.equals("tests/lua/test.lua:16:0:--[[", entries[2]) + local entries = + core.get_captures({ queries = { "comments" }, bufids = buffers }) + + eq(#entries, 2) + eq(entries[1].lnum, 13) + eq(entries[1].col, 0) + eq(entries[1].line, "-- Local object") + eq(entries[2].line, "--[[") end) end) diff --git a/tests/make_spec.lua b/tests/make_spec.lua index e658a3d..0573fdc 100644 --- a/tests/make_spec.lua +++ b/tests/make_spec.lua @@ -1,26 +1,33 @@ describe("make", function() - - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals + it("load", function() vim.cmd.edit("tests/make/Makefile") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) + + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "all"), "all") - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries={"labels"}, bufids=buffers}) + core.get_captures({ queries = { "labels" }, bufids = buffers }) end) it("labels", function() - local entries = lens._get_captures({queries={"labels"}, bufids=buffers}) + local entries = core.get_captures({ queries = { "labels" }, bufids = buffers }) - -- labels - assert.equals(#entries, 5) - assert.equals("tests/make/Makefile:1:0:.PHONY: all", entries[1]) - assert.equals("tests/make/Makefile:3:0:all: lint test", entries[2]) - assert.equals("tests/make/Makefile:5:0:test:", entries[3]) - assert.equals("tests/make/Makefile:8:0:lint:", entries[4]) - assert.equals("tests/make/Makefile:11:0:docgen:", entries[5]) + eq(#entries, 5) + eq(entries[1].filename, "tests/make/Makefile") + eq(entries[1].lnum, 1) + eq(entries[1].col, 0) + eq(entries[1].line, ".PHONY: all") + eq(entries[2].line, "all: lint test") + eq(entries[3].line, "test:") + eq(entries[4].line, "lint:") + eq(entries[5].line, "docgen:") end) end) diff --git a/tests/markdown_spec.lua b/tests/markdown_spec.lua index 426aeb0..98d2370 100644 --- a/tests/markdown_spec.lua +++ b/tests/markdown_spec.lua @@ -1,25 +1,31 @@ describe("markdown", function() - - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/markdown/note.md") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) + + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "Heading"), "Heading") - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries={"labels"}, bufids=buffers}) + core.get_captures({ queries = { "labels" }, bufids = buffers }) end) it("labels", function() - local entries = lens._get_captures({queries={"labels"}, bufids=buffers}) + local entries = core.get_captures({ queries = { "labels" }, bufids = buffers }) - -- labels - assert.equals(#entries, 4) - assert.equals("tests/markdown/note.md:1:0:# Heading#1", entries[1]) - assert.equals("tests/markdown/note.md:3:0:## Heading#2.1", entries[2]) - assert.equals("tests/markdown/note.md:5:0:## Heading#2.2", entries[3]) - assert.equals("tests/markdown/note.md:7:0:### Heading#3", entries[4]) + eq(#entries, 4) + eq(entries[1].filename, "tests/markdown/note.md") + eq(entries[1].lnum, 1) + eq(entries[1].col, 0) + eq(entries[1].line, "# Heading#1") + eq(entries[2].line, "## Heading#2.1") + eq(entries[3].line, "## Heading#2.2") + eq(entries[4].line, "### Heading#3") end) end) diff --git a/tests/php_spec.lua b/tests/php_spec.lua index fee0002..b73bda8 100644 --- a/tests/php_spec.lua +++ b/tests/php_spec.lua @@ -1,50 +1,55 @@ describe("php", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/php/test.php") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "php"), "php") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({ - queries = {"functions"}, - bufids = buffers - }) - - assert.equals(#entries, 3) - assert.equals("tests/php/test.php:6:2: function __construct($age) {", - entries[1]) - assert.equals("tests/php/test.php:9:2: function getAge() {", entries[2]) - assert.equals("tests/php/test.php:14:0:function newPerson($age) {", - entries[3]) + local entries = core.get_captures({ queries = { "functions" }, bufids = buffers }) + + eq(#entries, 3) + eq(entries[1].filename, "tests/php/test.php") + eq(entries[1].lnum, 6) + eq(entries[1].col, 2) + + eq(entries[1].line, " function __construct($age) {") + eq(entries[2].line, " function getAge() {") + eq(entries[3].line, "function newPerson($age) {") end) it("callings", function() - local entries = lens._get_captures({ - queries = {"callings"}, - bufids = buffers - }) - - assert.equals(#entries, 5) - assert.equals("tests/php/test.php:21:0:$p = newPerson(42);", entries[1]) - assert.equals("tests/php/test.php:23:9:$num1 = $p->getAge();", - entries[2]) + local entries = core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 5) + eq(entries[1].filename, "tests/php/test.php") + eq(entries[1].lnum, 21) + eq(entries[1].col, 0) + + eq(entries[1].line, "$p = newPerson(42);") + eq(entries[2].line, "$num1 = $p->getAge();") end) it("comments", function() - local entries = lens._get_captures({ - queries = {"comments"}, - bufids = buffers - }) - - assert.equals(#entries, 2) - assert.equals("tests/php/test.php:3:0:// A person", entries[1]) - assert.equals("tests/php/test.php:18:0:/*", entries[2]) + local entries = core.get_captures({ queries = { "comments" }, bufids = buffers }) + + eq(#entries, 2) + eq(entries[1].filename, "tests/php/test.php") + eq(entries[1].lnum, 3) + eq(entries[1].col, 0) + + eq(entries[1].line, "// A person") + eq(entries[2].line, "/*") end) end) diff --git a/tests/python_spec.lua b/tests/python_spec.lua index 5cc5997..9b25220 100644 --- a/tests/python_spec.lua +++ b/tests/python_spec.lua @@ -1,66 +1,62 @@ describe("python", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/python/test.py") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "python3"), "python3") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({ - queries = {"functions"}, - bufids = buffers - }) + local entries = + core.get_captures({ queries = { "functions" }, bufids = buffers }) + + eq(#entries, 4) + eq(entries[1].filename, "tests/python/test.py") + eq(entries[1].lnum, 11) + eq(entries[1].col, 4) - assert.equals(#entries, 4) - assert.equals( - "tests/python/test.py:11:4: def __init__(self, name: str, born: str):", - entries[1]) - assert.equals("tests/python/test.py:15:4: def print(self, format):", - entries[2]) - assert.equals("tests/python/test.py:20:0:def format(p: Person) -> str:", - entries[3]) - assert.equals("tests/python/test.py:32:0:def main():", entries[4]) + eq(entries[1].line, " def __init__(self, name: str, born: str):") + eq(entries[2].line, " def print(self, format):") + eq(entries[3].line, "def format(p: Person) -> str:") + eq(entries[4].line, "def main():") end) it("callings", function() - local entries = lens._get_captures({ - queries = {"callings"}, - bufids = buffers - }) + local entries = + core.get_captures({ queries = { "callings" }, bufids = buffers }) - assert.equals(#entries, 6) - assert.equals("tests/python/test.py:16:8: print(format(self))", - entries[1]) - assert.equals( - 'tests/python/test.py:24:19: borndate = datetime.strptime(p.born, "%d-%m-%Y")', - entries[2]) - assert.equals("tests/python/test.py:25:14: now = datetime.today()", - entries[3]) - assert.equals( - 'tests/python/test.py:34:4: donald = Person(name="Donald Duck", born="07-09-1934")', - entries[4]) - assert.equals("tests/python/test.py:35:8: donald.print(format)", - entries[5]) - assert.equals("tests/python/test.py:39:4: main()", entries[6]) + eq(#entries, 6) + eq(entries[1].lnum, 16) + eq(entries[1].col, 8) + + eq(entries[1].line, " print(format(self))") + eq(entries[2].line, ' borndate = datetime.strptime(p.born, "%d-%m-%Y")') + eq(entries[3].line, " now = datetime.today()") + eq(entries[4].line, ' donald = Person(name="Donald Duck", born="07-09-1934")') + eq(entries[5].line, " donald.print(format)") + eq(entries[6].line, " main()") end) it("comments", function() - local entries = lens._get_captures({ - queries = {"comments"}, - bufids = buffers - }) + local entries = + core.get_captures({ queries = { "comments" }, bufids = buffers }) + + eq(#entries, 4) + eq(entries[1].lnum, 1) + eq(entries[1].col, 0) - assert.equals(#entries, 4) - assert.equals("tests/python/test.py:1:0:#!/usr/bin/env python3", - entries[1]) - assert.equals('tests/python/test.py:3:0:"""', entries[2]) - assert.equals('tests/python/test.py:21:8: """', entries[3]) - assert.equals("tests/python/test.py:33:4: # Create Donald", - entries[4]) + eq(entries[1].line, "#!/usr/bin/env python3") + eq(entries[2].line, '"""') + eq(entries[3].line, ' """') + eq(entries[4].line, " # Create Donald") end) end) diff --git a/tests/ruby_spec.lua b/tests/ruby_spec.lua index 37aeef9..b9ea1f8 100644 --- a/tests/ruby_spec.lua +++ b/tests/ruby_spec.lua @@ -1,59 +1,60 @@ describe("ruby", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/ruby/test.rb") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "frozen_string_literal"), "frozen_string_literal") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({ - queries = {"functions"}, - bufids = buffers - }) - - assert.equals(#entries, 6) - assert.equals("tests/ruby/test.rb:7:2: attr_reader :born, :name", - entries[1]) - assert.equals("tests/ruby/test.rb:9:2: def initialize(born, name)", - entries[2]) - assert.equals("tests/ruby/test.rb:15:0:def wrapped_string(dist)", - entries[3]) - assert.equals("tests/ruby/test.rb:19:0:def to_string(dist)", entries[4]) - assert.equals("tests/ruby/test.rb:23:0:def print_intro", entries[5]) - assert.equals( - "tests/ruby/test.rb:30:0:def days_since_birth(born, convf = method(:wrapped_string))", - entries[6]) + local entries = core.get_captures({ queries = { "functions" }, bufids = buffers }) + + eq(#entries, 6) + eq(entries[1].filename, "tests/ruby/test.rb") + eq(entries[1].lnum, 7) + eq(entries[1].col, 2) + + eq(entries[1].line, " attr_reader :born, :name") + eq(entries[2].line, " def initialize(born, name)") + eq(entries[3].line, "def wrapped_string(dist)") + eq(entries[4].line, "def to_string(dist)") + eq(entries[5].line, "def print_intro") + eq(entries[6].line, "def days_since_birth(born, convf = method(:wrapped_string))") end) it("callings", function() - local entries = lens._get_captures({ - queries = {"callings"}, - bufids = buffers - }) - - assert.equals(#entries, 14) - assert.equals("tests/ruby/test.rb:3:0:require 'date'", entries[1]) - assert.equals("tests/ruby/test.rb:7:2: attr_reader :born, :name", - entries[2]) - assert.equals('tests/ruby/test.rb:16:8: "[#{dist.to_i}]"', entries[3]) + local entries = core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 14) + eq(entries[1].filename, "tests/ruby/test.rb") + eq(entries[1].lnum, 3) + eq(entries[1].col, 0) + + eq(entries[1].line, "require 'date'") + eq(entries[2].line, " attr_reader :born, :name") + eq(entries[3].line, ' "[#{dist.to_i}]"') end) it("comments", function() - local entries = lens._get_captures({ - queries = {"comments"}, - bufids = buffers - }) - - assert.equals(#entries, 3) - assert.equals("tests/ruby/test.rb:1:0:# frozen_string_literal: true", - entries[1]) - assert.equals("tests/ruby/test.rb:5:0:# A person", entries[2]) - assert.equals("tests/ruby/test.rb:27:0:=begin", entries[3]) + local entries = core.get_captures({ queries = { "comments" }, bufids = buffers }) + + eq(#entries, 3) + eq(entries[1].filename, "tests/ruby/test.rb") + eq(entries[1].lnum, 1) + eq(entries[1].col, 0) + + eq(entries[1].line, "# frozen_string_literal: true") + eq(entries[2].line, "# A person") + eq(entries[3].line, "=begin") end) end) diff --git a/tests/rust_spec.lua b/tests/rust_spec.lua index 3cb9f3f..b7bba82 100644 --- a/tests/rust_spec.lua +++ b/tests/rust_spec.lua @@ -1,74 +1,60 @@ describe("rust", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/rust/src/main.rs") buffers = vim.api.nvim_list_bufs() + eq(#buffers, 1) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries = {"functions"}, bufids = buffers}) + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) + + -- make sure buffer has content + eq(string.match(content[1], "DateTime"), "DateTime") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("functions", function() - local entries = lens._get_captures({ - queries = {"functions"}, - bufids = buffers - }) + local entries = core.get_captures({ queries = { "functions" }, bufids = buffers }) + + eq(#entries, 4) + eq(entries[1].filename, "tests/rust/src/main.rs") + eq(entries[1].lnum, 9) + eq(entries[1].col, 4) - assert.equals(#entries, 4) - assert.equals( - "tests/rust/src/main.rs:9:4: fn calc_age_in_days(&self) -> i64 {", - entries[1]) - assert.equals( - "tests/rust/src/main.rs:22:4: fn print(&self, f: fn(&Person) -> String) {", - entries[2]) - assert.equals( - "tests/rust/src/main.rs:30:0:fn format_person(p: &Person) -> String {", - entries[3]) - assert.equals("tests/rust/src/main.rs:36:0:fn main() {", entries[4]) + eq(entries[1].line, " fn calc_age_in_days(&self) -> i64 {") + eq(entries[2].line, " fn print(&self, f: fn(&Person) -> String) {") + eq(entries[3].line, "fn format_person(p: &Person) -> String {") + eq(entries[4].line, "fn main() {") end) it("callings", function() - local entries = lens._get_captures({ - queries = {"callings"}, - bufids = buffers - }) - - assert.equals(#entries, 7) - assert.equals( - "tests/rust/src/main.rs:10:8: let today = Utc::now();", - entries[1]) - assert.equals( - 'tests/rust/src/main.rs:12:12: chrono::NaiveDate::parse_from_str(&self.born, "%d-%m-%Y")', - entries[2]) - assert.equals( - "tests/rust/src/main.rs:19:8: today.signed_duration_since(borndate).num_days()", - entries[3]) - - assert.equals( - "tests/rust/src/main.rs:31:4: let age = p.calc_age_in_days();", - entries[4]) - assert.equals( - 'tests/rust/src/main.rs:39:8: name: "Donald Duck".to_string(),', - entries[5]) - assert.equals( - 'tests/rust/src/main.rs:40:8: born: "07-09-1934".to_string(),', - entries[6]) - assert.equals( - "tests/rust/src/main.rs:43:4: donald.print(format_person);", - entries[7]) + local entries = core.get_captures({ queries = { "callings" }, bufids = buffers }) + + eq(#entries, 7) + eq(entries[1].filename, "tests/rust/src/main.rs") + eq(entries[1].lnum, 10) + eq(entries[1].col, 8) + + eq(entries[1].line, " let today = Utc::now();") + eq(entries[2].line, ' chrono::NaiveDate::parse_from_str(&self.born, "%d-%m-%Y")') + eq(entries[3].line, " today.signed_duration_since(borndate).num_days()") + eq(entries[4].line, " let age = p.calc_age_in_days();") + eq(entries[5].line, ' name: "Donald Duck".to_string(),') + eq(entries[6].line, ' born: "07-09-1934".to_string(),') + eq(entries[7].line, " donald.print(format_person);") end) it("comments", function() - local entries = lens._get_captures({ - queries = {"comments"}, - bufids = buffers - }) - - assert.equals(#entries, 2) - assert.equals("tests/rust/src/main.rs:27:0:/*", entries[1]) - assert.equals("tests/rust/src/main.rs:37:4: // Create Donald", - entries[2]) + local entries = core.get_captures({ queries = { "comments" }, bufids = buffers }) + + eq(#entries, 2) + eq(entries[1].filename, "tests/rust/src/main.rs") + eq(entries[1].lnum, 27) + eq(entries[1].col, 0) + eq(entries[1].line, "/*") + eq(entries[2].line, " // Create Donald") end) end) diff --git a/tests/toml_spec.lua b/tests/toml_spec.lua index 754349f..6206b23 100644 --- a/tests/toml_spec.lua +++ b/tests/toml_spec.lua @@ -1,25 +1,33 @@ describe("toml", function() - - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals it("load", function() vim.cmd.edit("tests/toml/test.toml") buffers = vim.api.nvim_list_bufs() - assert.equal(#buffers, 1) + eq(#buffers, 1) + + local content = vim.api.nvim_buf_get_lines(buffers[1], 0, -1, false) - lens = require("telescope._extensions.agrolenslib") - lens._get_captures({queries={"labels"}, bufids=buffers}) + -- make sure buffer has content + eq(string.match(content[1], "document"), "document") + + core.get_captures({ queries = { "functions" }, bufids = buffers }) end) it("labels", function() - local entries = lens._get_captures({queries={"labels"}, bufids=buffers}) + local entries = core.get_captures({ queries = { "labels" }, bufids = buffers }) + + eq(#entries, 5) + eq(entries[1].filename, "tests/toml/test.toml") + eq(entries[1].lnum, 5) + eq(entries[1].col, 0) - assert.equals(#entries, 5) - assert.equals("tests/toml/test.toml:5:0:[owner]", entries[1]) - assert.equals("tests/toml/test.toml:9:0:[database]", entries[2]) - assert.equals("tests/toml/test.toml:15:0:[servers]", entries[3]) - assert.equals("tests/toml/test.toml:17:0:[servers.alpha]", entries[4]) - assert.equals("tests/toml/test.toml:21:0:[servers.beta]", entries[5]) + eq(entries[1].line, "[owner]") + eq(entries[2].line, "[database]") + eq(entries[3].line, "[servers]") + eq(entries[4].line, "[servers.alpha]") + eq(entries[5].line, "[servers.beta]") end) end) diff --git a/tests/utils_spec.lua b/tests/utils_spec.lua new file mode 100644 index 0000000..af593d8 --- /dev/null +++ b/tests/utils_spec.lua @@ -0,0 +1,33 @@ +describe("utils", function() + local utils = require("telescope._extensions.utils") + + local eq = assert.equals + + it("ltrim", function() + eq(utils.ltrim(" testing"), "testing") + eq(utils.ltrim(" testing "), "testing ") + end) + + it("all_trim", function() + eq(utils.all_trim(" testing"), "testing") + eq(utils.all_trim(" testing "), "testing") + end) + + it("file_extention", function() + eq(utils.file_extension(vim.fs.basename("/home/myuser/test.go")), "go") + eq(utils.file_extension(vim.fs.basename("/home/myuser/test.test.js")), "test.js") + end) + + it("matchstr", function() + eq(utils.matchstr("get the curr", [[\k*$]]), "curr") + eq(utils.matchstr("ent word in a line ", [[\k*]]), "ent") + end) + + it("split", function() + local elems = utils.split("test1=test2= test3", "=") + eq(elems[1], "test1") + eq(elems[2], "test2") + eq(elems[3], " test3") + end) + +end) diff --git a/tests/yaml_spec.lua b/tests/yaml_spec.lua index 476a31c..b1b27f9 100644 --- a/tests/yaml_spec.lua +++ b/tests/yaml_spec.lua @@ -1,18 +1,22 @@ describe("yaml", function() - it("docker-compose", function() - local lens = nil - local buffers = nil + local core = require("agrolens.core") + local buffers = nil + local eq = assert.equals + it("docker-compose", function() vim.cmd.edit("tests/yaml/docker-compose.yml") buffers = vim.api.nvim_list_bufs() - lens = require("telescope._extensions.agrolenslib") - local entries = lens._get_captures({queries = {"docker-compose"}, bufids = buffers}) + local entries = core.get_captures({ queries = { "docker-compose" }, bufids = buffers }) - assert.equals(#entries, 3) - assert.equals("tests/yaml/docker-compose.yml:4:2: fakelookup:", entries[1]) - assert.equals("tests/yaml/docker-compose.yml:9:2: shell:", entries[2]) - assert.equals("tests/yaml/docker-compose.yml:14:2: test-runner:", entries[3]) + eq(#entries, 3) + eq(entries[1].filename, "tests/yaml/docker-compose.yml") + eq(entries[1].lnum, 4) + eq(entries[1].col, 2) + + eq(entries[1].line, " fakelookup:") + eq(entries[2].line, " shell:") + eq(entries[3].line, " test-runner:") vim.cmd("%bdelete") end) @@ -20,21 +24,25 @@ end) describe("yaml2", function() it("github-workflow-steps", function() - local lens = nil + local core = require("agrolens.core") local buffers = nil + local eq = assert.equals vim.cmd.edit("tests/yaml/github-ci.yml") buffers = vim.api.nvim_list_bufs() - lens = require("telescope._extensions.agrolenslib") - local entries = lens._get_captures({queries = {"github-workflow-steps"}, bufids = buffers}) + local entries = core.get_captures({ queries = { "github-workflow-steps" }, bufids = buffers }) + + eq(#entries, 12) + eq(entries[1].filename, "tests/yaml/github-ci.yml") + eq(entries[1].lnum, 29) + eq(entries[1].col, 20) - assert.equals(#entries, 12) - assert.equals("tests/yaml/github-ci.yml:29:20: - name: Checkout", entries[1]) - assert.equals("tests/yaml/github-ci.yml:30:22: uses: actions/checkout@v3", entries[2]) - assert.equals("tests/yaml/github-ci.yml:32:20: - name: Setup node", entries[3]) - assert.equals("tests/yaml/github-ci.yml:33:22: uses: actions/setup-node@v3", entries[4]) - assert.equals("tests/yaml/github-ci.yml:38:20: - name: Install", entries[5]) - assert.equals("tests/yaml/github-ci.yml:39:21: run: npm ci", entries[6]) + eq(entries[1].line, " - name: Checkout") + eq(entries[2].line, " uses: actions/checkout@v3") + eq(entries[3].line, " - name: Setup node") + eq(entries[4].line, " uses: actions/setup-node@v3") + eq(entries[5].line, " - name: Install") + eq(entries[6].line, " run: npm ci") end) end)