Merge pull request #1 from ThePrimeagen/stylua

feat: Add stylua

Author: ThePrimeagen

lua/refactoring/106.lua

@@ -12,17 +12,25 @@ local REFACTORING_OPTIONS = {
             extract_function = function(opts)
                 return {
                     create = table.concat(vim.tbl_flatten({
-                        string.format("local function %s(%s)", opts.name, table.concat(opts.args, ", ")),
+                        string.format(
+                            "local function %s(%s)",
+                            opts.name,
+                            table.concat(opts.args, ", ")
+                        ),
                         opts.body,
                         "end",
-                        ""
+                        "",
                     }), "\n"),
 
-                    call = string.format("%s(%s)", opts.name, table.concat(opts.args, ", ")),
+                    call = string.format(
+                        "%s(%s)",
+                        opts.name,
+                        table.concat(opts.args, ", ")
+                    ),
                 }
             end,
-        }
-    }
+        },
+    },
 }
 
 local function get_selection_range()
@@ -42,24 +50,34 @@ local function vim_range_to_ts_range(start_row, start_col, end_row, end_col)
 end
 
 -- 106
-local function get_text_edits(selected_local_references, end_row, lang, start_col, start_row, end_col, scope_range, function_name)
+local function get_text_edits(
+    selected_local_references,
+    end_row,
+    lang,
+    start_col,
+    start_row,
+    end_col,
+    scope_range,
+    function_name
+)
     -- local declaration within the selection range.
     local lsp_text_edits = {}
-    local extract_function = REFACTORING_OPTIONS.code_generation[lang].extract_function({
-        args = vim.tbl_keys(selected_local_references),
-        body = vim.api.nvim_buf_get_lines(0, start_row, end_row, false),
-        name = function_name,
-    })
+    local extract_function =
+        REFACTORING_OPTIONS.code_generation[lang].extract_function({
+            args = vim.tbl_keys(selected_local_references),
+            body = vim.api.nvim_buf_get_lines(0, start_row, end_row, false),
+            name = function_name,
+        })
     table.insert(lsp_text_edits, {
         range = scope_range,
-        newText = string.format("\n%s", extract_function.create)
+        newText = string.format("\n%s", extract_function.create),
     })
     table.insert(lsp_text_edits, {
         range = {
-            start = {line = start_row, character = start_col},
-            ["end"] = {line = end_row, character = end_col}
+            start = { line = start_row, character = start_col },
+            ["end"] = { line = end_row, character = end_col },
         },
-        newText = string.format("\n%s", extract_function.call)
+        newText = string.format("\n%s", extract_function.call),
     })
     return lsp_text_edits
 end
@@ -96,17 +114,38 @@ REFACTORING.extract = function(bufnr)
     local lang = vim.bo.filetype
     local start_row, start_col, end_row, end_col = get_selection_range()
     local ts_start_row, ts_start_col, ts_end_row, ts_end_col =
-        vim_range_to_ts_range(start_row, start_col, end_row, end_col)
+        vim_range_to_ts_range(
+            start_row,
+            start_col,
+            end_row,
+            end_col
+        )
     local root = utils.get_root(lang)
-    local scope = utils.get_scope_over_selection(root, start_row, start_col, end_row + 1, end_col, lang)
+    local scope = utils.get_scope_over_selection(
+        root,
+        start_row,
+        start_col,
+        end_row + 1,
+        end_col,
+        lang
+    )
 
     if scope == nil then
         error("Scope is nil")
     end
 
     local local_defs = vim.tbl_filter(function(node)
-        return not utils.range_contains_node(node, ts_start_row, ts_start_col, ts_end_row, ts_end_col)
-    end, utils.get_locals_defs(scope, lang))
+        return not utils.range_contains_node(
+            node,
+            ts_start_row,
+            ts_start_col,
+            ts_end_row,
+            ts_end_col
+        )
+    end, utils.get_locals_defs(
+        scope,
+        lang
+    ))
 
     local function_args = utils.get_function_args(scope, lang)
     local local_def_map = get_local_definitions(local_defs, function_args)
@@ -115,8 +154,15 @@ REFACTORING.extract = function(bufnr)
 
     for _, local_ref in pairs(local_references) do
         local local_name = ts_utils.get_node_text(local_ref)[1]
-        if utils.range_contains_node(local_ref, ts_start_row, ts_start_col, ts_end_row, ts_end_col) and
-            local_def_map[local_name] then
+        if
+            utils.range_contains_node(
+                local_ref,
+                ts_start_row,
+                ts_start_col,
+                ts_end_row,
+                ts_end_col
+            ) and local_def_map[local_name]
+        then
             selected_local_references[local_name] = true
         end
     end
