refactor: simplify opener logic

Author: wincent

ARCHITECTURE.md

@@ -18,7 +18,7 @@ These finders are hard-coded in the Command-T source code as functions.
 
 In the following discussion, note that there are a few sets of confusing, overlapping, or overloading terms that would make a good target for refactoring:
 
-- "open", "on_open", "opener": used at various layers of abstraction for configuration key names, callbacks, parameters, and so on.
+- "open", "on_open": used at various layers of abstraction for configuration key names, callbacks, parameters, and so on.
 - "config" vs "options": used to describe user-supplied settings, defaults, and also function-level parameters.
 
 ## List-based finder life-cycle
@@ -39,7 +39,7 @@ In the following discussion, note that there are a few sets of confusing, overla
    1. It looks up the finder config under the `name` key (`'buffer'`, for example) of the user's settings (obtained via a call to `commandt.options()`, which returns a _copy_ of the user's settings, or falls back to the defaults if there are no explicit user settings).
    2. If the config defines an `options` callback, it calls the callback with the existing options so that it has an opportunity to transform those options, and then sanitizes them. This is used by several finders to force the display of dotfiles (ie. by unconditionally setting `always_show_dot_files` to `true`, and `never_show_dot_files` to `false`); specifically, the `'buffer'`, `'help'`, `'history'`, `'jump'`, `'line'`, `'search'`, and `'tag'` finders.
    3. If the config defines an `on_directory` callback, it calls the callback with the directory to give it the opportunity to transform the directory. This is used by finders which change their root directory based on the `commandt.traverse` setting; if no directory is provided, and the user settings require it, the callback will attempt to infer an appropriate directory, using the current working directory as a fallback. Finders which use `on_directory` include `'fd'`, `'find'`, `'git'`, and `'rg'`.
