refactor: analyzer.lua (#38)

Author: nabekou29

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+max_line_length = 120
+insert_final_newline = true

lua/js-i18n/analyzer.lua

@@ -73,52 +73,51 @@ end
 --- Treesitterパーサーをセットアップしてキーにマッチするノードを取得する関数
 --- @param bufnr number 文言ファイルのバッファ番号
 --- @param keys string[] キー
---- @param start? integer 開始位置
---- @param stop? integer 終了位置
 --- @return TSNode | nil, string | nil
-function M.get_node_for_key(bufnr, keys, start, stop)
-  keys = { unpack(keys) }
-  local key = table.concat(keys, c.config.key_separator)
+function M.get_node_for_key(bufnr, keys)
   local ts = vim.treesitter
 
   local parser = ts.get_parser(bufnr, "json")
   local tree = parser:parse()[1]
   local root = tree:root()
 
-  local query =
-    ts.query.parse("json", '(pair key: (string) @key (#eq? @key "\\"' .. keys[1] .. '\\""))')
-
-  --- @type TSNode[]
-  local match_nodes = {}
+  local json_node = root
+  for i, k in ipairs(keys) do
+    local query = ts.query.parse("json", [[
+      (pair
+        key: (string) @key (#eq? @key "\"]] .. k .. [[\"")
+        value: [(object)(string)] @value
+      )
+    ]])
+
+    local key_node = nil
+    local key_node_depth = 9999
+    local value_node = nil
+    local value_node_depth = 9999
+    for id, node, _ in query:iter_captures(json_node, bufnr) do
+      local name = query.captures[id]
+      local depth = calculate_node_depth(node)
+      if name == "key" and depth < key_node_depth then
+        key_node = node
+        key_node_depth = depth
+      elseif name == "value" and depth < value_node_depth then
+        value_node = node
+        value_node_depth = depth
+      end
+    end
 
-  for _, match, _ in query:iter_matches(root, bufnr, start, stop) do
-    for _, node in ipairs(match) do
-      table.insert(match_nodes, node)
+    if key_node == nil or value_node == nil then
+      break
     end
-  end
 
-  --- @type TSNode
-  local node = vim
-    .iter(match_nodes)
-    -- find min depth
-    :fold(match_nodes[1], function(acc, node)
-      if calculate_node_depth(node) < calculate_node_depth(acc) then
-        return node
-      else
-        return acc
-      end
-    end)
-
-  if #keys == 1 then
-    return node, nil
-  elseif node ~= nil then
-    table.remove(keys, 1)
-    local parent = node:parent()
-    if parent ~= nil then
-      return M.get_node_for_key(bufnr, keys, parent:start(), parent:end_())
+    if i == #keys then
+      return key_node, nil
     end
+
+    json_node = value_node
   end
 
+  local key = table.concat(keys, c.config.key_separator)
   return nil, "Key not found: " .. key
 end
 

tests/busted.lua

@@ -8,7 +8,7 @@ require("lazy.minit").busted({
   spec = {
     "nvim-lua/plenary.nvim",
     "neovim/nvim-lspconfig",
-    { "nvim-treesitter/nvim-treesitter", build = ":TSUpdate javascript typescript tsx" },
+    { "nvim-treesitter/nvim-treesitter", build = ":TSUpdate json javascript typescript tsx" },
     { dir = vim.uv.cwd(), opts = {} },
   },
 })

tests/js-i18n/analyzer_spec.lua

@@ -2,72 +2,107 @@ local helper = require("tests.helper")
 
 local analyzer = require("js-i18n.analyzer")
 
---- test helper
+describe("analyzer.get_node_for_key", function()
+  --- @type test.Project
+  local project = nil
+  before_each(function()
+    project = helper.use_project("i18next")
+  end)
 
---- @param get_project function(): test.Project
---- @param file string
---- @param assertion function(result: FindTExpressionResultItem[], utils: table)
-local function test_analyze_file(get_project, file, assertion)
-  it("should find 't' function calls in " .. file, function()
-    -- Arrange
-    local project = get_project()
-    vim.cmd("e " .. project.path .. "/test_analyzer/" .. file)
+  after_each(function()
+    vim.cmd("bufdo bd!")
+  end)
 
-    -- Act
-    local result = analyzer.find_call_t_expressions(0)
+  local tests = {
+    -- stylua: ignore start
+    { key = "exists-key", exp_key_row = 2 },
+    { key = "nested.key", exp_key_row = 4 },
+    { key = "nested",     exp_key_row = 3 },
+    -- stylua: ignore end
+  }
 
-    local assert_item = function(idx, exp)
-      local item = result[idx]
+  for _, test in ipairs(tests) do
+    it("#hoge " .. test.key, function()
+      -- Arrange
+      vim.cmd("e " .. project.path .. "/locales/en/translation.json")
 
-      local function assert_key_value(key)
-        -- stylua: ignore start
-        assert(
-          exp[key] == item[key],
-          string.format("result[%d].%s to be equal.\nPassed:\n(%s) %s\nExpected:\n(%s) %s",
-            idx, key, type(item[key]), item[key], type(exp[key]), exp[key])
-        )
-        -- stylua: ignore end
+      -- Act
+      local result = analyzer.get_node_for_key(0, vim.split(test.key, ".", { plain = true }))
+
+      -- Assert
+      if not result then
+        error("Key not found: " .. test.key)
       end
-      assert_key_value("key")
-      assert_key_value("key_prefix")
-      assert_key_value("key_arg")
-    end
+      local key_row = result:start() + 1
+      assert.are.equal(test.exp_key_row, key_row)
+    end)
+  end
+end)
 
-    local assert_items = function(exp_list)
-      assert.are.equal(#exp_list, #result)
-      for idx, exp in ipairs(exp_list) do
-        assert_item(idx, exp)
+describe("analyzer.find_call_t_expressions", function()
+  --- @param get_project function(): test.Project
+  --- @param file string
+  --- @param assertion function(result: FindTExpressionResultItem[], utils: table)
+  local function test_analyze_file(get_project, file, assertion)
+    it("should find 't' function calls in " .. file, function()
+      --Arrange
+      local project = get_project()
+      vim.cmd("e " .. project.path .. "/test_analyzer/" .. file)
+
+      -- Act
+      local result = analyzer.find_call_t_expressions(0)
+
+      local assert_item = function(idx, exp)
+        local item = result[idx]
+
+        local function assert_key_value(key)
+          -- stylua: ignore start
+          assert(
+            exp[key] == item[key],
+            string.format("result[%d].%s to be equal.\nPassed:\n(%s) %s\nExpected:\n(%s) %s",
+              idx, key, type(item[key]), item[key], type(exp[key]), exp[key])
+          )
+          -- stylua: ignore end
+        end
+        assert_key_value("key")
+        assert_key_value("key_prefix")
+        assert_key_value("key_arg")
       end
-    end
 
-    -- Assert
-    assertion(result, {
-      assert_item = assert_item,
-      assert_items = assert_items,
-    })
-  end)
-end
-
---- @param get_project function(): test.Project
---- @param text string
---- @param expected boolean
-local function test_find_t_call(get_project, text, expected)
-  local assertion = expected and "should" or "should NOT"
-  it(assertion .. " find 't' function calls in `" .. text .. "`", function()
-    -- Arrange
-    local project = get_project()
-    vim.cmd("e " .. project.path .. "/index.js")
-    vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.split(text, "\n"))
-
-    -- Act
-    local result = analyzer.find_call_t_expressions(0)
-
-    -- Assert
-    assert.are.equal(expected and 1 or 0, #result)
-  end)
-end
+      local assert_items = function(exp_list)
+        assert.are.equal(#exp_list, #result)
+        for idx, exp in ipairs(exp_list) do
+          assert_item(idx, exp)
+        end
+      end
+
+      -- Assert
+      assertion(result, {
+        assert_item = assert_item,
+        assert_items = assert_items,
+      })
+    end)
+  end
+
+  --- @param get_project function(): test.Project
+  --- @param text string
+  --- @param expected boolean
+  local function test_find_t_call(get_project, text, expected)
+    local assertion = expected and "should" or "should NOT"
+    it(assertion .. " find 't' function calls in `" .. text .. "`", function()
+      -- Arrange
+      local project = get_project()
+      vim.cmd("e " .. project.path .. "/index.js")
+      vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.split(text, "\n"))
+
+      -- Act
+      local result = analyzer.find_call_t_expressions(0)
+
+      -- Assert
+      assert.are.equal(expected and 1 or 0, #result)
+    end)
+  end
 
-describe("analyzer.find_call_t_expressions", function()
   describe("when using 'i18next'", function()
     --- @type test.Project
     local project = nil