refactor!: don't use autocmd to format new notes

- standardise and rename format_notes and format_references options
- keep track of popups to prep for handling multi select and open notes
  in search

Author: jghauser

README.md

@@ -392,7 +392,7 @@ enable_icons = true,
   -- This function runs when first opening a new note. The `entry` arg is a table
   -- containing all the information about the entry (see above `data_tbl_schema`).
   -- This example is meant to be used with the `markdown` filetype.
-  format_notes_fn = function(entry)
+  format_notes = function(entry)
     -- Some string formatting templates (see above `results_format` option for
     -- more details)
     local title_format = {
@@ -413,14 +413,11 @@ enable_icons = true,
       "---",
       "",
     }
-    -- Insert the lines
-    vim.api.nvim_buf_set_lines(0, 0, #lines, false, lines)
-    -- Move cursor to the bottom
-    vim.cmd("normal G")
+    return lines
   end,
   -- This function runs when inserting a formatted reference (currently by `f/c-f` in
-  -- Telescope). It works similarly to the `format_notes_fn` above.
-  format_references_fn = function(entry)
+  -- Telescope). It works similarly to the `format_notes` above.
+  format_references = function(entry)
     local reference_format = {
       { "author",  "%s ",   "" },
       { "year",    "(%s). ", "" },
@@ -433,7 +430,8 @@ enable_icons = true,
     for k, v in ipairs(reference_data) do
       reference_data[k] = v[1]
     end
-    return table.concat(reference_data)
+    local lines = { table.concat(reference_data) }
+    return lines
   end,
 },
 

lua/papis/config.lua

