fix!: require tree-sitter-regexp 0.21 and nvim 0.9.5

Author: bennypowers

lua/regexplainer.lua

@@ -39,8 +39,7 @@ local au = vim.api.nvim_create_autocmd
 local config_command_map = {
   show       = { 'RegexplainerShow', 'Show Regexplainer' },
   hide       = { 'RegexplainerHide', 'Hide Regexplainer' },
-  toggle     = { 'RegexplainerToggle', 'Toggle Regexplainer' },
-  yank       = { 'RegexplainerYank', 'Yank Regexplainer' },
+  toggle     = { 'RegexplainerToggle', 'Toggle Regexplainer' }, yank       = { 'RegexplainerYank', 'Yank Regexplainer' },
   show_split = { 'RegexplainerShowSplit', 'Show Regexplainer in a split Window' },
   show_popup = { 'RegexplainerShowPopup', 'Show Regexplainer in a popup' },
 }
@@ -79,27 +78,23 @@ local local_config = extend('keep', default_config, {})
 ---@param options? RegexplainerOptions overrides for this call
 ---@return nil|number bufnr the bufnr of the regexplaination
 --
-local function show(options)
+local function show_for_real(options)
   options = extend('force', local_config, options or {})
-  local node, error = tree.get_regexp_pattern_at_cursor()
+  local node, scratchnr, error = tree.get_regexp_pattern_at_cursor()
 
   if error and options.debug then
     utils.notify('Rexexplainer: ' .. error, 'debug')
-  elseif node then
-    ---@type RegexplainerRenderer
-    local renderer
+  elseif node and scratchnr then
     ---@type boolean, RegexplainerRenderer
-    local can_render, _renderer = pcall(require, 'regexplainer.renderers.' .. options.mode)
+    local can_render, renderer = pcall(require, 'regexplainer.renderers.' .. options.mode)
 
-    if can_render then
-      renderer = _renderer
-    else
+    if not can_render then
       utils.notify(options.mode .. ' is not a valid renderer', 'warning')
       utils.notify(renderer, 'error')
       renderer = require 'regexplainer.renderers.narrative'
     end
 
-    local components = component.make_components(node, nil, node)
+    local components = component.make_components(scratchnr, node, nil, node)
 
     local buffer = Buffers.get_buffer(options)
 
@@ -112,17 +107,17 @@ local function show(options)
                    components,
                    options,
                    {
-                     full_regexp_text = get_node_text(node, 0),
+                     full_regexp_text = get_node_text(node, scratchnr),
                    })
-    return buffer.bufnr
+    return scratchnr
   else
     Buffers.hide_all()
   end
 end
 
 local disable_auto = false
 
-local show_debounced_trailing, timer_trailing = defer.debounce_trailing(show, 5)
+local show_debounced_trailing, timer_trailing = defer.debounce_trailing(show_for_real, 5)
 
 Buffers.register_timer(timer_trailing)
 
@@ -132,9 +127,11 @@ local M = {}
 ---@param options? RegexplainerOptions
 function M.show(options)
   disable_auto = true
-  local bufnr = show(options)
+  local scratchnr = show_for_real(options)
   disable_auto = false
-  return bufnr
+  if scratchnr then
+    vim.api.nvim_buf_delete(scratchnr, { force = true })
+  end
 end
 
 --- Yank the explainer for the regexp under the cursor into a given register
@@ -144,11 +141,7 @@ function M.yank(options)
   if type(options) == 'string' then
     options = { register = options }
   end
-  show(vim.tbl_deep_extend(
-    'force',
-    options,
-    { display = 'register' }
-  ))
+  show_for_real(vim.tbl_deep_extend('force', options, { display = 'register' }))
   disable_auto = false
 end
 
@@ -219,7 +212,7 @@ end
 function M.debug_components()
   ---@type any
   local mode = 'debug'
-  show({ auto = false, display = 'split', mode = mode })
+  show_for_real({ auto = false, display = 'split', mode = mode })
 end
 
 return M

lua/regexplainer/component/init.lua

@@ -117,14 +117,6 @@ function M.is_lookaround_assertion(component)
   return component.type:find('^lookaround_assertion') ~= nil
 end
 
----@param component RegexplainerComponent
----@return boolean
---
-function M.is_lookbehind_assertion(component)
-  return component.type:find('^lookaround_assertion') ~= nil
-end
-
-
 -- Does a container component contain nothing by pattern_characters?
 ---@param component RegexplainerComponent
 ---@return boolean
