feat(footnotes): Use footnotes from tree-sitter grammar (#1140)

Author: kristijanhusak

docs/configuration.org

@@ -2969,6 +2969,8 @@ The following highlight groups are used:
 - =@org.agenda.today=: Highlight for today in Agenda view - linked to =@org.bold=
 - =@org.agenda.weekend=: Highlight for weekend days in Agenda view - linked to =@org.bold=
 - =@org.agenda.weekend.today=: Highlight for today when it is a weekend day in Agenda view - linked to =@org.bold=
+- =@org.footnote=: Highlight for footnote definition - linked to =@markup.link.url=
+- =@org.footnote.reference=: Highlight for footnote reference - linked to =@markup.link.url=
 
 📝 NOTE:
 Colors used for todo keywords and agenda states (deadline, schedule ok,

lua/orgmode/colors/highlighter/markup/footnotes.lua

@@ -22,7 +22,6 @@ end
 function OrgMarkup:_init_highlighters()
   self.parsers = {
     emphasis = require('orgmode.colors.highlighter.markup.emphasis'):new({ markup = self }),
-    footnote = require('orgmode.colors.highlighter.markup.footnotes'):new({ markup = self }),
     latex = require('orgmode.colors.highlighter.markup.latex'):new({ markup = self }),
   }
 end
@@ -77,7 +76,6 @@ function OrgMarkup:get_node_highlights(root_node, source, line)
   local result = {
     emphasis = {},
     latex = {},
-    footnote = {},
   }
   ---@type OrgMarkupNode[]
   local entries = {}

lua/orgmode/colors/highlighter/markup/init.lua

@@ -67,6 +67,7 @@ function M.link_highlights()
     ['@org.latex'] = '@markup.math',
     ['@org.latex_env'] = '@markup.environment',
     ['@org.footnote'] = '@markup.link.url',
+    ['@org.footnote.reference'] = '@markup.link.url',
     -- Other
     ['@org.table.delimiter'] = '@punctuation.special',
     ['@org.table.heading'] = '@markup.heading',

lua/orgmode/colors/highlights.lua

@@ -836,59 +836,38 @@ function OrgFile:get_links()
   return links
 end
 
-memoize('get_footnote_references')
----@return OrgFootnote[]
-function OrgFile:get_footnote_references()
+---@param footnote_reference OrgFootnote
+---@return OrgFootnote | nil
+function OrgFile:find_footnote_definition(footnote_reference)
   self:parse(true)
-  local ts_query = ts_utils.get_query([[
-      (paragraph (expr) @footnotes)
-      (drawer (contents (expr) @footnotes))
-      (headline (item (expr)) @footnotes)
-      (fndef) @footnotes
-  ]])
+  local ts_query = ts_utils.get_query(([[
+      (fndef label: (expr) @_label (#eq? @_label "%s")) @footnotes
+  ]]):format(footnote_reference.label))
 
-  local footnotes = {}
-  local processed_lines = {}
   for _, match in ts_query:iter_captures(self.root, self:get_source()) do
-    local line_start, _, line_end = match:range()
-    if not processed_lines[line_start] then
-      if line_start == line_end then
-        vim.list_extend(footnotes, Footnote.all_from_line(self.lines[line_start + 1], line_start + 1))
-        processed_lines[line_start] = true
-      else
-        for line = line_start, line_end - 1 do
-          vim.list_extend(footnotes, Footnote.all_from_line(self.lines[line + 1], line + 1))
-          processed_lines[line] = true
-        end
-      end
+    if match and match:type() == 'fndef' then
+      return Footnote.from_node(match, self:get_source())
     end
   end
-  return footnotes
 end
 
----@param footnote_reference OrgFootnote
+---@param footnote_definition OrgFootnote
 ---@return OrgFootnote | nil
-function OrgFile:find_footnote(footnote_reference)
-  local footnotes = self:get_footnote_references()
-  for i = #footnotes, 1, -1 do
-    if footnotes[i].value:lower() == footnote_reference.value:lower() and footnotes[i].range.start_col == 1 then
-      return footnotes[i]
-    end
-  end
-end
+function OrgFile:find_footnote_reference(footnote_definition)
+  self:parse(true)
+  local ts_query = ts_utils.get_query(([[
+      (fnref label: (expr) @_label (#eq? @_label "%s")) @footnotes
+  ]]):format(footnote_definition.label))
 
----@param footnote OrgFootnote
----@return OrgFootnote | nil
-function OrgFile:find_footnote_reference(footnote)
-  local footnotes = self:get_footnote_references()
-  for i = #footnotes, 1, -1 do
-    if
-      footnotes[i].value:lower() == footnote.value:lower()
-      and footnotes[i].range.start_line < footnote.range.start_line
-    then
-      return footnotes[i]
+  local matches = {}
+  for _, match in ts_query:iter_captures(self.root, self:get_source()) do
+    if match:type() == 'fnref' then
+      table.insert(matches, match)
     end
   end
+  if #matches > 0 then
+    return Footnote.from_node(matches[#matches], self:get_source())
+  end
 end
 
 memoize('get_directive')

lua/orgmode/files/file.lua

@@ -1,54 +1,45 @@
 local Range = require('orgmode.files.elements.range')
+local ts_utils = require('orgmode.utils.treesitter')
 
 ---@class OrgFootnote
----@field value string
----@field range? OrgRange
+---@field label string
+---@field range OrgRange
+---@field is_reference boolean
 local OrgFootnote = {}
 OrgFootnote.__index = OrgFootnote
 
-local pattern = '%[fn:[^%]]+%]'
-
----@param str string
----@param range? OrgRange
+---@param label string
+---@param range OrgRange
+---@param is_reference boolean
 ---@return OrgFootnote
-function OrgFootnote:new(str, range)
+function OrgFootnote:new(label, range, is_reference)
   local this = setmetatable({}, { __index = OrgFootnote })
-  this.value = str
+  this.label = label
   this.range = range
+  this.is_reference = is_reference or false
   return this
 end
 
 function OrgFootnote:get_name()
-  local name = self.value:match('^%[fn:([^%]]+)%]$')
-  return name
+  return self.label
 end
 
+---@param node TSNode | nil
+---@param source? number | string
 ---@return OrgFootnote | nil
-function OrgFootnote.at_cursor()
-  local line_nr = vim.fn.line('.')
-  local col = vim.fn.col('.') or 0
-  local on_line = OrgFootnote.all_from_line(vim.fn.getline('.'), line_nr)
+function OrgFootnote.from_node(node, source)
+  local fnode = ts_utils.closest_node(ts_utils.get_node(), { 'fnref', 'fndef' })
+  if not fnode then
+    return nil
+  end
 
-  return vim.iter(on_line):find(function(footnote)
-    return footnote.range:is_in_range(line_nr, col)
-  end)
+  local text = vim.treesitter.get_node_text(fnode:field('label')[1], source or 0)
+  return OrgFootnote:new(text, Range.from_node(node), fnode:type() == 'fnref')
 end
 
----@return OrgFootnote[]
-function OrgFootnote.all_from_line(line, line_number)
-  local links = {}
-  for link in line:gmatch(pattern) do
-    local start_from = #links > 0 and links[#links].range.end_col or nil
-    local from, to = line:find(pattern, start_from)
-    if from and to then
-      local range = Range.from_line(line_number)
-      range.start_col = from
-      range.end_col = to
-      table.insert(links, OrgFootnote:new(link, range))
-    end
-  end
-
-  return links
+---@return OrgFootnote | nil
+function OrgFootnote.at_cursor()
+  return OrgFootnote.from_node(ts_utils.get_node(), vim.api.nvim_get_current_buf())
 end
 
 return OrgFootnote

lua/orgmode/objects/footnote.lua

@@ -917,14 +917,28 @@ function OrgMappings:open_at_point()
 
   local footnote = Footnote.at_cursor()
   if footnote then
-    return self:_jump_to_footnote(footnote)
+    if footnote.is_reference then
+      return self:_jump_to_footnote_definition(footnote)
+    end
+    return self:_jump_to_footnote_reference(footnote)
   end
 end
 
+function OrgMappings:_jump_to_footnote_reference(footnote_definition)
+  local file = self.files:get_current_file()
+  local reference = file:find_footnote_reference(footnote_definition)
+
+  if not reference then
+    return utils.echo_info(('Cannot find reference for footnote "%s"'):format(footnote_definition:get_name()))
+  end
+
+  return vim.fn.cursor({ reference.range.start_line, reference.range.start_col })
+end
+
 ---@param footnote_reference OrgFootnote
-function OrgMappings:_jump_to_footnote(footnote_reference)
+function OrgMappings:_jump_to_footnote_definition(footnote_reference)
   local file = self.files:get_current_file()
-  local footnote = file:find_footnote(footnote_reference)
+  local footnote = file:find_footnote_definition(footnote_reference)
 
   if not footnote then
     local choice = vim.fn.confirm('No footnote found. Create one?', '&Yes\n&No')
@@ -933,31 +947,20 @@ function OrgMappings:_jump_to_footnote(footnote_reference)
     end
 
     local footnotes_headline = file:find_headline_by_title('footnotes')
+    local fndef = ('[fn:%s] '):format(footnote_reference.label)
     if footnotes_headline then
       local append_line = footnotes_headline:get_append_line()
-      vim.api.nvim_buf_set_lines(0, append_line, append_line, false, { footnote_reference.value .. ' ' })
-      vim.fn.cursor({ append_line + 1, #footnote_reference.value + 1 })
+      vim.api.nvim_buf_set_lines(0, append_line, append_line, false, { fndef })
+      vim.fn.cursor({ append_line + 1, #fndef })
       return vim.cmd('startinsert!')
     end
     local last_line = vim.api.nvim_buf_line_count(0)
-    vim.api.nvim_buf_set_lines(0, last_line, last_line, false, { '', '* Footnotes', footnote_reference.value .. ' ' })
-    vim.fn.cursor({ last_line + 3, #footnote_reference.value + 1 })
+    vim.api.nvim_buf_set_lines(0, last_line, last_line, false, { '', '* Footnotes', fndef })
+    vim.fn.cursor({ last_line + 3, #fndef })
     return vim.cmd('startinsert!')
   end
 
-  local is_footnote_marker = footnote.range:is_same(footnote_reference.range)
-
-  if not is_footnote_marker then
-    return vim.fn.cursor({ footnote.range.start_line, footnote.range.start_col })
-  end
-
-  local reference = file:find_footnote_reference(footnote)
-
-  if reference then
-    return vim.fn.cursor({ reference.range.start_line, reference.range.start_col })
-  end
-
-  utils.echo_info(('Cannot find reference for footnote "%s"'):format(footnote_reference:get_name()))
+  return vim.fn.cursor({ footnote.range.start_line, footnote.range.start_col })
 end
 
 function OrgMappings:export()