@@ -129,7 +175,16 @@ REFACTORING.extract = function(bufnr)
     local function_name = vim.fn.input("106: Extract Function Name > ")
 
     -- TODO: Polor, could you also make the variable that is returned the first
-    local text_edits = get_text_edits(selected_local_references, end_row, lang, start_col, start_row, end_col, scope_range, function_name)
+    local text_edits = get_text_edits(
+        selected_local_references,
+        end_row,
+        lang,
+        start_col,
+        start_row,
+        end_col,
+        scope_range,
+        function_name
+    )
     vim.lsp.util.apply_text_edits(text_edits, 0)
 end
 

lua/refactoring/106_spec.lua

@@ -17,11 +17,12 @@ describe("Refactoring", function()
         vim.cmd(":norm! ggVjj")
 
         eq(0, vim.fn.col("'<"), "Selections start at 0")
-        eq(#"foo = foo + 5 + foo" + 1, vim.fn.col("'>"), "Selection stops + 1 after last line.")
+        eq(
+            #"foo = foo + 5 + foo" + 1,
+            vim.fn.col("'>"),
+            "Selection stops + 1 after last line."
+        )
 
         -- print("COL", vim.fn.col("'<"), vim.fn.col("'>"))
     end)
 end)
-
-
-

lua/refactoring/dev.lua

@@ -4,4 +4,3 @@ M.reload = function()
 end
 
 return M
-

lua/refactoring/intersect.lua

@@ -1,4 +1,3 @@
-
 -- Array<node_wrapper>
 local intersect_nodes = function(nodes, row, col)
     local found = {}
@@ -14,4 +13,3 @@ local intersect_nodes = function(nodes, row, col)
     end
     return found
 end
-

lua/refactoring/query.lua

@@ -1,4 +1,2 @@
 function find_identifiers()
 end
-
-

lua/refactoring/refactoring.lua

@@ -1,2 +0,0 @@
-
-

lua/refactoring/utils.lua

@@ -27,16 +27,16 @@ M.get_bounded_query = function(query, lang, startR, stopR)
             table.insert(out, node)
         end)
     end
-    return out;
+    return out
 end
 
 local refactor_constants = {
     lua = {
         scope = {
             ["function"] = true,
-            ["function_definition"] = true
-        }
-    }
+            ["function_definition"] = true,
+        },
+    },
 }
 
 -- determines if a contains node b.
@@ -48,8 +48,8 @@ function M.node_contains(a, b)
     end
 
     local start_row, start_col, end_row, end_col = b:range()
-    return ts_utils.is_in_node_range(a, start_row, start_col) and
-           ts_utils.is_in_node_range(a, end_row, end_col)
+    return ts_utils.is_in_node_range(a, start_row, start_col)
+        and ts_utils.is_in_node_range(a, end_row, end_col)
 end
 
 -- determines if a node exists within a range.  Imagine a range selection
@@ -59,7 +59,8 @@ end
 -- @param a the containing node
 -- @param b the node to be contained
 M.range_contains_node = function(node, start_row, start_col, end_row, end_col)
-    local node_start_row, node_start_col, node_end_row, node_end_col = node:range()
+    local node_start_row, node_start_col, node_end_row, node_end_col =
+        node:range()
 
     -- There are five possible conditions
     -- 1. node start/end row are contained exclusively within the range.
@@ -77,11 +78,10 @@ M.range_contains_node = function(node, start_row, start_col, end_row, end_col)
     if start_row < node_start_row and end_row > node_end_row then
         return true
     elseif start_row == end_row then
-        return start_row == node_start_row and
-               end_row == node_end_row and
-               start_col <= node_start_col and
-               end_col >= node_end_col
-
+        return start_row == node_start_row
+            and end_row == node_end_row
+            and start_col <= node_start_col
+            and end_col >= node_end_col
     elseif start_row == node_start_row and start_row == node_end_row then
         return start_col <= node_start_col
     elseif end_row == node_start_row and end_row == node_end_row then
@@ -93,23 +93,27 @@ M.range_contains_node = function(node, start_row, start_col, end_row, end_col)
     return false
 end
 
-M.get_scope_over_selection = function(root, start_line, start_col, end_line, end_col, lang)
-    local start_scope = M.get_scope(root, start_line, start_col, lang)
-    local end_scope = M.get_scope(root, end_line, end_col, lang)
+M.get_scope_over_selection =
+    function(root, start_line, start_col, end_line, end_col, lang)
+        local start_scope = M.get_scope(root, start_line, start_col, lang)
+        local end_scope = M.get_scope(root, end_line, end_col, lang)
 