@@ -201,13 +193,14 @@ end
 ---@alias TreesitterNode any
 
 --- Transform a treesitter node to a table of components which are easily rendered
+---@param bufnr           number
 ---@param node            TSNode
----@param parent?         TSNode
+---@param parent?         RegexplainerComponent
 ---@param root_regex_node TSNode
 ---@return RegexplainerComponent[]
 --
-function M.make_components(node, parent, root_regex_node)
-  local text = get_node_text(node, 0)
+function M.make_components(bufnr, node, parent, root_regex_node)
+  local text = get_node_text(node, bufnr)
   local cached = lookuptables[text]
   if cached then return cached end
 
@@ -226,7 +219,7 @@ function M.make_components(node, parent, root_regex_node)
   for child in node:iter_children() do
     local type = child:type()
 
-    local child_text = get_node_text(child, 0)
+    local child_text = get_node_text(child, bufnr)
 
     local previous = components[#components]
 
@@ -298,40 +291,18 @@ function M.make_components(node, parent, root_regex_node)
       -- see https://github.com/tree-sitter/tree-sitter-javascript/issues/214
       --
     elseif type == 'ERROR' then
-      local error_text = get_node_text(child, 0)
+      local error_text = get_node_text(child, bufnr)
       local row, e_start, _, e_end = child:range()
       local _, re_start = node:range()
-
-      -- TODO: until treesitter supports lookbehind, we can parse it ourselves
-      -- This code, however, is not ready to use
-
-      local from_re_start_to_err_start = e_start - re_start + 1
-
-      local error_term_text = text:sub(from_re_start_to_err_start)
-
-      local lookbehind = error_term_text:match [[(%(%?<!?(.*)%))]]
-
-      local is_lookbehind = lookbehind ~= nil
-
-      if is_lookbehind then
-        table.insert(components, {
-          type = 'lookbehind_assertion',
-          text = lookbehind,
-          negative = lookbehind:match [[^%(%?<!]] ~= nil,
-          depth = (parent and parent.depth or 0) + 1,
-          children = M.make_components(child, nil, root_regex_node)
-        })
-      else
-        table.insert(components, {
-          type = type,
-          text = get_node_text(child, 0),
-          error = {
-            text = error_text,
-            position = { row, { e_start, e_end } },
-            start_offset = re_start,
-          },
-        })
-      end
+      table.insert(components, {
+        type = type,
+        text = get_node_text(child, bufnr),
+        error = {
+          text = error_text,
+          position = { row, { e_start, e_end } },
+          start_offset = re_start,
+        },
+      })
       -- all other node types should be added to the tree
     else
 
@@ -349,12 +320,12 @@ function M.make_components(node, parent, root_regex_node)
       -- negated character class
       if type == 'character_class' and component.text:find [[^%[%^]] then
         component.negative = true
-        component.children = M.make_components(child, nil, root_regex_node)
+        component.children = M.make_components(bufnr, child, nil, root_regex_node)
         table.insert(components, component)
 
         -- alternations are containers which do not increase depth
       elseif type == 'alternation' then
-        component.children = M.make_components(child, nil, root_regex_node)
+        component.children = M.make_components(bufnr, child, nil, root_regex_node)
         table.insert(components, component)
 
         -- skip group_name and punctuation nodes
@@ -372,7 +343,7 @@ function M.make_components(node, parent, root_regex_node)
             -- find the group_name and apply it to the component
             for grandchild in child:iter_children() do
               if node_pred.is_group_name(grandchild) then
-                component.group_name = get_node_text(grandchild, 0)
+                component.group_name = get_node_text(grandchild, bufnr)
                 break
               end
             end
@@ -387,7 +358,7 @@ function M.make_components(node, parent, root_regex_node)
           end
 
           -- once state has been set above, process the children
-          component.children = M.make_components(child, component, root_regex_node)
+          component.children = M.make_components(bufnr, child, component, root_regex_node)
 
           -- FIXME: find the root cause of this weird case
           if #component.children == 1

lua/regexplainer/renderers/narrative/init.lua

@@ -5,28 +5,11 @@ local buffers   = require 'regexplainer.buffers'
 --
 local M = {}
 
-local function check_for_lookbehind(components)
-  for _, component in ipairs(components) do
-    if component.type == 'lookbehind_assertion' or check_for_lookbehind(component.children or {}) then
-      return true
-    end
-  end
-  return false
-end
-
 ---@param components RegexplainerComponent[]
 ---@param options    RegexplainerOptions
 ---@param state      RegexplainerRendererState
 function M.get_lines(components, options, state)
-  local lines = narrative.recurse(components, options, state)
-  local found = check_for_lookbehind(components)
-  if found then
-    table.insert(lines, 1, '⚠️ **Lookbehinds are poorly supported**')
-    table.insert(lines, 2, '⚠️ results may not be accurate')
-    table.insert(lines, 3, '⚠️ See https://github.com/tree-sitter/tree-sitter-regex/issues/13')
-    table.insert(lines, 4, '')
-  end
-  return lines
+  return narrative.recurse(components, options, state)
 end
 
 ---@param buffer RegexplainerBuffer

lua/regexplainer/utils/treesitter.lua

@@ -1,10 +1,11 @@
 local M = {}
 
+local get_cursor = vim.api.nvim_win_get_cursor
 local get_query = vim.treesitter.query.get
 local get_parser = vim.treesitter.get_parser
-local get_node_text = vim.treesitter.get_node_text or vim.treesitter.query.get_node_text
-local get_node = vim.treesitter.get_node
+local get_node_text = vim.treesitter.get_node_text or vim.treesitter.query.get_node_text local get_node = vim.treesitter.get_node
 local get_captures_at_cursor = vim.treesitter.get_captures_at_cursor
+local is_in_node_range = vim.treesitter.is_in_node_range
 
 local node_types = {
   'alternation',
@@ -40,6 +41,24 @@ for _, type in ipairs(node_types) do
   end
 end
 
+---@param original_node TSNode regex_pattern node
+---@return TSNode|nil, integer|nil, string|nil
+local function get_pattern(original_node)
+  local buf = vim.api.nvim_create_buf(false, false)
+  vim.api.nvim_buf_set_lines(buf, 0, 1,true, { get_node_text(original_node, 0) })
+  local node
+  for _, tree in ipairs(get_parser(buf, 'regex'):parse()) do
+    node = tree:root()
+    while node and node:type() ~= 'pattern' do
+      node = node:child(0)
+    end
+  end
+  if node and node:type() == 'pattern' then
+    return node, buf, nil
+  end
+  return nil, buf, 'could not find pattern node'
+end
+
 function M.has_regexp_at_cursor()
   for _, cap in ipairs(get_captures_at_cursor(0)) do
     if cap == 'string.regexp' then
@@ -113,25 +132,27 @@ end
 
 --- Using treesitter, find the current node at cursor, and traverse up to the
 --- document root to determine if we're on a regexp
----@return any, string|nil
+---@return TSNode|nil, integer|nil, string|nil
 --
 function M.get_regexp_pattern_at_cursor()
-  local lang_tree = vim.treesitter.get_parser(0, 'regex')
-  local query = vim.treesitter.query.get('regex', 'regexplainer')
-  if query then
-    local cursor_range = vim.api.nvim_win_get_cursor(0)
-    local cursor_row, cursor_col = unpack(cursor_range)
-    local cursor_node = get_node_at_cursor(lang_tree)
-    if cursor_node then
-      for id, node in query:iter_captures(cursor_node:tree():root(), 0) do
-        local name = query.captures[id] -- name of the capture in the query
-        if name == 'regexplainer.pattern' and is_in_node_range(node, cursor_row - 1, cursor_col) then
-          return node, nil
-        end
-      end
+  local parser = get_parser(0)
+        parser:parse()
+  local query = get_query(parser:lang(), 'regexplainer')
+  if not query then
+    return nil, nil, 'could not load regexplainer query for ' .. parser:lang()
+  end
+  local cursor_node = get_node()
+  if not cursor_node then
+    return nil, nil, 'could not get node at cursor'
+  end
+  local row, col = cursor_node:range()
+  for id, node in query:iter_captures(cursor_node:tree():root(), 0, row, row + 1) do
+    local name = query.captures[id] -- name of the capture in the query
+    if name == 'regexplainer.pattern' and is_in_node_range(node, row, col) then
+      return get_pattern(node)
     end
   end
-  return nil, 'no node'
+  return nil, nil, 'no node'
 end
 
 return M

queries/javascript/regexplainer.scm

@@ -1 +1,2 @@
-(regex) @regexplainer.regex
+(regex
+  (regex_pattern) @regexplainer.pattern) @regexplainer.regex