@@ -85,7 +85,7 @@ local default_config = {
   papis_conf_keys = { "info-name", "notes-name", "dir", "opentool" },
   enable_icons = true,
   ["formatter"] = {
-    format_notes_fn = function(entry)
+    format_notes = function(entry)
       local title_format = {
         { "author", "%s ",   "" },
         { "year",   "(%s) ", "" },
@@ -101,10 +101,9 @@ local default_config = {
         "---",
         "",
       }
-      vim.api.nvim_buf_set_lines(0, 0, #lines, false, lines)
-      vim.cmd("normal G")
+      return lines
     end,
-    format_references_fn = function(entry)
+    format_references = function(entry)
       local reference_format = {
         { "author",  "%s ",    "" },
         { "year",    "(%s). ", "" },
@@ -117,7 +116,8 @@ local default_config = {
       for k, v in ipairs(reference_data) do
         reference_data[k] = v[1]
       end
-      return table.concat(reference_data)
+      local lines = { table.concat(reference_data) }
+      return lines
     end,
   },
   ["at-cursor"] = {

lua/papis/formatter/init.lua

@@ -6,28 +6,23 @@
 --
 
 local log = require("papis.log")
+local config = require("papis.config")
 
-local create_autocmd = vim.api.nvim_create_autocmd
-local create_augroup = vim.api.nvim_create_augroup
-
-local augroup = create_augroup("papisFormatter", { clear = true })
-local autocmd = {
-  pattern = nil,
-  callback = nil,
-  group = augroup,
-  once = true,
-  desc = "Papis: format a newly created note",
-}
+local api = vim.api
 
 local M = {}
 
-function M.create_autocmd(pattern, callback, entry)
-  autocmd.pattern = pattern
-  autocmd.callback = function()
-    log.debug("Running formatter callback...")
-    callback(entry)
-  end
-  create_autocmd("BufEnter", autocmd)
+function M.format_entire_file(entry)
+  log.debug("Formatting new notes file")
+  local lines = config["formatter"].format_notes(entry)
+  local notes_path = entry.notes[1]
+  local buf = api.nvim_create_buf(false, false)
+  api.nvim_buf_set_name(buf, notes_path)
+  api.nvim_buf_set_lines(buf, 0, #lines, false, lines)
+  api.nvim_buf_call(buf, function()
+    vim.cmd('write')
+  end)
+  api.nvim_buf_delete(buf, {})
 end
 
 return M

lua/papis/utils.lua

@@ -110,6 +110,7 @@ function M:do_open_attached_files(papis_id)
   end
 end
 
+local popups = {}
 ---Opens a text file with neovim, asking to select one if there are multiple buf_options
 ---@param papis_id string #The `papis_id` of the entry
 ---@param type string #Either "note" or "info", specifying the type of file
@@ -137,7 +138,8 @@ function M:do_open_text_file(papis_id, type)
       for _, line in pairs(lines_text) do
         width = math.max(width, #line[1])
       end
-      local popup = NuiPopup({
+      local current_popup = #popups + 1
+      popups[current_popup] = NuiPopup({
         enter = true,
         position = "50%",
         size = {
@@ -154,28 +156,25 @@ function M:do_open_text_file(papis_id, type)
         },
       })
 
-      popup:map("n", { "Y", "y", "<cr>" }, function(_)
-        popup:unmount()
+      popups[current_popup]:map("n", { "Y", "y", "<cr>" }, function(_)
+        popups[current_popup]:unmount()
+        popups[current_popup] = nil
         local config = require("papis.config")
         local create_new_note_fn = config.create_new_note_fn
         local notes_name = db.config:get_conf_value("notes_name")
-        local enable_modules = config.enable_modules
         create_new_note_fn(papis_id, notes_name)
-        if enable_modules["formatter"] then
-          entry = db.data:get({ papis_id = papis_id })[1]
-          local pattern = [[*]] .. notes_name:match("^.+(%..+)$")
-          log.debug("Formatter autocmd pattern: " .. vim.inspect(pattern))
-          local callback = config["formatter"].format_notes_fn
-          require("papis.formatter").create_autocmd(pattern, callback, entry)
-        end
         local entry_has_note = new_timer()
         local file_opened = false
         entry_has_note:start(
           0,
           5,
           vim.schedule_wrap(function()
-            entry = db.data:get({ papis_id = papis_id }, { "notes" })[1]
+            entry = db.data:get({ papis_id = papis_id })[1]
             if entry.notes and not file_opened then
+              local enable_modules = config.enable_modules
+              if enable_modules["formatter"] then
+                require("papis.formatter").format_entire_file(entry)
+              end
               log.debug("Opening newly created notes file")
               self:do_open_text_file(papis_id, type)
               file_opened = true
@@ -185,22 +184,24 @@ function M:do_open_text_file(papis_id, type)
           end)
         )
       end, { noremap = true, nowait = true })
-      popup:map("n", { "N", "n", "<esc>", "q" }, function(_)
-        popup:unmount()
+      popups[current_popup]:map("n", { "N", "n", "<esc>", "q" }, function(_)
+        popups[current_popup]:unmount()
+        popups[current_popup] = nil
       end, { noremap = true, nowait = true })
 
-      popup:on({ nuiEvent.BufLeave }, function()
-        popup:unmount()
+      popups[current_popup]:on({ nuiEvent.BufLeave }, function()
+        popups[current_popup]:unmount()
+        popups[current_popup] = nil
       end, { once = true })
 
       for k, line in pairs(lines_text) do
         local nuiline = NuiLine()
         nuiline:append(unpack(line))
-        nuiline:render(popup.bufnr, -1, k)
+        nuiline:render(popups[current_popup].bufnr, -1, k)
       end
 
       vim.schedule(function()
-        popup:mount()
+        popups[current_popup]:mount()
       end)
     end
   elseif type == "info" then

lua/telescope/_extensions/papis/actions.lua

@@ -55,14 +55,15 @@ M.ref_insert_formatted = function(prompt_bufnr)
   if vim.tbl_isempty(multi) then
     local papis_id = action_state.get_selected_entry().id.papis_id
     local full_entry = db.data:get({ papis_id = papis_id })[1]
-    local full_reference = config["formatter"].format_references_fn(full_entry)
-    string_to_insert = full_reference
+    local full_reference = config["formatter"].format_references(full_entry)
+    string_to_insert = full_reference[1]
   else
     for _, entry in pairs(multi) do
       local papis_id = entry.id.papis_id
       local full_entry = db.data:get({ papis_id = papis_id })[1]
-      local full_reference = config["formatter"].format_references_fn(full_entry)
-      string_to_insert = string_to_insert .. full_reference .. " "
+      local full_reference = config["formatter"].format_references(full_entry)
+      -- TODO: this should be able to use arbitary length `full_reference`s
+      string_to_insert = string_to_insert .. full_reference[1] .. " "
     end
   end