-   4. It prepares an `open` callback with signature `open(item, ex_command)` and assigns it back to the `options` object that will be passed into the `finders.list` or `finders.command` implementation, and also into `ui.show()`. This `open` callback will in turn forward to the `open` implementation specified in the config, if provided, otherwise falling back to `commandt.open(item, ex_command)` which is otherwise known as `sbuffer(buffer, command)` (it's called "smart" because it tries to intelligently pick the right place to open the requested buffer). Finders which specify a custom `'open'` in their config include `'fd'`, `'find'`, `'git'`, and `'rg'`; which all pass in an `on_open(item, ex_command, directory, _options, opener, _context)` implementation which uses the `opener` to open a relativized path (ie. `opener(relativize(directory, item), ex_command)`); note that the `opener` here is actually `commandt.open` (ie. `sbuffer()`). In contrast, the `'help'`, `'history'`, `'line'`, `'search'`, and `'tag'` finders define totally custom open callbacks. Finally, the `'buffer'` and `'jump'` finders define nothing, which means they use the fallback.
+   4. It prepares an `open` callback with signature `open(item, ex_command)` and assigns it back to the `options` object that will be passed into the `finders.list` or `finders.command` implementation, and also into `ui.show()`. This `open` callback will in turn forward to the `open` implementation specified in the config, if provided, otherwise falling back to `commandt.open(item, ex_command)` which is otherwise known as `sbuffer(buffer, command)` (it's called "smart" because it tries to intelligently pick the right place to open the requested buffer). Finders which specify a custom `'open'` in their config include `'fd'`, `'find'`, `'git'`, and `'rg'`; which all pass in an `on_open(item, ex_command, directory, _options, _context)` implementation which uses `sbuffer()` to open a relativized path (ie. `sbuffer(relativize(directory, item), ex_command)`). In contrast, the `'help'`, `'history'`, `'line'`, `'search'`, and `'tag'` finders define totally custom open callbacks. Finally, the `'buffer'` and `'jump'` finders define nothing, which means they use the fallback.
    5. If the finder config provides a `candidates` field, it obtains the actual list finder and context by passing in the `directory`, `config.candidates`, and `options`. Otherwise, it must contain a `command` field and it obtains a command finder passing in `directory`, `config.command`, `options`, and `name` (the `name` is used to look up finder-specific settings in the `options`).
    6. If the finder config provides a `fallback` field set to `true`, it adds the fallback finder to the `finder` object, passing in the original `finder`, `directory`, and `options` (this fallback finder is a lazy wrapper around the built-in file finder, which gets invoked if the primary finder fails.
    7. It invokes `ui.show()`, passing in the `finder` and `options`, merging in three additional settings: `name`, `mode` (`mode` is `'virtual'`, `'file'` or `nil`), and an `on_close` callback set to `config.on_close`. Finders which actually specify an `on_close` are `'fd'`, `'find'`, `'rg'`, and the built-in file finders; they all use `popd` for this purpose, to reset to the original working directory in case the user specified a temporary directory as an argument to those finders (the watchman finder doesn't need this as it does not change into a temporary directory even when the user specifies a directory argument).
@@ -49,7 +49,7 @@ In the following discussion, note that there are a few sets of confusing, overla
    1. `Prompt.new()` captures various settings, including `on_open` and `mappings`. It creates a window with `Window.new()` and `self._window:show()`, and sets up mappings inside that window with `self._window:map()`. When the user chooses to open a selection via a mapping, the prompt will call the `on_open` callback with either `'edit'`, `'split'`, `'tabedit'`, or `'vsplit'` as an argument.
 8. The `on_open` callback, which is actually `ui.open(ex_command)` (`ex_command` is `'edit'`, `'split'` etc), calls `close()`, which closes the windows and invokes any `on_close` callback.
 9. If the UI has an `on_open` callback, it calls it so that it can transform the result. Only the built-in file finder and the watchman finder use this, and they both use it to relativize the result in relation to the `directory`.
-10. The thing that actually opens the result is called with `vim.defer_fn()`, to give autocommands a chance to run. The called function is `current_finder.open(result, ex_command)`. Recall from the above that finders like `'fd'` pass in an `options.open` that relativizes the path and uses the `opener` (`commandt.open()`) to do a "smart open". Finders like the `'help'` finder define a custom callback. Finders like `'buffer'` and `'jump'` define no `on_open`, so use the default.
+10. The thing that actually opens the result is called with `vim.defer_fn()`, to give autocommands a chance to run. The called function is `current_finder.open(result, ex_command)`. Recall from the above that finders like `'fd'` pass in an `options.open` that relativizes the path and uses `sbuffer()` to do a "smart open". Finders like the `'help'` finder define a custom callback. Finders like `'buffer'` and `'jump'` define no `on_open`, so use the default.
 
 ## Command-based finder life-cycle
 

lua/wincent/commandt/init.lua

@@ -78,8 +78,8 @@ end
 -- Common `on_open` implementation used by several "command" finders that equips
 -- them to deal with automatic directory changes caused by the `traverse`
 -- setting.
-local function on_open(item, ex_command, directory, _options, opener, _context)
-  opener(relativize(directory, item), ex_command)
+local function on_open(item, ex_command, directory, _options, _context)
+  sbuffer(relativize(directory, item), ex_command)
 end
 
 local help_opened = false
@@ -432,7 +432,7 @@ local default_options = {
         return commands
       end,
       mode = 'virtual',
-      open = function(item, _ex_command, _directory, _options, _opener, _context)
+      open = function(item, _ex_command, _directory, _options, _context)
         vim.api.nvim_feedkeys(':' .. item, 'nt', true)
       end,
       options = force_dot_files,
@@ -517,7 +517,7 @@ local default_options = {
         return helptags
       end,
       mode = 'virtual',
-      open = function(item, ex_command, _directory, _options, _opener, _context)
+      open = function(item, ex_command, _directory, _options, _context)
         local command = 'help'
         if ex_command == 'split' then
           -- Split is the default, so for this finder, we abuse "split" mode to do
@@ -557,7 +557,7 @@ local default_options = {
         return commands
       end,
       mode = 'virtual',
-      open = function(item, _ex_command, _directory, _options, _opener, _context)
+      open = function(item, _ex_command, _directory, _options, _context)
         vim.api.nvim_feedkeys(':' .. item, 'nt', true)
       end,
       options = force_dot_files,
@@ -625,7 +625,7 @@ local default_options = {
         return result
       end,
       mode = 'virtual',
-      open = function(item, _ex_command, _directory, _options, _opener, _context)
+      open = function(item, _ex_command, _directory, _options, _context)
         -- Extract line number from (eg) "some line contents:100".
         local suffix = string.find(item, '%d+$')
         local index = tonumber(item:sub(suffix))
@@ -659,7 +659,7 @@ local default_options = {
         return commands
       end,
       mode = 'virtual',
-      open = function(item, _ex_command, _directory, _options, _opener, _context)
+      open = function(item, _ex_command, _directory, _options, _context)
         vim.api.nvim_feedkeys('/' .. item, 'nt', true)
       end,
       options = force_dot_files,
@@ -685,9 +685,9 @@ local default_options = {
         return result, candidates
       end,
       mode = 'virtual',
-      open = function(item, ex_command, _directory, options, opener, context)
+      open = function(item, ex_command, _directory, options, context)
         local tag = context[item]
-        opener(tag.filename, ex_command)
+        sbuffer(tag.filename, ex_command)
 
         -- Strip leading and trailing slashes, and use \M ('nomagic'):
         -- ie. "/^int main()$/" → "\M^int main()$"