diff options
32 files changed, 1181 insertions, 979 deletions
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 6d3d3fec4..16d8fdb2e 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -18,3 +18,14 @@ jobs: - name: Run Luacheck run: sudo ./scripts/style-check.sh + + stylua: + name: StyLua + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Lint with stylua + uses: JohnnyMorganz/stylua-action@1.0.0 + with: + token: ${{ secrets.GITHUB_TOKEN }} + args: --check . diff --git a/.stylua.toml b/.stylua.toml new file mode 100644 index 000000000..364ef9c9f --- /dev/null +++ b/.stylua.toml @@ -0,0 +1,3 @@ +indent_type = "Spaces" +indent_width = 2 +no_call_parentheses = true diff --git a/.styluaignore b/.styluaignore new file mode 100644 index 000000000..2b6c4c6ab --- /dev/null +++ b/.styluaignore @@ -0,0 +1 @@ +tests/indent/lua/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index dbf3c3d26..b89e13ae1 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -15,12 +15,13 @@ Depending on which part of the plugin you want to contribute to, please read the ## Style Checks and Tests We haven't implemented any functional tests yet. Feel free to contribute. -However, we check code style with `luacheck`! +However, we check code style with `luacheck` and `stylua`! Please install luacheck and activate our `pre-push` hook to automatically check style before every push: ```bash luarocks install luacheck +cargo install stylua ln -s ../../scripts/pre-push .git/hooks/pre-push ``` diff --git a/lua/nvim-treesitter.lua b/lua/nvim-treesitter.lua index 145df7be8..af46bd017 100644 --- a/lua/nvim-treesitter.lua +++ b/lua/nvim-treesitter.lua @@ -1,24 +1,23 @@ -if not pcall(require,"vim.treesitter.languagetree") then - error("nvim-treesitter requires a more recent Neovim nightly version!") +if not pcall(require, "vim.treesitter.languagetree") then + error "nvim-treesitter requires a more recent Neovim nightly version!" end -local install = require'nvim-treesitter.install' -local utils = require'nvim-treesitter.utils' -local ts_utils = require'nvim-treesitter.ts_utils' -local info = require'nvim-treesitter.info' -local configs = require'nvim-treesitter.configs' -local parsers = require'nvim-treesitter.parsers' - +local install = require "nvim-treesitter.install" +local utils = require "nvim-treesitter.utils" +local ts_utils = require "nvim-treesitter.ts_utils" +local info = require "nvim-treesitter.info" +local configs = require "nvim-treesitter.configs" +local parsers = require "nvim-treesitter.parsers" -- Registers all query predicates -require"nvim-treesitter.query_predicates" +require "nvim-treesitter.query_predicates" local M = {} function M.setup() - utils.setup_commands('install', install.commands) - utils.setup_commands('info', info.commands) - utils.setup_commands('configs', configs.commands) + utils.setup_commands("install", install.commands) + utils.setup_commands("info", info.commands) + utils.setup_commands("configs", configs.commands) configs.init() end @@ -35,37 +34,43 @@ local get_line_for_node = function(node, type_patterns, transform_fn) break end end - if not is_valid then return '' end - local line = transform_fn(vim.trim(ts_utils.get_node_text(node)[1] or '')) + if not is_valid then + return "" + end + local line = transform_fn(vim.trim(ts_utils.get_node_text(node)[1] or "")) -- Escape % to avoid statusline to evaluate content as expression - return line:gsub('%%', '%%%%') + return line:gsub("%%", "%%%%") end -- Trim spaces and opening brackets from end local transform_line = function(line) - return line:gsub('%s*[%[%(%{]*%s*$', '') + return line:gsub("%s*[%[%(%{]*%s*$", "") end function M.statusline(opts) - if not parsers.has_parser() then return end + if not parsers.has_parser() then + return + end local options = opts or {} - if type(opts) == 'number' then - options = {indicator_size = opts} + if type(opts) == "number" then + options = { indicator_size = opts } end local indicator_size = options.indicator_size or 100 - local type_patterns = options.type_patterns or {'class', 'function', 'method'} + local type_patterns = options.type_patterns or { "class", "function", "method" } local transform_fn = options.transform_fn or transform_line - local separator = options.separator or ' -> ' + local separator = options.separator or " -> " local current_node = ts_utils.get_node_at_cursor() - if not current_node then return "" end + if not current_node then + return "" + end local lines = {} local expr = current_node while expr do local line = get_line_for_node(expr, type_patterns, transform_fn) - if line ~= '' and not vim.tbl_contains(lines, line) then + if line ~= "" and not vim.tbl_contains(lines, line) then table.insert(lines, 1, line) end expr = expr:parent() @@ -74,7 +79,7 @@ function M.statusline(opts) local text = table.concat(lines, separator) local text_len = #text if text_len > indicator_size then - return '...'..text:sub(text_len - indicator_size, text_len) + return "..." .. text:sub(text_len - indicator_size, text_len) end return text diff --git a/lua/nvim-treesitter/caching.lua b/lua/nvim-treesitter/caching.lua index bfda39622..cff0b5a1f 100644 --- a/lua/nvim-treesitter/caching.lua +++ b/lua/nvim-treesitter/caching.lua @@ -12,7 +12,7 @@ function M.create_buffer_cache() __index = function(tbl, key) rawset(tbl, key, {}) return rawget(tbl, key) - end + end, }) function cache.set(type_name, bufnr, value) @@ -23,7 +23,7 @@ function M.create_buffer_cache() on_detach = function() cache.remove(type_name, bufnr) return true - end + end, }) end diff --git a/lua/nvim-treesitter/configs.lua b/lua/nvim-treesitter/configs.lua index f6815a80f..9d54ed8b8 100644 --- a/lua/nvim-treesitter/configs.lua +++ b/lua/nvim-treesitter/configs.lua @@ -1,10 +1,10 @@ local api = vim.api -local queries = require'nvim-treesitter.query' -local ts_query = require'vim.treesitter.query' -local parsers = require'nvim-treesitter.parsers' -local utils = require'nvim-treesitter.utils' -local caching = require'nvim-treesitter.caching' +local queries = require "nvim-treesitter.query" +local ts_query = require "vim.treesitter.query" +local parsers = require "nvim-treesitter.parsers" +local utils = require "nvim-treesitter.utils" +local caching = require "nvim-treesitter.caching" local M = {} @@ -12,7 +12,7 @@ local config = { modules = {}, ensure_installed = {}, ignore_install = {}, - update_strategy = 'lockfile', + update_strategy = "lockfile", } -- List of modules that need to be setup on initialization. local queued_modules_defs = {} @@ -20,31 +20,33 @@ local queued_modules_defs = {} local is_initialized = false local builtin_modules = { highlight = { - module_path = 'nvim-treesitter.highlight', + module_path = "nvim-treesitter.highlight", enable = false, - disable = {'markdown'}, -- FIXME(vigoux): markdown highlighting breaks everything for now + disable = { "markdown" }, -- FIXME(vigoux): markdown highlighting breaks everything for now custom_captures = {}, is_supported = queries.has_highlights, additional_vim_regex_highlighting = false, }, incremental_selection = { - module_path = 'nvim-treesitter.incremental_selection', + module_path = "nvim-treesitter.incremental_selection", enable = false, disable = {}, keymaps = { - init_selection="gnn", - node_incremental="grn", - scope_incremental="grc", - node_decremental="grm" + init_selection = "gnn", + node_incremental = "grn", + scope_incremental = "grc", + node_decremental = "grm", }, - is_supported = function() return true end + is_supported = function() + return true + end, }, indent = { - module_path = 'nvim-treesitter.indent', + module_path = "nvim-treesitter.indent", enable = false, disable = {}, - is_supported = queries.has_indents - } + is_supported = queries.has_indents, + }, } local attached_buffers_by_module = caching.create_buffer_cache() @@ -53,11 +55,13 @@ local attached_buffers_by_module = caching.create_buffer_cache() local function resolve_module(mod_name) local config_mod = M.get_module(mod_name) - if not config_mod then return end + if not config_mod then + return + end - if type(config_mod.attach) == 'function' and type(config_mod.detach) == 'function' then + if type(config_mod.attach) == "function" and type(config_mod.detach) == "function" then return config_mod - elseif type(config_mod.module_path) == 'string' then + elseif type(config_mod.module_path) == "string" then return require(config_mod.module_path) end end @@ -92,7 +96,9 @@ end -- @param mod path to module local function enable_all(mod) local config_mod = M.get_module(mod) - if not config_mod then return end + if not config_mod then + return + end for _, bufnr in pairs(api.nvim_list_bufs()) do enable_module(mod, bufnr) @@ -120,7 +126,7 @@ local function disable_mod_conf_autocmd(mod) end -- TODO(kyazdani): detach the correct autocmd... doesn't work when using %s, cmd. -- This will remove all autocomands! - api.nvim_command("autocmd! NvimTreesitter FileType *") + api.nvim_command "autocmd! NvimTreesitter FileType *" config_mod.loaded = false end @@ -129,7 +135,9 @@ end -- @param mod path to module local function disable_all(mod) local config_mod = M.get_module(mod) - if not config_mod or not config_mod.enable then return end + if not config_mod or not config_mod.enable then + return + end for _, bufnr in pairs(api.nvim_list_bufs()) do disable_module(mod, bufnr) @@ -158,7 +166,9 @@ end -- @param mod path to module local function toggle_all(mod) local config_mod = M.get_module(mod) - if not config_mod then return end + if not config_mod then + return + end if config_mod.enable then disable_all(mod) @@ -175,11 +185,11 @@ local function recurse_modules(accumulator, root, path) local root = root or config.modules for name, module in pairs(root) do - local new_path = path and (path..'.'..name) or name + local new_path = path and (path .. "." .. name) or name if M.is_module(module) then accumulator(name, module, new_path, root) - elseif type(module) == 'table' then + elseif type(module) == "table" then recurse_modules(accumulator, module, new_path) end end @@ -189,53 +199,56 @@ end -- @param process_function function used as the `process` parameter -- for vim.inspect (https://github.com/kikito/inspect.lua#optionsprocess) local function config_info(process_function) - process_function = process_function or function(item, path) - if path[#path] == vim.inspect.METATABLE then return end - if path[#path] == "is_supported" then return end - return item - end - print(vim.inspect(config, {process = process_function})) + process_function = process_function + or function(item, path) + if path[#path] == vim.inspect.METATABLE then + return + end + if path[#path] == "is_supported" then + return + end + return item + end + print(vim.inspect(config, { process = process_function })) end function M.edit_query_file(query_group, lang) lang = lang or parsers.get_buf_lang() local files = ts_query.get_query_files(lang, query_group, true) if #files == 0 then - vim.notify('No query file found! Creating a new one!') + vim.notify "No query file found! Creating a new one!" M.edit_query_file_user_after(query_group, lang) elseif #files == 1 then - vim.cmd(':edit '..files[1]) + vim.cmd(":edit " .. files[1]) else local counter = 0 local choices = { - 'Select a file:', + "Select a file:", unpack(vim.tbl_map(function(f) - counter = counter + 1 - return counter..'. '..f - end, - files - )) + counter = counter + 1 + return counter .. ". " .. f + end, files)), } local choice = vim.fn.inputlist(choices) if choice > 0 and choice <= #files then - vim.cmd(':edit '..files[choice]) + vim.cmd(":edit " .. files[choice]) end end end function M.edit_query_file_user_after(query_group, lang) lang = lang or parsers.get_buf_lang() - local folder = utils.join_path(vim.fn.stdpath('config'), 'after', 'queries', lang) - local file = utils.join_path(folder, query_group..'.scm') + local folder = utils.join_path(vim.fn.stdpath "config", "after", "queries", lang) + local file = utils.join_path(folder, query_group .. ".scm") if vim.fn.isdirectory(folder) ~= 1 then - local choice = vim.fn.inputlist({'"'..folder.." does not exist. Create it?", "1. Yes", "2. No"}) + local choice = vim.fn.inputlist { '"' .. folder .. " does not exist. Create it?", "1. Yes", "2. No" } if choice == 1 then vim.fn.mkdir(folder, "p", "0755") else return end end - vim.cmd(':edit '..file) + vim.cmd(":edit " .. file) end M.commands = { @@ -311,14 +324,18 @@ function M.is_enabled(mod, lang) end local module_config = M.get_module(mod) - if not module_config then return false end + if not module_config then + return false + end if not module_config.enable or not module_config.is_supported(lang) then return false end for _, parser in pairs(module_config.disable) do - if lang == parser then return false end + if lang == parser then + return false + end end return true @@ -327,12 +344,12 @@ end -- Setup call for users to override module configurations. -- @param user_data module overrides function M.setup(user_data) - config.modules = vim.tbl_deep_extend('force', config.modules, user_data) + config.modules = vim.tbl_deep_extend("force", config.modules, user_data) config.ignore_install = user_data.ignore_install or {} local ensure_installed = user_data.ensure_installed or {} if #ensure_installed > 0 then - require'nvim-treesitter.install'.ensure_installed(ensure_installed) + require("nvim-treesitter.install").ensure_installed(ensure_installed) end config.modules.ensure_installed = nil @@ -381,7 +398,9 @@ function M.define_modules(mod_defs) group[key] = vim.tbl_extend("keep", mod, { enable = false, disable = {}, - is_supported = function() return true end + is_supported = function() + return true + end, }) end, mod_defs) @@ -404,9 +423,7 @@ function M.attach_module(mod_name, bufnr, lang) local lang = lang or parsers.get_buf_lang(bufnr) local resolved_mod = resolve_module(mod_name) - if resolved_mod - and not attached_buffers_by_module.has(mod_name, bufnr) - and M.is_enabled(mod_name, lang) then + if resolved_mod and not attached_buffers_by_module.has(mod_name, bufnr) and M.is_enabled(mod_name, lang) then attached_buffers_by_module.set(mod_name, bufnr, true) resolved_mod.attach(bufnr, lang) end @@ -450,9 +467,9 @@ end -- A module should contain an attach and detach function. -- @param mod the module table function M.is_module(mod) - return type(mod) == 'table' - and ((type(mod.attach) == 'function' and type(mod.detach) == 'function') - or type(mod.module_path) == 'string') + return type(mod) == "table" and ((type(mod.attach) == "function" and type(mod.detach) == "function") or type( + mod.module_path + ) == "string") end -- Initializes built-in modules and any queued modules diff --git a/lua/nvim-treesitter/fold.lua b/lua/nvim-treesitter/fold.lua index 8fb6e4af1..d12f1d06c 100644 --- a/lua/nvim-treesitter/fold.lua +++ b/lua/nvim-treesitter/fold.lua @@ -1,17 +1,19 @@ local api = vim.api -local tsutils = require'nvim-treesitter.ts_utils' -local query = require'nvim-treesitter.query' -local parsers = require'nvim-treesitter.parsers' +local tsutils = require "nvim-treesitter.ts_utils" +local query = require "nvim-treesitter.query" +local parsers = require "nvim-treesitter.parsers" local M = {} -- This is cached on buf tick to avoid computing that multiple times -- Especially not for every line in the file when `zx` is hit local folds_levels = tsutils.memoize_by_buf_tick(function(bufnr) - local max_fold_level = api.nvim_win_get_option(0, 'foldnestmax') + local max_fold_level = api.nvim_win_get_option(0, "foldnestmax") local parser = parsers.get_parser(bufnr) - if not parser then return {} end + if not parser then + return {} + end local matches = query.get_capture_matches_recursively(bufnr, function(lang) if query.has_folds(lang) then @@ -44,13 +46,13 @@ local folds_levels = tsutils.memoize_by_buf_tick(function(bufnr) local current_level = 0 -- We now have the list of fold opening and closing, fill the gaps and mark where fold start - for lnum=0, api.nvim_buf_line_count(bufnr) do - local prefix = '' + for lnum = 0, api.nvim_buf_line_count(bufnr) do + local prefix = "" local shift = levels_tmp[lnum] or 0 -- Determine if it's the start of a fold if levels_tmp[lnum] and shift >= 0 then - prefix = '>' + prefix = ">" end current_level = current_level + shift @@ -67,13 +69,15 @@ local folds_levels = tsutils.memoize_by_buf_tick(function(bufnr) end) function M.get_fold_indic(lnum) - if not parsers.has_parser() or not lnum then return '0' end + if not parsers.has_parser() or not lnum then + return "0" + end local buf = api.nvim_get_current_buf() local levels = folds_levels(buf) or {} - return levels[lnum] or '0' + return levels[lnum] or "0" end return M diff --git a/lua/nvim-treesitter/health.lua b/lua/nvim-treesitter/health.lua index 9eeb99147..037c5b147 100644 --- a/lua/nvim-treesitter/health.lua +++ b/lua/nvim-treesitter/health.lua @@ -1,75 +1,92 @@ local api = vim.api local fn = vim.fn -local queries = require'nvim-treesitter.query' -local info = require'nvim-treesitter.info' -local shell = require'nvim-treesitter.shell_command_selectors' -local install = require'nvim-treesitter.install' +local queries = require "nvim-treesitter.query" +local info = require "nvim-treesitter.info" +local shell = require "nvim-treesitter.shell_command_selectors" +local install = require "nvim-treesitter.install" local health_start = vim.fn["health#report_start"] -local health_ok = vim.fn['health#report_ok'] -local health_error = vim.fn['health#report_error'] -local health_warn = vim.fn['health#report_warn'] +local health_ok = vim.fn["health#report_ok"] +local health_error = vim.fn["health#report_error"] +local health_warn = vim.fn["health#report_warn"] local M = {} local NVIM_TREESITTER_MINIMUM_ABI = 13 local function install_health() - health_start('Installation') + health_start "Installation" - if fn.executable('tree-sitter') == 0 then - health_warn('`tree-sitter` executable not found (parser generator, only needed for :TSInstallFromGrammar,'.. - ' not required for :TSInstall)') + if fn.executable "tree-sitter" == 0 then + health_warn( + "`tree-sitter` executable not found (parser generator, only needed for :TSInstallFromGrammar," + .. " not required for :TSInstall)" + ) else - local handle = io.popen('tree-sitter -V') - local result = handle:read("*a") + local handle = io.popen "tree-sitter -V" + local result = handle:read "*a" handle:close() - local version = vim.split(result,'\n')[1]:match('[^tree%psitter].*') + local version = vim.split(result, "\n")[1]:match "[^tree%psitter].*" health_ok( - "`tree-sitter` found " .. - (version or "(unknown version)") .. " (parser generator, only needed for :TSInstallFromGrammar)" + "`tree-sitter` found " + .. (version or "(unknown version)") + .. " (parser generator, only needed for :TSInstallFromGrammar)" ) end - if fn.executable('node') == 0 then - health_warn('`node` executable not found (only needed for :TSInstallFromGrammar,'.. - ' not required for :TSInstall)') + if fn.executable "node" == 0 then + health_warn( + "`node` executable not found (only needed for :TSInstallFromGrammar," .. " not required for :TSInstall)" + ) else - local handle = io.popen('node --version') - local result = handle:read("*a") + local handle = io.popen "node --version" + local result = handle:read "*a" handle:close() - local version = vim.split(result,'\n')[1] - health_ok('`node` found '..version..' (only needed for :TSInstallFromGrammar)') + local version = vim.split(result, "\n")[1] + health_ok("`node` found " .. version .. " (only needed for :TSInstallFromGrammar)") end - if fn.executable('git') == 0 then - health_error('`git` executable not found.', { - 'Install it with your package manager.', - 'Check that your `$PATH` is set correctly.' + if fn.executable "git" == 0 then + health_error("`git` executable not found.", { + "Install it with your package manager.", + "Check that your `$PATH` is set correctly.", }) else - health_ok('`git` executable found.') + health_ok "`git` executable found." end local cc = shell.select_executable(install.compilers) if not cc then - health_error('`cc` executable not found.', { - 'Check that any of '..vim.inspect(install.compilers)..' is in your $PATH' - ..' or set the environment variable CC or `require"nvim-treesitter.install".compilers` explicitly!' + health_error("`cc` executable not found.", { + "Check that any of " + .. vim.inspect(install.compilers) + .. " is in your $PATH" + .. ' or set the environment variable CC or `require"nvim-treesitter.install".compilers` explicitly!', }) else - health_ok('`'..cc..'` executable found. Selected from '..vim.inspect(install.compilers)) + health_ok("`" .. cc .. "` executable found. Selected from " .. vim.inspect(install.compilers)) end if vim.treesitter.language_version then if vim.treesitter.language_version >= NVIM_TREESITTER_MINIMUM_ABI then - health_ok('Neovim was compiled with tree-sitter runtime ABI version '..vim.treesitter.language_version - ..' (required >='..NVIM_TREESITTER_MINIMUM_ABI..'). Parsers must be compatible with runtime ABI.') + health_ok( + "Neovim was compiled with tree-sitter runtime ABI version " + .. vim.treesitter.language_version + .. " (required >=" + .. NVIM_TREESITTER_MINIMUM_ABI + .. "). Parsers must be compatible with runtime ABI." + ) else - health_error('Neovim was compiled with tree-sitter runtime ABI version '..vim.treesitter.language_version..'.\n' - ..'nvim-treesitter expects at least ABI version '..NVIM_TREESITTER_MINIMUM_ABI..'\n' - ..'Please make sure that Neovim is linked against are recent tree-sitter runtime when building' - ..' or raise an issue at your Neovim packager. Parsers must be compatible with runtime ABI.') + health_error( + "Neovim was compiled with tree-sitter runtime ABI version " + .. vim.treesitter.language_version + .. ".\n" + .. "nvim-treesitter expects at least ABI version " + .. NVIM_TREESITTER_MINIMUM_ABI + .. "\n" + .. "Please make sure that Neovim is linked against are recent tree-sitter runtime when building" + .. " or raise an issue at your Neovim packager. Parsers must be compatible with runtime ABI." + ) end end end @@ -90,35 +107,35 @@ function M.checkhealth() -- Installation dependency checks install_health() queries.invalidate_query_cache() - health_start("Parser/Features H L F I") + health_start "Parser/Features H L F I" -- Parser installation checks for _, parser_name in pairs(info.installed_parsers()) do - local installed = #api.nvim_get_runtime_file('parser/'..parser_name..'.so', false) + local installed = #api.nvim_get_runtime_file("parser/" .. parser_name .. ".so", false) -- Only print informations about installed parsers if installed >= 1 then local multiple_parsers = installed > 1 and "+" or "" - local out = " - "..parser_name..multiple_parsers..string.rep(" ", 15 - (#parser_name + #multiple_parsers)) + local out = " - " .. parser_name .. multiple_parsers .. string.rep(" ", 15 - (#parser_name + #multiple_parsers)) for _, query_group in pairs(queries.built_in_query_groups) do local status, err = query_status(parser_name, query_group) - out = out..status.." " + out = out .. status .. " " if err then - table.insert(error_collection, {parser_name, query_group, err}) + table.insert(error_collection, { parser_name, query_group, err }) end end print(out) end end - print([[ + print [[ Legend: H[ighlight], L[ocals], F[olds], I[ndents] +) multiple parsers found, only one will be used - x) errors found in the query, try to run :TSUpdate {lang}]]) + x) errors found in the query, try to run :TSUpdate {lang}]] if #error_collection > 0 then - print('\nThe following errors have been detected:') + print "\nThe following errors have been detected:" for _, p in ipairs(error_collection) do local lang, type, err = unpack(p) - health_error(lang..'('..type..'): '..err) + health_error(lang .. "(" .. type .. "): " .. err) end end end diff --git a/lua/nvim-treesitter/highlight.lua b/lua/nvim-treesitter/highlight.lua index a106c6204..e082bd5e9 100644 --- a/lua/nvim-treesitter/highlight.lua +++ b/lua/nvim-treesitter/highlight.lua @@ -1,11 +1,10 @@ local api = vim.api local ts = vim.treesitter -local parsers = require'nvim-treesitter.parsers' -local configs = require'nvim-treesitter.configs' +local parsers = require "nvim-treesitter.parsers" +local configs = require "nvim-treesitter.configs" -local M = { -} +local M = {} local hlmap = vim.treesitter.highlighter.hl_map @@ -104,7 +103,7 @@ hlmap["variable.builtin"] = "TSVariableBuiltin" function M.attach(bufnr, lang) local parser = parsers.get_parser(bufnr, lang) - local config = configs.get_module('highlight') + local config = configs.get_module "highlight" for k, v in pairs(config.custom_captures) do hlmap[k] = v @@ -112,9 +111,9 @@ function M.attach(bufnr, lang) ts.highlighter.new(parser, {}) - local is_table = type(config.additional_vim_regex_highlighting) == 'table' + local is_table = type(config.additional_vim_regex_highlighting) == "table" if config.additional_vim_regex_highlighting and (not is_table or config.additional_vim_regex_highlighting[lang]) then - api.nvim_buf_set_option(bufnr, 'syntax', 'ON') + api.nvim_buf_set_option(bufnr, "syntax", "ON") end end @@ -122,7 +121,7 @@ function M.detach(bufnr) if ts.highlighter.active[bufnr] then ts.highlighter.active[bufnr]:destroy() end - api.nvim_buf_set_option(bufnr, 'syntax', 'ON') + api.nvim_buf_set_option(bufnr, "syntax", "ON") end return M diff --git a/lua/nvim-treesitter/incremental_selection.lua b/lua/nvim-treesitter/incremental_selection.lua index 8a6f326ac..eb8b49961 100644 --- a/lua/nvim-treesitter/incremental_selection.lua +++ b/lua/nvim-treesitter/incremental_selection.lua @@ -1,10 +1,10 @@ local api = vim.api -local configs = require'nvim-treesitter.configs' -local ts_utils = require'nvim-treesitter.ts_utils' -local locals = require'nvim-treesitter.locals' -local parsers = require'nvim-treesitter.parsers' -local queries = require'nvim-treesitter.query' +local configs = require "nvim-treesitter.configs" +local ts_utils = require "nvim-treesitter.ts_utils" +local locals = require "nvim-treesitter.locals" +local parsers = require "nvim-treesitter.parsers" +local queries = require "nvim-treesitter.query" local M = {} @@ -21,8 +21,8 @@ end -- -- The range of ts nodes start with 0 and the ending range is exclusive. local function visual_selection_range() - local _, csrow, cscol, _ = unpack(vim.fn.getpos("'<")) - local _, cerow, cecol, _ = unpack(vim.fn.getpos("'>")) + local _, csrow, cscol, _ = unpack(vim.fn.getpos "'<") + local _, cerow, cecol, _ = unpack(vim.fn.getpos "'>") local start_row, start_col, end_row, end_col @@ -39,8 +39,8 @@ local function visual_selection_range() end -- The last char in ts is equivalent to the EOF in another line. - local last_row = vim.fn.line("$") - local last_col = vim.fn.col({last_row, "$"}) + local last_row = vim.fn.line "$" + local last_col = vim.fn.col { last_row, "$" } last_row = last_row - 1 last_col = last_col - 1 if end_row == last_row and end_col == last_col then @@ -92,12 +92,7 @@ local function select_incremental(get_parent) end node = parent local srow, scol, erow, ecol = node:range() - local same_range = ( - srow == csrow - and scol == cscol - and erow == cerow - and ecol == cecol - ) + local same_range = (srow == csrow and scol == cscol and erow == cerow and ecol == cecol) if not same_range then table.insert(selections[buf], node) if node ~= nodes[#nodes] then @@ -126,7 +121,9 @@ end) function M.node_decremental() local buf = api.nvim_get_current_buf() local nodes = selections[buf] - if not nodes or #nodes < 2 then return end + if not nodes or #nodes < 2 then + return + end table.remove(selections[buf]) local node = nodes[#nodes] @@ -134,13 +131,13 @@ function M.node_decremental() end function M.attach(bufnr) - local config = configs.get_module('incremental_selection') + local config = configs.get_module "incremental_selection" for funcname, mapping in pairs(config.keymaps) do local mode if funcname == "init_selection" then - mode = 'n' + mode = "n" else - mode = 'x' + mode = "x" end local cmd = string.format(":lua require'nvim-treesitter.incremental_selection'.%s()<CR>", funcname) api.nvim_buf_set_keymap(bufnr, mode, mapping, cmd, { silent = true, noremap = true }) @@ -148,12 +145,12 @@ function M.attach(bufnr) end function M.detach(bufnr) - local config = configs.get_module('incremental_selection') + local config = configs.get_module "incremental_selection" for f, mapping in pairs(config.keymaps) do if f == "init_selection" then - api.nvim_buf_del_keymap(bufnr, 'n', mapping) + api.nvim_buf_del_keymap(bufnr, "n", mapping) else - api.nvim_buf_del_keymap(bufnr, 'x', mapping) + api.nvim_buf_del_keymap(bufnr, "x", mapping) end end end diff --git a/lua/nvim-treesitter/indent.lua b/lua/nvim-treesitter/indent.lua index e66edf1d0..af08bcd6f 100644 --- a/lua/nvim-treesitter/indent.lua +++ b/lua/nvim-treesitter/indent.lua @@ -1,6 +1,6 @@ -local parsers = require'nvim-treesitter.parsers' -local queries = require'nvim-treesitter.query' -local tsutils = require'nvim-treesitter.ts_utils' +local parsers = require "nvim-treesitter.parsers" +local queries = require "nvim-treesitter.query" +local tsutils = require "nvim-treesitter.ts_utils" local M = {} @@ -8,7 +8,9 @@ local M = {} local function get_node_at_line(root, lnum) for node in root:iter_children() do local srow, _, erow = node:range() - if srow == lnum then return node end + if srow == lnum then + return node + end if node:child_count() > 0 and srow < lnum and lnum <= erow then return get_node_at_line(node, lnum) @@ -17,13 +19,15 @@ local function get_node_at_line(root, lnum) end local function node_fmt(node) - if not node then return nil end + if not node then + return nil + end return tostring(node) end local get_indents = tsutils.memoize_by_buf_tick(function(bufnr, root, lang) local get_map = function(capture) - local matches = queries.get_capture_matches(bufnr, capture, 'indents', root, lang) or {} + local matches = queries.get_capture_matches(bufnr, capture, "indents", root, lang) or {} local map = {} for _, node in ipairs(matches) do map[tostring(node)] = true @@ -32,29 +36,33 @@ local get_indents = tsutils.memoize_by_buf_tick(function(bufnr, root, lang) end return { - indents = get_map('@indent.node'), - branches = get_map('@branch.node'), - returns = get_map('@return.node'), - ignores = get_map('@ignore.node'), + indents = get_map "@indent.node", + branches = get_map "@branch.node", + returns = get_map "@return.node", + ignores = get_map "@ignore.node", } end, { -- Memoize by bufnr and lang together. key = function(bufnr, _, lang) - return tostring(bufnr) .. '_' .. lang - end + return tostring(bufnr) .. "_" .. lang + end, }) function M.get_indent(lnum) local parser = parsers.get_parser() - if not parser or not lnum then return -1 end + if not parser or not lnum then + return -1 + end local root, _, lang_tree = tsutils.get_root_for_position(lnum, 0, parser) -- Not likely, but just in case... - if not root then return 0 end + if not root then + return 0 + end local q = get_indents(vim.api.nvim_get_current_buf(), root, lang_tree:lang()) - local node = get_node_at_line(root, lnum-1) + local node = get_node_at_line(root, lnum - 1) local indent = 0 local indent_size = vim.fn.shiftwidth() @@ -65,11 +73,11 @@ function M.get_indent(lnum) if not node then local prevnonblank = vim.fn.prevnonblank(lnum) if prevnonblank ~= lnum then - local prev_node = get_node_at_line(root, prevnonblank-1) + local prev_node = get_node_at_line(root, prevnonblank - 1) -- get previous node in any case to avoid erroring - while not prev_node and prevnonblank-1 > 0 do - prevnonblank = vim.fn.prevnonblank(prevnonblank-1) - prev_node = get_node_at_line(root, prevnonblank-1) + while not prev_node and prevnonblank - 1 > 0 do + prevnonblank = vim.fn.prevnonblank(prevnonblank - 1) + prev_node = get_node_at_line(root, prevnonblank - 1) end -- nodes can be marked @return to prevent using them @@ -91,7 +99,7 @@ function M.get_indent(lnum) -- if the prevnonblank fails (prev_node wraps our line) we need to fall back to taking -- the first child of the node that wraps the current line, or the wrapper itself if not node then - local wrapper = root:descendant_for_range(lnum-1, 0, lnum-1, -1) + local wrapper = root:descendant_for_range(lnum - 1, 0, lnum - 1, -1) node = wrapper:child(0) or wrapper if q.indents[node_fmt(wrapper)] ~= nil and wrapper ~= root then indent = indent_size @@ -107,7 +115,7 @@ function M.get_indent(lnum) while node do -- do not indent if we are inside an @ignore block - if q.ignores[node_fmt(node)] and node:start() < lnum-1 and node:end_() > lnum-1 then + if q.ignores[node_fmt(node)] and node:start() < lnum - 1 and node:end_() > lnum - 1 then return -1 end @@ -129,8 +137,8 @@ local indent_funcs = {} function M.attach(bufnr) indent_funcs[bufnr] = vim.bo.indentexpr - vim.bo.indentexpr = 'nvim_treesitter#indent()' - vim.api.nvim_command("au Filetype "..vim.bo.filetype.." setlocal indentexpr=nvim_treesitter#indent()") + vim.bo.indentexpr = "nvim_treesitter#indent()" + vim.api.nvim_command("au Filetype " .. vim.bo.filetype .. " setlocal indentexpr=nvim_treesitter#indent()") end function M.detach(bufnr) diff --git a/lua/nvim-treesitter/info.lua b/lua/nvim-treesitter/info.lua index 0b14c4f36..1ba7620b9 100644 --- a/lua/nvim-treesitter/info.lua +++ b/lua/nvim-treesitter/info.lua @@ -1,24 +1,26 @@ local api = vim.api -local configs = require'nvim-treesitter.configs' -local parsers = require'nvim-treesitter.parsers' +local configs = require "nvim-treesitter.configs" +local parsers = require "nvim-treesitter.parsers" local M = {} local function install_info() local max_len = 0 for _, ft in pairs(parsers.available_parsers()) do - if #ft > max_len then max_len = #ft end + if #ft > max_len then + max_len = #ft + end end local parser_list = parsers.available_parsers() table.sort(parser_list) for _, ft in pairs(parser_list) do - local is_installed = #api.nvim_get_runtime_file('parser/'..ft..'.so', false) > 0 - api.nvim_out_write(ft..string.rep(' ', max_len - #ft + 1)) + local is_installed = #api.nvim_get_runtime_file("parser/" .. ft .. ".so", false) > 0 + api.nvim_out_write(ft .. string.rep(" ", max_len - #ft + 1)) if is_installed then - api.nvim_out_write("[✓] installed\n") + api.nvim_out_write "[✓] installed\n" else - api.nvim_out_write("[✗] not installed\n") + api.nvim_out_write "[✗] not installed\n" end end end @@ -30,8 +32,8 @@ end local function namespace_modules(modulelist) local modules = {} for _, module in ipairs(modulelist) do - if module:find('%.') then - local namespace, submodule = module:match('^(.*)%.(.*)$') + if module:find "%." then + local namespace, submodule = module:match "^(.*)%.(.*)$" if not modules[namespace] then modules[namespace] = {} end @@ -61,46 +63,48 @@ local function append_module_table(curbuf, parserlist, namespace, modulelist) table.sort(modulelist) -- header - local header = '>> ' .. namespace .. string.rep(' ', maxlen_parser - #namespace - 1) + local header = ">> " .. namespace .. string.rep(" ", maxlen_parser - #namespace - 1) for _, module in pairs(modulelist) do - header = header .. module .. ' ' + header = header .. module .. " " end - api.nvim_buf_set_lines(curbuf, -1, -1, true, {header}) + api.nvim_buf_set_lines(curbuf, -1, -1, true, { header }) -- actual table for _, parser in ipairs(parserlist) do - local padding = string.rep(' ', maxlen_parser - #parser + 2) - local line = parser .. padding - local namespace_prefix = (namespace == 'default') and '' or namespace .. '.' + local padding = string.rep(" ", maxlen_parser - #parser + 2) + local line = parser .. padding + local namespace_prefix = (namespace == "default") and "" or namespace .. "." for _, module in pairs(modulelist) do local modlen = #module module = namespace_prefix .. module if configs.is_enabled(module, parser) then - line = line .. '✓' + line = line .. "✓" else - line = line .. '✗' + line = line .. "✗" end - line = line .. string.rep(' ', modlen + 1) + line = line .. string.rep(" ", modlen + 1) end - api.nvim_buf_set_lines(curbuf, -1, -1, true, {line}) + api.nvim_buf_set_lines(curbuf, -1, -1, true, { line }) end - api.nvim_buf_set_lines(curbuf, -1, -1, true, {''}) + api.nvim_buf_set_lines(curbuf, -1, -1, true, { "" }) end local function print_info_modules(parserlist, module) - api.nvim_command('enew') + api.nvim_command "enew" local curbuf = api.nvim_get_current_buf() local modules if module then - modules = namespace_modules({module}) + modules = namespace_modules { module } else modules = namespace_modules(configs.available_modules()) end local namespaces = {} - for k, _ in pairs(modules) do table.insert(namespaces, k) end + for k, _ in pairs(modules) do + table.insert(namespaces, k) + end table.sort(namespaces) table.sort(parserlist) @@ -108,9 +112,10 @@ local function print_info_modules(parserlist, module) append_module_table(curbuf, parserlist, namespace, modules[namespace]) end - api.nvim_buf_set_option(curbuf, 'modified', false) - api.nvim_buf_set_option(curbuf, 'buftype', 'nofile') - api.nvim_exec([[ + api.nvim_buf_set_option(curbuf, "modified", false) + api.nvim_buf_set_option(curbuf, "buftype", "nofile") + api.nvim_exec( + [[ syntax match TSModuleInfoGood /✓/ syntax match TSModuleInfoBad /✗/ syntax match TSModuleInfoHeader /^>>.*$/ contains=TSModuleInfoNamespace @@ -121,11 +126,15 @@ local function print_info_modules(parserlist, module) highlight default link TSModuleInfoHeader Type highlight default link TSModuleInfoNamespace Statement highlight default link TSModuleInfoParser Identifier - ]], false) + ]], + false + ) end local function module_info(module) - if module and not configs.get_module(module) then return end + if module and not configs.get_module(module) then + return + end local parserlist = parsers.available_parsers() if module then diff --git a/lua/nvim-treesitter/install.lua b/lua/nvim-treesitter/install.lua index c2bdc9343..25ec2be1f 100644 --- a/lua/nvim-treesitter/install.lua +++ b/lua/nvim-treesitter/install.lua @@ -2,16 +2,16 @@ local api = vim.api local fn = vim.fn local luv = vim.loop -local utils = require'nvim-treesitter.utils' -local parsers = require'nvim-treesitter.parsers' -local info = require'nvim-treesitter.info' -local configs = require'nvim-treesitter.configs' -local shell = require'nvim-treesitter.shell_command_selectors' +local utils = require "nvim-treesitter.utils" +local parsers = require "nvim-treesitter.parsers" +local info = require "nvim-treesitter.info" +local configs = require "nvim-treesitter.configs" +local shell = require "nvim-treesitter.shell_command_selectors" local M = {} local lockfile = {} -M.compilers = { vim.fn.getenv('CC'), "cc", "gcc", "clang", "cl" } +M.compilers = { vim.fn.getenv "CC", "cc", "gcc", "clang", "cl" } local started_commands = 0 local finished_commands = 0 @@ -31,27 +31,31 @@ local function reset_progress_counter() end local function get_job_status() - return "[nvim-treesitter] ["..finished_commands.."/"..started_commands - ..(failed_commands > 0 and ", failed: "..failed_commands or "").."]" + return "[nvim-treesitter] [" + .. finished_commands + .. "/" + .. started_commands + .. (failed_commands > 0 and ", failed: " .. failed_commands or "") + .. "]" end local function get_revision(lang) if #lockfile == 0 then - local filename = utils.join_path(utils.get_package_path(), 'lockfile.json') + local filename = utils.join_path(utils.get_package_path(), "lockfile.json") lockfile = vim.fn.filereadable(filename) == 1 and vim.fn.json_decode(vim.fn.readfile(filename)) or {} end return (lockfile[lang] and lockfile[lang].revision) end local function get_installed_revision(lang) - local lang_file = utils.join_path(utils.get_parser_info_dir(), lang..'.revision') + local lang_file = utils.join_path(utils.get_parser_info_dir(), lang .. ".revision") if vim.fn.filereadable(lang_file) == 1 then return vim.fn.readfile(lang_file)[1] end end local function is_installed(lang) - return #api.nvim_get_runtime_file('parser/'..lang..'.so', false) > 0 + return #api.nvim_get_runtime_file("parser/" .. lang .. ".so", false) > 0 end local function needs_update(lang) @@ -61,17 +65,16 @@ end local function outdated_parsers() return vim.tbl_filter(function(lang) return needs_update(lang) - end, - info.installed_parsers()) + end, info.installed_parsers()) end local function onread(handle, is_stderr) return function(err, data) if data then if is_stderr then - complete_error_output[handle] = (complete_error_output[handle] or '')..data + complete_error_output[handle] = (complete_error_output[handle] or "") .. data else - complete_std_output[handle] = (complete_std_output[handle] or '')..data + complete_std_output[handle] = (complete_std_output[handle] or "") .. data end end end @@ -83,52 +86,62 @@ function M.iter_cmd(cmd_list, i, lang, success_message) end if i == #cmd_list + 1 then finished_commands = finished_commands + 1 - return print(get_job_status().." "..success_message) + return print(get_job_status() .. " " .. success_message) end local attr = cmd_list[i] - if attr.info then print(get_job_status().." "..attr.info) end + if attr.info then + print(get_job_status() .. " " .. attr.info) + end - if type(attr.cmd) == 'function' then + if type(attr.cmd) == "function" then local ok, err = pcall(attr.cmd) if ok then M.iter_cmd(cmd_list, i + 1, lang, success_message) else failed_commands = failed_commands + 1 finished_commands = finished_commands + 1 - return api.nvim_err_writeln((attr.err or ("Failed to execute the following command:\n"..vim.inspect(attr))) - ..'\n'..vim.inspect(err)) + return api.nvim_err_writeln( + (attr.err or ("Failed to execute the following command:\n" .. vim.inspect(attr))) .. "\n" .. vim.inspect(err) + ) end else local handle local stdout = luv.new_pipe(false) local stderr = luv.new_pipe(false) - attr.opts.stdio = {nil, stdout, stderr} - handle = luv.spawn(attr.cmd, attr.opts, vim.schedule_wrap(function(code) - if code ~= 0 then - stdout:read_stop() - stderr:read_stop() - end - stdout:close() - stderr:close() - handle:close() - if code ~= 0 then - failed_commands = failed_commands + 1 - finished_commands = finished_commands + 1 - if complete_std_output[handle] and complete_std_output[handle] ~= '' then - print(complete_std_output[handle]) + attr.opts.stdio = { nil, stdout, stderr } + handle = luv.spawn( + attr.cmd, + attr.opts, + vim.schedule_wrap(function(code) + if code ~= 0 then + stdout:read_stop() + stderr:read_stop() end + stdout:close() + stderr:close() + handle:close() + if code ~= 0 then + failed_commands = failed_commands + 1 + finished_commands = finished_commands + 1 + if complete_std_output[handle] and complete_std_output[handle] ~= "" then + print(complete_std_output[handle]) + end - local err_msg = complete_error_output[handle] or '' - api.nvim_err_writeln( - 'nvim-treesitter['..lang..']: ' - ..(attr.err or ("Failed to execute the following command:\n"..vim.inspect(attr))) - ..'\n' - ..err_msg) - return - end - M.iter_cmd(cmd_list, i + 1, lang, success_message) - end)) + local err_msg = complete_error_output[handle] or "" + api.nvim_err_writeln( + "nvim-treesitter[" + .. lang + .. "]: " + .. (attr.err or ("Failed to execute the following command:\n" .. vim.inspect(attr))) + .. "\n" + .. err_msg + ) + return + end + M.iter_cmd(cmd_list, i + 1, lang, success_message) + end) + ) luv.read_start(stdout, onread(handle, false)) luv.read_start(stderr, onread(handle, true)) end @@ -142,7 +155,7 @@ local function get_command(cmd) end end - local final = string.format('%s %s', cmd.cmd, options) + local final = string.format("%s %s", cmd.cmd, options) if cmd.opts and cmd.opts.cwd then final = shell.make_directory_change_for_command(cmd.opts.cwd, final) end @@ -155,19 +168,18 @@ local function iter_cmd_sync(cmd_list) print(cmd.info) end - if type(cmd.cmd) == 'function' then + if type(cmd.cmd) == "function" then cmd.cmd() else local ret = vim.fn.system(get_command(cmd)) if vim.v.shell_error ~= 0 then print(ret) - api.nvim_err_writeln((cmd.err and cmd.err..'\n' or '') - .."Failed to execute the following command:\n" - ..vim.inspect(cmd)) + api.nvim_err_writeln( + (cmd.err and cmd.err .. "\n" or "") .. "Failed to execute the following command:\n" .. vim.inspect(cmd) + ) return false end end - end return true @@ -178,7 +190,7 @@ local function run_install(cache_folder, install_folder, lang, repo, with_sync, local path_sep = utils.get_path_sep() - local project_name = 'tree-sitter-'..lang + local project_name = "tree-sitter-" .. lang local maybe_local_path = vim.fn.expand(repo.url) local from_local_path = vim.fn.isdirectory(maybe_local_path) == 1 if from_local_path then @@ -190,33 +202,40 @@ local function run_install(cache_folder, install_folder, lang, repo, with_sync, if from_local_path then compile_location = repo.url else - local repo_location = string.gsub(repo.location or project_name, '/', path_sep) - compile_location = cache_folder..path_sep..repo_location + local repo_location = string.gsub(repo.location or project_name, "/", path_sep) + compile_location = cache_folder .. path_sep .. repo_location end - local parser_lib_name = install_folder..path_sep..lang..".so" + local parser_lib_name = install_folder .. path_sep .. lang .. ".so" generate_from_grammar = repo.requires_generate_from_grammar or generate_from_grammar - if generate_from_grammar and vim.fn.executable('tree-sitter') ~= 1 then - api.nvim_err_writeln('tree-sitter CLI not found: `tree-sitter` is not executable!') + if generate_from_grammar and vim.fn.executable "tree-sitter" ~= 1 then + api.nvim_err_writeln "tree-sitter CLI not found: `tree-sitter` is not executable!" if repo.requires_generate_from_grammar then - api.nvim_err_writeln('tree-sitter CLI is needed because `'..lang..'` is marked that it needs ' - ..'to be generated from the grammar definitions to be compatible with nvim!') + api.nvim_err_writeln( + "tree-sitter CLI is needed because `" + .. lang + .. "` is marked that it needs " + .. "to be generated from the grammar definitions to be compatible with nvim!" + ) end return end - if generate_from_grammar and vim.fn.executable('node') ~= 1 then - api.nvim_err_writeln('Node JS not found: `node` is not executable!') + if generate_from_grammar and vim.fn.executable "node" ~= 1 then + api.nvim_err_writeln "Node JS not found: `node` is not executable!" return end local cc = shell.select_executable(M.compilers) if not cc then - api.nvim_err_writeln('No C compiler found! "' - ..table.concat(vim.tbl_filter(function(c) return type(c) == 'string' end, M.compilers), '", "') - ..'" are not executable.') + api.nvim_err_writeln('No C compiler found! "' .. table.concat( + vim.tbl_filter(function(c) + return type(c) == "string" + end, M.compilers), + '", "' + ) .. '" are not executable.') return end - local revision = configs.get_update_strategy() == 'lockfile' and get_revision(lang) + local revision = configs.get_update_strategy() == "lockfile" and get_revision(lang) local command_list = {} if not from_local_path then @@ -225,83 +244,86 @@ local function run_install(cache_folder, install_folder, lang, repo, with_sync, end if generate_from_grammar then if repo.generate_requires_npm then - if vim.fn.executable('npm') ~= 1 then - api.nvim_err_writeln('`'..lang..'` requires NPM to be installed from grammar.js') + if vim.fn.executable "npm" ~= 1 then + api.nvim_err_writeln("`" .. lang .. "` requires NPM to be installed from grammar.js") return end vim.list_extend(command_list, { { - cmd = 'npm', - info = 'Installing NPM dependencies of '..lang..' parser', - err = 'Error during `npm install` (required for parser generation of '..lang..' with npm dependencies)', + cmd = "npm", + info = "Installing NPM dependencies of " .. lang .. " parser", + err = "Error during `npm install` (required for parser generation of " .. lang .. " with npm dependencies)", opts = { - args = {'install'}, - cwd = compile_location - } - } + args = { "install" }, + cwd = compile_location, + }, + }, }) end vim.list_extend(command_list, { { - cmd = vim.fn.exepath('tree-sitter'), - info = 'Generating source files from grammar.js...', + cmd = vim.fn.exepath "tree-sitter", + info = "Generating source files from grammar.js...", err = 'Error during "tree-sitter generate"', opts = { - args = {'generate'}, - cwd = compile_location - } - } + args = { "generate" }, + cwd = compile_location, + }, + }, }) end vim.list_extend(command_list, { { cmd = cc, - info = 'Compiling...', - err = 'Error during compilation', + info = "Compiling...", + err = "Error during compilation", opts = { args = vim.tbl_flatten(shell.select_compiler_args(repo, cc)), - cwd = compile_location - } + cwd = compile_location, + }, }, - shell.select_mv_cmd('parser.so', parser_lib_name, compile_location), + shell.select_mv_cmd("parser.so", parser_lib_name, compile_location), { cmd = function() - vim.fn.writefile({revision or ''}, utils.join_path(utils.get_parser_info_dir(), lang..'.revision')) - end - } + vim.fn.writefile({ revision or "" }, utils.join_path(utils.get_parser_info_dir(), lang .. ".revision")) + end, + }, }) if not from_local_path then - vim.list_extend(command_list, {shell.select_install_rm_cmd(cache_folder, project_name)}) + vim.list_extend(command_list, { shell.select_install_rm_cmd(cache_folder, project_name) }) end if with_sync then if iter_cmd_sync(command_list) == true then - print('Treesitter parser for '..lang..' has been installed') + print("Treesitter parser for " .. lang .. " has been installed") end else - M.iter_cmd(command_list, 1, lang, 'Treesitter parser for '..lang..' has been installed') + M.iter_cmd(command_list, 1, lang, "Treesitter parser for " .. lang .. " has been installed") end end local function install_lang(lang, ask_reinstall, cache_folder, install_folder, with_sync, generate_from_grammar) + if is_installed(lang) and ask_reinstall ~= "force" then + if not ask_reinstall then + return + end - if is_installed(lang) and ask_reinstall ~= 'force' then - if not ask_reinstall then return end - - local yesno = fn.input(lang .. ' parser already available: would you like to reinstall ? y/n: ') - print('\n ') -- mandatory to avoid messing up command line - if not string.match(yesno, '^y.*') then return end + local yesno = fn.input(lang .. " parser already available: would you like to reinstall ? y/n: ") + print "\n " + if not string.match(yesno, "^y.*") then + return + end end local parser_config = parsers.get_parser_configs()[lang] if not parser_config then - return api.nvim_err_writeln('Parser not available for language '..lang) + return api.nvim_err_writeln("Parser not available for language " .. lang) end local install_info = parser_config.install_info vim.validate { - url={ install_info.url, 'string' }, - files={ install_info.files, 'table' } + url = { install_info.url, "string" }, + files = { install_info.files, "table" }, } run_install(cache_folder, install_folder, lang, install_info, with_sync, generate_from_grammar) @@ -314,27 +336,31 @@ local function install(options) local generate_from_grammar = options.generate_from_grammar local exclude_configured_parsers = options.exclude_configured_parsers - return function (...) - if fn.executable('git') == 0 then - return api.nvim_err_writeln('Git is required on your system to run this command') + return function(...) + if fn.executable "git" == 0 then + return api.nvim_err_writeln "Git is required on your system to run this command" end local cache_folder, err = utils.get_cache_dir() - if err then return api.nvim_err_writeln(err) end + if err then + return api.nvim_err_writeln(err) + end local install_folder, err = utils.get_parser_install_dir() - if err then return api.nvim_err_writeln(err) end + if err then + return api.nvim_err_writeln(err) + end local languages local ask - if ... == 'all' then + if ... == "all" then languages = parsers.available_parsers() ask = false - elseif ... == 'maintained' then + elseif ... == "maintained" then languages = parsers.maintained_parsers() ask = false else - languages = vim.tbl_flatten({...}) + languages = vim.tbl_flatten { ... } ask = ask_reinstall end @@ -354,69 +380,73 @@ end function M.update(options) options = options or {} - return function (...) + return function(...) M.lockfile = {} reset_progress_counter() - if ... and ... ~= 'all' then - local languages = vim.tbl_flatten({...}) + if ... and ... ~= "all" then + local languages = vim.tbl_flatten { ... } local installed = 0 for _, lang in ipairs(languages) do - if (not is_installed(lang)) or (needs_update(lang)) then - installed = installed + 1 - install({ - ask_reinstall = 'force', - with_sync = options.with_sync })(lang) - end + if (not is_installed(lang)) or (needs_update(lang)) then + installed = installed + 1 + install { + ask_reinstall = "force", + with_sync = options.with_sync, + }(lang) + end end if installed == 0 then - print('Parsers are up-to-date!') + print "Parsers are up-to-date!" end else - local parsers_to_update = configs.get_update_strategy() == 'lockfile' - and outdated_parsers() + local parsers_to_update = configs.get_update_strategy() == "lockfile" and outdated_parsers() or info.installed_parsers() if #parsers_to_update == 0 then - print('All parsers are up-to-date!') + print "All parsers are up-to-date!" end for _, lang in pairs(parsers_to_update) do - install({ - ask_reinstall = 'force', + install { + ask_reinstall = "force", exclude_configured_parsers = true, - with_sync = options.with_sync - })(lang) + with_sync = options.with_sync, + }(lang) end end end end function M.uninstall(...) - local path_sep = '/' - if fn.has('win32') == 1 then - path_sep = '\\' + local path_sep = "/" + if fn.has "win32" == 1 then + path_sep = "\\" end - if vim.tbl_contains({'all', 'maintained'}, ...) then + if vim.tbl_contains({ "all", "maintained" }, ...) then reset_progress_counter() local installed = info.installed_parsers() if ... == "maintained" then local maintained = parsers.maintained_parsers() - installed = vim.tbl_filter(function(l) return vim.tbl_contains(maintained, l) end, installed) + installed = vim.tbl_filter(function(l) + return vim.tbl_contains(maintained, l) + end, installed) end for _, langitem in pairs(installed) do M.uninstall(langitem) end elseif ... then - local languages = vim.tbl_flatten({...}) + local languages = vim.tbl_flatten { ... } for _, lang in ipairs(languages) do local install_dir, err = utils.get_parser_install_dir() - if err then return api.nvim_err_writeln(err) end + if err then + return api.nvim_err_writeln(err) + end - local parser_lib = install_dir..path_sep..lang..".so" + local parser_lib = install_dir .. path_sep .. lang .. ".so" local command_list = { - shell.select_rm_file_cmd(parser_lib, "Uninstalling parser for "..lang) + shell.select_rm_file_cmd(parser_lib, "Uninstalling parser for " .. lang), } - M.iter_cmd(command_list, 1, lang, 'Treesitter parser for '..lang..' has been uninstalled') + M.iter_cmd(command_list, 1, lang, "Treesitter parser for " .. lang .. " has been uninstalled") end end end @@ -428,38 +458,41 @@ function M.write_lockfile(verbose, skip_langs) skip_langs = skip_langs or {} for k, v in pairs(parsers.get_parser_configs()) do - table.insert(sorted_parsers, {name = k, parser = v}) + table.insert(sorted_parsers, { name = k, parser = v }) end - table.sort(sorted_parsers, function(a, b) return a.name < b.name end) + table.sort(sorted_parsers, function(a, b) + return a.name < b.name + end) for _, v in ipairs(sorted_parsers) do - if not vim.tbl_contains(skip_langs, v.name) then -- I'm sure this can be done in aync way with iter_cmd - local sha = vim.split(vim.fn.systemlist('git ls-remote '..v.parser.install_info.url)[1], '\t')[1] + local sha = vim.split(vim.fn.systemlist("git ls-remote " .. v.parser.install_info.url)[1], "\t")[1] lockfile[v.name] = { revision = sha } if verbose then - print(v.name..': '..sha) + print(v.name .. ": " .. sha) end else - print('Skipping '..v.name) + print("Skipping " .. v.name) end end if verbose then print(vim.inspect(lockfile)) end - vim.fn.writefile(vim.fn.split(vim.fn.json_encode(lockfile), '\n'), - utils.join_path(utils.get_package_path(), "lockfile.json")) + vim.fn.writefile( + vim.fn.split(vim.fn.json_encode(lockfile), "\n"), + utils.join_path(utils.get_package_path(), "lockfile.json") + ) end -M.ensure_installed = install({ exclude_configured_parsers = true }) +M.ensure_installed = install { exclude_configured_parsers = true } M.commands = { TSInstall = { - run = install({ ask_reinstall = true }), - ['run!'] = install({ ask_reinstall = 'force' }), + run = install { ask_reinstall = true }, + ["run!"] = install { ask_reinstall = "force" }, args = { "-nargs=+", "-bang", @@ -467,8 +500,8 @@ M.commands = { }, }, TSInstallFromGrammar = { - run = install({ generate_from_grammar = true, ask_reinstall = true }), - ['run!'] = install({ generate_from_grammar = true, ask_reinstall = 'force' }), + run = install { generate_from_grammar = true, ask_reinstall = true }, + ["run!"] = install { generate_from_grammar = true, ask_reinstall = "force" }, args = { "-nargs=+", "-bang", @@ -476,8 +509,8 @@ M.commands = { }, }, TSInstallSync = { - run = install( { with_sync = true, ask_reinstall = true }), - ['run!'] = install( { with_sync = true, ask_reinstall = 'force' }), + run = install { with_sync = true, ask_reinstall = true }, + ["run!"] = install { with_sync = true, ask_reinstall = "force" }, args = { "-nargs=+", "-bang", @@ -485,14 +518,14 @@ M.commands = { }, }, TSUpdate = { - run = M.update({}), + run = M.update {}, args = { "-nargs=*", "-complete=custom,nvim_treesitter#installed_parsers", }, }, TSUpdateSync = { - run = M.update({ with_sync = true }), + run = M.update { with_sync = true }, args = { "-nargs=*", "-complete=custom,nvim_treesitter#installed_parsers", diff --git a/lua/nvim-treesitter/locals.lua b/lua/nvim-treesitter/locals.lua index 17982340d..741a7631f 100644 --- a/lua/nvim-treesitter/locals.lua +++ b/lua/nvim-treesitter/locals.lua @@ -2,25 +2,25 @@ -- Locals are a generalization of definition and scopes -- its the way nvim-treesitter uses to "understand" the code -local queries = require'nvim-treesitter.query' -local ts_utils = require'nvim-treesitter.ts_utils' +local queries = require "nvim-treesitter.query" +local ts_utils = require "nvim-treesitter.ts_utils" local api = vim.api local M = {} function M.collect_locals(bufnr) - return queries.collect_group_results(bufnr, 'locals') + return queries.collect_group_results(bufnr, "locals") end -- Iterates matches from a locals query file. -- @param bufnr the buffer -- @param root the root node function M.iter_locals(bufnr, root) - return queries.iter_group_results(bufnr, 'locals', root) + return queries.iter_group_results(bufnr, "locals", root) end function M.get_locals(bufnr) - return queries.get_matches(bufnr, 'locals') + return queries.get_matches(bufnr, "locals") end --- Creates unique id for a node based on text and range @@ -30,7 +30,7 @@ end -- @returns a string id function M.get_definition_id(scope, node_text) -- Add a vaild starting character in case node text doesn't start with a valid one. - return table.concat({ 'k', node_text or '', scope:range() }, '_') + return table.concat({ "k", node_text or "", scope:range() }, "_") end function M.get_definitions(bufnr) @@ -131,11 +131,7 @@ function M.recurse_local_nodes(local_def, accumulator, full_match, last_match) accumulator(local_def, local_def.node, full_match, last_match) else for match_key, def in pairs(local_def) do - M.recurse_local_nodes( - def, - accumulator, - full_match and (full_match..'.'..match_key) or match_key, - match_key) + M.recurse_local_nodes(def, accumulator, full_match and (full_match .. "." .. match_key) or match_key, match_key) end end end @@ -188,10 +184,10 @@ function M.get_definition_scopes(node, bufnr, scope_type) -- Definition is valid for the containing scope -- and the containing scope of that scope - if scope_type == 'parent' then + if scope_type == "parent" then scope_count = 2 -- Definition is valid in all parent scopes - elseif scope_type == 'global' then + elseif scope_type == "global" then scope_count = nil end @@ -200,7 +196,9 @@ function M.get_definition_scopes(node, bufnr, scope_type) table.insert(scopes, scope) i = i + 1 - if scope_count and i >= scope_count then break end + if scope_count and i >= scope_count then + break + end end return scopes @@ -231,13 +229,16 @@ function M.find_usages(node, scope_node, bufnr) local bufnr = bufnr or api.nvim_get_current_buf() local node_text = ts_utils.get_node_text(node, bufnr)[1] - if not node_text or #node_text < 1 then return {} end + if not node_text or #node_text < 1 then + return {} + end local scope_node = scope_node or ts_utils.get_root_for_node(node) local usages = {} for match in M.iter_locals(bufnr, scope_node) do - if match.reference + if + match.reference and match.reference.node and ts_utils.get_node_text(match.reference.node, bufnr)[1] == node_text then @@ -257,7 +258,9 @@ function M.containing_scope(node, bufnr, allow_scope) local allow_scope = allow_scope == nil or allow_scope == true local scopes = M.get_scopes(bufnr) - if not node or not scopes then return end + if not node or not scopes then + return + end local iter_node = node @@ -272,7 +275,9 @@ function M.nested_scope(node, cursor_pos) local bufnr = api.nvim_get_current_buf() local scopes = M.get_scopes(bufnr) - if not node or not scopes then return end + if not node or not scopes then + return + end local row = cursor_pos.row local col = cursor_pos.col @@ -280,7 +285,7 @@ function M.nested_scope(node, cursor_pos) for _, child in ipairs(ts_utils.get_named_children(scope)) do local row_, col_ = child:start() - if vim.tbl_contains(scopes, child) and ((row_+1 == row and col_ > col) or row_+1 > row) then + if vim.tbl_contains(scopes, child) and ((row_ + 1 == row and col_ > col) or row_ + 1 > row) then return child end end @@ -290,12 +295,16 @@ function M.next_scope(node) local bufnr = api.nvim_get_current_buf() local scopes = M.get_scopes(bufnr) - if not node or not scopes then return end + if not node or not scopes then + return + end local scope = M.containing_scope(node) local parent = scope:parent() - if not parent then return end + if not parent then + return + end local is_prev = true for _, child in ipairs(ts_utils.get_named_children(parent)) do @@ -311,16 +320,20 @@ function M.previous_scope(node) local bufnr = api.nvim_get_current_buf() local scopes = M.get_scopes(bufnr) - if not node or not scopes then return end + if not node or not scopes then + return + end local scope = M.containing_scope(node) local parent = scope:parent() - if not parent then return end + if not parent then + return + end local is_prev = true local children = ts_utils.get_named_children(parent) - for i=#children,1,-1 do + for i = #children, 1, -1 do if children[i] == scope then is_prev = false elseif not is_prev and vim.tbl_contains(scopes, children[i]) then diff --git a/lua/nvim-treesitter/parsers.lua b/lua/nvim-treesitter/parsers.lua index c6bd9b8a1..b4d730e8d 100644 --- a/lua/nvim-treesitter/parsers.lua +++ b/lua/nvim-treesitter/parsers.lua @@ -4,7 +4,7 @@ local ts = vim.treesitter local ft_to_parsername = {} local function update_ft_to_parsername(name, parser) - if type(parser.used_by) == 'table' then + if type(parser.used_by) == "table" then for _, ft in pairs(parser.used_by) do ft_to_parsername[ft] = name end @@ -14,19 +14,22 @@ end local list = setmetatable({}, { __newindex = function(table, parsername, parserconfig) - - rawset(table, parsername, setmetatable(parserconfig, { - __newindex = function(parserconfigtable, key, value) - if key == "used_by" then - ft_to_parsername[value] = parsername - else - rawset(parserconfigtable, key, value) - end - end - })) + rawset( + table, + parsername, + setmetatable(parserconfig, { + __newindex = function(parserconfigtable, key, value) + if key == "used_by" then + ft_to_parsername[value] = parsername + else + rawset(parserconfigtable, key, value) + end + end, + }) + ) update_ft_to_parsername(parsername, parserconfig) - end + end, }) list.javascript = { @@ -34,16 +37,16 @@ list.javascript = { url = "https://github.com/tree-sitter/tree-sitter-javascript", files = { "src/parser.c", "src/scanner.c" }, }, - used_by = { 'javascriptreact' }, - maintainers = {"@steelsojka"}, + used_by = { "javascriptreact" }, + maintainers = { "@steelsojka" }, } list.c = { install_info = { url = "https://github.com/tree-sitter/tree-sitter-c", - files = { "src/parser.c" } + files = { "src/parser.c" }, }, - maintainers = {"@vigoux"}, + maintainers = { "@vigoux" }, } list.clojure = { @@ -51,7 +54,7 @@ list.clojure = { url = "https://github.com/sogaiu/tree-sitter-clojure", files = { "src/parser.c" }, }, - maintainers = {"@sogaiu"}, + maintainers = { "@sogaiu" }, } list.commonlisp = { @@ -60,8 +63,8 @@ list.commonlisp = { files = { "src/parser.c" }, generate_requires_npm = true, }, - filetype = 'lisp', - maintainers = {"@theHamsta"}, + filetype = "lisp", + maintainers = { "@theHamsta" }, } list.cpp = { @@ -70,16 +73,16 @@ list.cpp = { files = { "src/parser.c", "src/scanner.cc" }, generate_requires_npm = true, }, - maintainers = {"@theHamsta"}, + maintainers = { "@theHamsta" }, } list.cuda = { install_info = { url = "https://github.com/theHamsta/tree-sitter-cuda", - files = {"src/parser.c", "src/scanner.cc"}, + files = { "src/parser.c", "src/scanner.cc" }, generate_requires_npm = true, }, - maintainers = {"@theHamsta"}, + maintainers = { "@theHamsta" }, } list.dockerfile = { @@ -88,7 +91,7 @@ list.dockerfile = { branch = "main", files = { "src/parser.c" }, }, - maintainers = {"@camdencheek"}, + maintainers = { "@camdencheek" }, } list.rust = { @@ -96,7 +99,7 @@ list.rust = { url = "https://github.com/tree-sitter/tree-sitter-rust", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@vigoux"}, + maintainers = { "@vigoux" }, } list.ledger = { @@ -104,15 +107,15 @@ list.ledger = { url = "https://github.com/cbarrete/tree-sitter-ledger", files = { "src/parser.c" }, }, - maintainers = {"@cbarrete"}, + maintainers = { "@cbarrete" }, } list.lua = { install_info = { url = "https://github.com/nvim-treesitter/tree-sitter-lua", - files = { "src/parser.c", "src/scanner.cc" } + files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {"@vigoux"}, + maintainers = { "@vigoux" }, } list.python = { @@ -120,7 +123,7 @@ list.python = { url = "https://github.com/tree-sitter/tree-sitter-python", files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {'@stsewd', "@theHamsta"}, + maintainers = { "@stsewd", "@theHamsta" }, } list.go = { @@ -128,7 +131,7 @@ list.go = { url = "https://github.com/tree-sitter/tree-sitter-go", files = { "src/parser.c" }, }, - maintainers = {"@theHamsta", "@WinWisely268"}, + maintainers = { "@theHamsta", "@WinWisely268" }, } list.gomod = { @@ -137,7 +140,7 @@ list.gomod = { branch = "main", files = { "src/parser.c" }, }, - maintainers = {"@camdencheek"}, + maintainers = { "@camdencheek" }, filetype = "gomod", } @@ -146,7 +149,7 @@ list.graphql = { url = "https://github.com/bkegley/tree-sitter-graphql", files = { "src/parser.c" }, }, - maintainers = {"@bkegley"}, + maintainers = { "@bkegley" }, } list.ruby = { @@ -154,7 +157,7 @@ list.ruby = { url = "https://github.com/tree-sitter/tree-sitter-ruby", files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {'@TravonteD'}, + maintainers = { "@TravonteD" }, } list.bash = { @@ -163,8 +166,8 @@ list.bash = { files = { "src/parser.c", "src/scanner.cc" }, }, used_by = { "zsh", "PKGBUILD" }, - filetype = 'sh', - maintainers = {"@TravonteD"}, + filetype = "sh", + maintainers = { "@TravonteD" }, } list.fish = { @@ -172,7 +175,7 @@ list.fish = { url = "https://github.com/krnik/tree-sitter-fish", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@krnik", "@ram02z"}, + maintainers = { "@krnik", "@ram02z" }, } list.php = { @@ -180,7 +183,7 @@ list.php = { url = "https://github.com/tree-sitter/tree-sitter-php", files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {"@tk-shirasaka"}, + maintainers = { "@tk-shirasaka" }, } list.java = { @@ -188,7 +191,7 @@ list.java = { url = "https://github.com/tree-sitter/tree-sitter-java", files = { "src/parser.c" }, }, - maintainers = {"@p00f"}, + maintainers = { "@p00f" }, } list.kotlin = { @@ -196,7 +199,7 @@ list.kotlin = { url = "https://github.com/tormodatt/tree-sitter-kotlin", files = { "src/parser.c" }, }, - maintainers = {"@tormodatt"}, + maintainers = { "@tormodatt" }, } list.html = { @@ -204,7 +207,7 @@ list.html = { url = "https://github.com/tree-sitter/tree-sitter-html", files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {"@TravonteD"}, + maintainers = { "@TravonteD" }, } list.julia = { @@ -212,7 +215,7 @@ list.julia = { url = "https://github.com/tree-sitter/tree-sitter-julia", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@mroavi", "@theHamsta"}, + maintainers = { "@mroavi", "@theHamsta" }, } list.json = { @@ -220,7 +223,7 @@ list.json = { url = "https://github.com/tree-sitter/tree-sitter-json", files = { "src/parser.c" }, }, - maintainers = {"@steelsojka"}, + maintainers = { "@steelsojka" }, } list.css = { @@ -228,15 +231,15 @@ list.css = { url = "https://github.com/tree-sitter/tree-sitter-css", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@TravonteD"}, + maintainers = { "@TravonteD" }, } list.scss = { install_info = { url = "https://github.com/serenadeai/tree-sitter-scss", - files = { "src/parser.c", "src/scanner.c" } + files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@elianiva"}, + maintainers = { "@elianiva" }, } list.erlang = { @@ -245,16 +248,16 @@ list.erlang = { files = { "src/parser.c" }, branch = "main", }, - maintainers = { '@ostera' }, + maintainers = { "@ostera" }, } list.elixir = { install_info = { url = "https://github.com/ananthakumaran/tree-sitter-elixir", - files = { "src/parser.c", "src/scanner.cc" }, - requires_generate_from_grammar = true, + files = { "src/parser.c", "src/scanner.cc" }, + requires_generate_from_grammar = true, }, - maintainers = { '@nifoc' }, + maintainers = { "@nifoc" }, } list.ocaml = { @@ -263,7 +266,7 @@ list.ocaml = { files = { "src/parser.c", "src/scanner.cc" }, location = "tree-sitter-ocaml/ocaml", }, - maintainers = {'@undu'}, + maintainers = { "@undu" }, } list.ocaml_interface = { @@ -272,25 +275,25 @@ list.ocaml_interface = { files = { "src/parser.c", "src/scanner.cc" }, location = "tree-sitter-ocaml_interface/interface", }, - maintainers = {'@undu'}, - filetype = 'ocamlinterface' + maintainers = { "@undu" }, + filetype = "ocamlinterface", } list.ocamllex = { install_info = { url = "https://github.com/atom-ocaml/tree-sitter-ocamllex", files = { "src/parser.c", "src/scanner.cc" }, - requires_generate_from_grammar = true, + requires_generate_from_grammar = true, }, - maintainers = {'@undu'}, + maintainers = { "@undu" }, } list.swift = { install_info = { url = "https://github.com/tree-sitter/tree-sitter-swift", files = { "src/parser.c" }, - requires_generate_from_grammar = true, - } + requires_generate_from_grammar = true, + }, } list.c_sharp = { @@ -298,8 +301,8 @@ list.c_sharp = { url = "https://github.com/tree-sitter/tree-sitter-c-sharp", files = { "src/parser.c", "src/scanner.c" }, }, - filetype = 'cs', - maintainers = {'@Luxed'}, + filetype = "cs", + maintainers = { "@Luxed" }, } list.typescript = { @@ -309,7 +312,7 @@ list.typescript = { location = "tree-sitter-typescript/typescript", generate_requires_npm = true, }, - maintainers = {"@steelsojka"}, + maintainers = { "@steelsojka" }, } list.tsx = { @@ -320,24 +323,24 @@ list.tsx = { generate_requires_npm = true, }, used_by = { "typescript.tsx" }, - filetype = 'typescriptreact', - maintainers = {'@steelsojka'} + filetype = "typescriptreact", + maintainers = { "@steelsojka" }, } list.scala = { install_info = { url = "https://github.com/tree-sitter/tree-sitter-scala", files = { "src/parser.c", "src/scanner.c" }, - } + }, } list.supercollider = { install_info = { url = "https://github.com/madskjeldgaard/tree-sitter-supercollider", - files = {"src/parser.c", "src/scanner.c"}, + files = { "src/parser.c", "src/scanner.c" }, branch = "main", }, - maintainers = {"@madskjeldgaard"}, + maintainers = { "@madskjeldgaard" }, filetype = "supercollider", } @@ -345,16 +348,16 @@ list.haskell = { install_info = { url = "https://github.com/tree-sitter/tree-sitter-haskell", files = { "src/parser.c", "src/scanner.cc" }, - } + }, } list.hcl = { install_info = { url = "https://github.com/MichaHoffmann/tree-sitter-hcl", - files = {"src/parser.c", "src/scanner.cc"}, - branch = "main" + files = { "src/parser.c", "src/scanner.cc" }, + branch = "main", }, - maintainers = {"@MichaHoffmann"}, + maintainers = { "@MichaHoffmann" }, filetype = "hcl", used_by = { "terraform", "packer", "nomad" }, } @@ -373,18 +376,18 @@ list.toml = { files = { "src/parser.c", "src/scanner.c" }, generate_requires_npm = true, }, - maintainers = {"@tk-shirasaka"}, + maintainers = { "@tk-shirasaka" }, } list.glimmer = { install_info = { url = "https://github.com/alexlafroscia/tree-sitter-glimmer", files = { "src/parser.c", "src/scanner.c" }, - branch = 'main', + branch = "main", }, readme_name = "Glimmer and Ember", maintainers = { "@alexlafroscia" }, - filetype = "handlebars" + filetype = "handlebars", } list.vue = { @@ -392,7 +395,7 @@ list.vue = { url = "https://github.com/ikatyang/tree-sitter-vue", files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {"@WhyNotHugo"}, + maintainers = { "@WhyNotHugo" }, } list.jsonc = { @@ -402,14 +405,14 @@ list.jsonc = { generate_requires_npm = true, }, readme_name = "JSON with comments", - maintainers = {"@WhyNotHugo"}, + maintainers = { "@WhyNotHugo" }, } list.elm = { install_info = { url = "https://github.com/elm-tooling/tree-sitter-elm", files = { "src/parser.c", "src/scanner.cc" }, - } + }, } list.yaml = { @@ -417,7 +420,7 @@ list.yaml = { url = "https://github.com/ikatyang/tree-sitter-yaml", files = { "src/parser.c", "src/scanner.cc" }, }, - maintainers = {"@stsewd"}, + maintainers = { "@stsewd" }, } list.nix = { @@ -425,7 +428,7 @@ list.nix = { url = "https://github.com/cstrahan/tree-sitter-nix", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@leo60228"}, + maintainers = { "@leo60228" }, } list.dart = { @@ -433,7 +436,7 @@ list.dart = { url = "https://github.com/UserNobody14/tree-sitter-dart", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@Akin909"}, + maintainers = { "@Akin909" }, } list.rst = { @@ -441,7 +444,7 @@ list.rst = { url = "https://github.com/stsewd/tree-sitter-rst", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@stsewd"}, + maintainers = { "@stsewd" }, } list.fennel = { @@ -449,7 +452,7 @@ list.fennel = { url = "https://github.com/travonted/tree-sitter-fennel", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {'@TravonteD'}, + maintainers = { "@TravonteD" }, } list.teal = { @@ -457,7 +460,7 @@ list.teal = { url = "https://github.com/euclidianAce/tree-sitter-teal", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {'@euclidianAce'}, + maintainers = { "@euclidianAce" }, } list.ql = { @@ -465,7 +468,7 @@ list.ql = { url = "https://github.com/tree-sitter/tree-sitter-ql", files = { "src/parser.c" }, }, - maintainers = {'@pwntester'}, + maintainers = { "@pwntester" }, } list.verilog = { @@ -482,9 +485,9 @@ list.verilog = { list.regex = { install_info = { url = "https://github.com/tree-sitter/tree-sitter-regex", - files = { "src/parser.c" } + files = { "src/parser.c" }, }, - maintainers = {"@theHamsta"}, + maintainers = { "@theHamsta" }, } list.comment = { @@ -492,7 +495,7 @@ list.comment = { url = "https://github.com/stsewd/tree-sitter-comment", files = { "src/parser.c", "src/scanner.c" }, }, - maintainers = {"@stsewd"}, + maintainers = { "@stsewd" }, } list.jsdoc = { @@ -500,16 +503,16 @@ list.jsdoc = { url = "https://github.com/tree-sitter/tree-sitter-jsdoc", files = { "src/parser.c" }, }, - maintainers = {"@steelsojka"}, + maintainers = { "@steelsojka" }, } list.query = { install_info = { url = "https://github.com/nvim-treesitter/tree-sitter-query", - files = { "src/parser.c" } + files = { "src/parser.c" }, }, readme_name = "Tree-sitter query language", - maintainers = {"@steelsojka"}, + maintainers = { "@steelsojka" }, } list.sparql = { @@ -525,10 +528,10 @@ list.gdscript = { install_info = { url = "https://github.com/PrestonKnopp/tree-sitter-gdscript", files = { "src/parser.c", "src/scanner.cc" }, - requires_generate_from_grammar = true, + requires_generate_from_grammar = true, }, readme_name = "Godot (gdscript)", - maintainers = {"@Shatur95"}, + maintainers = { "@Shatur95" }, } list.turtle = { @@ -545,9 +548,9 @@ list.devicetree = { url = "https://github.com/joelspadin/tree-sitter-devicetree", files = { "src/parser.c" }, branch = "main", - requires_generate_from_grammar = true, + requires_generate_from_grammar = true, }, - filetype = 'dts', + filetype = "dts", maintainers = { "@jedrzejboczar" }, } @@ -563,7 +566,7 @@ list.svelte = { list.r = { install_info = { url = "https://github.com/r-lib/tree-sitter-r", - files = { "src/parser.c" } + files = { "src/parser.c" }, }, maintainers = { "@jimhester" }, } @@ -582,8 +585,8 @@ list.latex = { url = "https://github.com/latex-lsp/tree-sitter-latex", files = { "src/parser.c" }, }, - filetype = 'tex', - used_by = {'cls', 'sty'}, + filetype = "tex", + used_by = { "cls", "sty" }, maintainers = { "@theHamsta by asking @clason" }, } @@ -592,36 +595,36 @@ list.bibtex = { url = "https://github.com/latex-lsp/tree-sitter-bibtex", files = { "src/parser.c" }, }, - filetype = 'bib', + filetype = "bib", maintainers = { "@theHamsta by asking @clason" }, } list.zig = { install_info = { url = "https://github.com/Himujjal/tree-sitter-zig", - files = { "src/parser.c" } + files = { "src/parser.c" }, }, filetype = "zig", - maintainers = { "@Himujjal" } + maintainers = { "@Himujjal" }, } list.fortran = { install_info = { url = "https://github.com/stadelmanma/tree-sitter-fortran", - files = { "src/parser.c", "src/scanner.cc", }, + files = { "src/parser.c", "src/scanner.cc" }, }, } list.cmake = { install_info = { url = "https://github.com/uyha/tree-sitter-cmake", - files = { "src/parser.c", "src/scanner.cc"}, + files = { "src/parser.c", "src/scanner.cc" }, }, maintainers = { "@uyha" }, } local M = { - list = list + list = list, } function M.ft_to_lang(ft) @@ -629,20 +632,23 @@ function M.ft_to_lang(ft) end function M.available_parsers() - if vim.fn.executable('tree-sitter') == 1 and vim.fn.executable('node') == 1 then + if vim.fn.executable "tree-sitter" == 1 and vim.fn.executable "node" == 1 then return vim.tbl_keys(M.list) else - return vim.tbl_filter(function(p) return not M.list[p].install_info.requires_generate_from_grammar end, - vim.tbl_keys(M.list)) + return vim.tbl_filter(function(p) + return not M.list[p].install_info.requires_generate_from_grammar + end, vim.tbl_keys( + M.list + )) end end function M.maintained_parsers() - local has_tree_sitter_cli = vim.fn.executable('tree-sitter') == 1 and vim.fn.executable('node') == 1 + local has_tree_sitter_cli = vim.fn.executable "tree-sitter" == 1 and vim.fn.executable "node" == 1 return vim.tbl_filter(function(lang) return M.list[lang].maintainers - and (has_tree_sitter_cli or not M.list[lang].install_info.requires_generate_from_grammar) end, - M.available_parsers()) + and (has_tree_sitter_cli or not M.list[lang].install_info.requires_generate_from_grammar) + end, M.available_parsers()) end function M.get_parser_configs() @@ -654,9 +660,9 @@ local parser_files function M.reset_cache() parser_files = setmetatable({}, { __index = function(tbl, key) - rawset(tbl, key, api.nvim_get_runtime_file('parser/' .. key .. '.*', false)) + rawset(tbl, key, api.nvim_get_runtime_file("parser/" .. key .. ".*", false)) return rawget(tbl, key) - end + end, }) end @@ -665,9 +671,13 @@ M.reset_cache() function M.has_parser(lang) local lang = lang or M.get_buf_lang(api.nvim_get_current_buf()) - if not lang or #lang == 0 then return false end + if not lang or #lang == 0 then + return false + end -- HACK: nvim internal API - if vim._ts_has_language(lang) then return true end + if vim._ts_has_language(lang) then + return true + end return #parser_files[lang] > 0 end diff --git a/lua/nvim-treesitter/query.lua b/lua/nvim-treesitter/query.lua index 44a6bccbd..1d8099ec9 100644 --- a/lua/nvim-treesitter/query.lua +++ b/lua/nvim-treesitter/query.lua @@ -1,15 +1,15 @@ local api = vim.api -local tsq = require'vim.treesitter.query' -local tsrange = require'nvim-treesitter.tsrange' -local utils = require'nvim-treesitter.utils' -local parsers = require'nvim-treesitter.parsers' -local caching = require'nvim-treesitter.caching' +local tsq = require "vim.treesitter.query" +local tsrange = require "nvim-treesitter.tsrange" +local utils = require "nvim-treesitter.utils" +local parsers = require "nvim-treesitter.parsers" +local caching = require "nvim-treesitter.caching" local M = {} local EMPTY_ITER = function() end -M.built_in_query_groups = {'highlights', 'locals', 'folds', 'indents', 'injections'} +M.built_in_query_groups = { "highlights", "locals", "folds", "indents", "injections" } -- Creates a function that checks whether a given query exists -- for a specific language. @@ -24,10 +24,10 @@ for _, query in ipairs(M.built_in_query_groups) do end function M.available_query_groups() - local query_files = api.nvim_get_runtime_file('queries/*/*.scm', true) + local query_files = api.nvim_get_runtime_file("queries/*/*.scm", true) local groups = {} for _, f in ipairs(query_files) do - groups[vim.fn.fnamemodify(f, ':t:r')] = true + groups[vim.fn.fnamemodify(f, ":t:r")] = true end local list = {} for k, _ in pairs(groups) do @@ -42,7 +42,7 @@ do local function update_cached_matches(bufnr, changed_tick, query_group) query_cache.set(query_group, bufnr, { tick = changed_tick, - cache= M.collect_group_results(bufnr, query_group) or {} + cache = M.collect_group_results(bufnr, query_group) or {}, }) end @@ -50,7 +50,7 @@ do bufnr = bufnr or api.nvim_get_current_buf() local cached_local = query_cache.get(query_group, bufnr) if not cached_local or api.nvim_buf_get_changedtick(bufnr) > cached_local.tick then - update_cached_matches(bufnr,api.nvim_buf_get_changedtick(bufnr), query_group) + update_cached_matches(bufnr, api.nvim_buf_get_changedtick(bufnr), query_group) end return query_cache.get(query_group, bufnr).cache @@ -58,7 +58,7 @@ do end local function runtime_queries(lang, query_name) - return api.nvim_get_runtime_file(string.format('queries/%s/%s.scm', lang, query_name), true) or {} + return api.nvim_get_runtime_file(string.format("queries/%s/%s.scm", lang, query_name), true) or {} end local query_files_cache = {} @@ -66,11 +66,11 @@ function M.has_query_files(lang, query_name) if not query_files_cache[lang] then query_files_cache[lang] = {} end - if query_files_cache[lang][query_name] == nil then - local files = runtime_queries(lang, query_name) - query_files_cache[lang][query_name] = files and #files > 0 - end - return query_files_cache[lang][query_name] + if query_files_cache[lang][query_name] == nil then + local files = runtime_queries(lang, query_name) + query_files_cache[lang][query_name] = files and #files > 0 + end + return query_files_cache[lang][query_name] end do @@ -117,7 +117,7 @@ do end end else - error("Cannot have query_name by itself!") + error "Cannot have query_name by itself!" end end end @@ -125,7 +125,7 @@ end --- This function is meant for an autocommand and not to be used. Only use if file is a query file. function M.invalidate_query_file(fname) local fnamemodify = vim.fn.fnamemodify - M.invalidate_query_cache(fnamemodify(fname, ':p:h:t'), fnamemodify(fname, ':t:r')) + M.invalidate_query_cache(fnamemodify(fname, ":p:h:t"), fnamemodify(fname, ":t:r")) end function M.iter_prepared_matches(query, qnode, bufnr, start_row, end_row) @@ -142,7 +142,7 @@ function M.iter_prepared_matches(query, qnode, bufnr, start_row, end_row) local function insert_to_path(object, path, value) local curr_obj = object - for index=1,(#path -1) do + for index = 1, (#path - 1) do if curr_obj[path[index]] == nil then curr_obj[path[index]] = {} end @@ -164,7 +164,7 @@ function M.iter_prepared_matches(query, qnode, bufnr, start_row, end_row) for id, node in pairs(match) do local name = query.captures[id] -- name of the capture in the query if name ~= nil then - local path = split(name..'.node') + local path = split(name .. ".node") insert_to_path(prepared_match, path, node) end end @@ -178,8 +178,11 @@ function M.iter_prepared_matches(query, qnode, bufnr, start_row, end_row) insert_to_path(prepared_match, split(pred[2]), pred[3]) end if pred[1] == "make-range!" and type(pred[2]) == "string" and #pred == 4 then - insert_to_path(prepared_match, split(pred[2]..'.node'), - tsrange.TSRange.from_nodes(bufnr, match[pred[3]], match[pred[4]])) + insert_to_path( + prepared_match, + split(pred[2] .. ".node"), + tsrange.TSRange.from_nodes(bufnr, match[pred[3]], match[pred[4]]) + ) end end end @@ -194,8 +197,8 @@ end -- Works like M.get_references or M.get_scopes except you can choose the capture -- Can also be a nested capture like @definition.function to get all nodes defining a function function M.get_capture_matches(bufnr, capture_string, query_group, root, lang) - if not string.sub(capture_string, 1, 1) == '@' then - print('capture_string must start with "@"') + if not string.sub(capture_string, 1, 1) == "@" then + print 'capture_string must start with "@"' return end @@ -214,7 +217,7 @@ function M.get_capture_matches(bufnr, capture_string, query_group, root, lang) end function M.find_best_match(bufnr, capture_string, query_group, filter_predicate, scoring_function, root) - if string.sub(capture_string, 1, 1) == '@' then + if string.sub(capture_string, 1, 1) == "@" then --remove leading "@" capture_string = string.sub(capture_string, 2) end @@ -248,10 +251,14 @@ end function M.iter_group_results(bufnr, query_group, root, root_lang) local buf_lang = parsers.get_buf_lang(bufnr) - if not buf_lang then return EMPTY_ITER end + if not buf_lang then + return EMPTY_ITER + end local parser = parsers.get_parser(bufnr, buf_lang) - if not parser then return EMPTY_ITER end + if not parser then + return EMPTY_ITER + end if not root then local first_tree = parser:trees()[1] @@ -261,9 +268,11 @@ function M.iter_group_results(bufnr, query_group, root, root_lang) end end - if not root then return EMPTY_ITER end + if not root then + return EMPTY_ITER + end - local range = {root:range()} + local range = { root:range() } if not root_lang then local lang_tree = parser:language_for_range(range) @@ -273,10 +282,14 @@ function M.iter_group_results(bufnr, query_group, root, root_lang) end end - if not root_lang then return EMPTY_ITER end + if not root_lang then + return EMPTY_ITER + end local query = M.get_query(root_lang, query_group) - if not query then return EMPTY_ITER end + if not query then + return EMPTY_ITER + end -- The end row is exclusive so we need to add 1 to it. return M.iter_prepared_matches(query, root, bufnr, range[1], range[3] + 1) @@ -300,8 +313,7 @@ end -- @param query_type The query to get the capture from. This is ignore if a function is provided -- for the captuer argument. function M.get_capture_matches_recursively(bufnr, capture_or_fn, query_type) - local type_fn = type(capture_or_fn) == 'function' - and capture_or_fn + local type_fn = type(capture_or_fn) == "function" and capture_or_fn or function() return capture_or_fn, query_type end diff --git a/lua/nvim-treesitter/query_predicates.lua b/lua/nvim-treesitter/query_predicates.lua index 1748250e5..11df59161 100644 --- a/lua/nvim-treesitter/query_predicates.lua +++ b/lua/nvim-treesitter/query_predicates.lua @@ -1,4 +1,4 @@ -local query = require"vim.treesitter.query" +local query = require "vim.treesitter.query" local function error(str) vim.api.nvim_err_writeln(str) @@ -21,7 +21,9 @@ local function valid_args(name, pred, count, strict_count) end query.add_predicate("nth?", function(match, pattern, bufnr, pred) - if not valid_args("nth?", pred, 2, true) then return end + if not valid_args("nth?", pred, 2, true) then + return + end local node = match[pred[2]] local n = pred[3] @@ -33,13 +35,17 @@ query.add_predicate("nth?", function(match, pattern, bufnr, pred) end) local function has_ancestor(match, pattern, bufnr, pred) - if not valid_args(pred[1], pred, 2) then return end + if not valid_args(pred[1], pred, 2) then + return + end local node = match[pred[2]] - local ancestor_types = {unpack(pred, 3)} - if not node then return true end + local ancestor_types = { unpack(pred, 3) } + if not node then + return true + end - local just_direct_parent = pred[1]:find('has-parent', 1, true) + local just_direct_parent = pred[1]:find("has-parent", 1, true) node = node:parent() while node do @@ -55,40 +61,48 @@ local function has_ancestor(match, pattern, bufnr, pred) return false end -query.add_predicate('has-ancestor?', has_ancestor) +query.add_predicate("has-ancestor?", has_ancestor) -query.add_predicate('has-parent?', has_ancestor) +query.add_predicate("has-parent?", has_ancestor) -query.add_predicate('is?', function(match, pattern, bufnr, pred) - if not valid_args("is?", pred, 2) then return end +query.add_predicate("is?", function(match, pattern, bufnr, pred) + if not valid_args("is?", pred, 2) then + return + end -- Avoid circular dependencies - local locals = require"nvim-treesitter.locals" + local locals = require "nvim-treesitter.locals" local node = match[pred[2]] - local types = {unpack(pred, 3)} + local types = { unpack(pred, 3) } - if not node then return true end + if not node then + return true + end local _, _, kind = locals.find_definition(node, bufnr) return vim.tbl_contains(types, kind) end) -query.add_predicate('has-type?', function(match, pattern, bufnr, pred) - if not valid_args(pred[1], pred, 2) then return end +query.add_predicate("has-type?", function(match, pattern, bufnr, pred) + if not valid_args(pred[1], pred, 2) then + return + end local node = match[pred[2]] - local types = {unpack(pred, 3)} + local types = { unpack(pred, 3) } - if not node then return true end + if not node then + return true + end return vim.tbl_contains(types, node:type()) end) -- Just avoid some anoying warnings for this directive -query.add_directive('make-range!', function() end) +query.add_directive("make-range!", function() end) -query.add_directive('downcase!', function(match, _, bufnr, pred, metadata) +query.add_directive("downcase!", function(match, _, bufnr, pred, metadata) local text, key, value if #pred == 3 then diff --git a/lua/nvim-treesitter/shell_command_selectors.lua b/lua/nvim-treesitter/shell_command_selectors.lua index c9f774df0..4a51ca9eb 100644 --- a/lua/nvim-treesitter/shell_command_selectors.lua +++ b/lua/nvim-treesitter/shell_command_selectors.lua @@ -1,116 +1,118 @@ local fn = vim.fn -local utils = require'nvim-treesitter.utils' +local utils = require "nvim-treesitter.utils" local M = {} function M.select_mkdir_cmd(directory, cwd, info_msg) - if fn.has('win32') == 1 then + if fn.has "win32" == 1 then return { - cmd = 'cmd', + cmd = "cmd", opts = { - args = { '/C', 'mkdir', directory}, + args = { "/C", "mkdir", directory }, cwd = cwd, }, info = info_msg, - err = "Could not create "..directory, + err = "Could not create " .. directory, } else return { - cmd = 'mkdir', + cmd = "mkdir", opts = { args = { directory }, cwd = cwd, }, info = info_msg, - err = "Could not create "..directory, + err = "Could not create " .. directory, } end end function M.select_rm_file_cmd(file, info_msg) - if fn.has('win32') == 1 then + if fn.has "win32" == 1 then return { - cmd = 'cmd', + cmd = "cmd", opts = { - args = { '/C', 'if', 'exist', file, 'del', file }, + args = { "/C", "if", "exist", file, "del", file }, }, info = info_msg, - err = "Could not delete "..file, + err = "Could not delete " .. file, } else return { - cmd = 'rm', + cmd = "rm", opts = { args = { file }, }, info = info_msg, - err = "Could not delete "..file, + err = "Could not delete " .. file, } end end function M.select_executable(executables) - return vim.tbl_filter(function(c) return c ~= vim.NIL and fn.executable(c) == 1 end, executables)[1] + return vim.tbl_filter(function(c) + return c ~= vim.NIL and fn.executable(c) == 1 + end, executables)[1] end function M.select_compiler_args(repo, compiler) - if (string.match(compiler, 'cl$') or string.match(compiler, 'cl.exe$')) then + if string.match(compiler, "cl$") or string.match(compiler, "cl.exe$") then return { - '/Fe:', - 'parser.so', - '/Isrc', + "/Fe:", + "parser.so", + "/Isrc", repo.files, - '-Os', - '/LD', + "-Os", + "/LD", } else local args = { - '-o', - 'parser.so', - '-I./src', + "-o", + "parser.so", + "-I./src", repo.files, - '-shared', - '-Os', - '-lstdc++', + "-shared", + "-Os", + "-lstdc++", } - if fn.has('win32') == 0 then - table.insert(args, '-fPIC') + if fn.has "win32" == 0 then + table.insert(args, "-fPIC") end return args end end function M.select_install_rm_cmd(cache_folder, project_name) - if fn.has('win32') == 1 then - local dir = cache_folder ..'\\'.. project_name + if fn.has "win32" == 1 then + local dir = cache_folder .. "\\" .. project_name return { - cmd = 'cmd', + cmd = "cmd", opts = { - args = { '/C', 'if', 'exist', dir, 'rmdir', '/s', '/q', dir }, - } + args = { "/C", "if", "exist", dir, "rmdir", "/s", "/q", dir }, + }, } else return { - cmd = 'rm', + cmd = "rm", opts = { - args = { '-rf', cache_folder..'/'..project_name }, - } + args = { "-rf", cache_folder .. "/" .. project_name }, + }, } end end function M.select_mv_cmd(from, to, cwd) - if fn.has('win32') == 1 then + if fn.has "win32" == 1 then return { - cmd = 'cmd', + cmd = "cmd", opts = { - args = { '/C', 'move', '/Y', from, to }, + args = { "/C", "move", "/Y", from, to }, cwd = cwd, - } + }, } else return { - cmd = 'mv', + cmd = "mv", opts = { args = { from, to }, cwd = cwd, @@ -120,93 +122,94 @@ function M.select_mv_cmd(from, to, cwd) end function M.select_download_commands(repo, project_name, cache_folder, revision) - - local can_use_tar = vim.fn.executable('tar') == 1 and vim.fn.executable('curl') == 1 + local can_use_tar = vim.fn.executable "tar" == 1 and vim.fn.executable "curl" == 1 local is_github = repo.url:find("github.com", 1, true) local is_gitlab = repo.url:find("gitlab.com", 1, true) - local is_windows = fn.has('win32') == 1 + local is_windows = fn.has "win32" == 1 revision = revision or repo.branch or "master" if can_use_tar and (is_github or is_gitlab) and not is_windows then - local path_sep = utils.get_path_sep() - local url = repo.url:gsub('.git$', '') + local url = repo.url:gsub(".git$", "") return { - M.select_install_rm_cmd(cache_folder, project_name..'-tmp'), + M.select_install_rm_cmd(cache_folder, project_name .. "-tmp"), { - cmd = 'curl', - info = 'Downloading...', - err = 'Error during download, please verify your internet connection', + cmd = "curl", + info = "Downloading...", + err = "Error during download, please verify your internet connection", opts = { args = { - '-L', -- follow redirects - is_github and url.."/archive/"..revision..".tar.gz" - or url.."/-/archive/"..revision.."/"..project_name.."-"..revision..".tar.gz", - '--output', - project_name..".tar.gz" + "-L", -- follow redirects + is_github and url .. "/archive/" .. revision .. ".tar.gz" + or url .. "/-/archive/" .. revision .. "/" .. project_name .. "-" .. revision .. ".tar.gz", + "--output", + project_name .. ".tar.gz", }, cwd = cache_folder, }, }, - M.select_mkdir_cmd(project_name..'-tmp', cache_folder, 'Creating temporary directory'), + M.select_mkdir_cmd(project_name .. "-tmp", cache_folder, "Creating temporary directory"), { - cmd = 'tar', - info = 'Extracting...', - err = 'Error during tarball extraction.', + cmd = "tar", + info = "Extracting...", + err = "Error during tarball extraction.", opts = { args = { - '-xvf', - project_name..".tar.gz", - '-C', - project_name..'-tmp', + "-xvf", + project_name .. ".tar.gz", + "-C", + project_name .. "-tmp", }, cwd = cache_folder, }, }, - M.select_rm_file_cmd(cache_folder..path_sep..project_name..".tar.gz"), - M.select_mv_cmd(utils.join_path(project_name..'-tmp', url:match('[^/]-$')..'-'..revision), + M.select_rm_file_cmd(cache_folder .. path_sep .. project_name .. ".tar.gz"), + M.select_mv_cmd( + utils.join_path(project_name .. "-tmp", url:match "[^/]-$" .. "-" .. revision), project_name, - cache_folder), - M.select_install_rm_cmd(cache_folder, project_name..'-tmp') + cache_folder + ), + M.select_install_rm_cmd(cache_folder, project_name .. "-tmp"), } else local git_folder = utils.join_path(cache_folder, project_name) - local clone_error = 'Error during download, please verify your internet connection' + local clone_error = "Error during download, please verify your internet connection" return { { - cmd = 'git', - info = 'Downloading...', + cmd = "git", + info = "Downloading...", err = clone_error, opts = { args = { - 'clone', + "clone", repo.url, - project_name + project_name, }, cwd = cache_folder, }, }, { - cmd = 'git', - info = 'Checking out locked revision', - err = 'Error while checking out revision', + cmd = "git", + info = "Checking out locked revision", + err = "Error while checking out revision", opts = { args = { - 'checkout', revision, + "checkout", + revision, }, - cwd = git_folder - } - } + cwd = git_folder, + }, + }, } end end function M.make_directory_change_for_command(dir, command) - if fn.has('win32') == 1 then + if fn.has "win32" == 1 then return string.format("pushd %s & %s & popd", dir, command) else return string.format("cd %s;\n %s", dir, command) diff --git a/lua/nvim-treesitter/ts_utils.lua b/lua/nvim-treesitter/ts_utils.lua index 1f7f20933..72a74edcc 100644 --- a/lua/nvim-treesitter/ts_utils.lua +++ b/lua/nvim-treesitter/ts_utils.lua @@ -1,7 +1,7 @@ local api = vim.api -local parsers = require'nvim-treesitter.parsers' -local utils = require'nvim-treesitter.utils' +local parsers = require "nvim-treesitter.parsers" +local utils = require "nvim-treesitter.utils" local M = {} @@ -11,20 +11,22 @@ local M = {} -- @return list of lines of text of the node function M.get_node_text(node, bufnr) local bufnr = bufnr or api.nvim_get_current_buf() - if not node then return {} end + if not node then + return {} + end -- We have to remember that end_col is end-exclusive local start_row, start_col, end_row, end_col = M.get_node_range(node) if start_row ~= end_row then - local lines = api.nvim_buf_get_lines(bufnr, start_row, end_row+1, false) - lines[1] = string.sub(lines[1], start_col+1) + local lines = api.nvim_buf_get_lines(bufnr, start_row, end_row + 1, false) + lines[1] = string.sub(lines[1], start_col + 1) lines[#lines] = string.sub(lines[#lines], 1, end_col) return lines else - local line = api.nvim_buf_get_lines(bufnr, start_row, start_row+1, false)[1] + local line = api.nvim_buf_get_lines(bufnr, start_row, start_row + 1, false)[1] -- If line is nil then the line is empty - return line and { string.sub(line, start_col+1, end_col) } or {} + return line and { string.sub(line, start_col + 1, end_col) } or {} end end @@ -32,7 +34,9 @@ end -- @param dest the possible parent -- @param source the possible child node function M.is_parent(dest, source) - if not (dest and source) then return false end + if not (dest and source) then + return false + end local current = source while current ~= nil do @@ -54,9 +58,11 @@ function M.get_next_node(node, allow_switch_parents, allow_next_parent) local destination_node local parent = node:parent() - if not parent then return end + if not parent then + return + end local found_pos = 0 - for i = 0,parent:named_child_count()-1,1 do + for i = 0, parent:named_child_count() - 1, 1 do if parent:named_child(i) == node then found_pos = i break @@ -83,10 +89,12 @@ end function M.get_previous_node(node, allow_switch_parents, allow_previous_parent) local destination_node local parent = node:parent() - if not parent then return end + if not parent then + return + end local found_pos = 0 - for i = 0,parent:named_child_count()-1,1 do + for i = 0, parent:named_child_count() - 1, 1 do if parent:named_child(i) == node then found_pos = i break @@ -107,8 +115,8 @@ end function M.get_named_children(node) local nodes = {} - for i=0,node:named_child_count() - 1,1 do - nodes[i+1] = node:named_child(i) + for i = 0, node:named_child_count() - 1, 1 do + nodes[i + 1] = node:named_child(i) end return nodes end @@ -118,19 +126,23 @@ function M.get_node_at_cursor(winnr) local cursor_range = { cursor[1] - 1, cursor[2] } local root = M.get_root_for_position(unpack(cursor_range)) - if not root then return end + if not root then + return + end return root:named_descendant_for_range(cursor_range[1], cursor_range[2], cursor_range[1], cursor_range[2]) end function M.get_root_for_position(line, col, root_lang_tree) if not root_lang_tree then - if not parsers.has_parser() then return end + if not parsers.has_parser() then + return + end root_lang_tree = parsers.get_parser() end - local lang_tree = root_lang_tree:language_for_range({ line, col, line, col }) + local lang_tree = root_lang_tree:language_for_range { line, col, line, col } for _, tree in ipairs(lang_tree:trees()) do local root = tree:root() @@ -157,13 +169,15 @@ function M.get_root_for_node(node) end function M.highlight_node(node, buf, hl_namespace, hl_group) - if not node then return end - M.highlight_range({node:range()}, buf, hl_namespace, hl_group) + if not node then + return + end + M.highlight_range({ node:range() }, buf, hl_namespace, hl_group) end function M.highlight_range(range, buf, hl_namespace, hl_group) local start_row, start_col, end_row, end_col = unpack(range) - vim.highlight.range(buf, hl_namespace, hl_group, {start_row, start_col}, {end_row, end_col}) + vim.highlight.range(buf, hl_namespace, hl_group, { start_row, start_col }, { end_row, end_col }) end -- Set visual selection to node @@ -173,8 +187,8 @@ function M.update_selection(buf, node, selection_mode) selection_mode = selection_mode or "charwise" local start_row, start_col, end_row, end_col = M.get_node_range(node) - if end_row == vim.fn.line('$') then - end_col = #vim.fn.getline('$') + if end_row == vim.fn.line "$" then + end_col = #vim.fn.getline "$" end -- Convert to 1-based indices @@ -186,12 +200,10 @@ function M.update_selection(buf, node, selection_mode) vim.fn.setpos(".", { buf, start_row, start_col, 0 }) -- Start visual selection in appropriate mode - local v_table = {charwise = "v", linewise = "V", blockwise = "<C-v>"} + local v_table = { charwise = "v", linewise = "V", blockwise = "<C-v>" } ---- Call to `nvim_replace_termcodes()` is needed for sending appropriate ---- command to enter blockwise mode - local mode_string = vim.api.nvim_replace_termcodes( - v_table[selection_mode] or selection_mode, true, true, true - ) + local mode_string = vim.api.nvim_replace_termcodes(v_table[selection_mode] or selection_mode, true, true, true) vim.cmd("normal! " .. mode_string) -- Convert exclusive end position to inclusive @@ -231,7 +243,7 @@ function M.is_in_node_range(node, line, col) end function M.get_node_range(node_or_range) - if type(node_or_range) == 'table' then + if type(node_or_range) == "table" then return unpack(node_or_range) else return node_or_range:range() @@ -242,7 +254,7 @@ function M.node_to_lsp_range(node) local start_line, start_col, end_line, end_col = M.get_node_range(node) local rtn = {} rtn.start = { line = start_line, character = start_col } - rtn['end'] = { line = end_line, character = end_col } + rtn["end"] = { line = end_line, character = end_col } return rtn end @@ -277,13 +289,13 @@ function M.memoize_by_buf_tick(fn, options) -- Clean up logic only! api.nvim_buf_attach(bufnr, false, { on_detach = detach_handler, - on_reload = detach_handler + on_reload = detach_handler, }) end cache[key] = { result = fn(...), - last_tick = tick + last_tick = tick, } return cache[key].result @@ -291,24 +303,28 @@ function M.memoize_by_buf_tick(fn, options) end function M.swap_nodes(node_or_range1, node_or_range2, bufnr, cursor_to_second) - if not node_or_range1 or not node_or_range2 then return end + if not node_or_range1 or not node_or_range2 then + return + end local range1 = M.node_to_lsp_range(node_or_range1) local range2 = M.node_to_lsp_range(node_or_range2) local text1 = M.get_node_text(node_or_range1) local text2 = M.get_node_text(node_or_range2) - local edit1 = { range = range1, newText = table.concat(text2, '\n') } - local edit2 = { range = range2, newText = table.concat(text1, '\n') } - vim.lsp.util.apply_text_edits({edit1, edit2}, bufnr) + local edit1 = { range = range1, newText = table.concat(text2, "\n") } + local edit2 = { range = range2, newText = table.concat(text1, "\n") } + vim.lsp.util.apply_text_edits({ edit1, edit2 }, bufnr) if cursor_to_second then utils.set_jump() local char_delta = 0 local line_delta = 0 - if range1["end"].line < range2.start.line - or (range1["end"].line == range2.start.line and range1["end"].character < range2.start.character) then + if + range1["end"].line < range2.start.line + or (range1["end"].line == range2.start.line and range1["end"].character < range2.start.character) + then line_delta = #text2 - #text1 end @@ -320,29 +336,32 @@ function M.swap_nodes(node_or_range1, node_or_range2, bufnr, cursor_to_second) --space_between_ranges = range2.start.character - range1["end"].character --char_delta = correction_after_line_change + text_now_before_range2 + space_between_ranges --- Equivalent to: - char_delta = #(text2[#text2]) - range1["end"].character + char_delta = #text2[#text2] - range1["end"].character -- add range1.start.character if last line of range1 (now text2) does not start at 0 if range1.start.line == range2.start.line + line_delta then char_delta = char_delta + range1.start.character end else - char_delta = #(text2[#text2]) - #(text1[#text1]) + char_delta = #text2[#text2] - #text1[#text1] end end - api.nvim_win_set_cursor(api.nvim_get_current_win(), - {range2.start.line + 1 + line_delta, - range2.start.character + char_delta}) + api.nvim_win_set_cursor( + api.nvim_get_current_win(), + { range2.start.line + 1 + line_delta, range2.start.character + char_delta } + ) end end function M.goto_node(node, goto_end, avoid_set_jump) - if not node then return end + if not node then + return + end if not avoid_set_jump then utils.set_jump() end - local range = {node:range()} + local range = { node:range() } local position if not goto_end then position = { range[1], range[2] } diff --git a/lua/nvim-treesitter/tsrange.lua b/lua/nvim-treesitter/tsrange.lua index f9de5f3d2..767cab779 100644 --- a/lua/nvim-treesitter/tsrange.lua +++ b/lua/nvim-treesitter/tsrange.lua @@ -3,75 +3,72 @@ local TSRange = {} TSRange.__index = TSRange local api = vim.api -local ts_utils = require'nvim-treesitter.ts_utils' +local ts_utils = require "nvim-treesitter.ts_utils" local function get_byte_offset(buf, row, col) - return api.nvim_buf_get_offset(buf, row) - + vim.fn.byteidx(api.nvim_buf_get_lines(buf, row, row + 1, false), col) + return api.nvim_buf_get_offset(buf, row) + vim.fn.byteidx(api.nvim_buf_get_lines(buf, row, row + 1, false), col) end function TSRange.new(buf, start_row, start_col, end_row, end_col) - return setmetatable( - { - start_pos = {start_row, start_col, get_byte_offset(buf, start_row, start_col)}, - end_pos = {end_row, end_col, get_byte_offset(buf, end_row, end_col)}, - buf = buf, - [1] = start_row, - [2] = start_col, - [3] = end_row, - [4] = end_col, - }, - TSRange) + return setmetatable({ + start_pos = { start_row, start_col, get_byte_offset(buf, start_row, start_col) }, + end_pos = { end_row, end_col, get_byte_offset(buf, end_row, end_col) }, + buf = buf, + [1] = start_row, + [2] = start_col, + [3] = end_row, + [4] = end_col, + }, TSRange) end function TSRange.from_nodes(buf, start_node, end_node) TSRange.__index = TSRange - local start_pos = start_node and {start_node:start()} or {end_node:start()} - local end_pos = end_node and {end_node:end_()} or {start_node:end_()} - return setmetatable( - { - start_pos = {start_pos[1], start_pos[2], start_pos[3]}, - end_pos = {end_pos[1], end_pos[2], end_pos[3]}, - buf = buf, - [1] = start_pos[1], - [2] = start_pos[2], - [3] = end_pos[1], - [4] = end_pos[2], - }, - TSRange) + local start_pos = start_node and { start_node:start() } or { end_node:start() } + local end_pos = end_node and { end_node:end_() } or { start_node:end_() } + return setmetatable({ + start_pos = { start_pos[1], start_pos[2], start_pos[3] }, + end_pos = { end_pos[1], end_pos[2], end_pos[3] }, + buf = buf, + [1] = start_pos[1], + [2] = start_pos[2], + [3] = end_pos[1], + [4] = end_pos[2], + }, TSRange) end function TSRange.from_table(buf, range) - return setmetatable( - { - start_pos = {range[1], range[2], get_byte_offset(buf, range[1], range[2])}, - end_pos = {range[3], range[4], get_byte_offset(buf, range[3], range[4])}, - buf = buf, - [1] = range[1], - [2] = range[2], - [3] = range[3], - [4] = range[4], - }, - TSRange) + return setmetatable({ + start_pos = { range[1], range[2], get_byte_offset(buf, range[1], range[2]) }, + end_pos = { range[3], range[4], get_byte_offset(buf, range[3], range[4]) }, + buf = buf, + [1] = range[1], + [2] = range[2], + [3] = range[3], + [4] = range[4], + }, TSRange) end function TSRange:parent() local root = ts_utils.get_root_for_position(self[1], self[2]) - return root - and root:named_descendant_for_range(self.start_pos[1], self.start_pos[2], self.end_pos[1], self.end_pos[2]) - or nil + return root and root:named_descendant_for_range( + self.start_pos[1], + self.start_pos[2], + self.end_pos[1], + self.end_pos[2] + ) or nil end -function TSRange:field() -end +function TSRange:field() end function TSRange:child_count() return #self:collect_children() end function TSRange:named_child_count() - return #self:collect_children(function(c) return c:named() end) + return #self:collect_children(function(c) + return c:named() + end) end function TSRange:iter_children() @@ -79,7 +76,9 @@ function TSRange:iter_children() return function() while true do local node = raw_iterator() - if not node then return end + if not node then + return + end local _, _, start_byte = node:start() local _, _, end_byte = node:end_() if start_byte >= self.start_pos[3] and end_byte <= self.end_pos[3] then @@ -104,7 +103,9 @@ function TSRange:child(index) end function TSRange:named_child(index) - return self:collect_children(function(c) return c.named() end)[index + 1] + return self:collect_children(function(c) + return c.named() + end)[index + 1] end function TSRange:start() @@ -120,7 +121,7 @@ function TSRange:range() end function TSRange:type() - return 'nvim-treesitter-range' + return "nvim-treesitter-range" end function TSRange:symbol() @@ -136,11 +137,18 @@ function TSRange:missing() end function TSRange:has_error() - return #self:collect_children(function(c) return c:has_error() end) > 0 and true or false + return #self:collect_children(function(c) + return c:has_error() + end) > 0 and true or false end function TSRange:sexpr() - return table.concat(vim.tbl_map(function(c) return c:sexpr() end, self:collect_children()), ' ') + return table.concat( + vim.tbl_map(function(c) + return c:sexpr() + end, self:collect_children()), + " " + ) end M.TSRange = TSRange diff --git a/lua/nvim-treesitter/utils.lua b/lua/nvim-treesitter/utils.lua index 947bd56fc..dcd1e135d 100644 --- a/lua/nvim-treesitter/utils.lua +++ b/lua/nvim-treesitter/utils.lua @@ -6,20 +6,23 @@ local M = {} function M.setup_commands(mod, commands) for command_name, def in pairs(commands) do - local call_fn = string.format("lua require'nvim-treesitter.%s'.commands.%s['run<bang>'](<f-args>)", - mod, command_name) - local parts = vim.tbl_flatten({ + local call_fn = string.format( + "lua require'nvim-treesitter.%s'.commands.%s['run<bang>'](<f-args>)", + mod, + command_name + ) + local parts = vim.tbl_flatten { "command!", def.args, command_name, call_fn, - }) + } api.nvim_command(table.concat(parts, " ")) end end function M.get_path_sep() - return fn.has('win32') == 1 and '\\' or '/' + return fn.has "win32" == 1 and "\\" or "/" end -- Returns a function that joins the given arguments with separator. Arguments @@ -29,40 +32,40 @@ print(M.generate_join(" ")("foo", "bar")) --]] -- prints "foo bar" function M.generate_join(separator) - return function (...) - return table.concat({...}, separator) + return function(...) + return table.concat({ ... }, separator) end end M.join_path = M.generate_join(M.get_path_sep()) -local join_space = M.generate_join(" ") +local join_space = M.generate_join " " function M.get_package_path() -- Path to this source file, removing the leading '@' - local source = string.sub(debug.getinfo(1, 'S').source, 2) + local source = string.sub(debug.getinfo(1, "S").source, 2) -- Path to the package root return fn.fnamemodify(source, ":p:h:h:h") end function M.get_cache_dir() - local cache_dir = fn.stdpath('data') + local cache_dir = fn.stdpath "data" - if luv.fs_access(cache_dir, 'RW') then + if luv.fs_access(cache_dir, "RW") then return cache_dir - elseif luv.fs_access('/tmp', 'RW') then - return '/tmp' + elseif luv.fs_access("/tmp", "RW") then + return "/tmp" end - return nil, join_space('Invalid cache rights,', fn.stdpath('data'), 'or /tmp should be read/write') + return nil, join_space("Invalid cache rights,", fn.stdpath "data", "or /tmp should be read/write") end -- Returns $XDG_DATA_HOME/nvim/site, but could use any directory that is in -- runtimepath function M.get_site_dir() local path_sep = M.get_path_sep() - return M.join_path(fn.stdpath('data'), path_sep, 'site') + return M.join_path(fn.stdpath "data", path_sep, "site") end -- Try the package dir of the nvim-treesitter plugin first, followed by the @@ -75,7 +78,7 @@ function M.get_parser_install_dir(folder_name) local package_path_parser_dir = M.join_path(package_path, folder_name) -- If package_path is read/write, use that - if luv.fs_access(package_path_parser_dir, 'RW') then + if luv.fs_access(package_path_parser_dir, "RW") then return package_path_parser_dir end @@ -87,24 +90,24 @@ function M.get_parser_install_dir(folder_name) if not luv.fs_stat(parser_dir) then local ok, error = pcall(vim.fn.mkdir, parser_dir, "p", "0755") if not ok then - return nil, join_space('Couldn\'t create parser dir', parser_dir, ':', error) + return nil, join_space("Couldn't create parser dir", parser_dir, ":", error) end return parser_dir end -- parser_dir exists, use it if it's read/write - if luv.fs_access(parser_dir, 'RW') then + if luv.fs_access(parser_dir, "RW") then return parser_dir end -- package_path isn't read/write, parser_dir exists but isn't read/write -- either, give up - return nil, join_space('Invalid cache rights,', package_path, 'or', parser_dir, 'should be read/write') + return nil, join_space("Invalid cache rights,", package_path, "or", parser_dir, "should be read/write") end function M.get_parser_info_dir() - return M.get_parser_install_dir('parser-info') + return M.get_parser_install_dir "parser-info" end -- Gets a property at path @@ -112,12 +115,14 @@ end -- @param path the '.' separated path -- @returns the value at path or nil function M.get_at_path(tbl, path) - if path == '' then return tbl end - local segments = vim.split(path, '.', true) + if path == "" then + return tbl + end + local segments = vim.split(path, ".", true) local result = tbl for _, segment in ipairs(segments) do - if type(result) == 'table' then + if type(result) == "table" then result = result[segment] end end @@ -173,11 +178,13 @@ function M.identity(a) end function M.constant(a) - return function() return a end + return function() + return a + end end function M.to_func(a) - return type(a) == 'function' and a or M.constant(a) + return type(a) == "function" and a or M.constant(a) end return M diff --git a/scripts/check-queries.lua b/scripts/check-queries.lua index 1429c5546..18821280e 100755 --- a/scripts/check-queries.lua +++ b/scripts/check-queries.lua @@ -1,7 +1,7 @@ -- Execute as `nvim --headless -c "luafile ./scripts/check-queries.lua"` local function extract_captures() - local lines = vim.fn.readfile("CONTRIBUTING.md") + local lines = vim.fn.readfile "CONTRIBUTING.md" local captures = {} local current_query @@ -18,17 +18,17 @@ local function extract_captures() end -- Complete captures for injections. - local parsers = require 'nvim-treesitter.info'.installed_parsers() + local parsers = require("nvim-treesitter.info").installed_parsers() for _, lang in pairs(parsers) do - table.insert(captures['injections'], lang) + table.insert(captures["injections"], lang) end return captures end local function do_check() - local parsers = require 'nvim-treesitter.info'.installed_parsers() - local queries = require 'nvim-treesitter.query' + local parsers = require("nvim-treesitter.info").installed_parsers() + local queries = require "nvim-treesitter.query" local query_types = queries.built_in_query_groups local captures = extract_captures() @@ -36,7 +36,7 @@ local function do_check() for _, lang in pairs(parsers) do for _, query_type in pairs(query_types) do - print('Checking '..lang..' '..query_type) + print("Checking " .. lang .. " " .. query_type) local ok, query = pcall(queries.get_query, lang, query_type) if not ok then vim.api.nvim_err_writeln(query) @@ -45,9 +45,9 @@ local function do_check() if query then for _, capture in ipairs(query.captures) do local is_valid = ( - vim.startswith(capture, "_") -- Helpers. - or vim.tbl_contains(captures[query_type], capture) - ) + vim.startswith(capture, "_") -- Helpers. + or vim.tbl_contains(captures[query_type], capture) + ) if not is_valid then local error = string.format("(x) Invalid capture @%s in %s for %s.", capture, query_type, lang) print(error) @@ -60,36 +60,36 @@ local function do_check() end if last_error then print() - print("Last error: ") + print "Last error: " error(last_error) end end - local ok, err = pcall(do_check) -local allowed_to_fail = vim.split(vim.env.ALLOWED_INSTALLATION_FAILURES or '', ",", true) +local allowed_to_fail = vim.split(vim.env.ALLOWED_INSTALLATION_FAILURES or "", ",", true) -for k, v in pairs(require 'nvim-treesitter.parsers'.get_parser_configs()) do - if not require 'nvim-treesitter.parsers'.has_parser(k) then +for k, v in pairs(require("nvim-treesitter.parsers").get_parser_configs()) do + if not require("nvim-treesitter.parsers").has_parser(k) then -- On CI all parsers that can be installed from C files should be installed - if vim.env.CI + if + vim.env.CI and not v.install_info.requires_generate_from_grammar - and not vim.tbl_contains(allowed_to_fail, k) then - - print('Error: parser for '..k..' is not installed') - vim.cmd('cq') + and not vim.tbl_contains(allowed_to_fail, k) + then + print("Error: parser for " .. k .. " is not installed") + vim.cmd "cq" else - print('Warning: parser for '..k..' is not installed') + print("Warning: parser for " .. k .. " is not installed") end end end if ok then - print('Check successful!\n') - vim.cmd('q') + print "Check successful!\n" + vim.cmd "q" else - print('Check failed:') + print "Check failed:" print(err) - print('\n') - vim.cmd('cq') + print "\n" + vim.cmd "cq" end diff --git a/scripts/minimal_init.lua b/scripts/minimal_init.lua index 45f436628..6fa862187 100644 --- a/scripts/minimal_init.lua +++ b/scripts/minimal_init.lua @@ -5,7 +5,7 @@ vim.cmd [[runtime! plugin/nvim-treesitter.vim]] vim.o.swapfile = false vim.bo.swapfile = false -require('nvim-treesitter.configs').setup { - ensure_installed = 'maintained', - indent = { enable = true }, +require("nvim-treesitter.configs").setup { + ensure_installed = "maintained", + indent = { enable = true }, } diff --git a/scripts/update-readme.lua b/scripts/update-readme.lua index d9c00683a..194f20551 100755 --- a/scripts/update-readme.lua +++ b/scripts/update-readme.lua @@ -1,41 +1,49 @@ -- Execute as `nvim --headless -c "luafile ./scripts/update-readme.lua"` -local parsers = require 'nvim-treesitter.parsers'.get_parser_configs() +local parsers = require("nvim-treesitter.parsers").get_parser_configs() local sorted_parsers = {} for k, v in pairs(parsers) do - table.insert(sorted_parsers, {name = k, parser = v}) + table.insert(sorted_parsers, { name = k, parser = v }) end -table.sort(sorted_parsers, function(a, b) return a.name < b.name end) +table.sort(sorted_parsers, function(a, b) + return a.name < b.name +end) -local generated_text = '' +local generated_text = "" for _, v in ipairs(sorted_parsers) do - local link = '['..(v.parser.readme_name or v.name)..']('..v.parser.install_info.url..')' + local link = "[" .. (v.parser.readme_name or v.name) .. "](" .. v.parser.install_info.url .. ")" if v.parser.maintainers then - generated_text = generated_text.. - '- [x] '..link..' (maintained by '..table.concat(v.parser.maintainers, ', ')..')\n' + generated_text = generated_text + .. "- [x] " + .. link + .. " (maintained by " + .. table.concat(v.parser.maintainers, ", ") + .. ")\n" else - generated_text = generated_text.. - '- [ ] '..link..'\n' + generated_text = generated_text .. "- [ ] " .. link .. "\n" end end print(generated_text) -print("\n") +print "\n" -local readme_text = table.concat(vim.fn.readfile('README.md'), '\n') +local readme_text = table.concat(vim.fn.readfile "README.md", "\n") -local new_readme_text = string.gsub(readme_text, "<!%-%-parserinfo%-%->.*<!%-%-parserinfo%-%->", - "<!--parserinfo-->\n"..generated_text.."<!--parserinfo-->") -vim.fn.writefile(vim.fn.split(new_readme_text, '\n'), "README.md") +local new_readme_text = string.gsub( + readme_text, + "<!%-%-parserinfo%-%->.*<!%-%-parserinfo%-%->", + "<!--parserinfo-->\n" .. generated_text .. "<!--parserinfo-->" +) +vim.fn.writefile(vim.fn.split(new_readme_text, "\n"), "README.md") -if string.find(readme_text, generated_text, 1, 'plain') then - print("README.md is up-to-date!") - vim.cmd('q') +if string.find(readme_text, generated_text, 1, "plain") then + print "README.md is up-to-date!" + vim.cmd "q" else - print("New README.md was written. Please commit that change! Old text was: ") + print "New README.md was written. Please commit that change! Old text was: " print(string.sub(readme_text, string.find(readme_text, "<!%-%-parserinfo%-%->.*<!%-%-parserinfo%-%->"))) - vim.cmd('cq') + vim.cmd "cq" end diff --git a/scripts/write-lockfile.lua b/scripts/write-lockfile.lua index 26d11f113..6658c8859 100644 --- a/scripts/write-lockfile.lua +++ b/scripts/write-lockfile.lua @@ -1,10 +1,10 @@ -- Execute as `nvim --headless -c "luafile ./scripts/write-lockfile.lua"` -local skip_langs = vim.fn.getenv('SKIP_LOCKFILE_UPDATE_FOR_LANGS') +local skip_langs = vim.fn.getenv "SKIP_LOCKFILE_UPDATE_FOR_LANGS" if skip_langs == vim.NIL then skip_langs = {} else - skip_langs = vim.fn.split(skip_langs, ',') + skip_langs = vim.fn.split(skip_langs, ",") end -print("Skipping languages: "..vim.inspect(skip_langs)) -require 'nvim-treesitter.install'.write_lockfile('verbose', skip_langs) -vim.cmd('q') +print("Skipping languages: " .. vim.inspect(skip_langs)) +require("nvim-treesitter.install").write_lockfile("verbose", skip_langs) +vim.cmd "q" diff --git a/tests/indent/c_spec.lua b/tests/indent/c_spec.lua index 94f3d739a..f48cbd0aa 100644 --- a/tests/indent/c_spec.lua +++ b/tests/indent/c_spec.lua @@ -1,35 +1,35 @@ -local Runner = require('tests.indent.common').Runner +local Runner = require("tests.indent.common").Runner -local runner = Runner:new(it, 'tests/indent/c', { +local runner = Runner:new(it, "tests/indent/c", { tabstop = 4, shiftwidth = 4, softtabstop = 0, expandtab = true, }) -describe('indent C:', function() - describe('whole file:', function() - runner:whole_file('.') +describe("indent C:", function() + describe("whole file:", function() + runner:whole_file "." end) - describe('new line:', function() - runner:new_line('array.c', { on_line = 2, text = '0,', indent = 4 }) - runner:new_line('cond.c', { on_line = 3, text = 'x++;', indent = 8 }) - runner:new_line('cond.c', { on_line = 8, text = 'x++;', indent = 8 }) - runner:new_line('expr.c', { on_line = 10, text = '2 *', indent = 8 }) - runner:new_line('func.c', { on_line = 17, text = 'int z,', indent = 4 }) - runner:new_line('label.c', { on_line = 3, text = 'normal:', indent = 0 }) - runner:new_line('loop.c', { on_line = 3, text = 'x++;', indent = 8 }) - runner:new_line('preproc_cond.c', { on_line = 5, text = 'x++;', indent = 4 }) - runner:new_line('preproc_func.c', { on_line = 3, text = 'x++; \\', indent = 8 }) - runner:new_line('string.c', { on_line = 1, text = 'brave new \\', indent = 0 }) - runner:new_line('string.c', { on_line = 4, text = '"brave new "', indent = 4 }) - runner:new_line('struct.c', { on_line = 4, text = 'int y;', indent = 8 }) - runner:new_line('switch.c', { on_line = 3, text = 'x++;', indent = 12 }) - runner:new_line('ternary.c', { on_line = 4, text = ': (x == 0) : 0', indent = 8 }) + describe("new line:", function() + runner:new_line("array.c", { on_line = 2, text = "0,", indent = 4 }) + runner:new_line("cond.c", { on_line = 3, text = "x++;", indent = 8 }) + runner:new_line("cond.c", { on_line = 8, text = "x++;", indent = 8 }) + runner:new_line("expr.c", { on_line = 10, text = "2 *", indent = 8 }) + runner:new_line("func.c", { on_line = 17, text = "int z,", indent = 4 }) + runner:new_line("label.c", { on_line = 3, text = "normal:", indent = 0 }) + runner:new_line("loop.c", { on_line = 3, text = "x++;", indent = 8 }) + runner:new_line("preproc_cond.c", { on_line = 5, text = "x++;", indent = 4 }) + runner:new_line("preproc_func.c", { on_line = 3, text = "x++; \\", indent = 8 }) + runner:new_line("string.c", { on_line = 1, text = "brave new \\", indent = 0 }) + runner:new_line("string.c", { on_line = 4, text = '"brave new "', indent = 4 }) + runner:new_line("struct.c", { on_line = 4, text = "int y;", indent = 8 }) + runner:new_line("switch.c", { on_line = 3, text = "x++;", indent = 12 }) + runner:new_line("ternary.c", { on_line = 4, text = ": (x == 0) : 0", indent = 8 }) -- the line after inserted one will be left with wrong indent but we only care about the inserted one - runner:new_line('no_braces.c', { on_line = 4, text = 'x++;', indent = 8 }) - runner:new_line('no_braces.c', { on_line = 7, text = 'x++;', indent = 8 }) - runner:new_line('no_braces.c', { on_line = 10, text = 'x++;', indent = 8 }) + runner:new_line("no_braces.c", { on_line = 4, text = "x++;", indent = 8 }) + runner:new_line("no_braces.c", { on_line = 7, text = "x++;", indent = 8 }) + runner:new_line("no_braces.c", { on_line = 10, text = "x++;", indent = 8 }) end) end) diff --git a/tests/indent/common.lua b/tests/indent/common.lua index ff30b5a5d..10a03a9c3 100644 --- a/tests/indent/common.lua +++ b/tests/indent/common.lua @@ -1,9 +1,9 @@ local M = {} -local assert = require('luassert') -local say = require('say') -local scan_dir = require('plenary.scandir').scan_dir -local Path = require('plenary.path') +local assert = require "luassert" +local say = require "say" +local scan_dir = require("plenary.scandir").scan_dir +local Path = require "plenary.path" local function same_indent(state, arguments) local before = arguments[1] @@ -11,11 +11,11 @@ local function same_indent(state, arguments) local ok = true local errors = { before = {}, after = {} } - for line = 1,#before do + for line = 1, #before do if before[line] ~= after[line] then -- store the actual indentation length for each line - errors.before[line] = #string.match(before[line], '^%s*') - errors.after[line] = #string.match(after[line], '^%s*') + errors.before[line] = #string.match(before[line], "^%s*") + errors.after[line] = #string.match(after[line], "^%s*") ok = false end end @@ -35,28 +35,33 @@ local function format_indent(arg, fmtargs) end width = width + 3 - local header_fmt = '%8s %2s%-' .. tostring(width + 1) .. 's %s' - local fmt = '%8s %2s |%-' .. tostring(width) .. 's |%s' + local header_fmt = "%8s %2s%-" .. tostring(width + 1) .. "s %s" + local fmt = "%8s %2s |%-" .. tostring(width) .. "s |%s" - local output = {header_fmt:format('', '', 'Found:', 'Expected:')} + local output = { header_fmt:format("", "", "Found:", "Expected:") } for i, line in ipairs(arg) do if fmtargs.errors.before[i] then - local indents = string.format('%d vs %d', fmtargs.errors.after[i], fmtargs.errors.before[i]) - table.insert(output, fmt:format(indents, '=>', fmtargs.other[i], line)) + local indents = string.format("%d vs %d", fmtargs.errors.after[i], fmtargs.errors.before[i]) + table.insert(output, fmt:format(indents, "=>", fmtargs.other[i], line)) else - table.insert(output, fmt:format('', '', fmtargs.other[i], line)) + table.insert(output, fmt:format("", "", fmtargs.other[i], line)) end end - return table.concat(output, '\n') + return table.concat(output, "\n") end -say:set_namespace('en') -say:set('assertion.same_indent.positive', 'Incorrect indentation\n%s') -say:set('assertion.same_indent.negative', 'Incorrect indentation\n%s') -assert:register('assertion', 'same_indent', same_indent, - 'assertion.same_indent.positive', 'assert.same_indent.negative') +say:set_namespace "en" +say:set("assertion.same_indent.positive", "Incorrect indentation\n%s") +say:set("assertion.same_indent.negative", "Incorrect indentation\n%s") +assert:register( + "assertion", + "same_indent", + same_indent, + "assertion.same_indent.positive", + "assert.same_indent.negative" +) -- Custom assertion better suited for indentation diffs local function compare_indent(before, after) @@ -66,7 +71,7 @@ local function compare_indent(before, after) end local function set_buf_indent_opts(opts) - local optnames = {'tabstop', 'shiftwidth', 'softtabstop', 'expandtab', 'filetype'} + local optnames = { "tabstop", "shiftwidth", "softtabstop", "expandtab", "filetype" } for _, opt in ipairs(optnames) do if opts[opt] ~= nil then vim.bo[opt] = opts[opt] @@ -78,10 +83,10 @@ function M.run_indent_test(file, runner, opts) assert.are.same(1, vim.fn.filereadable(file), string.format('File "%s" not readable', file)) -- load reference file - vim.cmd(string.format('edit %s', file)) + vim.cmd(string.format("edit %s", file)) local before = vim.api.nvim_buf_get_lines(0, 0, -1, true) - assert.are.same('nvim_treesitter#indent()', vim.bo.indentexpr) + assert.are.same("nvim_treesitter#indent()", vim.bo.indentexpr) set_buf_indent_opts(opts) -- perform the test @@ -91,14 +96,14 @@ function M.run_indent_test(file, runner, opts) local after = vim.api.nvim_buf_get_lines(0, 0, -1, true) -- clear any changes to avoid 'No write since last change (add ! to override)' - vim.cmd 'edit!' + vim.cmd "edit!" return before, after end function M.indent_whole_file(file, opts) local before, after = M.run_indent_test(file, function() - vim.cmd 'silent normal gg=G' + vim.cmd "silent normal gg=G" end, opts) compare_indent(before, after) @@ -114,11 +119,11 @@ end function M.indent_new_line(file, spec, opts) local before, after = M.run_indent_test(file, function() -- move to the line and input the new one - vim.cmd(string.format('normal! %dG', spec.on_line)) - vim.cmd(string.format('normal! o%s', spec.text)) + vim.cmd(string.format("normal! %dG", spec.on_line)) + vim.cmd(string.format("normal! o%s", spec.text)) end, opts) - local indent = type(spec.indent) == 'string' and spec.indent or string.rep(' ', spec.indent) + local indent = type(spec.indent) == "string" and spec.indent or string.rep(" ", spec.indent) table.insert(before, spec.on_line + 1, indent .. spec.text) compare_indent(before, after) @@ -140,7 +145,7 @@ function Runner:new(it, base_dir, buf_opts) end function Runner:whole_file(dirs) - dirs = type(dirs) == "table" and dirs or {dirs} + dirs = type(dirs) == "table" and dirs or { dirs } dirs = vim.tbl_map(function(dir) dir = self.base_dir / Path:new(dir) assert.is.same(1, vim.fn.isdirectory(dir.filename)) @@ -157,7 +162,7 @@ end function Runner:new_line(file, spec, title) title = title and title or tostring(spec.on_line) - self.it(string.format('%s[%s]', file, title), function() + self.it(string.format("%s[%s]", file, title), function() local path = self.base_dir / file M.indent_new_line(path.filename, spec, self.buf_opts) end) diff --git a/tests/indent/cpp_spec.lua b/tests/indent/cpp_spec.lua index 81e9a0a58..ad5034156 100644 --- a/tests/indent/cpp_spec.lua +++ b/tests/indent/cpp_spec.lua @@ -1,42 +1,42 @@ -local Runner = require('tests.indent.common').Runner +local Runner = require("tests.indent.common").Runner -- will use both c/ and cpp/ -local run = Runner:new(it, 'tests/indent', { +local run = Runner:new(it, "tests/indent", { tabstop = 4, shiftwidth = 4, softtabstop = 0, expandtab = true, - filetype = 'cpp', + filetype = "cpp", }) -describe('indent C++:', function() - describe('whole file:', function() - run:whole_file({'c/', 'cpp/'}) +describe("indent C++:", function() + describe("whole file:", function() + run:whole_file { "c/", "cpp/" } end) - describe('new line:', function() - run:new_line('cpp/access.cpp', { on_line = 3, text = 'protected:', indent = 0 }) - run:new_line('cpp/class.cpp', { on_line = 2, text = 'using T = int;', indent = 4 }) - run:new_line('cpp/stream.cpp', { on_line = 5, text = '<< x + 3', indent = 8 }) + describe("new line:", function() + run:new_line("cpp/access.cpp", { on_line = 3, text = "protected:", indent = 0 }) + run:new_line("cpp/class.cpp", { on_line = 2, text = "using T = int;", indent = 4 }) + run:new_line("cpp/stream.cpp", { on_line = 5, text = "<< x + 3", indent = 8 }) -- TODO: find a clean way to import these from c_spec.lua - run:new_line('c/array.c', { on_line = 2, text = '0,', indent = 4 }) - run:new_line('c/cond.c', { on_line = 3, text = 'x++;', indent = 8 }) - run:new_line('c/cond.c', { on_line = 8, text = 'x++;', indent = 8 }) - run:new_line('c/expr.c', { on_line = 10, text = '2 *', indent = 8 }) - run:new_line('c/func.c', { on_line = 17, text = 'int z,', indent = 4 }) - run:new_line('c/label.c', { on_line = 3, text = 'normal:', indent = 0 }) - run:new_line('c/loop.c', { on_line = 3, text = 'x++;', indent = 8 }) - run:new_line('c/preproc_cond.c', { on_line = 5, text = 'x++;', indent = 4 }) - run:new_line('c/preproc_func.c', { on_line = 3, text = 'x++; \\', indent = 8 }) - run:new_line('c/string.c', { on_line = 1, text = 'brave new \\', indent = 0 }) - run:new_line('c/string.c', { on_line = 4, text = '"brave new "', indent = 4 }) - run:new_line('c/struct.c', { on_line = 4, text = 'int y;', indent = 8 }) - run:new_line('c/switch.c', { on_line = 3, text = 'x++;', indent = 12 }) - run:new_line('c/ternary.c', { on_line = 4, text = ': (x == 0) : 0', indent = 8 }) + run:new_line("c/array.c", { on_line = 2, text = "0,", indent = 4 }) + run:new_line("c/cond.c", { on_line = 3, text = "x++;", indent = 8 }) + run:new_line("c/cond.c", { on_line = 8, text = "x++;", indent = 8 }) + run:new_line("c/expr.c", { on_line = 10, text = "2 *", indent = 8 }) + run:new_line("c/func.c", { on_line = 17, text = "int z,", indent = 4 }) + run:new_line("c/label.c", { on_line = 3, text = "normal:", indent = 0 }) + run:new_line("c/loop.c", { on_line = 3, text = "x++;", indent = 8 }) + run:new_line("c/preproc_cond.c", { on_line = 5, text = "x++;", indent = 4 }) + run:new_line("c/preproc_func.c", { on_line = 3, text = "x++; \\", indent = 8 }) + run:new_line("c/string.c", { on_line = 1, text = "brave new \\", indent = 0 }) + run:new_line("c/string.c", { on_line = 4, text = '"brave new "', indent = 4 }) + run:new_line("c/struct.c", { on_line = 4, text = "int y;", indent = 8 }) + run:new_line("c/switch.c", { on_line = 3, text = "x++;", indent = 12 }) + run:new_line("c/ternary.c", { on_line = 4, text = ": (x == 0) : 0", indent = 8 }) -- the line after inserted one will be left with wrong indent but we only care about the inserted one - run:new_line('c/no_braces.c', { on_line = 4, text = 'x++;', indent = 8 }) - run:new_line('c/no_braces.c', { on_line = 7, text = 'x++;', indent = 8 }) - run:new_line('c/no_braces.c', { on_line = 10, text = 'x++;', indent = 8 }) + run:new_line("c/no_braces.c", { on_line = 4, text = "x++;", indent = 8 }) + run:new_line("c/no_braces.c", { on_line = 7, text = "x++;", indent = 8 }) + run:new_line("c/no_braces.c", { on_line = 10, text = "x++;", indent = 8 }) end) end) diff --git a/tests/indent/lua_spec.lua b/tests/indent/lua_spec.lua index bb975c595..c107a700f 100644 --- a/tests/indent/lua_spec.lua +++ b/tests/indent/lua_spec.lua @@ -1,35 +1,33 @@ -local Runner = require('tests.indent.common').Runner +local Runner = require("tests.indent.common").Runner -local run = Runner:new(it, 'tests/indent/lua', { +local run = Runner:new(it, "tests/indent/lua", { tabstop = 2, shiftwidth = 2, softtabstop = 0, expandtab = true, }) - -describe('indent Lua:', function() - describe('whole file:', function() - run:whole_file('.') +describe("indent Lua:", function() + describe("whole file:", function() + run:whole_file "." end) - describe('new line:', function() - run:new_line('comment.lua', { on_line = 1, text = 'line', indent = '-- ' }) - run:new_line('comment.lua', { on_line = 5, text = 'multiline', indent = ' ' }) - run:new_line('func.lua', { on_line = 1, text = 'x = x + 1', indent = 2 }) - run:new_line('func.lua', { on_line = 2, text = 'y = y + 1', indent = 4 }) - run:new_line('func.lua', { on_line = 5, text = '3,', indent = 4 }) - run:new_line('string.lua', { on_line = 1, text = 'x', indent = 0 }) - run:new_line('string.lua', { on_line = 2, text = 'x', indent = 0 }) - run:new_line('string.lua', { on_line = 3, text = 'x', indent = 2 }) - run:new_line('string.lua', { on_line = 4, text = 'x', indent = 4 }) - run:new_line('table.lua', { on_line = 1, text = 'b = 0,', indent = 2 }) - run:new_line('table.lua', { on_line = 5, text = '4,', indent = 4 }) - run:new_line('table.lua', { on_line = 7, text = '4,', indent = 4 }) - run:new_line('loop.lua', { on_line = 4, text = 'x = x + 1', indent = 2 }) - run:new_line('cond.lua', { on_line = 5, text = 'x = x + 1', indent = 2 }) - run:new_line('cond.lua', { on_line = 7, text = 'x = x + 1', indent = 2 }) - run:new_line('cond.lua', { on_line = 8, text = 'x = x + 1', indent = 4 }) + describe("new line:", function() + run:new_line("comment.lua", { on_line = 1, text = "line", indent = "-- " }) + run:new_line("comment.lua", { on_line = 5, text = "multiline", indent = " " }) + run:new_line("func.lua", { on_line = 1, text = "x = x + 1", indent = 2 }) + run:new_line("func.lua", { on_line = 2, text = "y = y + 1", indent = 4 }) + run:new_line("func.lua", { on_line = 5, text = "3,", indent = 4 }) + run:new_line("string.lua", { on_line = 1, text = "x", indent = 0 }) + run:new_line("string.lua", { on_line = 2, text = "x", indent = 0 }) + run:new_line("string.lua", { on_line = 3, text = "x", indent = 2 }) + run:new_line("string.lua", { on_line = 4, text = "x", indent = 4 }) + run:new_line("table.lua", { on_line = 1, text = "b = 0,", indent = 2 }) + run:new_line("table.lua", { on_line = 5, text = "4,", indent = 4 }) + run:new_line("table.lua", { on_line = 7, text = "4,", indent = 4 }) + run:new_line("loop.lua", { on_line = 4, text = "x = x + 1", indent = 2 }) + run:new_line("cond.lua", { on_line = 5, text = "x = x + 1", indent = 2 }) + run:new_line("cond.lua", { on_line = 7, text = "x = x + 1", indent = 2 }) + run:new_line("cond.lua", { on_line = 8, text = "x = x + 1", indent = 4 }) end) end) - diff --git a/tests/indent/python_spec.lua b/tests/indent/python_spec.lua index 6bff4d6d6..e67029d0a 100644 --- a/tests/indent/python_spec.lua +++ b/tests/indent/python_spec.lua @@ -1,38 +1,38 @@ -local Runner = require('tests.indent.common').Runner +local Runner = require("tests.indent.common").Runner -local run = Runner:new(it, 'tests/indent/python', { +local run = Runner:new(it, "tests/indent/python", { tabstop = 4, shiftwidth = 4, softtabstop = 0, expandtab = true, }) -describe('indent Python:', function() - describe('whole file:', function() - run:whole_file('.') +describe("indent Python:", function() + describe("whole file:", function() + run:whole_file "." end) - describe('new line:', function() - run:new_line('aligned_indent.py', { on_line = 1, text = 'arg3,', indent = 19 }) - run:new_line('basic_blocks.py', { on_line = 1, text = 'wait,', indent = 4 }) - run:new_line('basic_blocks.py', { on_line = 6, text = 'x += 1', indent = 4 }) - run:new_line('basic_blocks.py', { on_line = 10, text = 'x += 1', indent = 8 }) - run:new_line('basic_blocks.py', { on_line = 7, text = 'x += 1', indent = 4 }, '7, after last line of a block') - run:new_line('basic_blocks.py', { on_line = 11, text = 'x += 1', indent = 8 }, '11, after last line of a block') - run:new_line('basic_collections.py', { on_line = 3, text = '4,', indent = 4 }) - run:new_line('comprehensions.py', { on_line = 8, text = 'if x != 2', indent = 4 }) - run:new_line('control_flow.py', { on_line = 23, text = 'x = 4', indent = 4 }) - run:new_line('hanging_indent.py', { on_line = 1, text = 'arg0,', indent = 8 }) - run:new_line('hanging_indent.py', { on_line = 5, text = '0,', indent = 4 }) - run:new_line('join_lines.py', { on_line = 1, text = '+ 1 \\', indent = 4 }) - run:new_line('join_lines.py', { on_line = 4, text = '+ 1 \\', indent = 4 }) - run:new_line('join_lines.py', { on_line = 7, text = '+ 1 \\', indent = 4 }) - run:new_line('nested_collections.py', { on_line = 5, text = '0,', indent = 12 }) - run:new_line('nested_collections.py', { on_line = 6, text = ',0', indent = 12 }) - run:new_line('nested_collections.py', { on_line = 29, text = '[1, 2],', indent = 12 }) - run:new_line('nested_collections.py', { on_line = 39, text = '0,', indent = 5 }) - run:new_line('strings.py', { on_line = 14, text = 'x', indent = 4 }) - run:new_line('strings.py', { on_line = 15, text = 'x', indent = 0 }) - run:new_line('strings.py', { on_line = 16, text = 'x', indent = 8 }) + describe("new line:", function() + run:new_line("aligned_indent.py", { on_line = 1, text = "arg3,", indent = 19 }) + run:new_line("basic_blocks.py", { on_line = 1, text = "wait,", indent = 4 }) + run:new_line("basic_blocks.py", { on_line = 6, text = "x += 1", indent = 4 }) + run:new_line("basic_blocks.py", { on_line = 10, text = "x += 1", indent = 8 }) + run:new_line("basic_blocks.py", { on_line = 7, text = "x += 1", indent = 4 }, "7, after last line of a block") + run:new_line("basic_blocks.py", { on_line = 11, text = "x += 1", indent = 8 }, "11, after last line of a block") + run:new_line("basic_collections.py", { on_line = 3, text = "4,", indent = 4 }) + run:new_line("comprehensions.py", { on_line = 8, text = "if x != 2", indent = 4 }) + run:new_line("control_flow.py", { on_line = 23, text = "x = 4", indent = 4 }) + run:new_line("hanging_indent.py", { on_line = 1, text = "arg0,", indent = 8 }) + run:new_line("hanging_indent.py", { on_line = 5, text = "0,", indent = 4 }) + run:new_line("join_lines.py", { on_line = 1, text = "+ 1 \\", indent = 4 }) + run:new_line("join_lines.py", { on_line = 4, text = "+ 1 \\", indent = 4 }) + run:new_line("join_lines.py", { on_line = 7, text = "+ 1 \\", indent = 4 }) + run:new_line("nested_collections.py", { on_line = 5, text = "0,", indent = 12 }) + run:new_line("nested_collections.py", { on_line = 6, text = ",0", indent = 12 }) + run:new_line("nested_collections.py", { on_line = 29, text = "[1, 2],", indent = 12 }) + run:new_line("nested_collections.py", { on_line = 39, text = "0,", indent = 5 }) + run:new_line("strings.py", { on_line = 14, text = "x", indent = 4 }) + run:new_line("strings.py", { on_line = 15, text = "x", indent = 0 }) + run:new_line("strings.py", { on_line = 16, text = "x", indent = 8 }) end) end) diff --git a/tests/indent/rust_spec.lua b/tests/indent/rust_spec.lua index d9163dee3..040e8c2f9 100644 --- a/tests/indent/rust_spec.lua +++ b/tests/indent/rust_spec.lua @@ -1,53 +1,53 @@ -local Runner = require('tests.indent.common').Runner +local Runner = require("tests.indent.common").Runner -local run = Runner:new(it, 'tests/indent/rust', { +local run = Runner:new(it, "tests/indent/rust", { tabstop = 4, shiftwidth = 4, softtabstop = 0, expandtab = true, }) -describe('indent Rust:', function() - describe('whole file:', function() - run:whole_file('.') +describe("indent Rust:", function() + describe("whole file:", function() + run:whole_file "." end) - describe('new line:', function() - run:new_line('array.rs', { on_line = 2, text = '0,', indent = 4 }) - run:new_line('array.rs', { on_line = 8, text = '0,', indent = 8 }) - run:new_line('comment.rs', { on_line = 3, text = 'a', indent = '/// ' }) - run:new_line('cond.rs', { on_line = 11, text = 'x += 1;', indent = 12 }) - run:new_line('cond.rs', { on_line = 2, text = 'x += 1;', indent = 8 }) - run:new_line('cond.rs', { on_line = 4, text = 'x += 1;', indent = 8 }) - run:new_line('cond.rs', { on_line = 6, text = 'x += 1;', indent = 8 }) - run:new_line('enum.rs', { on_line = 2, text = 'Q,', indent = 4 }) - run:new_line('enum.rs', { on_line = 4, text = 'i32,', indent = 8 }) - run:new_line('enum.rs', { on_line = 8, text = 'z: u32,', indent = 8 }) - run:new_line('func.rs', { on_line = 1, text = 'let _x = 1;', indent = 4 }) - run:new_line('func.rs', { on_line = 6, text = 'z: i32,', indent = 4 }) - run:new_line('impl.rs', { on_line = 3, text = 'const FOO: u32 = 1;', indent = 4 }) - run:new_line('impl.rs', { on_line = 4, text = 'let _x = 1;', indent = 8 }) - run:new_line('loop.rs', { on_line = 10, text = 'x += 1;', indent = 8 }) - run:new_line('loop.rs', { on_line = 2, text = 'x += 1;', indent = 8 }) - run:new_line('loop.rs', { on_line = 6, text = 'x += 1;', indent = 8 }) - run:new_line('macro.rs', { on_line = 1, text = '() => {},', indent = 4 }) - run:new_line('macro.rs', { on_line = 12, text = 'B C', indent = 4 }) - run:new_line('macro.rs', { on_line = 2, text = 'struct $c;', indent = 8 }) - run:new_line('match.rs', { on_line = 2, text = '-1 => -1,', indent = 8 }) - run:new_line('match.rs', { on_line = 7, text = 'let y = 1;', indent = 12 }) - run:new_line('mod.rs', { on_line = 1, text = 'const Z: i32 = 1;', indent = 4 }) - run:new_line('mod.rs', { on_line = 2, text = 'const Z: i32 = 1;', indent = 4 }) - run:new_line('mod.rs', { on_line = 6, text = 'const Z: i32 = 1;', indent = 8 }) - run:new_line('string.rs', { on_line = 2, text = 'brave new', indent = 0 }) - run:new_line('string.rs', { on_line = 5, text = 'brave new \\', indent = 8 }) - run:new_line('string.rs', { on_line = 9, text = 'brave new \\', indent = 8 }) - run:new_line('struct.rs', { on_line = 1, text = 'z: i32,', indent = 4 }) - run:new_line('struct.rs', { on_line = 2, text = 'z: i32,', indent = 4 }) - run:new_line('trait.rs', { on_line = 4, text = 'fn baz();', indent = 4 }) - run:new_line('trait.rs', { on_line = 7, text = 'fn baz();', indent = 4 }) - run:new_line('trait.rs', { on_line = 8, text = '()', indent = 8 }) - run:new_line('where.rs', { on_line = 17, text = 'T: Debug,', indent = 4 }) - run:new_line('where.rs', { on_line = 2, text = 'T: Debug,', indent = 4 }) - run:new_line('where.rs', { on_line = 9, text = 'T: Debug,', indent = 4 }) + describe("new line:", function() + run:new_line("array.rs", { on_line = 2, text = "0,", indent = 4 }) + run:new_line("array.rs", { on_line = 8, text = "0,", indent = 8 }) + run:new_line("comment.rs", { on_line = 3, text = "a", indent = "/// " }) + run:new_line("cond.rs", { on_line = 11, text = "x += 1;", indent = 12 }) + run:new_line("cond.rs", { on_line = 2, text = "x += 1;", indent = 8 }) + run:new_line("cond.rs", { on_line = 4, text = "x += 1;", indent = 8 }) + run:new_line("cond.rs", { on_line = 6, text = "x += 1;", indent = 8 }) + run:new_line("enum.rs", { on_line = 2, text = "Q,", indent = 4 }) + run:new_line("enum.rs", { on_line = 4, text = "i32,", indent = 8 }) + run:new_line("enum.rs", { on_line = 8, text = "z: u32,", indent = 8 }) + run:new_line("func.rs", { on_line = 1, text = "let _x = 1;", indent = 4 }) + run:new_line("func.rs", { on_line = 6, text = "z: i32,", indent = 4 }) + run:new_line("impl.rs", { on_line = 3, text = "const FOO: u32 = 1;", indent = 4 }) + run:new_line("impl.rs", { on_line = 4, text = "let _x = 1;", indent = 8 }) + run:new_line("loop.rs", { on_line = 10, text = "x += 1;", indent = 8 }) + run:new_line("loop.rs", { on_line = 2, text = "x += 1;", indent = 8 }) + run:new_line("loop.rs", { on_line = 6, text = "x += 1;", indent = 8 }) + run:new_line("macro.rs", { on_line = 1, text = "() => {},", indent = 4 }) + run:new_line("macro.rs", { on_line = 12, text = "B C", indent = 4 }) + run:new_line("macro.rs", { on_line = 2, text = "struct $c;", indent = 8 }) + run:new_line("match.rs", { on_line = 2, text = "-1 => -1,", indent = 8 }) + run:new_line("match.rs", { on_line = 7, text = "let y = 1;", indent = 12 }) + run:new_line("mod.rs", { on_line = 1, text = "const Z: i32 = 1;", indent = 4 }) + run:new_line("mod.rs", { on_line = 2, text = "const Z: i32 = 1;", indent = 4 }) + run:new_line("mod.rs", { on_line = 6, text = "const Z: i32 = 1;", indent = 8 }) + run:new_line("string.rs", { on_line = 2, text = "brave new", indent = 0 }) + run:new_line("string.rs", { on_line = 5, text = "brave new \\", indent = 8 }) + run:new_line("string.rs", { on_line = 9, text = "brave new \\", indent = 8 }) + run:new_line("struct.rs", { on_line = 1, text = "z: i32,", indent = 4 }) + run:new_line("struct.rs", { on_line = 2, text = "z: i32,", indent = 4 }) + run:new_line("trait.rs", { on_line = 4, text = "fn baz();", indent = 4 }) + run:new_line("trait.rs", { on_line = 7, text = "fn baz();", indent = 4 }) + run:new_line("trait.rs", { on_line = 8, text = "()", indent = 8 }) + run:new_line("where.rs", { on_line = 17, text = "T: Debug,", indent = 4 }) + run:new_line("where.rs", { on_line = 2, text = "T: Debug,", indent = 4 }) + run:new_line("where.rs", { on_line = 9, text = "T: Debug,", indent = 4 }) end) end) |