-    if start_scope ~= end_scope then
-        error("Selection spans over two scopes, cannot determine scope")
-    end
+        if start_scope ~= end_scope then
+            error("Selection spans over two scopes, cannot determine scope")
+        end
 
-    return start_scope
-end
+        return start_scope
+    end
 
 M.get_scope = function(root, line, col, lang)
     local function_scopes = {}
     local query = vim.treesitter.get_query(lang, "locals")
 
     for id, n, _ in query:iter_captures(root, 0, 0, -1) do
-        if query.captures[id] == "scope" and refactor_constants[lang].scope[n:type()] then
+        if
+            query.captures[id] == "scope"
+            and refactor_constants[lang].scope[n:type()]
+        then
             table.insert(function_scopes, n)
         end
     end
@@ -120,9 +124,10 @@ M.get_scope = function(root, line, col, lang)
         -- should a scope that contains another scope but terminates at the
         -- same point be the outer or inner?  Should potentially be considered
         -- a list of scopes...
-        if ts_utils.is_in_node_range(scope, line, col) and
-            (out == nil or M.node_contains(out, scope)) then
-
+        if
+            ts_utils.is_in_node_range(scope, line, col)
+            and (out == nil or M.node_contains(out, scope))
+        then
             out = scope
         end
     end
@@ -133,7 +138,9 @@ end
 local function get_refactoring_query(lang)
     local query = vim.treesitter.get_query(lang, "refactoring")
     if not query then
-        error("refactoring not supported in this language.  Please provide a queries/<lang>/refactoring.scm")
+        error(
+            "refactoring not supported in this language.  Please provide a queries/<lang>/refactoring.scm"
+        )
     end
     return query
 end
@@ -142,7 +149,10 @@ local function pluck_by_capture(scope, lang, query, capture_name)
     local local_defs = {}
     local root = M.get_root(lang)
     for id, node, _ in query:iter_captures(root, 0, 0, -1) do
-        if query.captures[id] == capture_name and M.node_contains(scope, node) then
+        if
+            query.captures[id] == capture_name
+            and M.node_contains(scope, node)
+        then
             table.insert(local_defs, node)
         end
     end
@@ -151,15 +161,30 @@ local function pluck_by_capture(scope, lang, query, capture_name)
 end
 
 M.get_function_args = function(scope, lang)
-    return pluck_by_capture(scope, lang, get_refactoring_query(lang), "definition.function_argument")
+    return pluck_by_capture(
+        scope,
+        lang,
+        get_refactoring_query(lang),
+        "definition.function_argument"
+    )
 end
 
 M.get_locals_defs = function(scope, lang)
-    return pluck_by_capture(scope, lang, get_refactoring_query(lang), "definition.local_var")
+    return pluck_by_capture(
+        scope,
+        lang,
+        get_refactoring_query(lang),
+        "definition.local_var"
+    )
 end
 
-M.get_all_identifiers  = function(scope, lang)
-    return pluck_by_capture(scope, lang, vim.treesitter.get_query(lang, "locals"), "reference")
+M.get_all_identifiers = function(scope, lang)
+    return pluck_by_capture(
+        scope,
+        lang,
+        vim.treesitter.get_query(lang, "locals"),
+        "reference"
+    )
 end
 
 -- is there a better way?
@@ -168,7 +193,7 @@ M.range_to_table = function(node)
         return "range nil"
     end
     local a, b, c, d = node:range()
-    return {a, b, c, d}
+    return { a, b, c, d }
 end
 
 return M

lua/refactoring/vim-helpers.lua

@@ -1,11 +1,12 @@
-
 local M = {}
 
 -- TODO: Probably do it this way... seems mucho better
 -- https://github.com/neovim/neovim/blob/6f48c018b526a776e38e94f58769c30141de9e0c/runtime/lua/vim/lsp/util.lua#L243
 function M.move_text(buf, from_start_row, from_end_row, to_start_row)
     if from_start_row <= to_start_row and from_end_row >= to_start_row then
-        error("vim-helpers#move_text has been provided a destination within the removal location.  Impossible!")
+        error(
+            "vim-helpers#move_text has been provided a destination within the removal location.  Impossible!"
+        )
     end
 
     if not vim.api.nvim_buf_is_valid(buf) then
@@ -14,7 +15,8 @@ function M.move_text(buf, from_start_row, from_end_row, to_start_row)
 
     local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
     for idx = from_start_row, from_end_row do
-        local to_remove_idx = from_start_row > to_start_row and idx or from_start_row
+        local to_remove_idx = from_start_row > to_start_row and idx
+            or from_start_row
         local line = lines[to_remove_idx]
 
         table.remove(lines, to_remove_idx)

stylua.toml

@@ -0,0 +1,3 @@
+column_width = 80
+indent_type = "Spaces"
+indent_width = 4