rename Range.from_txtobj => from_motion

.busted

@@ -1,13 +0,0 @@
-return {
-  _all = {
-    coverage = false,
-    lpath = "lua/?.lua;lua/?/init.lua",
-    lua = "nvim -u NONE -i NONE -l",
-  },
-  default = {
-    verbose = true
-  },
-  tests = {
-    verbose = true
-  },
-}

.github/workflows/ci.yaml

@@ -2,28 +2,15 @@
 name: NeoVim tests
 on: [push]
 jobs:
-  code-quality:
+  plenary-tests:
     runs-on: ubuntu-latest
     env:
       XDG_CONFIG_HOME: ${{ github.workspace }}/.config/
     steps:
       - uses: actions/checkout@v4
-      - uses: cachix/install-nix-action@v31
+      - uses: rhysd/action-setup-vim@v1
         with:
-          nix_path: nixpkgs=channel:nixos-unstable
+          neovim: true
-
+          version: v0.11.0
-      - name: Populate Nix store
+          arch: 'x86_64'
-        run:
+      - run: make test
-          nix-shell --pure --run 'true'
-
-      - name: Type-check with lua-language-server
-        run:
-          nix-shell --pure --run 'make lint'
-
-      - name: Check formatting with stylua
-        run:
-          nix-shell --pure --run 'make fmt-check'
-
-      - name: Run busted tests
-        run:
-          nix-shell --pure --run 'make test'

.gitignore

@@ -1,3 +1,2 @@
+/.lux/
 *.src.rock
-*.aider*
-luacov.*.out

.luacov

@@ -1,6 +0,0 @@
-return {
-  include = {
-    'lua/u/',
-  },
-  tick = true,
-}

.woodpecker/ci.yaml

@@ -1,10 +0,0 @@
-when:
-  - event: push
-
-steps:
-  - name: build
-    image: nixos/nix
-    commands:
-      - nix-shell --pure --run 'make lint'
-      - nix-shell --pure --run 'make fmt-check'
-      - nix-shell --pure --run 'make test'

Makefile

@@ -1,24 +1,16 @@
-all: lint fmt-check test
+PLENARY_DIR=~/.local/share/nvim/site/pack/test/opt/plenary.nvim
+
+all: lint test
 
 lint:
-	@echo "## Typechecking"
+	lua-language-server --check=lua/u/ --checklevel=Hint
-	@lua-language-server --check=lua/u/ --checklevel=Error
+	lux check
-
-fmt-check:
-	@echo "## Checking code format"
-	@stylua --check .
 
 fmt:
-	@echo "## Formatting code"
+	stylua .
-	@stylua .
 
-test:
+test: $(PLENARY_DIR)
-	@rm -f luacov.*.out
+	NVIM_APPNAME=noplugstest nvim -u NORC --headless -c 'set packpath+=~/.local/share/nvim/site' -c 'packadd plenary.nvim' -c "PlenaryBustedDirectory spec/"
-	@echo "## Running tests"
-	@busted --coverage --verbose
-	@echo "## Generating coverage report"
-	@luacov
-	@awk '/^Summary$$/{flag=1;next} flag{print}' luacov.report.out
 
-watch:
+$(PLENARY_DIR):
-	@watchexec -c -e lua make
+	git clone https://github.com/nvim-lua/plenary.nvim/ $(PLENARY_DIR)

README.md

@@ -1,40 +1,26 @@
 # u.nvim
 
-Welcome to **u.nvim** - a powerful Lua library designed to enhance your text
+Welcome to **u.nvim** – a powerful Lua library designed to enhance your text manipulation experience in NeoVim, focusing primarily on a context-aware "Range" utility. This utility allows you to work efficiently with text selections based on various conditions, in a variety of contexts, making coding and editing more intuitive and productive.
-manipulation experience in NeoVim, focusing on text-manipulation utilities.
-This includes a `Range` utility, allowing you to work efficiently with text
-selections based on various conditions, as well as a declarative `Render`-er,
-making coding and editing more intuitive and productive.
 
-This is meant to be used as a **library**, not a plugin. On its own, `u.nvim`
+This is meant to be used as a **library**, not a plugin. On its own, `u.nvim` does nothing. It is meant to be used by plugin authors, to make their lives easier based on the variety of utilities I found I needed while growing my NeoVim config. To get an idea of what a plugin built on top of `u.nvim` would look like, check out the [examples/](./examples/) directory.
-does nothing. It is meant to be used by plugin authors, to make their lives
-easier based on the variety of utilities I found I needed while growing my
-NeoVim config. To get an idea of what a plugin built on top of `u.nvim` would
-look like, check out the [examples/](./examples/) directory.
 
 ## Features
 
-- **Rendering System**: a utility that can declaratively render NeoVim-specific
+- **Rendering System**: a utility that can declaratively render NeoVim-specific hyperscript into a buffer, supporting creating/managing extmarks, highlights, and key-event handling (requires NeoVim >0.11)
-  hyperscript into a buffer, supporting creating/managing extmarks, highlights,
+- **Signals**: a simple dependency tracking system that pairs well with the rendering utilities for creating reactive/interactive UIs in NeoVim.
-  and key-event handling (requires NeoVim >0.11)
+- **Range Utility**: Get context-aware selections with ease. Replace regions with new text. Think of it as a programmatic way to work with visual selections (or regions of text).
-- **Signals**: a simple dependency tracking system that pairs well with the
-  rendering utilities for creating reactive/interactive UIs in NeoVim.
-- **Range Utility**: Get context-aware selections with ease. Replace regions
-  with new text. Think of it as a programmatic way to work with visual
-  selections (or regions of text).
 - **Code Writer**: Write code with automatic indentation and formatting.
-- **Operator Key Mapping**: Flexible key mapping that works with the selected
+- **Operator Key Mapping**: Flexible key mapping that works with the selected text.
-  text.
+- **Text and Position Utilities**: Convenient functions to manage text objects and cursor positions.
-- **Text and Position Utilities**: Convenient functions to manage text objects
-  and cursor positions.
 
 ### Installation
 
-This being a library, and not a proper plugin, it is recommended that you
+lazy.nvim:
-vendor the specific version of this library that you need, including it in your
+```lua
-code. Package managers are a developing landscape for Lua in the context of
+-- Setting `lazy = true` ensures that the library is only loaded
-NeoVim. Perhaps in the future, `lux` will eliminate the need to vendor this
+-- when `require 'u.<utility>' is called.
-library in your application code.
+{ 'jrop/u.nvim', lazy = true }
+```
 
 ## Signal and Rendering Usage
 
@@ -125,9 +111,7 @@ end)
 
 ### `u.tracker`
 
-The `u.tracker` module provides a simple API for creating reactive variables.
+The `u.tracker` module provides a simple API for creating reactive variables. These can be composed in Effects and Memos utilizing Execution Contexts that track what signals are used by effects/memos.
-These can be composed in Effects and Memos utilizing Execution Contexts that
-track what signals are used by effects/memos.
 
 ```lua
 local tracker = require('u.tracker')
@@ -150,8 +134,7 @@ The renderer library renders hyperscript into a buffer. Each render performs a
 minimal set of changes in order to transform the current buffer text into the
 desired state.
 
-**Hyperscript** is just 1) _text_ 2) `<text>` tags, which can be nested in 3)
+**Hyperscript** is just 1) _text_ 2) `<text>` tags, which can be nested in 3) Lua tables for readability:
-Lua tables for readability:
 
 ```lua
 local h = require('u.renderer').h
@@ -213,8 +196,7 @@ renderer:render(
 )
 ```
 
-**Rendering**: The renderer library provides a `render` function that takes
+**Rendering**: The renderer library provides a `render` function that takes hyperscript in, and converts it to formatted buffer text:
-hyperscript in, and converts it to formatted buffer text:
 
 ```lua
 local Renderer = require('u.renderer').Renderer
@@ -237,37 +219,22 @@ buf:render {
 
 <blockquote>
 <del>
-I love NeoVim. I am coming to love Lua. I don't like 1-based indices; perhaps I
+I love NeoVim. I am coming to love Lua. I don't like 1-based indices; perhaps I am too old. Perhaps I am too steeped in the history of loving the elegance of simple pointer arithmetic. Regardless, the way positions are addressed in NeoVim/Vim is (terrifyingly) mixed. Some methods return 1-based, others accept only 0-based. In order to stay sane, I had to make a choice to store everything in one, uniform representation in this library. I chose (what I humbly think is the only sane way) to stick with the tried-and-true 0-based index scheme. That abstraction leaks into the public API of this library.
-am too old. Perhaps I am too steeped in the history of loving the elegance of
-simple pointer arithmetic. Regardless, the way positions are addressed in
-NeoVim/Vim is (terrifyingly) mixed. Some methods return 1-based, others accept
-only 0-based. In order to stay sane, I had to make a choice to store everything
-in one, uniform representation in this library. I chose (what I humbly think is
-the only sane way) to stick with the tried-and-true 0-based index scheme. That
-abstraction leaks into the public API of this library.
 </del>
 </blockquote>
 
 <br />
 <b>This has changed in v2</b>. After much thought, I realized that:
 
-1. The 0-based indexing in NeoVim is prevelant in the `:api`, which is designed
+1. The 0-based indexing in NeoVim is prevelant in the `:api`, which is designed to be exposed to many languages. As such, it makes sense for this interface to use 0-based indexing. However, many internal Vim functions use 1-based indexing.
-   to be exposed to many languages. As such, it makes sense for this interface
+2. This is a Lua library (surprise, surprise, duh) - the idioms of the language should take precedence over my preference
-   to use 0-based indexing. However, many internal Vim functions use 1-based
+3. There were subtle bugs in the code where indices weren't being normalized to 0-based, anyways. Somehow it worked most of the time.
-   indexing.
-2. This is a Lua library (surprise, surprise, duh) - the idioms of the language
-   should take precedence over my preference
-3. There were subtle bugs in the code where indices weren't being normalized to
-   0-based, anyways. Somehow it worked most of the time.
 
-As such, this library now uses 1-based indexing everywhere, doing the necessary
+As such, this library now uses 1-based indexing everywhere, doing the necessary interop conversions when calling `:api` functions.
-interop conversions when calling `:api` functions.
 
 ### 1. Creating a Range
 
-The `Range` utility is the main feature upon which most other things in this
+The `Range` utility is the main feature upon which most other things in this library are built, aside from a few standalone utilities. Ranges can be constructed manually, or preferably, obtained based on a variety of contexts.
-library are built, aside from a few standalone utilities. Ranges can be
-constructed manually, or preferably, obtained based on a variety of contexts.
 
 ```lua
 local Range = require 'u.range'
@@ -278,9 +245,7 @@ Range.new(start, stop, 'v') -- charwise selection
 Range.new(start, stop, 'V') -- linewise selection
 ```
 
-This is usually not how you want to obtain a `Range`, however. Usually you want
+This is usually not how you want to obtain a `Range`, however. Usually you want to get the corresponding context of an edit operation and just "get me the current Range that represents this context".
-to get the corresponding context of an edit operation and just "get me the
-current Range that represents this context".
 
 ```lua
 -- get the first line in a buffer:
@@ -295,8 +260,7 @@ Range.from_motion('iW')
 Range.from_motion('a"')
 
 -- Get the currently visually selected text:
--- NOTE: this does NOT work within certain contexts; more specialized utilities
+-- NOTE: this does NOT work within certain contexts; more specialized utilities are more appropriate in certain circumstances
--- are more appropriate in certain circumstances
 Range.from_vtext()
 
 --
@@ -308,8 +272,7 @@ function MyOpFunc(ty)
   local range = Range.from_op_func(ty)
   -- do something with the range
 end
--- Try invoking this with: `<Leader>toaw`, and the current word will be the
+-- Try invoking this with: `<Leader>toaw`, and the current word will be the context:
--- context:
 vim.keymap.set('<Leader>to', function()
   vim.g.operatorfunc = 'v:lua.MyOpFunc'
   return 'g@'
@@ -318,8 +281,7 @@ end, { expr = true })
 --
 -- Commands:
 --
--- When executing commands in a visual context, getting the selected text has
+-- When executing commands in a visual context, getting the selected text has to be done differently:
--- to be done differently:
 vim.api.nvim_create_user_command('MyCmd', function(args)
   local range = Range.from_cmd_args(args)
   if range == nil then
@@ -330,8 +292,7 @@ vim.api.nvim_create_user_command('MyCmd', function(args)
 end, { range = true })
 ```
 
-So far, that's a lot of ways to _get_ a `Range`. But what can you do with a
+So far, that's a lot of ways to _get_ a `Range`. But what can you do with a range once you have one? Plenty, it turns out!
-range once you have one? Plenty, it turns out!
 
 ```lua
 local range = ...
@@ -401,11 +362,11 @@ Access and manipulate buffers easily:
 ```lua
 local Buffer = require 'u.buffer'
 local buf = Buffer.current()
-buf.b.<option>        -- get buffer-local variables
-buf.b.<option>  = ... -- set buffer-local variables
-buf.bo.<option>       -- get buffer options
-buf.bo.<option> = ... -- set buffer options
 buf:line_count() -- the number of lines in the current buffer
+buf:get_option '...'
+buf:set_option('...', ...)
+buf:get_var '...'
+buf:set_var('...', ...)
 buf:all() -- returns a Range representing the entire buffer
 buf:is_empty() -- returns true if the buffer has no text
 buf:append_line '...'
@@ -420,20 +381,8 @@ buf:txtobj('iw')      -- returns a Range representing the text object 'iw' in th
 
 Copyright (c) 2024 jrapodaca@gmail.com
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

examples/counter.lua

@@ -1,5 +1,5 @@
-local Buffer = require 'u.buffer'
 local tracker = require 'u.tracker'
+local Buffer = require 'u.buffer'
 local h = require('u.renderer').h
 
 -- Create an buffer for the UI

examples/filetree.lua

@@ -10,10 +10,10 @@
 --   change on the underlying filesystem.
 --------------------------------------------------------------------------------
 
---- @alias u.examples.FsDir { kind: 'dir'; path: string; expanded: boolean; children: u.examples.FsNode[] }
+--- @alias FsDir { kind: 'dir'; path: string; expanded: boolean; children: FsNode[] }
---- @alias u.examples.FsFile { kind: 'file'; path: string }
+--- @alias FsFile { kind: 'file'; path: string }
---- @alias u.examples.FsNode u.examples.FsDir | u.examples.FsFile
+--- @alias FsNode FsDir | FsFile
---- @alias u.examples.ShowOpts { root_path?: string, width?: number, focus_path?: string }
+--- @alias ShowOpts { root_path?: string, width?: number, focus_path?: string }
 
 local Buffer = require 'u.buffer'
 local Renderer = require('u.renderer').Renderer
@@ -44,7 +44,11 @@ end
 
 --- Normalizes the given path to an absolute path.
 --- @param path string
-function H.normalize(path) return vim.fs.abspath(vim.fs.normalize(path)) end
+function H.normalize(path)
+  path = vim.fs.normalize(path)
+  if path:sub(1, 1) ~= '/' then path = vim.fs.joinpath(vim.uv.cwd(), path) end
+  return vim.fs.normalize(path)
+end
 
 --- Computes the relative path from `base` to `path`.
 --- @param path string
@@ -58,13 +62,13 @@ function H.relative(path, base)
 end
 
 --- @param root_path string
---- @return { tree: u.examples.FsDir; path_to_node: table<string, u.examples.FsNode> }
+--- @return { tree: FsDir; path_to_node: table<string, FsNode> }
 function H.get_tree_inf(root_path)
   logger:info { 'get_tree_inf', root_path }
-  --- @type table<string, u.examples.FsNode>
+  --- @type table<string, FsNode>
   local path_to_node = {}
 
-  --- @type u.examples.FsDir
+  --- @type FsDir
   local tree = {
     kind = 'dir',
     path = H.normalize(root_path or '.'),
@@ -77,8 +81,8 @@ function H.get_tree_inf(root_path)
   return { tree = tree, path_to_node = path_to_node }
 end
 
---- @param tree u.examples.FsDir
+--- @param tree FsDir
---- @param path_to_node table<string, u.examples.FsNode>
+--- @param path_to_node table<string, FsNode>
 function H.populate_dir_children(tree, path_to_node)
   tree.children = {}
 
@@ -121,10 +125,7 @@ end
 ---
 --- @return { expand: fun(path: string), collapse: fun(path: string) }
 local function _render_in_buffer(opts)
-  local winnr = vim.api.nvim_buf_call(
+  local winnr = vim.api.nvim_buf_call(opts.bufnr, function() return vim.api.nvim_get_current_win() end)
-    opts.bufnr,
-    function() return vim.api.nvim_get_current_win() end
-  )
   local s_tree_inf = tracker.create_signal(H.get_tree_inf(opts.root_path))
   local s_focused_path = tracker.create_signal(H.normalize(opts.focus_path or opts.root_path))
 
@@ -135,7 +136,7 @@ local function _render_in_buffer(opts)
       local parts = H.split_path(H.relative(focused_path, tree_inf.tree.path))
       local path_to_node = tree_inf.path_to_node
 
-      --- @param node u.examples.FsDir
+      --- @param node FsDir
       --- @param child_names string[]
       local function expand_to(node, child_names)
         if #child_names == 0 then return end
@@ -154,35 +155,19 @@ local function _render_in_buffer(opts)
     end)
   end)
 
+  -- --
+  -- -- TODO: :help watch-file
+  -- --
+  -- local watcher = vim.uv.new_fs_event()
+  -- if watcher ~= nil then
+  --   watcher:start(root_path, { recursive = true }, function(err, fname, status)
+  --     -- TODO: more efficient update:
+  --     s_tree_inf:set(H.get_tree(root_path))
   --
-  -- :help watch-file
+  --     -- TODO: proper disposal
-  --
+  --     watcher:stop()
-  local watcher = vim.uv.new_fs_event()
+  --   end)
-  if watcher ~= nil then
+  -- end
-    --- @diagnostic disable-next-line: unused-local
-    watcher:start(opts.root_path, { recursive = true }, function(_err, fname, _status)
-      fname = H.normalize(fname)
-
-      local dir_path = vim.fs.dirname(fname)
-      local dir = s_tree_inf:get().path_to_node[dir_path]
-      if not dir then return end
-
-      s_tree_inf:schedule_update(function(tree_inf)
-        H.populate_dir_children(dir, tree_inf.path_to_node)
-        return tree_inf
-      end)
-    end)
-  end
-  vim.api.nvim_create_autocmd('WinClosed', {
-    once = true,
-    pattern = tostring(winnr),
-    callback = function()
-      if watcher == nil then return end
-
-      watcher:stop()
-      watcher = nil
-    end,
-  })
 
   local controller = {}
 
@@ -310,7 +295,7 @@ local function _render_in_buffer(opts)
   --
   local renderer = Renderer.new(opts.bufnr)
   tracker.create_effect(function()
-    --- @type { tree: u.examples.FsDir; path_to_node: table<string, u.examples.FsNode> }
+    --- @type { tree: FsDir; path_to_node: table<string, FsNode> }
     local tree_inf = s_tree_inf:get()
     local tree = tree_inf.tree
 
@@ -329,7 +314,7 @@ local function _render_in_buffer(opts)
 
     --- Since the filesystem is a recursive tree of nodes, we need to
     --- recursively render each node. This function does just that:
-    --- @param node u.examples.FsNode
+    --- @param node FsNode
     --- @param level number
     local function render_node(node, level)
       local name = vim.fs.basename(node.path)
@@ -346,11 +331,7 @@ local function _render_in_buffer(opts)
           return ''
         end,
         n = function()
-          vim.schedule(
+          vim.schedule(function() controller.new(node.kind == 'file' and vim.fs.dirname(node.path) or node.path) end)
-            function()
-              controller.new(node.kind == 'file' and vim.fs.dirname(node.path) or node.path)
-            end
-          )
           return ''
         end,
         r = function()
@@ -370,11 +351,7 @@ local function _render_in_buffer(opts)
         local icon = node.expanded and '' or ''
         tb:put {
           current_line > 1 and '\n',
-          h(
+          h('text', { hl = 'Constant', nmap = nmaps }, { string.rep('  ', level), icon, ' ', name }),
-            'text',
-            { hl = 'Constant', nmap = nmaps },
-            { string.rep('  ', level), icon, ' ', name }
-          ),
         }
         if node.expanded then
           for _, child in ipairs(node.children) do
@@ -414,7 +391,7 @@ end
 local current_inf = nil
 
 --- Show the filetree:
---- @param opts? u.examples.ShowOpts
+--- @param opts? ShowOpts
 function M.show(opts)
   if current_inf ~= nil then return current_inf.controller end
   opts = opts or {}
@@ -434,8 +411,8 @@ function M.show(opts)
     callback = M.hide,
   })
 
-  vim.wo[0][0].number = false
+  vim.wo.number = false
-  vim.wo[0][0].relativenumber = false
+  vim.wo.relativenumber = false
 
   local bufnr = vim.api.nvim_get_current_buf()
 
@@ -456,7 +433,7 @@ function M.hide()
 end
 
 --- Toggle the filetree:
---- @param opts? u.examples.ShowOpts
+--- @param opts? ShowOpts
 function M.toggle(opts)
   if current_inf == nil then
     M.show(opts)

examples/form.lua

@@ -1,117 +0,0 @@
--- form.lua:
---
--- This is a runnable example of a form. Open this file in Neovim, and execute
--- `:luafile %` to run it. It will create a new buffer to the side, and render
--- an interactive form. Edit the "inputs" between the `[...]` brackets, and
--- watch the buffer react immediately to your changes.
---
-
-local Renderer = require('u.renderer').Renderer
-local h = require('u.renderer').h
-local tracker = require 'u.tracker'
-
--- Create a new, temporary, buffer to the side:
-vim.cmd.vnew()
-vim.bo.buftype = 'nofile'
-vim.bo.bufhidden = 'wipe'
-vim.bo.buflisted = false
-local renderer = Renderer.new()
-
--- Create two signals:
-local s_name = tracker.create_signal 'whoever-you-are'
-local s_age = tracker.create_signal 'ideally-a-number'
-
--- We can create derived information from the signals above. Say we want to do
--- some validation on the input for `age`: we can do that with a memo:
-local s_age_info = tracker.create_memo(function()
-  local age_raw = s_age:get()
-  local age_digits = age_raw:match '^%s*(%d+)%s*$'
-  local age_n = age_digits and tonumber(age_digits) or nil
-  return {
-    type = age_n and 'number' or 'string',
-    raw = age_raw,
-    n = age_n,
-    n1 = age_n and age_n + 1 or nil,
-  }
-end)
-
--- This is the render effect that depends on the signals created above. This
--- will re-run every time one of the signals changes.
-tracker.create_effect(function()
-  local name = s_name:get()
-  local age = s_age:get()
-  local age_info = s_age_info:get()
-
-  -- Each time the signals change, we re-render the buffer:
-  renderer:render {
-    h.Type({}, '# Form Example'),
-    '\n\n',
-
-    -- We can also listen for when specific locations in the buffer change, on
-    -- a tag-by-tag basis. This gives us two-way data-binding between the
-    -- buffer and the signals.
-    {
-      'Name: ',
-      h.Structure({
-        on_change = function(text) s_name:set(text) end,
-      }, name),
-    },
-    {
-      '\nAge: ',
-      h.Structure({
-        on_change = function(text) s_age:set(text) end,
-      }, age),
-    },
-
-    '\n\n',
-
-    -- Show the values of the signals here, too, so that we can see the
-    -- reactivity in action. If you change the values in the tags above, you
-    -- can see the changes reflected here immediately.
-    { 'Hello, "', name, '"!' },
-
-    --
-    -- A more complex example: we can do much more complex rendering, based on
-    -- the state. For example, if you type different values into the `age`
-    -- field, you can see not only the displayed information change, but also
-    -- the color of the highlights in this section will adapt to the type of
-    -- information that has been detected.
-    --
-    -- If string input is detected, values below are shown in the
-    -- `String`/`ErrorMsg` highlight groups.
-    --
-    -- If number input is detected, values below are shown in the `Number`
-    -- highlight group.
-    --
-    -- If a valid number is entered, then this section also displays how old
-    -- you willl be next year (`n + 1`).
-    --
-
-    '\n\n',
-    h.Type({}, '## Computed Information (derived from `age`)'),
-    '\n\n',
-    {
-      'Type: ',
-      h('text', {
-        hl = age_info.type == 'number' and 'Number' or 'String',
-      }, age_info.type),
-    },
-    { '\nRaw input: ', h.String({}, '"' .. age_info.raw .. '"') },
-    {
-      '\nCurrent age: ',
-      age_info.n
-          -- Show the age:
-          and h.Number({}, tostring(age_info.n))
-        -- Show an error-placeholder if the age is invalid:
-        or h.ErrorMsg({}, '(?)'),
-    },
-
-    -- This part is shown conditionally, i.e., only if the age next year can be
-    -- computed:
-    age_info.n1
-      and {
-        '\nAge next year: ',
-        h.Number({}, tostring(age_info.n1)),
-      },
-  }
-end)

examples/notify.lua

@@ -1,7 +1,8 @@
-local Renderer = require('u.renderer').Renderer
+local Buffer = require 'u.buffer'
 local TreeBuilder = require('u.renderer').TreeBuilder
 local tracker = require 'u.tracker'
 local utils = require 'u.utils'
+local Window = require 'my.window'
 
 local TIMEOUT = 4000
 local ICONS = {
@@ -13,25 +14,15 @@ local ICONS = {
 }
 local DEFAULT_ICON = { text = '', group = 'DiagnosticSignOk' }
 
-local S_EDITOR_DIMENSIONS =
+--- @alias Notification {
-  tracker.create_signal(utils.get_editor_dimensions(), 's:editor_dimensions')
-vim.api.nvim_create_autocmd('VimResized', {
-  callback = function()
-    local new_dim = utils.get_editor_dimensions()
-    S_EDITOR_DIMENSIONS:set(new_dim)
-  end,
-})
-
---- @alias u.examples.Notification {
 ---   kind: number;
 ---   id: number;
 ---   text: string;
----   timer: uv.uv_timer_t;
 --- }
 
 local M = {}
 
---- @type { win: integer, buf: integer, renderer: u.renderer.Renderer } | nil
+--- @type Window | nil
 local notifs_w
 
 local s_notifications_raw = tracker.create_signal {}
@@ -39,49 +30,44 @@ local s_notifications = s_notifications_raw:debounce(50)
 
 -- Render effect:
 tracker.create_effect(function()
-  --- @type u.examples.Notification[]
+  --- @type Notification[]
   local notifs = s_notifications:get()
-  --- @type { width: integer, height: integer }
-  local editor_size = S_EDITOR_DIMENSIONS:get()
 
   if #notifs == 0 then
     if notifs_w then
-      if vim.api.nvim_win_is_valid(notifs_w.win) then vim.api.nvim_win_close(notifs_w.win, true) end
+      notifs_w:close(true)
       notifs_w = nil
     end
     return
   end
 
+  vim.schedule(function()
+    local editor_size = utils.get_editor_dimensions()
     local avail_width = editor_size.width
     local float_width = 40
-  local float_height = math.min(#notifs, editor_size.height - 3)
     local win_config = {
       relative = 'editor',
       anchor = 'NE',
       row = 0,
       col = avail_width,
       width = float_width,
-    height = float_height,
+      height = math.min(#notifs, editor_size.height - 3),
       border = 'single',
       focusable = false,
-    zindex = 900,
     }
-  vim.schedule(function()
     if not notifs_w or not vim.api.nvim_win_is_valid(notifs_w.win) then
-      local b = vim.api.nvim_create_buf(false, true)
+      notifs_w = Window.new(Buffer.create(false, true), win_config)
-      local w = vim.api.nvim_open_win(b, false, win_config)
+      vim.wo[notifs_w.win].cursorline = false
-      vim.wo[w].cursorline = false
+      vim.wo[notifs_w.win].list = false
-      vim.wo[w].list = false
+      vim.wo[notifs_w.win].listchars = ''
-      vim.wo[w].listchars = ''
+      vim.wo[notifs_w.win].number = false
-      vim.wo[w].number = false
+      vim.wo[notifs_w.win].relativenumber = false
-      vim.wo[w].relativenumber = false
+      vim.wo[notifs_w.win].wrap = false
-      vim.wo[w].wrap = false
-      notifs_w = { win = w, buf = b, renderer = Renderer.new(b) }
     else
-      vim.api.nvim_win_set_config(notifs_w.win, win_config)
+      notifs_w:set_config(win_config)
     end
 
-    notifs_w.renderer:render(TreeBuilder.new()
+    notifs_w:render(TreeBuilder.new()
       :nest(function(tb)
         for idx, notif in ipairs(notifs) do
           if idx > 1 then tb:put '\n' end
@@ -93,81 +79,48 @@ tracker.create_effect(function()
       end)
       :tree())
     vim.api.nvim_win_call(notifs_w.win, function()
-      vim.fn.winrestview {
+      -- scroll to bottom:
-        -- scroll all the way left:
+      vim.cmd.normal 'G'
-        leftcol = 0,
+      -- scroll all the way to the left:
-        -- set the bottom line to be at the bottom of the window:
+      vim.cmd.normal '9999zh'
-        topline = vim.api.nvim_buf_line_count(notifs_w.buf) - win_config.height + 1,
-      }
     end)
   end)
 end)
 
---- @param id number
+local _orig_notify
-local function _delete_notif(id)
+
-  --- @param notifs u.examples.Notification[]
+--- @param msg string
+--- @param level integer|nil
+--- @param opts table|nil
+local function my_notify(msg, level, opts)
+  vim.schedule(function() _orig_notify(msg, level, opts) end)
+  if level == nil then level = vim.log.levels.INFO end
+  if level < vim.log.levels.INFO then return end
+
+  local id = math.random(math.huge)
+
+  --- @param notifs Notification[]
+  s_notifications_raw:schedule_update(function(notifs)
+    table.insert(notifs, { kind = level, id = id, text = msg })
+    return notifs
+  end)
+
+  vim.defer_fn(function()
+    --- @param notifs Notification[]
     s_notifications_raw:schedule_update(function(notifs)
       for i, notif in ipairs(notifs) do
         if notif.id == id then
-        notif.timer:stop()
-        notif.timer:close()
           table.remove(notifs, i)
           break
         end
       end
       return notifs
     end)
-end
+  end, TIMEOUT)
-
-local _orig_notify
-
---- @param msg string
---- @param level integer|nil
---- @param opts? { id: number }
-function M.notify(msg, level, opts)
-  if level == nil then level = vim.log.levels.INFO end
-
-  opts = opts or {}
-  local id = opts.id or math.random(999999999)
-
-  --- @type u.examples.Notification?
-  local notif = vim.iter(s_notifications_raw:get()):find(function(n) return n.id == id end)
-  if not notif then
-    -- Create a new notification (maybe):
-    if vim.trim(msg) == '' then return id end
-    if level < vim.log.levels.INFO then return id end
-
-    local timer = assert((vim.uv or vim.loop).new_timer(), 'could not create timer')
-    timer:start(TIMEOUT, 0, function() _delete_notif(id) end)
-    notif = {
-      id = id,
-      kind = level,
-      text = msg,
-      timer = timer,
-    }
-    --- @param notifs u.examples.Notification[]
-    s_notifications_raw:schedule_update(function(notifs)
-      table.insert(notifs, notif)
-      return notifs
-    end)
-  else
-    -- Update an existing notification:
-    s_notifications_raw:schedule_update(function(notifs)
-      -- We already have a copy-by-reference of the notif we want to modify:
-      notif.timer:stop()
-      notif.text = msg
-      notif.kind = level
-      notif.timer:start(TIMEOUT, 0, function() _delete_notif(id) end)
-
-      return notifs
-    end)
-  end
-
-  return id
 end
 
 local _once_msgs = {}
-function M.notify_once(msg, level, opts)
+local function my_notify_once(msg, level, opts)
   if vim.tbl_contains(_once_msgs, msg) then return false end
   table.insert(_once_msgs, msg)
   vim.notify(msg, level, opts)
@@ -177,8 +130,8 @@ end
 function M.setup()
   if _orig_notify == nil then _orig_notify = vim.notify end
 
-  vim.notify = M.notify
+  vim.notify = my_notify
-  vim.notify_once = M.notify_once
+  vim.notify_once = my_notify_once
 end
 
 return M

examples/picker.lua

@@ -1,5 +1,5 @@
-local Buffer = require 'u.buffer'
 local utils = require 'u.utils'
+local Buffer = require 'u.buffer'
 local Renderer = require('u.renderer').Renderer
 local h = require('u.renderer').h
 local TreeBuilder = require('u.renderer').TreeBuilder
@@ -7,8 +7,7 @@ local tracker = require 'u.tracker'
 
 local M = {}
 
-local S_EDITOR_DIMENSIONS =
+local S_EDITOR_DIMENSIONS = tracker.create_signal(utils.get_editor_dimensions(), 's:editor_dimensions')
-  tracker.create_signal(utils.get_editor_dimensions(), 's:editor_dimensions')
 vim.api.nvim_create_autocmd('VimResized', {
   callback = function()
     local new_dim = utils.get_editor_dimensions()
@@ -44,7 +43,7 @@ local function shallow_copy_arr(arr) return vim.iter(arr):totable() end
 --    shortest portion of this function.
 --------------------------------------------------------------------------------
 
---- @alias u.examples.SelectController {
+--- @alias SelectController {
 ---   get_items: fun(): T[];
 ---   set_items: fun(items: T[]);
 ---   set_filter_text: fun(filter_text: string);
@@ -53,17 +52,17 @@ local function shallow_copy_arr(arr) return vim.iter(arr):totable() end
 ---   set_selected_indices: fun(indicies: number[], ephemeral?: boolean);
 ---   close: fun();
 --- }
---- @alias u.examples.SelectOpts<T> {
+--- @alias SelectOpts<T> {
 ---   items: `T`[];
 ---   multi?: boolean;
----   format_item?: fun(item: T): u.renderer.Tree;
+---   format_item?: fun(item: T): Tree;
 ---   on_finish?: fun(items: T[], indicies: number[]);
 ---   on_selection_changed?: fun(items: T[], indicies: number[]);
----   mappings?: table<string, fun(select: u.examples.SelectController)>;
+---   mappings?: table<string, fun(select: SelectController)>;
 --- }
 
 --- @generic T
---- @param opts u.examples.SelectOpts<T>
+--- @param opts SelectOpts<T>
 function M.create_picker(opts) -- {{{
   local is_in_insert_mode = vim.api.nvim_get_mode().mode:sub(1, 1) == 'i'
   local stopinsert = not is_in_insert_mode
@@ -203,9 +202,7 @@ function M.create_picker(opts) -- {{{
 
   local s_filter_text_undebounced = tracker.create_signal('', 's:filter_text')
   w_input_buf:autocmd('TextChangedI', {
-    callback = safe_wrap(
+    callback = safe_wrap(function() s_filter_text_undebounced:set(vim.api.nvim_get_current_line()) end),
-      function() s_filter_text_undebounced:set(vim.api.nvim_get_current_line()) end
-    ),
   })
   local s_filter_text = s_filter_text_undebounced:debounce(50)
 
@@ -214,15 +211,10 @@ function M.create_picker(opts) -- {{{
   --
 
   local s_formatted_items = tracker.create_memo(function()
-    local function _format_item(item)
+    local function _format_item(item) return opts.format_item and opts.format_item(item) or tostring(item) end
-      return opts.format_item and opts.format_item(item) or tostring(item)
-    end
 
     local items = s_items:get()
-    return vim
+    return vim.iter(items):map(function(item) return { item = item, formatted = _format_item(item) } end):totable()
-      .iter(items)
-      :map(function(item) return { item = item, formatted = _format_item(item) } end)
-      :totable()
   end)
 
   -- When the filter text changes, update the filtered items:
@@ -231,10 +223,8 @@ function M.create_picker(opts) -- {{{
       local formatted_items = s_formatted_items:get()
       local filter_text = vim.trim(s_filter_text:get()):lower()
 
-      --- @type string
+      local filter_pattern = ''
-      local filter_pattern
+      local use_plain_pattern = false
-      --- @type boolean
-      local use_plain_pattern
       if #formatted_items > 250 and #filter_text <= 3 then
         filter_pattern = filter_text
         use_plain_pattern = true
@@ -257,9 +247,7 @@ function M.create_picker(opts) -- {{{
       local new_filtered_items = vim
         .iter(formatted_items)
         :enumerate()
-        :map(
+        :map(function(i, inf) return { orig_idx = i, item = inf.item, formatted = inf.formatted } end)
-          function(i, inf) return { orig_idx = i, item = inf.item, formatted = inf.formatted } end
-        )
         :filter(function(inf)
           if filter_text == '' then return true end
           local formatted_as_string = Renderer.markup_to_string({ tree = inf.formatted }):lower()
@@ -267,7 +255,9 @@ function M.create_picker(opts) -- {{{
           formatted_strings[inf.orig_idx] = formatted_as_string
           if use_plain_pattern then
             local x, y = formatted_as_string:find(filter_pattern, 1, true)
-            if x ~= nil and y ~= nil then matches[inf.orig_idx] = formatted_as_string:sub(x, y) end
+            if x ~= nil and y ~= nil then
+              matches[inf.orig_idx] = formatted_as_string:sub(x, y)
+            end
           else
             matches[inf.orig_idx] = string.match(formatted_as_string, filter_pattern)
           end
@@ -330,9 +320,7 @@ function M.create_picker(opts) -- {{{
       local filtered_items = s_filtered_items:get()
       local cursor_index = s_cursor_index:get()
       local indices = shallow_copy_arr(selected_indices)
-      if #indices == 0 and #filtered_items > 0 then
+      if #indices == 0 and #filtered_items > 0 then indices = { filtered_items[cursor_index].orig_idx } end
-        indices = { filtered_items[cursor_index].orig_idx }
-      end
       return {
         items = vim.iter(indices):map(function(i) return items[i] end):totable(),
         indices = indices,
@@ -409,18 +397,8 @@ function M.create_picker(opts) -- {{{
     end
     s_cursor_index:set(next_cursor_index)
   end
-  vim.keymap.set(
+  vim.keymap.set('i', '<C-n>', safe_wrap(action_next_line), { buffer = w_input_buf.bufnr, desc = 'Picker: next' })
-    'i',
+  vim.keymap.set('i', '<Down>', safe_wrap(action_next_line), { buffer = w_input_buf.bufnr, desc = 'Picker: next' })
-    '<C-n>',
-    safe_wrap(action_next_line),
-    { buffer = w_input_buf.bufnr, desc = 'Picker: next' }
-  )
-  vim.keymap.set(
-    'i',
-    '<Down>',
-    safe_wrap(action_next_line),
-    { buffer = w_input_buf.bufnr, desc = 'Picker: next' }
-  )
 
   local function action_prev_line()
     local max_line = #s_filtered_items:get()
@@ -428,18 +406,8 @@ function M.create_picker(opts) -- {{{
     if next_cursor_index - s_top_offset:get() < 1 then s_top_offset:set(s_top_offset:get() - 1) end
     s_cursor_index:set(next_cursor_index)
   end
-  vim.keymap.set(
+  vim.keymap.set('i', '<C-p>', safe_wrap(action_prev_line), { buffer = w_input_buf.bufnr, desc = 'Picker: previous' })
-    'i',
+  vim.keymap.set('i', '<Up>', safe_wrap(action_prev_line), { buffer = w_input_buf.bufnr, desc = 'Picker: previous' })
-    '<C-p>',
-    safe_wrap(action_prev_line),
-    { buffer = w_input_buf.bufnr, desc = 'Picker: previous' }
-  )
-  vim.keymap.set(
-    'i',
-    '<Up>',
-    safe_wrap(action_prev_line),
-    { buffer = w_input_buf.bufnr, desc = 'Picker: previous' }
-  )
 
   vim.keymap.set(
     'i',
@@ -449,9 +417,7 @@ function M.create_picker(opts) -- {{{
 
       local index = s_filtered_items:get()[s_cursor_index:get()].orig_idx
       if vim.tbl_contains(s_selected_indices:get(), index) then
-        s_selected_indices:set(
+        s_selected_indices:set(vim.iter(s_selected_indices:get()):filter(function(i) return i ~= index end):totable())
-          vim.iter(s_selected_indices:get()):filter(function(i) return i ~= index end):totable()
-        )
       else
         local new_selected_indices = shallow_copy_arr(s_selected_indices:get())
         table.insert(new_selected_indices, index)
@@ -463,12 +429,7 @@ function M.create_picker(opts) -- {{{
   )
 
   for key, fn in pairs(opts.mappings or {}) do
-    vim.keymap.set(
+    vim.keymap.set('i', key, safe_wrap(function() return fn(controller) end), { buffer = w_input_buf.bufnr })
-      'i',
-      key,
-      safe_wrap(function() return fn(controller) end),
-      { buffer = w_input_buf.bufnr }
-    )
   end
 
   -- Render:
@@ -538,9 +499,10 @@ function M.create_picker(opts) -- {{{
       if ephemeral == nil then ephemeral = false end
 
       if ephemeral and #indicies == 1 then
-        local matching_filtered_item_idx, _ = vim.iter(s_filtered_items:get()):enumerate():find(
+        local matching_filtered_item_idx, _ = vim
-          function(_idx, inf) return inf.orig_idx == indicies[1] end
+          .iter(s_filtered_items:get())
-        )
+          :enumerate()
+          :find(function(_idx, inf) return inf.orig_idx == indicies[1] end)
         if matching_filtered_item_idx ~= nil then s_cursor_index:set(indicies[1]) end
       else
         if not opts.multi then
@@ -557,7 +519,7 @@ function M.create_picker(opts) -- {{{
     return safe_run(function() H.finish(true) end)
   end
 
-  return controller --[[@as u.examples.SelectController]]
+  return controller --[[@as SelectController]]
 end -- }}}
 
 --------------------------------------------------------------------------------
@@ -759,10 +721,7 @@ function M.files(opts) -- {{{
       -- fast laptop. Show a warning and truncate the list in this case.
       if #lines >= opts.limit then
         if not job_inf.notified_over_limit then
-          vim.notify(
+          vim.notify('Picker list is too large (truncating list to ' .. opts.limit .. ' items)', vim.log.levels.WARN)
-            'Picker list is too large (truncating list to ' .. opts.limit .. ' items)',
-            vim.log.levels.WARN
-          )
           pcall(vim.fn.jobstop, job_inf.id)
           job_inf.notified_over_limit = true
         end
@@ -805,7 +764,10 @@ function M.buffers() -- {{{
       -- trim leading `cwd` from the buffer name:
       if item_name:sub(1, #cwd) == cwd then item_name = item_name:sub(#cwd + 1) end
 
-      return TreeBuilder.new():put(item.changed == 1 and '[+] ' or '    '):put(item_name):tree()
+      return TreeBuilder.new()
+        :put(item.changed == 1 and '[+] ' or '    ')
+        :put(item_name)
+        :tree()
     end,
 
     --- @params items { bufnr: number }[]
@@ -918,9 +880,7 @@ function M.lsp_code_symbols() -- {{{
     local item = items[1]
 
     -- Jump to the file/buffer:
-    local buf = vim
+    local buf = vim.iter(vim.fn.getbufinfo { buflisted = 1 }):find(function(b) return b.name == item.filename end)
-      .iter(vim.fn.getbufinfo { buflisted = 1 })
-      :find(function(b) return b.name == item.filename end)
     if buf ~= nil then
       vim.api.nvim_win_set_buf(0, buf.bufnr)
     else

examples/splitjoin.lua

@@ -1,6 +1,6 @@
+local vim_repeat = require 'u.repeat'
 local CodeWriter = require 'u.codewriter'
 local Range = require 'u.range'
-local vim_repeat = require 'u.repeat'
 
 local M = {}
 

examples/surround.lua

@@ -1,12 +1,11 @@
+local vim_repeat = require 'u.repeat'
+local Pos = require 'u.pos'
+local Range = require 'u.range'
 local Buffer = require 'u.buffer'
 local CodeWriter = require 'u.codewriter'
-local Range = require 'u.range'
-local vim_repeat = require 'u.repeat'
 
 local M = {}
 
-local ESC = vim.api.nvim_replace_termcodes('<Esc>', true, false, true)
-
 local surrounds = {
   [')'] = { left = '(', right = ')' },
   ['('] = { left = '( ', right = ' )' },
@@ -127,7 +126,7 @@ function M.setup()
 
     do_surround(range, bounds)
     -- this is a visual mapping: end in normal mode:
-    vim.cmd.normal(ESC)
+    vim.cmd { cmd = 'normal', args = { '' }, bang = true }
   end, { noremap = true, silent = true })
 
   -- Change
@@ -170,19 +169,29 @@ function M.setup()
         local irange = Range.from_motion('i' .. from_c, { user_defined = true })
         if arange == nil or irange == nil then return end
 
-        local lrange, rrange = arange:difference(irange)
+        local lrange = Range.new(arange.start, irange.start:must_next(-1))
-        if not lrange or not rrange then return end
+        local rrange = Range.new(irange.stop:must_next(1), arange.stop)
 
         rrange:replace(to.right)
         lrange:replace(to.left)
       else
         -- replace `from.right` with `to.right`:
-        local right_text = arange:sub(-1, -#from.right)
+        local last_line = arange:line(-1):text()
-        right_text:replace(to.right)
+        local from_right_match = last_line:match(vim.pesc(from.right) .. '$')
+        if from_right_match then
+          local match_start = arange.stop:clone()
+          match_start.col = match_start.col - #from_right_match + 1
+          Range.new(match_start, arange.stop):replace(to.right)
+        end
 
         -- replace `from.left` with `to.left`:
-        local left_text = arange:sub(1, #from.left)
+        local first_line = arange:line(1):text()
-        left_text:replace(to.left)
+        local from_left_match = first_line:match('^' .. vim.pesc(from.left))
+        if from_left_match then
+          local match_end = arange.start:clone()
+          match_end.col = match_end.col + #from_left_match - 1
+          Range.new(arange.start, match_end):replace(to.left)
+        end
       end
     end)
   end, { noremap = true, silent = true })

examples/text-objects.lua

@@ -1,7 +1,7 @@
-local Buffer = require 'u.buffer'
+local txtobj = require 'u.txtobj'
 local Pos = require 'u.pos'
 local Range = require 'u.range'
-local txtobj = require 'u.txtobj'
+local Buffer = require 'u.buffer'
 
 local M = {}
 

lua/u/buffer.lua

@@ -2,24 +2,20 @@ local Range = require 'u.range'
 local Renderer = require('u.renderer').Renderer
 
 --- @class u.Buffer
---- @field bufnr integer
+--- @field bufnr number
---- @field b vim.var_accessor
+--- @field private renderer u.Renderer
---- @field bo vim.bo
---- @field renderer u.renderer.Renderer
 local Buffer = {}
-Buffer.__index = Buffer
 
 --- @param bufnr? number
 --- @return u.Buffer
 function Buffer.from_nr(bufnr)
   if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
+
   local renderer = Renderer.new(bufnr)
   return setmetatable({
     bufnr = bufnr,
-    b = vim.b[bufnr],
-    bo = vim.bo[bufnr],
     renderer = renderer,
-  }, Buffer)
+  }, { __index = Buffer })
 end
 
 --- @return u.Buffer
@@ -28,16 +24,26 @@ function Buffer.current() return Buffer.from_nr(0) end
 --- @param listed boolean
 --- @param scratch boolean
 --- @return u.Buffer
-function Buffer.create(listed, scratch)
+function Buffer.create(listed, scratch) return Buffer.from_nr(vim.api.nvim_create_buf(listed, scratch)) end
-  return Buffer.from_nr(vim.api.nvim_create_buf(listed, scratch))
-end
 
 function Buffer:set_tmp_options()
-  self.bo.bufhidden = 'delete'
+  self:set_option('bufhidden', 'delete')
-  self.bo.buflisted = false
+  self:set_option('buflisted', false)
-  self.bo.buftype = 'nowrite'
+  self:set_option('buftype', 'nowrite')
 end
 
+--- @param nm string
+function Buffer:get_option(nm) return vim.api.nvim_get_option_value(nm, { buf = self.bufnr }) end
+
+--- @param nm string
+function Buffer:set_option(nm, val) return vim.api.nvim_set_option_value(nm, val, { buf = self.bufnr }) end
+
+--- @param nm string
+function Buffer:get_var(nm) return vim.api.nvim_buf_get_var(self.bufnr, nm) end
+
+--- @param nm string
+function Buffer:set_var(nm, val) return vim.api.nvim_buf_set_var(self.bufnr, nm, val) end
+
 function Buffer:line_count() return vim.api.nvim_buf_line_count(self.bufnr) end
 
 function Buffer:all() return Range.from_buf_text(self.bufnr) end
@@ -61,71 +67,21 @@ end
 --- @param stop number 1-based line index
 function Buffer:lines(start, stop) return Range.from_lines(self.bufnr, start, stop) end
 
---- @param motion string
+--- @param txt_obj string
 --- @param opts? { contains_cursor?: boolean; pos?: u.Pos }
-function Buffer:motion(motion, opts)
+function Buffer:txtobj(txt_obj, opts)
   opts = vim.tbl_extend('force', opts or {}, { bufnr = self.bufnr })
-  return Range.from_motion(motion, opts)
+  return Range.from_motion(txt_obj, opts)
 end
 
---- @param event vim.api.keyset.events|vim.api.keyset.events[]
+--- @param event string|string[]
 --- @diagnostic disable-next-line: undefined-doc-name
 --- @param opts vim.api.keyset.create_autocmd
 function Buffer:autocmd(event, opts)
   vim.api.nvim_create_autocmd(event, vim.tbl_extend('force', opts, { buffer = self.bufnr }))
 end
 
---- @param fn function
+--- @param tree Tree
-function Buffer:call(fn) return vim.api.nvim_buf_call(self.bufnr, fn) end
-
---- @param tree u.renderer.Tree
 function Buffer:render(tree) return self.renderer:render(tree) end
 
---- Filter buffer content through an external command (like Vim's :%!)
---- @param cmd string[] Command to run (with arguments)
---- @param opts? {cwd?: string, preserve_cursor?: boolean}
---- @return nil
---- @throws string Error message if command fails
---- @note Special placeholders in cmd:
----   - $FILE: replaced with the buffer's filename (if any)
----   - $DIR: replaced with the buffer's directory (if any)
-function Buffer:filter_cmd(cmd, opts)
-  opts = opts or {}
-  local cwd = opts.cwd or vim.uv.cwd()
-  local old_lines = self:all():lines()
-  -- Save cursor position if needed, defaulting to true
-  local save_pos = opts.preserve_cursor ~= false and vim.fn.winsaveview()
-
-  -- Run the command
-  local result = vim
-    .system(
-      -- Replace special placeholders in `cmd` with their values:
-      vim
-        .iter(cmd)
-        :map(function(x)
-          if x == '$FILE' then return vim.api.nvim_buf_get_name(self.bufnr) end
-          if x == '$DIR' then return vim.fs.dirname(vim.api.nvim_buf_get_name(self.bufnr)) end
-          return x
-        end)
-        :totable(),
-      {
-        cwd = cwd,
-        stdin = old_lines,
-        text = true,
-      }
-    )
-    :wait()
-
-  -- Check for command failure
-  if result.code ~= 0 then error('Command failed: ' .. (result.stderr or '')) end
-
-  -- Process and apply the result
-  local new_lines = vim.split(result.stdout, '\n')
-  if new_lines[#new_lines] == '' then table.remove(new_lines) end
-  Renderer.patch_lines(self.bufnr, old_lines, new_lines)
-
-  -- Restore cursor position if saved
-  if save_pos then vim.fn.winrestview(save_pos) end
-end
-
 return Buffer

lua/u/codewriter.lua

@@ -5,7 +5,6 @@ local Buffer = require 'u.buffer'
 --- @field indent_level number
 --- @field indent_str string
 local CodeWriter = {}
-CodeWriter.__index = CodeWriter
 
 --- @param indent_level? number
 --- @param indent_str? string
@@ -19,7 +18,7 @@ function CodeWriter.new(indent_level, indent_str)
     indent_level = indent_level,
     indent_str = indent_str,
   }
-  setmetatable(cw, CodeWriter)
+  setmetatable(cw, { __index = CodeWriter })
   return cw
 end
 
@@ -32,14 +31,13 @@ end
 --- @param line string
 --- @param bufnr? number
 function CodeWriter.from_line(line, bufnr)
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
+  if bufnr == nil then bufnr = vim.api.nvim_get_current_buf() end
 
   local ws = line:match '^%s*'
   local expandtab = vim.api.nvim_get_option_value('expandtab', { buf = bufnr })
   local shiftwidth = vim.api.nvim_get_option_value('shiftwidth', { buf = bufnr })
 
-  --- @type number
+  local indent_level = 0
-  local indent_level
   local indent_str = ''
   if expandtab then
     while #indent_str < shiftwidth do

lua/u/extmark.lua

@@ -1,71 +0,0 @@
-local Pos = require 'u.pos'
-
----@class u.Extmark
----@field bufnr integer
----@field id integer
----@field nsid integer
-local Extmark = {}
-Extmark.__index = Extmark
-
---- @param bufnr integer
---- @param nsid integer
---- @param id integer
-function Extmark.new(bufnr, nsid, id)
-  return setmetatable({
-    bufnr = bufnr,
-    nsid = nsid,
-    id = id,
-  }, Extmark)
-end
-
---- @param range u.Range
---- @param nsid integer
-function Extmark.from_range(range, nsid)
-  local r = range:to_charwise()
-  local stop = r.stop or r.start
-  local end_row = stop.lnum - 1
-  local end_col = stop.col
-  if range.mode == 'V' then
-    end_row = end_row + 1
-    end_col = 0
-  end
-  local id = vim.api.nvim_buf_set_extmark(r.start.bufnr, nsid, r.start.lnum - 1, r.start.col - 1, {
-    right_gravity = false,
-    end_right_gravity = true,
-    end_row = end_row,
-    end_col = end_col,
-  })
-  return Extmark.new(r.start.bufnr, nsid, id)
-end
-
-function Extmark:range()
-  local Range = require 'u.range'
-
-  local raw_extmark =
-    vim.api.nvim_buf_get_extmark_by_id(self.bufnr, self.nsid, self.id, { details = true })
-  local start_row0, start_col0, details = unpack(raw_extmark)
-
-  --- @type u.Pos
-  local start = Pos.from00(self.bufnr, start_row0, start_col0)
-  --- @type u.Pos?
-  local stop = details
-    and details.end_row
-    and details.end_col
-    and Pos.from01(self.bufnr, details.end_row, details.end_col)
-
-  local n_buf_lines = vim.api.nvim_buf_line_count(self.bufnr)
-  if stop and stop.lnum > n_buf_lines then
-    stop.lnum = n_buf_lines
-    stop = stop:eol()
-  end
-  if stop and stop.col == 0 then
-    stop.col = 1
-    stop = stop:next(-1)
-  end
-
-  return Range.new(start, stop, 'v')
-end
-
-function Extmark:delete() vim.api.nvim_buf_del_extmark(self.bufnr, self.nsid, self.id) end
-
-return Extmark

lua/u/logger.lua

@@ -1,9 +1,7 @@
 local M = {}
 
-local LOG_ROOT = vim.fs.joinpath(vim.fn.stdpath 'cache', 'u.log')
-
 --- @params name string
-function M.file_for_name(name) return vim.fs.joinpath(LOG_ROOT, name .. '.log.jsonl') end
+function M.file_for_name(name) return vim.fs.joinpath(vim.fn.stdpath 'cache', 'u.log', name .. '.log.jsonl') end
 
 --------------------------------------------------------------------------------
 -- Logger class
@@ -11,6 +9,7 @@ function M.file_for_name(name) return vim.fs.joinpath(LOG_ROOT, name .. '.log.js
 
 --- @class u.Logger
 --- @field name string
+--- @field private fd number
 local Logger = {}
 Logger.__index = Logger
 M.Logger = Logger
@@ -19,7 +18,10 @@ M.Logger = Logger
 function Logger.new(name)
   local file_path = M.file_for_name(name)
   vim.fn.mkdir(vim.fs.dirname(file_path), 'p')
-  local self = setmetatable({ name = name }, Logger)
+  local self = setmetatable({
+    name = name,
+    fd = (vim.uv or vim.loop).fs_open(file_path, 'a', tonumber('644', 8)),
+  }, Logger)
   return self
 end
 
@@ -28,12 +30,7 @@ end
 function Logger:write(level, ...)
   local data = { ... }
   if #data == 1 then data = data[1] end
-  local f = assert(io.open(M.file_for_name(self.name), 'a'), 'could not open file')
+  (vim.uv or vim.loop).fs_write(self.fd, vim.json.encode { ts = os.date(), level = level, data = data } .. '\n')
-  assert(
-    f:write(vim.json.encode { ts = os.date(), level = level, data = data } .. '\n'),
-    'could not write to file'
-  )
-  f:close()
 end
 
 function Logger:trace(...) self:write('INFO', ...) end
@@ -62,12 +59,6 @@ function M.setup()
     vim.cmd.terminal('tail -f "' .. log_file_path .. '"')
     vim.cmd.startinsert()
   end, { nargs = '*' })
-
-  vim.api.nvim_create_user_command(
-    'Logroot',
-    function() vim.api.nvim_echo({ { LOG_ROOT } }, false, {}) end,
-    {}
-  )
 end
 
 return M

lua/u/opkeymap.lua

@@ -8,7 +8,7 @@ local __U__OpKeymapOpFunc_rhs = nil
 --- @type nil|fun(range: u.Range): fun():any|nil
 --- @param ty 'line'|'char'|'block'
 -- selene: allow(unused_variable)
-function _G.__U__OpKeymapOpFunc(ty)
+function __U__OpKeymapOpFunc(ty)
   if __U__OpKeymapOpFunc_rhs ~= nil then
     local range = Range.from_op_func(ty)
     __U__OpKeymapOpFunc_rhs(range)

lua/u/pos.lua

@@ -2,27 +2,16 @@ local MAX_COL = vim.v.maxcol
 
 --- @param bufnr number
 --- @param lnum number 1-based
-local function line_text(bufnr, lnum)
+local function line_text(bufnr, lnum) return vim.api.nvim_buf_get_lines(bufnr, lnum - 1, lnum, false)[1] end
-  return vim.api.nvim_buf_get_lines(bufnr, lnum - 1, lnum, false)[1]
-end
 
 --- @class u.Pos
---- @field bufnr integer buffer number
+--- @field bufnr number buffer number
---- @field lnum integer 1-based line index
+--- @field lnum number 1-based line index
---- @field col integer 1-based column index
+--- @field col number 1-based column index
 --- @field off number
 local Pos = {}
-Pos.__index = Pos
 Pos.MAX_COL = MAX_COL
 
-function Pos.__tostring(self)
-  if self.off ~= 0 then
-    return string.format('Pos(%d:%d){bufnr=%d, off=%d}', self.lnum, self.col, self.bufnr, self.off)
-  else
-    return string.format('Pos(%d:%d){bufnr=%d}', self.lnum, self.col, self.bufnr)
-  end
-end
-
 --- @param bufnr? number
 --- @param lnum number 1-based
 --- @param col number 1-based
@@ -31,68 +20,56 @@ end
 function Pos.new(bufnr, lnum, col, off)
   if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
   if off == nil then off = 0 end
-  --- @type u.Pos
+  local pos = {
-  return setmetatable({
     bufnr = bufnr,
     lnum = lnum,
     col = col,
     off = off,
-  }, Pos)
+  }
+
+  local function str()
+    if pos.off ~= 0 then
+      return string.format('Pos(%d:%d){bufnr=%d, off=%d}', pos.lnum, pos.col, pos.bufnr, pos.off)
+    else
+      return string.format('Pos(%d:%d){bufnr=%d}', pos.lnum, pos.col, pos.bufnr)
+    end
+  end
+  setmetatable(pos, {
+    __index = Pos,
+    __tostring = str,
+    __lt = Pos.__lt,
+    __le = Pos.__le,
+    __eq = Pos.__eq,
+  })
+  return pos
 end
-
---- @param bufnr? number
---- @param lnum0 number 1-based
---- @param col0 number 1-based
---- @param off? number
-function Pos.from00(bufnr, lnum0, col0, off) return Pos.new(bufnr, lnum0 + 1, col0 + 1, off) end
-
---- @param bufnr? number
---- @param lnum0 number 1-based
---- @param col1 number 1-based
---- @param off? number
-function Pos.from01(bufnr, lnum0, col1, off) return Pos.new(bufnr, lnum0 + 1, col1, off) end
-
---- @param bufnr? number
---- @param lnum1 number 1-based
---- @param col0 number 1-based
---- @param off? number
-function Pos.from10(bufnr, lnum1, col0, off) return Pos.new(bufnr, lnum1, col0 + 1, off) end
 
 function Pos.invalid() return Pos.new(0, 0, 0, 0) end
 
+function Pos.is(x)
+  if not type(x) == 'table' then return false end
+  local mt = getmetatable(x)
+  return mt and mt.__index == Pos
+end
+
 function Pos.__lt(a, b) return a.lnum < b.lnum or (a.lnum == b.lnum and a.col < b.col) end
 function Pos.__le(a, b) return a < b or a == b end
-function Pos.__eq(a, b)
+function Pos.__eq(a, b) return Pos.is(a) and Pos.is(b) and a.bufnr == b.bufnr and a.lnum == b.lnum and a.col == b.col end
-  return getmetatable(a) == Pos
-    and getmetatable(b) == Pos
-    and a.bufnr == b.bufnr
-    and a.lnum == b.lnum
-    and a.col == b.col
-end
 function Pos.__add(x, y)
   if type(x) == 'number' then
     x, y = y, x
   end
-  if getmetatable(x) ~= Pos or type(y) ~= 'number' then return nil end
+  if not Pos.is(x) or type(y) ~= 'number' then return nil end
   return x:next(y)
 end
 function Pos.__sub(x, y)
   if type(x) == 'number' then
     x, y = y, x
   end
-  if getmetatable(x) ~= Pos or type(y) ~= 'number' then return nil end
+  if not Pos.is(x) or type(y) ~= 'number' then return nil end
   return x:next(-y)
 end
 
---- @param bufnr number
---- @param lnum number
-function Pos.from_eol(bufnr, lnum)
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
-  local pos = Pos.new(bufnr, lnum, 0)
-  pos.col = pos:line():len()
-  return pos
-end
-
 --- @param name string
 --- @return u.Pos
 function Pos.from_pos(name)
@@ -100,7 +77,7 @@ function Pos.from_pos(name)
   return Pos.new(p[1], p[2], p[3], p[4])
 end
 
-function Pos:is_invalid() return self.lnum == 0 and self.col == 0 and self.off == 0 end
+function Pos:is_invalid() return self.bufnr == 0 and self.lnum == 0 and self.col == 0 and self.off == 0 end
 
 function Pos:clone() return Pos.new(self.bufnr, self.lnum, self.col, self.off) end
 
@@ -122,16 +99,9 @@ end
 
 function Pos:as_vim() return { self.bufnr, self.lnum, self.col, self.off } end
 
-function Pos:eol() return Pos.from_eol(self.bufnr, self.lnum) end
-
 --- @param pos string
 function Pos:save_to_pos(pos) vim.fn.setpos(pos, { self.bufnr, self.lnum, self.col, self.off }) end
 
---- @param winnr? integer
-function Pos:save_to_cursor(winnr)
-  vim.api.nvim_win_set_cursor(winnr or 0, { self.lnum, self.col - 1 })
-end
-
 --- @param mark string
 function Pos:save_to_mark(mark)
   local p = self:as_real()
@@ -232,9 +202,7 @@ end
 --- @return u.Pos|nil
 function Pos:find_match(max_chars, invocations)
   if invocations == nil then invocations = {} end
-  if vim.tbl_contains(invocations, function(p) return self == p end, { predicate = true }) then
+  if vim.tbl_contains(invocations, function(p) return self == p end, { predicate = true }) then return nil end
-    return nil
-  end
   table.insert(invocations, self)
 
   local openers = { '{', '[', '(', '<' }
@@ -244,10 +212,7 @@ function Pos:find_match(max_chars, invocations)
   local is_closer = vim.tbl_contains(closers, c)
   if not is_opener and not is_closer then return nil end
 
-  local i, _ = vim
+  local i, _ = vim.iter(is_opener and openers or closers):enumerate():find(function(_, c2) return c == c2 end)
-    .iter(is_opener and openers or closers)
-    :enumerate()
-    :find(function(_, c2) return c == c2 end)
   -- Store the character we will be looking for:
   local c_match = (is_opener and closers or openers)[i]
 
@@ -290,14 +255,7 @@ end
 --- @param lines string|string[]
 function Pos:insert_before(lines)
   if type(lines) == 'string' then lines = vim.split(lines, '\n') end
-  vim.api.nvim_buf_set_text(
+  vim.api.nvim_buf_set_text(self.bufnr, self.lnum - 1, self.col - 1, self.lnum - 1, self.col - 1, lines)
-    self.bufnr,
-    self.lnum - 1,
-    self.col - 1,
-    self.lnum - 1,
-    self.col - 1,
-    lines
-  )
 end
 
 return Pos

lua/u/range.lua

@@ -1,41 +1,17 @@
-local Extmark = require 'u.extmark'
 local Pos = require 'u.pos'
 
-local ESC = vim.api.nvim_replace_termcodes('<Esc>', true, false, true)
+local orig_on_yank = (vim.hl or vim.highlight).on_yank
-local NS = vim.api.nvim_create_namespace 'u.range'
+local on_yank_enabled = true;
+((vim.hl or vim.highlight) --[[@as any]]).on_yank = function(opts)
+  if not on_yank_enabled then return end
+  return orig_on_yank(opts)
+end
 
 --- @class u.Range
 --- @field start u.Pos
 --- @field stop u.Pos|nil
 --- @field mode 'v'|'V'
 local Range = {}
-Range.__index = Range
-function Range.__tostring(self)
-  --- @param p u.Pos
-  local function posstr(p)
-    if p == nil then
-      return 'nil'
-    elseif p.off ~= 0 then
-      return string.format('Pos(%d:%d){off=%d}', p.lnum, p.col, p.off)
-    else
-      return string.format('Pos(%d:%d)', p.lnum, p.col)
-    end
-  end
-
-  local _1 = posstr(self.start)
-  local _2 = posstr(self.stop)
-  return string.format(
-    'Range{bufnr=%d, mode=%s, start=%s, stop=%s}',
-    self.start.bufnr,
-    self.mode,
-    _1,
-    _2
-  )
-end
-
---------------------------------------------------------------------------------
--- Range constructors:
---------------------------------------------------------------------------------
 
 --- @param start u.Pos
 --- @param stop u.Pos|nil
@@ -47,24 +23,29 @@ function Range.new(start, stop, mode)
   end
 
   local r = { start = start, stop = stop, mode = mode or 'v' }
+  local function str()
+    --- @param p u.Pos
+    local function posstr(p)
+      if p == nil then
+        return 'nil'
+      elseif p.off ~= 0 then
+        return string.format('Pos(%d:%d){off=%d}', p.lnum, p.col, p.off)
+      else
+        return string.format('Pos(%d:%d)', p.lnum, p.col)
+      end
+    end
 
-  setmetatable(r, Range)
+    local _1 = posstr(r.start)
+    local _2 = posstr(r.stop)
+    return string.format('Range{bufnr=%d, mode=%s, start=%s, stop=%s}', r.start.bufnr, r.mode, _1, _2)
+  end
+  setmetatable(r, { __index = Range, __tostring = str })
   return r
 end
 
---- @param ranges (u.Range|nil)[]
+function Range.is(x)
-function Range.smallest(ranges)
+  local mt = getmetatable(x)
-  --- @type u.Range[]
+  return mt and mt.__index == Range
-  ranges = vim.iter(ranges):filter(function(r) return r ~= nil and not r:is_empty() end):totable()
-  if #ranges == 0 then return nil end
-
-  -- find smallest match
-  local smallest = ranges[1]
-  for _, r in ipairs(ranges) do
-    local start, stop = r.start, r.stop
-    if start > smallest.start and stop < smallest.stop then smallest = r end
-  end
-  return smallest
 end
 
 --- @param lpos string
@@ -111,111 +92,81 @@ function Range.from_lines(bufnr, start_line, stop_line)
   return Range.new(Pos.new(bufnr, start_line, 1), Pos.new(bufnr, stop_line, Pos.MAX_COL), 'V')
 end
 
---- @param motion string
+--- @param text_obj string
 --- @param opts? { bufnr?: number; contains_cursor?: boolean; pos?: u.Pos, user_defined?: boolean }
 --- @return u.Range|nil
-function Range.from_motion(motion, opts)
+function Range.from_motion(text_obj, opts)
-  -- Options handling:
   opts = opts or {}
-  if opts.bufnr == nil or opts.bufnr == 0 then opts.bufnr = vim.api.nvim_get_current_buf() end
+  if opts.bufnr == nil then opts.bufnr = vim.api.nvim_get_current_buf() end
   if opts.contains_cursor == nil then opts.contains_cursor = false end
   if opts.user_defined == nil then opts.user_defined = false end
 
-  -- Extract some information from the motion:
+  --- @type "a" | "i"
-  --- @type 'a'|'i', string
+  local selection_type = text_obj:sub(1, 1)
-  local scope, motion_rest = motion:sub(1, 1), motion:sub(2)
+  local obj_type = text_obj:sub(#text_obj, #text_obj)
-  local is_txtobj = scope == 'a' or scope == 'i'
+  local is_quote = vim.tbl_contains({ "'", '"', '`' }, obj_type)
-  local is_quote_txtobj = is_txtobj and vim.tbl_contains({ "'", '"', '`' }, motion_rest)
+  local cursor = Pos.from_pos '.'
 
-  -- Capture the original state of the buffer for restoration later.
+  --- @type u.Pos
+  local start
+  --- @type u.Pos
+  local stop
+
+  vim.api.nvim_buf_call(opts.bufnr, function()
     local original_state = {
       winview = vim.fn.winsaveview(),
       regquote = vim.fn.getreg '"',
-    cursor = vim.fn.getpos '.',
+      posdot = vim.fn.getpos '.',
-    pos_lbrack = vim.fn.getpos "'[",
+      poslb = vim.fn.getpos "'[",
-    pos_rbrack = vim.fn.getpos "']",
+      posrb = vim.fn.getpos "']",
-    opfunc = vim.go.operatorfunc,
-    prev_captured_range = _G.Range__from_motion_opfunc_captured_range,
-    prev_mode = vim.fn.mode(),
-    vinf = Range.from_vtext(),
     }
-  --- @type u.Range|nil
-  _G.Range__from_motion_opfunc_captured_range = nil
 
-  vim.api.nvim_buf_call(opts.bufnr, function()
     if opts.pos ~= nil then opts.pos:save_to_pos '.' end
 
-    _G.Range__from_motion_opfunc = function(ty)
+    Pos.invalid():save_to_pos "'["
-      _G.Range__from_motion_opfunc_captured_range = Range.from_op_func(ty)
+    Pos.invalid():save_to_pos "']"
-    end
+
-    local old_eventignore = vim.o.eventignore
+    local prev_on_yank_enabled = on_yank_enabled
-    vim.o.eventignore = 'all'
+    on_yank_enabled = false
-    vim.go.operatorfunc = 'v:lua.Range__from_motion_opfunc'
     vim.cmd {
       cmd = 'normal',
       bang = not opts.user_defined,
-      args = { ESC .. 'g@' .. motion },
+      args = { '""y' .. text_obj },
       mods = { silent = true },
     }
-    vim.o.eventignore = old_eventignore
+    on_yank_enabled = prev_on_yank_enabled
-  end)
+
-  local captured_range = _G.Range__from_motion_opfunc_captured_range
+    start = Pos.from_pos "'["
+    stop = Pos.from_pos "']"
 
     -- Restore original state:
     vim.fn.winrestview(original_state.winview)
     vim.fn.setreg('"', original_state.regquote)
-  vim.fn.setpos('.', original_state.cursor)
+    vim.fn.setpos('.', original_state.posdot)
-  vim.fn.setpos("'[", original_state.pos_lbrack)
+    vim.fn.setpos("'[", original_state.poslb)
-  vim.fn.setpos("']", original_state.pos_rbrack)
+    vim.fn.setpos("']", original_state.posrb)
-  if original_state.prev_mode ~= 'n' then original_state.vinf:set_visual_selection() end
-  vim.go.operatorfunc = original_state.opfunc
-  _G.Range__from_motion_opfunc_captured_range = original_state.prev_captured_range
 
-  if not captured_range then return nil end
-
-  -- Fixup the bounds:
     if
       -- I have no idea why, but when yanking `i"`, the stop-mark is
       -- placed on the ending quote. For other text-objects, the stop-
       -- mark is placed before the closing character.
-    (is_quote_txtobj and scope == 'i' and captured_range.stop:char() == motion_rest)
+      (is_quote and selection_type == 'i' and stop:char() == obj_type)
       -- *Sigh*, this also sometimes happens for `it` as well.
-    or (motion == 'it' and captured_range.stop:char() == '<')
+      or (text_obj == 'it' and stop:char() == '<')
     then
-    captured_range.stop = captured_range.stop:next(-1) or captured_range.stop
+      stop = stop:next(-1) or stop
     end
-  if is_quote_txtobj and scope == 'a' then
+  end)
-    captured_range.start = captured_range.start:find_next(1, motion_rest) or captured_range.start
+
-    captured_range.stop = captured_range.stop:find_next(-1, motion_rest) or captured_range.stop
+  if start == stop and start:is_invalid() then return nil end
+  if opts.contains_cursor and not Range.new(start, stop):contains(cursor) then return nil end
+
+  if is_quote and selection_type == 'a' then
+    start = start:find_next(1, obj_type) or start
+    stop = stop:find_next(-1, obj_type) or stop
   end
 
-  if
+  return Range.new(start, stop)
-    opts.contains_cursor and not captured_range:contains(Pos.new(unpack(original_state.cursor)))
-  then
-    return nil
-  end
-
-  return captured_range
-end
-
---- @param opts? { contains_cursor?: boolean }
-function Range.from_tsquery_caps(bufnr, query, opts)
-  opts = opts or { contains_cursor = true }
-
-  local ranges = Range.from_buf_text(bufnr):tsquery(query)
-  if not ranges then return end
-  if not opts.contains_cursor then return ranges end
-
-  local cursor = Pos.from_pos '.'
-  return vim.tbl_map(function(cap_ranges)
-    return vim
-      .iter(cap_ranges)
-      :filter(
-        --- @param r u.Range
-        function(r) return r:contains(cursor) end
-      )
-      :totable()
-  end, ranges)
 end
 
 --- Get range information from the currently selected visual text.
@@ -245,24 +196,22 @@ end
 --- @param args unknown
 --- @return u.Range|nil
 function Range.from_cmd_args(args)
-  if args.range == 0 then return nil end
-
-  local bufnr = vim.api.nvim_get_current_buf()
-  if args.range == 1 then
-    return Range.new(Pos.new(bufnr, args.line1, 1), Pos.new(bufnr, args.line1, Pos.MAX_COL), 'V')
-  end
-
-  local is_visual = vim.fn.histget('cmd', -1):sub(1, 5) == [['<,'>]]
   --- @type 'v'|'V'
-  local mode = is_visual and vim.fn.visualmode() or 'V'
+  local mode
-
+  --- @type nil|u.Pos
-  if is_visual then
+  local start
-    return Range.new(Pos.from_pos "'<", Pos.from_pos "'>", mode)
+  local stop
+  if args.range == 0 then
+    return nil
   else
-    return Range.new(Pos.new(bufnr, args.line1, 1), Pos.new(bufnr, args.line2, Pos.MAX_COL), mode)
+    start = Pos.from_pos "'<"
+    stop = Pos.from_pos "'>"
+    mode = stop:is_col_max() and 'V' or 'v'
   end
+  return Range.new(start, stop, mode)
 end
 
+---
 function Range.find_nearest_brackets()
   return Range.smallest {
     Range.from_motion('a<', { contains_cursor = true }),
@@ -280,15 +229,26 @@ function Range.find_nearest_quotes()
   }
 end
 
---------------------------------------------------------------------------------
+--- @param ranges (u.Range|nil)[]
--- Structural utilities:
+function Range.smallest(ranges)
---------------------------------------------------------------------------------
+  --- @type u.Range[]
+  ranges = vim.iter(ranges):filter(function(r) return r ~= nil and not r:is_empty() end):totable()
+  if #ranges == 0 then return nil end
 
-function Range:clone()
+  -- find smallest match
-  return Range.new(self.start:clone(), self.stop ~= nil and self.stop:clone() or nil, self.mode)
+  local smallest = ranges[1]
+  for _, r in ipairs(ranges) do
+    local start, stop = r.start, r.stop
+    if start > smallest.start and stop < smallest.stop then smallest = r end
+  end
+  return smallest
 end
 
-function Range:is_empty() return self.stop == nil end
+function Range:clone() return Range.new(self.start:clone(), self.stop ~= nil and self.stop:clone() or nil, self.mode) end
+function Range:line_count()
+  if self:is_empty() then return 0 end
+  return self.stop.lnum - self.start.lnum + 1
+end
 
 function Range:to_linewise()
   local r = self:clone()
@@ -300,142 +260,7 @@ function Range:to_linewise()
   return r
 end
 
-function Range:to_charwise()
+function Range:is_empty() return self.stop == nil end
-  local r = self:clone()
-  r.mode = 'v'
-  if r.stop:is_col_max() then r.stop = r.stop:as_real() end
-  return r
-end
-
---- @param x u.Pos | u.Range
-function Range:contains(x)
-  if getmetatable(x) == Pos then
-    return not self:is_empty() and x >= self.start and x <= self.stop
-  elseif getmetatable(x) == Range then
-    return self:contains(x.start) and self:contains(x.stop)
-  end
-  return false
-end
-
---- @param other u.Range
---- @return u.Range|nil, u.Range|nil
-function Range:difference(other)
-  local outer, inner = self, other
-  if not outer:contains(inner) then
-    outer, inner = inner, outer
-  end
-  if not outer:contains(inner) then return nil, nil end
-
-  local left
-  if outer.start ~= inner.start then
-    local stop = inner.start:clone() - 1
-    left = Range.new(outer.start, stop)
-  else
-    left = Range.new(outer.start) -- empty range
-  end
-
-  local right
-  if inner.stop ~= outer.stop then
-    local start = inner.stop:clone() + 1
-    right = Range.new(start, outer.stop)
-  else
-    right = Range.new(inner.stop) -- empty range
-  end
-
-  return left, right
-end
-
---- @param left string
---- @param right string
-function Range:save_to_pos(left, right)
-  self.start:save_to_pos(left);
-  (self:is_empty() and self.start or self.stop):save_to_pos(right)
-end
-
---- @param left string
---- @param right string
-function Range:save_to_marks(left, right)
-  self.start:save_to_mark(left);
-  (self:is_empty() and self.start or self.stop):save_to_mark(right)
-end
-
-function Range:save_to_extmark() return Extmark.from_range(self, NS) end
-
-function Range:set_visual_selection()
-  if self:is_empty() then return end
-  if vim.api.nvim_get_current_buf() ~= self.start.bufnr then
-    error 'Range:set_visual_selection() called on a buffer other than the current buffer'
-  end
-
-  local curr_mode = vim.fn.mode()
-  if curr_mode ~= self.mode then vim.cmd.normal { args = { self.mode }, bang = true } end
-
-  self.start:save_to_pos '.'
-  vim.cmd.normal { args = { 'o' }, bang = true }
-  self.stop:save_to_pos '.'
-end
-
---------------------------------------------------------------------------------
--- Text access/manipulation utilities:
---------------------------------------------------------------------------------
-
---- @param query string
-function Range:tsquery(query)
-  local bufnr = self.start.bufnr
-
-  local lang = vim.treesitter.language.get_lang(vim.bo[bufnr].filetype)
-  if lang == nil then return end
-  local parser = vim.treesitter.get_parser(bufnr, lang)
-  if parser == nil then return end
-  local tree = parser:parse()[1]
-  if tree == nil then return end
-
-  local root = tree:root()
-  local q = vim.treesitter.query.parse(lang, query)
-  --- @type table<string, u.Range[]>
-  local ranges = {}
-  for id, match, _meta in
-    q:iter_captures(root, bufnr, self.start.lnum - 1, (self.stop or self.start).lnum)
-  do
-    local start_row0, start_col0, stop_row0, stop_col0 = match:range()
-    local range = Range.new(
-      Pos.new(bufnr, start_row0 + 1, start_col0 + 1),
-      Pos.new(bufnr, stop_row0 + 1, stop_col0),
-      'v'
-    )
-    if range.stop.lnum > vim.api.nvim_buf_line_count(bufnr) then
-      range.stop = range.stop:must_next(-1)
-    end
-
-    local capture_name = q.captures[id]
-    if not ranges[capture_name] then ranges[capture_name] = {} end
-    if self:contains(range) then table.insert(ranges[capture_name], range) end
-  end
-
-  return ranges
-end
-
-function Range:length()
-  if self:is_empty() then return 0 end
-
-  local line_positions =
-    vim.fn.getregionpos(self.start:as_real():as_vim(), self.stop:as_real():as_vim(), { type = 'v' })
-
-  local len = 0
-  for linenr, line in ipairs(line_positions) do
-    if linenr > 1 then len = len + 1 end -- each newline is counted as a char
-    local line_start_col = line[1][3]
-    local line_stop_col = line[2][3]
-    local line_len = line_stop_col - line_start_col + 1
-    len = len + line_len
-  end
-  return len
-end
-
-function Range:line_count()
-  if self:is_empty() then return 0 end
-  return self.stop.lnum - self.start.lnum + 1
-end
 
 function Range:trim_start()
   if self:is_empty() then return end
@@ -461,46 +286,8 @@ function Range:trim_stop()
   return r
 end
 
---- @param i number 1-based
+--- @param p u.Pos
---- @param j? number 1-based
+function Range:contains(p) return not self:is_empty() and p >= self.start and p <= self.stop end
-function Range:sub(i, j)
-  local line_positions =
-    vim.fn.getregionpos(self.start:as_real():as_vim(), self.stop:as_real():as_vim(), { type = 'v' })
-
-  --- @param idx number 1-based
-  --- @return u.Pos|nil
-  local function get_pos(idx)
-    if idx < 0 then return get_pos(self:length() + idx + 1) end
-
-    -- find the position of the first line that contains the i-th character:
-    local curr_len = 0
-    for linenr, line in ipairs(line_positions) do
-      if linenr > 1 then curr_len = curr_len + 1 end -- each newline is counted as a char
-      local line_start_col = line[1][3]
-      local line_stop_col = line[2][3]
-      local line_len = line_stop_col - line_start_col + 1
-
-      if curr_len + line_len >= idx then
-        return Pos.new(self.start.bufnr, line[1][2], line_start_col + (idx - curr_len) - 1)
-      end
-      curr_len = curr_len + line_len
-    end
-  end
-
-  local start = get_pos(i)
-  if not start then
-    -- start is inalid, so return an empty range:
-    return Range.new(self.start, nil, self.mode)
-  end
-
-  local stop
-  if j then stop = get_pos(j) end
-  if not stop then
-    -- stop is inalid, so return an empty range:
-    return Range.new(start, nil, self.mode)
-  end
-  return Range.new(start, stop, 'v')
-end
 
 --- @return string[]
 function Range:lines()
@@ -511,15 +298,17 @@ end
 --- @return string
 function Range:text() return vim.fn.join(self:lines(), '\n') end
 
+--- @param i number 1-based
+--- @param j? number 1-based
+function Range:sub(i, j) return self:text():sub(i, j) end
+
 --- @param l number
--- luacheck: ignore
 --- @return { line: string; idx0: { start: number; stop: number; }; lnum: number; range: fun():u.Range; text: fun():string }|nil
 function Range:line(l)
   if l < 0 then l = self:line_count() + l + 1 end
   if l > self:line_count() then return end
 
-  local line_indices =
+  local line_indices = vim.fn.getregionpos(self.start:as_vim(), self.stop:as_vim(), { type = self.mode })
-    vim.fn.getregionpos(self.start:as_vim(), self.stop:as_vim(), { type = self.mode })
   local line_bounds = line_indices[l]
 
   local start = Pos.new(unpack(line_bounds[1]))
@@ -538,9 +327,7 @@ function Range:replace(replacement)
   local function update_stop_non_linewise()
     local new_last_line_num = self.start.lnum + #replacement - 1
     local new_last_col = #(replacement[#replacement] or '')
-    if new_last_line_num == self.start.lnum then
+    if new_last_line_num == self.start.lnum then new_last_col = new_last_col + self.start.col - 1 end
-      new_last_col = new_last_col + self.start.col - 1
-    end
     self.stop = Pos.new(bufnr, new_last_line_num, new_last_col)
   end
   local function update_stop_linewise()
@@ -610,12 +397,48 @@ end
 --- @param amount number
 function Range:must_shrink(amount)
   local shrunk = self:shrink(amount)
-  if shrunk == nil or shrunk:is_empty() then
+  if shrunk == nil or shrunk:is_empty() then error 'error in Range:must_shrink: Range:shrink() returned nil' end
-    error 'error in Range:must_shrink: Range:shrink() returned nil'
-  end
   return shrunk
 end
 
+--- @param left string
+--- @param right string
+function Range:save_to_pos(left, right)
+  if self:is_empty() then
+    self.start:save_to_pos(left)
+    self.start:save_to_pos(right)
+  else
+    self.start:save_to_pos(left)
+    self.stop:save_to_pos(right)
+  end
+end
+
+--- @param left string
+--- @param right string
+function Range:save_to_marks(left, right)
+  if self:is_empty() then
+    self.start:save_to_mark(left)
+    self.start:save_to_mark(right)
+  else
+    self.start:save_to_mark(left)
+    self.stop:save_to_mark(right)
+  end
+end
+
+function Range:set_visual_selection()
+  if self:is_empty() then return end
+  if vim.api.nvim_get_current_buf() ~= self.start.bufnr then
+    error 'Range:set_visual_selection() called on a buffer other than the current buffer'
+  end
+
+  local curr_mode = vim.fn.mode()
+  if curr_mode ~= self.mode then vim.cmd.normal { args = { self.mode }, bang = true } end
+
+  self.start:save_to_pos '.'
+  vim.cmd.normal { args = { 'o' }, bang = true }
+  self.stop:save_to_pos '.'
+end
+
 --- @param group string
 --- @param opts? { timeout?: number, priority?: number, on_macro?: boolean }
 function Range:highlight(group, opts)
@@ -629,8 +452,8 @@ function Range:highlight(group, opts)
 
   local ns = vim.api.nvim_create_namespace ''
 
-  local winview = vim.fn.winsaveview()
+  local winview = vim.fn.winsaveview();
-  vim.hl.range(
+  (vim.hl or vim.highlight).range(
     self.start.bufnr,
     ns,
     group,

lua/u/renderer.lua

@@ -1,63 +1,32 @@
-function _G.URendererOpFuncSwallow() end
-
-local ENABLE_LOG = false
-
-local function log(...)
-  if not ENABLE_LOG then return end
-
-  local f = assert(io.open(vim.fs.joinpath(vim.fn.stdpath 'log', 'u.renderer.log'), 'a+'))
-  f:write(os.date() .. '\t' .. vim.inspect { ... } .. '\n')
-  f:close()
-end
-
 local M = {}
 local H = {}
 
---- @alias u.renderer.TagEventHandler fun(tag: u.renderer.Tag, mode: string, lhs: string): string
+--- @alias Tag { kind: 'tag'; name: string, attributes: table<string, unknown>, children: Tree }
+--- @alias Node nil | boolean | string | Tag
+--- @alias Tree Node | Node[]
 
---- @alias u.renderer.TagAttributes { [string]?: unknown; imap?: table<string, u.renderer.TagEventHandler>; nmap?: table<string, u.renderer.TagEventHandler>; vmap?: table<string, u.renderer.TagEventHandler>; xmap?: table<string, u.renderer.TagEventHandler>; omap?: table<string, u.renderer.TagEventHandler>, on_change?: fun(text: string): unknown }
+--- @param name string
-
+--- @param attributes? table<string, any>
---- @class u.renderer.Tag
+--- @param children? Node | Node[]
---- @field kind 'tag'
+--- @return Tag
---- @field name string
+function M.h(name, attributes, children)
---- @field attributes u.renderer.TagAttributes
---- @field children u.renderer.Tree
-
---- @alias u.renderer.Node nil | boolean | string | u.renderer.Tag
---- @alias u.renderer.Tree u.renderer.Node | u.renderer.Node[]
-
--- luacheck: ignore
---- @type table<string, fun(attributes: u.renderer.TagAttributes, children: u.renderer.Tree): u.renderer.Tag> & fun(name: string, attributes: u.renderer.TagAttributes, children: u.renderer.Tree): u.renderer.Tag>
-M.h = setmetatable({}, {
-  __call = function(_, name, attributes, children)
   return {
     kind = 'tag',
     name = name,
     attributes = attributes or {},
     children = children,
   }
-  end,
-  __index = function(_, name)
-    return function(attributes, children)
-      return M.h('text', vim.tbl_deep_extend('force', { hl = name }, attributes), children)
 end
-  end,
-})
 
 -- Renderer {{{
---- @class u.renderer.RendererExtmark
+--- @alias RendererExtmark { id?: number; start: [number, number]; stop: [number, number]; opts: any; tag: any }
---- @field id? number
---- @field start [number, number]
---- @field stop [number, number]
---- @field opts vim.api.keyset.set_extmark
---- @field tag u.renderer.Tag
 
---- @class u.renderer.Renderer
+--- @class u.Renderer
 --- @field bufnr number
 --- @field ns number
 --- @field changedtick number
---- @field old { lines: string[]; extmarks: u.renderer.RendererExtmark[] }
+--- @field old { lines: string[]; extmarks: RendererExtmark[] }
---- @field curr { lines: string[]; extmarks: u.renderer.RendererExtmark[] }
+--- @field curr { lines: string[]; extmarks: RendererExtmark[] }
 local Renderer = {}
 Renderer.__index = Renderer
 M.Renderer = Renderer
@@ -76,7 +45,7 @@ function Renderer.is_tag_arr(x)
 end
 --- @param bufnr number|nil
 function Renderer.new(bufnr) -- {{{
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
+  if bufnr == nil then bufnr = vim.api.nvim_get_current_buf() end
 
   if vim.b[bufnr]._renderer_ns == nil then
     vim.b[bufnr]._renderer_ns = vim.api.nvim_create_namespace('my.renderer:' .. tostring(bufnr))
@@ -89,18 +58,12 @@ function Renderer.new(bufnr) -- {{{
     old = { lines = {}, extmarks = {} },
     curr = { lines = {}, extmarks = {} },
   }, Renderer)
-
-  vim.api.nvim_create_autocmd({ 'TextChanged', 'TextChangedI', 'TextChangedP' }, {
-    buffer = bufnr,
-    callback = function() self:_on_text_changed() end,
-  })
-
   return self
 end -- }}}
 
 --- @param opts {
----   tree: u.renderer.Tree;
+---   tree: Tree;
----   on_tag?: fun(tag: u.renderer.Tag, start0: [number, number], stop0: [number, number]): any;
+---   on_tag?: fun(tag: Tag, start0: [number, number], stop0: [number, number]): any;
 --- }
 function Renderer.markup_to_lines(opts) -- {{{
   --- @type string[]
@@ -119,7 +82,7 @@ function Renderer.markup_to_lines(opts) -- {{{
     curr_col1 = 1
   end
 
-  --- @param node u.renderer.Node
+  --- @param node Node
   local function visit(node) -- {{{
     if node == nil or type(node) == 'boolean' then return end
 
@@ -135,12 +98,12 @@ function Renderer.markup_to_lines(opts) -- {{{
       -- visit the children:
       if Renderer.is_tag_arr(node.children) then
         for _, child in
-          ipairs(node.children --[[@as u.renderer.Node[] ]])
+          ipairs(node.children --[[@as Node[] ]])
         do
           -- newlines are not controlled by array entries, do NOT output a line here:
           visit(child)
         end
-      else -- luacheck: ignore
+      else
         visit(node.children)
       end
 
@@ -159,70 +122,12 @@ function Renderer.markup_to_lines(opts) -- {{{
 end -- }}}
 
 --- @param opts {
----   tree: u.renderer.Tree;
+---   tree: string;
----   format_tag?: fun(tag: u.renderer.Tag): string;
+---   format_tag?: fun(tag: Tag): string;
 --- }
 function Renderer.markup_to_string(opts) return table.concat(Renderer.markup_to_lines(opts), '\n') end
 
---- @param bufnr number
+--- @param tree Tree
---- @param old_lines string[] | nil
---- @param new_lines string[]
-function Renderer.patch_lines(bufnr, old_lines, new_lines) -- {{{
-  --
-  -- Helpers:
-  --
-
-  --- @param start integer
-  --- @param end_ integer
-  --- @param strict_indexing boolean
-  --- @param replacement string[]
-  local function _set_lines(start, end_, strict_indexing, replacement)
-    vim.api.nvim_buf_set_lines(bufnr, start, end_, strict_indexing, replacement)
-  end
-
-  --- @param start_row integer
-  --- @param start_col integer
-  --- @param end_row integer
-  --- @param end_col integer
-  --- @param replacement string[]
-  local function _set_text(start_row, start_col, end_row, end_col, replacement)
-    vim.api.nvim_buf_set_text(bufnr, start_row, start_col, end_row, end_col, replacement)
-  end
-
-  -- Morph the text to the desired state:
-  local line_changes =
-    H.levenshtein(old_lines or vim.api.nvim_buf_get_lines(bufnr, 0, -1, false), new_lines)
-  for _, line_change in ipairs(line_changes) do
-    local lnum0 = line_change.index - 1
-
-    if line_change.kind == 'add' then
-      _set_lines(lnum0, lnum0, true, { line_change.item })
-    elseif line_change.kind == 'change' then
-      -- Compute inter-line diff, and apply:
-      local col_changes =
-        H.levenshtein(vim.split(line_change.from, ''), vim.split(line_change.to, ''))
-
-      for _, col_change in ipairs(col_changes) do
-        local cnum0 = col_change.index - 1
-        if col_change.kind == 'add' then
-          _set_text(lnum0, cnum0, lnum0, cnum0, { col_change.item })
-        elseif col_change.kind == 'change' then
-          _set_text(lnum0, cnum0, lnum0, cnum0 + 1, { col_change.to })
-        elseif col_change.kind == 'delete' then
-          _set_text(lnum0, cnum0, lnum0, cnum0 + 1, {})
-        else -- luacheck: ignore
-          -- No change
-        end
-      end
-    elseif line_change.kind == 'delete' then
-      _set_lines(lnum0, lnum0 + 1, true, {})
-    else -- luacheck: ignore
-      -- No change
-    end
-  end
-end -- }}}
-
---- @param tree u.renderer.Tree
 function Renderer:render(tree) -- {{{
   local changedtick = vim.b[self.bufnr].changedtick
   if changedtick ~= self.changedtick then
@@ -230,7 +135,7 @@ function Renderer:render(tree) -- {{{
     self.changedtick = changedtick
   end
 
-  --- @type u.renderer.RendererExtmark[]
+  --- @type RendererExtmark[]
   local extmarks = {}
 
   --- @type string[]
@@ -245,69 +150,101 @@ function Renderer:render(tree) -- {{{
           tag.attributes.extmark.hl_group = tag.attributes.extmark.hl_group or hl
         end
 
-        local extmark_opts = tag.attributes.extmark or {}
+        local extmark = tag.attributes.extmark
 
         -- Set any necessary keymaps:
         for _, mode in ipairs { 'i', 'n', 'v', 'x', 'o' } do
           for lhs, _ in pairs(tag.attributes[mode .. 'map'] or {}) do
             -- Force creating an extmark if there are key handlers. To accurately
             -- sense the bounds of the text, we need an extmark:
-            vim.keymap.set(mode, lhs, function()
+            extmark = extmark or {}
-              local result = self:_expr_map_callback(mode, lhs)
+            vim.keymap.set(
-              -- If the handler indicates that it wants to swallow the event,
+              'n',
-              -- we have to convert that intention into something compatible
+              lhs,
-              -- with expr-mappings, which don't support '<Nop>' (they try to
+              function() return self:_expr_map_callback('n', lhs) end,
-              -- execute the literal characters). We'll use the 'g@' operator
+              { buffer = self.bufnr, expr = true, replace_keycodes = true }
-              -- to do that, forwarding the event to an operatorfunc that does
+            )
-              -- nothing:
-              if result == '' then
-                if mode == 'i' then
-                  return ''
-                else
-                  vim.go.operatorfunc = 'v:lua.URendererOpFuncSwallow'
-                  return 'g@ '
-                end
-              end
-              return result
-            end, { buffer = self.bufnr, expr = true, replace_keycodes = true })
           end
         end
 
+        if extmark then
           table.insert(extmarks, {
             start = start0,
             stop = stop0,
-          opts = extmark_opts,
+            opts = extmark,
             tag = tag,
           })
         end
+      end
     end, -- }}}
   }
 
   self.old = self.curr
   self.curr = { lines = lines, extmarks = extmarks }
   self:_reconcile()
-  vim.cmd.doautocmd { args = { 'User', 'Renderer:' .. tostring(self.bufnr) .. ':render' } }
 end -- }}}
 
+--- @private
+--- @param start integer
+--- @param end_ integer
+--- @param strict_indexing boolean
+--- @param replacement string[]
+function Renderer:_set_lines(start, end_, strict_indexing, replacement)
+  vim.api.nvim_buf_set_lines(self.bufnr, start, end_, strict_indexing, replacement)
+end
+
+--- @private
+--- @param start_row integer
+--- @param start_col integer
+--- @param end_row integer
+--- @param end_col integer
+--- @param replacement string[]
+function Renderer:_set_text(start_row, start_col, end_row, end_col, replacement)
+  vim.api.nvim_buf_set_text(self.bufnr, start_row, start_col, end_row, end_col, replacement)
+end
+
 --- @private
 function Renderer:_reconcile() -- {{{
+  local line_changes = H.levenshtein(self.old.lines, self.curr.lines)
+  self.old = self.curr
+
   --
   -- Step 1: morph the text to the desired state:
   --
-  Renderer.patch_lines(self.bufnr, self.old.lines, self.curr.lines)
+  for _, line_change in ipairs(line_changes) do
+    local lnum0 = line_change.index - 1
+
+    if line_change.kind == 'add' then
+      self:_set_lines(lnum0, lnum0, true, { line_change.item })
+    elseif line_change.kind == 'change' then
+      -- Compute inter-line diff, and apply:
+      local col_changes = H.levenshtein(vim.split(line_change.from, ''), vim.split(line_change.to, ''))
+
+      for _, col_change in ipairs(col_changes) do
+        local cnum0 = col_change.index - 1
+        if col_change.kind == 'add' then
+          self:_set_text(lnum0, cnum0, lnum0, cnum0, { col_change.item })
+        elseif col_change.kind == 'change' then
+          self:_set_text(lnum0, cnum0, lnum0, cnum0 + 1, { col_change.to })
+        elseif col_change.kind == 'delete' then
+          self:_set_text(lnum0, cnum0, lnum0, cnum0 + 1, {})
+        else
+          -- No change
+        end
+      end
+    elseif line_change.kind == 'delete' then
+      self:_set_lines(lnum0, lnum0 + 1, true, {})
+    else
+      -- No change
+    end
+  end
   self.changedtick = vim.b[self.bufnr].changedtick
 
   --
   -- Step 2: reconcile extmarks:
-  -- You may be tempted to try to keep track of which extmarks are needed, and
-  -- only delete those that are not needed. However, each time a tree is
-  -- rendered, brand new extmarks are created. For simplicity, it is better to
-  -- just delete all extmarks, and recreate them.
   --
-
   -- Clear current extmarks:
   vim.api.nvim_buf_clear_namespace(self.bufnr, self.ns, 0, -1)
-
   -- Set current extmarks:
   for _, extmark in ipairs(self.curr.extmarks) do
     extmark.id = vim.api.nvim_buf_set_extmark(
@@ -319,18 +256,9 @@ function Renderer:_reconcile() -- {{{
         id = extmark.id,
         end_row = extmark.stop[1],
         end_col = extmark.stop[2],
-        -- If we change the text starting from the beginning (where the extmark
-        -- is), we don't want the extmark to move to the right.
-        right_gravity = false,
-        -- If we change the text starting from the end (where the end extmark
-        -- is), we don't want the extmark to stay stationary: we want it to
-        -- move to the right.
-        end_right_gravity = true,
       }, extmark.opts)
     )
   end
-
-  self.old = self.curr
 end -- }}}
 
 --- @private
@@ -340,9 +268,7 @@ function Renderer:_expr_map_callback(mode, lhs) -- {{{
   -- find the tag with the smallest intersection that contains the cursor:
   local pos0 = vim.api.nvim_win_get_cursor(0)
   pos0[1] = pos0[1] - 1 -- make it actually 0-based
-  log('_expr_map_callback: pos0:', pos0)
+  local pos_infos = self:get_pos_infos(pos0)
-  local pos_infos = self:get_tags_at(pos0)
-  log('_expr_map_callback: pos_infos:', pos_infos)
 
   if #pos_infos == 0 then return lhs end
 
@@ -352,10 +278,9 @@ function Renderer:_expr_map_callback(mode, lhs) -- {{{
     local tag = pos_info.tag
 
     -- is the tag listening?
-    --- @type u.renderer.TagEventHandler?
     local f = vim.tbl_get(tag.attributes, mode .. 'map', lhs)
     if type(f) == 'function' then
-      local result = f(tag, mode, lhs)
+      local result = f()
       if result == '' then
         -- bubble-up to the next tag, but set cancel to true, in case there are
         -- no more tags to bubble up to:
@@ -370,197 +295,23 @@ function Renderer:_expr_map_callback(mode, lhs) -- {{{
   return cancel and '' or lhs
 end -- }}}
 
-function Renderer:_on_text_changed() -- {{{
-  -- Reset changedtick, so that the reconciler knows to refresh its cached
-  -- buffer-content before computing the diff:
-  self.changedtick = 0
-
-  --- @type integer, integer
-  local l, c = unpack(vim.api.nvim_win_get_cursor(0))
-  l = l - 1 -- make it actually 0-based
-  local pos_infos = self:get_tags_at({ l, c }, 'i')
-  log('_on_text_changed', { cursor_0_0 = { l, c }, pos_infos = pos_infos })
-  for _, pos_info in ipairs(pos_infos) do
-    local extmark_inf = pos_info.extmark
-    local tag = pos_info.tag
-
-    local on_change = tag.attributes.on_change
-    if on_change and type(on_change) == 'function' then
-      local extmark =
-        vim.api.nvim_buf_get_extmark_by_id(self.bufnr, self.ns, extmark_inf.id, { details = true })
-
-      --- @type integer, integer, vim.api.keyset.extmark_details
-      local start_row0, start_col0, details = unpack(extmark)
-      local end_row0, end_col0 = details.end_row, details.end_col
-      log('_on_text_changed: fetched current extmark for pos_info', {
-        pos_info = pos_info,
-        curr_extmark = {
-          start_row0 = start_row0,
-          start_col0 = start_col0,
-          end_row0 = end_row0,
-          end_col0 = end_col0,
-          details = details,
-        },
-      })
-
-      if start_row0 == end_row0 and start_col0 == end_col0 then
-        on_change ''
-        return
-      end
-
-      local buf_max_line0 = math.max(1, vim.api.nvim_buf_line_count(self.bufnr) - 1)
-      if end_row0 > buf_max_line0 then
-        end_row0 = buf_max_line0
-        local last_line = vim.api.nvim_buf_get_lines(self.bufnr, end_row0, end_row0 + 1, false)[1]
-          or ''
-        end_col0 = last_line:len()
-      end
-      if end_col0 == 0 then
-        end_row0 = end_row0 - 1
-        local last_line = vim.api.nvim_buf_get_lines(self.bufnr, end_row0, end_row0 + 1, false)[1]
-          or ''
-        end_col0 = last_line:len()
-      end
-      log('_on_text_changed: after position correction', {
-        curr_extmark = {
-          start_row0 = start_row0,
-          start_col0 = start_col0,
-          end_row0 = end_row0,
-          end_col0 = end_col0,
-        },
-      })
-
-      if start_row0 == end_row0 and start_col0 == end_col0 then
-        on_change ''
-        return
-      end
-
-      local pos1 = { self.bufnr, start_row0 + 1, start_col0 + 1 }
-      local pos2 = { self.bufnr, end_row0 + 1, end_col0 }
-      local ok, lines = pcall(vim.fn.getregion, pos1, pos2, { type = 'v' })
-      if not ok then
-        log('_on_text_changed: getregion: invalid-pos ', {
-          { pos1, pos2 },
-        })
-        vim.api.nvim_echo({
-          { '(u.nvim:getregion:invalid-pos) ', 'ErrorMsg' },
-          {
-            '{ start, end } = ' .. vim.inspect({ pos1, pos2 }, { newline = ' ', indent = '' }),
-          },
-        }, true, {})
-        error(lines)
-      end
-      local text = table.concat(lines, '\n')
-      on_change(text)
-    end
-  end
-end -- }}}
-
---- @private
-function Renderer:_debug() -- {{{
-  local prev_w = vim.api.nvim_get_current_win()
-  vim.cmd.vnew()
-  local info_bufnr = vim.api.nvim_get_current_buf()
-  vim.bo.bufhidden = 'delete'
-  vim.bo.buflisted = false
-  vim.bo.buftype = 'nowrite'
-
-  local ids = {}
-  local function cleanup()
-    for _, id in ipairs(ids) do
-      vim.api.nvim_del_autocmd(id)
-    end
-    vim.api.nvim_buf_delete(info_bufnr, { force = true })
-  end
-
-  local function autocmd_callback()
-    if vim.api.nvim_get_current_win() ~= prev_w then return end
-
-    local l, c = unpack(vim.api.nvim_win_get_cursor(0))
-    l = l - 1 -- make it actually 0-based
-
-    local info = {
-      cursor = {
-        pos = { l, c },
-        tags = self:get_tags_at { l, c },
-        extmarks = vim.api.nvim_buf_get_extmarks(
-          self.bufnr,
-          self.ns,
-          { l, c },
-          { l, c },
-          { details = true, overlap = true }
-        ),
-      },
-      computed = {
-        extmarks = self.curr.extmarks,
-      },
-    }
-    vim.api.nvim_buf_set_lines(info_bufnr, 0, -1, true, vim.split(vim.inspect(info), '\n'))
-  end
-
-  table.insert(
-    ids,
-    vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
-      callback = autocmd_callback,
-    })
-  )
-  table.insert(
-    ids,
-    vim.api.nvim_create_autocmd({ 'User' }, {
-      pattern = 'Renderer:' .. tostring(self.bufnr) .. ':render',
-      callback = autocmd_callback,
-    })
-  )
-  table.insert(
-    ids,
-    vim.api.nvim_create_autocmd('WinClosed', {
-      pattern = tostring(vim.api.nvim_get_current_win()),
-      callback = cleanup,
-    })
-  )
-  table.insert(
-    ids,
-    vim.api.nvim_create_autocmd('WinClosed', {
-      pattern = tostring(prev_w),
-      callback = cleanup,
-    })
-  )
-
-  vim.api.nvim_set_current_win(prev_w)
-end -- }}}
-
 --- Returns pairs of extmarks and tags associate with said extmarks. The
 --- returned tags/extmarks are sorted smallest (innermost) to largest
 --- (outermost).
 ---
 --- @private (private for now)
 --- @param pos0 [number; number]
---- @param mode string?
+--- @return { extmark: RendererExtmark; tag: Tag; }[]
---- @return { extmark: u.renderer.RendererExtmark; tag: u.renderer.Tag; }[]
+function Renderer:get_pos_infos(pos0) -- {{{
-function Renderer:get_tags_at(pos0, mode) -- {{{
   local cursor_line0, cursor_col0 = pos0[1], pos0[2]
-  if not mode then mode = vim.api.nvim_get_mode().mode end
-  mode = mode:sub(1, 1) -- we don't care about sub-modes
-
-  local raw_overlapping_extmarks = vim.api.nvim_buf_get_extmarks(
-    self.bufnr,
-    self.ns,
-    pos0,
-    pos0,
-    { details = true, overlap = true }
-  )
-  log(
-    'get_tags_at: context:',
-    { pos0 = pos0, mode = mode, raw_overlapping_extmarks = raw_overlapping_extmarks }
-  )
 
   -- The cursor (block) occupies **two** extmark spaces: one for it's left
   -- edge, and one for it's right. We need to do our own intersection test,
   -- because the NeoVim API is over-inclusive in what it returns:
-  --- @type u.renderer.RendererExtmark[]
+  --- @type RendererExtmark[]
-  local mapped_extmarks = vim
+  local intersecting_extmarks = vim
-    .iter(raw_overlapping_extmarks)
+    .iter(vim.api.nvim_buf_get_extmarks(self.bufnr, self.ns, pos0, pos0, { details = true, overlap = true }))
-    --- @return u.renderer.RendererExtmark
+    --- @return RendererExtmark
     :map(function(ext)
       --- @type number, number, number, { end_row?: number; end_col?: number }|nil
       local id, line0, col0, details = unpack(ext)
@@ -571,43 +322,13 @@ function Renderer:get_tags_at(pos0, mode) -- {{{
       end
       return { id = id, start = start, stop = stop, opts = details }
     end)
-    :totable()
+    --- @param ext RendererExtmark
-
-  local intersecting_extmarks = vim
-    .iter(mapped_extmarks)
-    --- @param ext u.renderer.RendererExtmark
     :filter(function(ext)
       if ext.stop[1] ~= nil and ext.stop[2] ~= nil then
-        -- If we've "ciw" and "collapsed" an extmark onto the cursor,
+        return cursor_line0 >= ext.start[1]
-        -- the cursor pos will equal the exmark's start AND end. In this
+          and cursor_col0 >= ext.start[2]
-        -- case, we want to include the extmark.
-        if
-          cursor_line0 == ext.start[1]
-          and cursor_col0 == ext.start[2]
-          and cursor_line0 == ext.stop[1]
-          and cursor_col0 == ext.stop[2]
-        then
-          return true
-        end
-
-        return
-          -- START: line check
-          cursor_line0 >= ext.start[1]
-            -- START: column check
-            and (cursor_line0 ~= ext.start[1] or cursor_col0 >= ext.start[2])
-            -- STOP: line check
           and cursor_line0 <= ext.stop[1]
-            -- STOP: column check
+          and cursor_col0 < ext.stop[2]
-            and (
-              cursor_line0 ~= ext.stop[1]
-              or (
-                mode == 'i'
-                  -- In insert mode, the cursor is "thin", so <= to compensate:
-                  and cursor_col0 <= ext.stop[2]
-                -- In normal mode, the cursor is "wide", so < to compensate:
-                or cursor_col0 < ext.stop[2]
-              )
-            )
       else
         return true
       end
@@ -617,8 +338,8 @@ function Renderer:get_tags_at(pos0, mode) -- {{{
   -- Sort the tags into smallest (inner) to largest (outer):
   table.sort(
     intersecting_extmarks,
-    --- @param x1 u.renderer.RendererExtmark
+    --- @param x1 RendererExtmark
-    --- @param x2 u.renderer.RendererExtmark
+    --- @param x2 RendererExtmark
     function(x1, x2)
       if
         x1.start[1] == x2.start[1]
@@ -640,10 +361,10 @@ function Renderer:get_tags_at(pos0, mode) -- {{{
   -- created extmarks in self.curr.extmarks, which also has which tag each
   -- extmark is associated with. Cross-reference with that list to get a list
   -- of tags that we need to fire events for:
-  --- @type { extmark: u.renderer.RendererExtmark; tag: u.renderer.Tag }[]
+  --- @type { extmark: RendererExtmark; tag: Tag }[]
   local matching_tags = vim
     .iter(intersecting_extmarks)
-    --- @param ext u.renderer.RendererExtmark
+    --- @param ext RendererExtmark
     :map(function(ext)
       for _, extmark_cache in ipairs(self.curr.extmarks) do
         if extmark_cache.id == ext.id then return { extmark = ext, tag = extmark_cache.tag } end
@@ -653,24 +374,11 @@ function Renderer:get_tags_at(pos0, mode) -- {{{
 
   return matching_tags
 end -- }}}
-
---- @private
---- @param tag_or_id string | u.renderer.Tag
---- @return { start: [number, number]; stop: [number, number] } | nil
-function Renderer:get_tag_bounds(tag_or_id) -- {{{
-  for _, x in ipairs(self.curr.extmarks) do
-    local pos = { start = x.start, stop = x.stop }
-    local does_tag_match = type(tag_or_id) == 'string' and x.tag.attributes.id == tag_or_id
-      or x.tag == tag_or_id
-    if does_tag_match then return pos end
-  end
-end -- }}}
-
 -- }}}
 
 -- TreeBuilder {{{
---- @class u.renderer.TreeBuilder
+--- @class u.TreeBuilder
---- @field private nodes u.renderer.Node[]
+--- @field private nodes Node[]
 local TreeBuilder = {}
 TreeBuilder.__index = TreeBuilder
 M.TreeBuilder = TreeBuilder
@@ -680,8 +388,8 @@ function TreeBuilder.new()
   return self
 end
 
---- @param nodes u.renderer.Tree
+--- @param nodes Tree
---- @return u.renderer.TreeBuilder
+--- @return u.TreeBuilder
 function TreeBuilder:put(nodes)
   table.insert(self.nodes, nodes)
   return self
@@ -689,16 +397,16 @@ end
 
 --- @param name string
 --- @param attributes? table<string, any>
---- @param children? u.renderer.Node | u.renderer.Node[]
+--- @param children? Node | Node[]
---- @return u.renderer.TreeBuilder
+--- @return u.TreeBuilder
 function TreeBuilder:put_h(name, attributes, children)
   local tag = M.h(name, attributes, children)
   table.insert(self.nodes, tag)
   return self
 end
 
---- @param fn fun(tb: u.renderer.TreeBuilder): any
+--- @param fn fun(TreeBuilder): any
---- @return u.renderer.TreeBuilder
+--- @return u.TreeBuilder
 function TreeBuilder:nest(fn)
   local nested_writer = TreeBuilder.new()
   fn(nested_writer)
@@ -706,40 +414,18 @@ function TreeBuilder:nest(fn)
   return self
 end
 
---- @generic T
+--- @return Tree
---- @param arr T[]
---- @param f fun(tb: u.renderer.TreeBuilder, item: T, idx: number): any
-function TreeBuilder:ipairs(arr, f)
-  return self:nest(function(tb)
-    for idx, item in ipairs(arr) do
-      f(tb, item, idx)
-    end
-  end)
-end
-
---- @param tab table
---- @param f fun(tb: u.renderer.TreeBuilder, key: any, value: any): any
-function TreeBuilder:pairs(tab, f)
-  return self:nest(function(tb)
-    for k, v in pairs(tab) do
-      f(tb, k, v)
-    end
-  end)
-end
-
---- @return u.renderer.Tree
 function TreeBuilder:tree() return self.nodes end
 -- }}}
 
 -- Levenshtein utility {{{
--- luacheck: ignore
+--- @alias LevenshteinChange<T> ({ kind: 'add'; item: T; index: number; } | { kind: 'delete'; item: T; index: number; } | { kind: 'change'; from: T; to: T; index: number; })
---- @alias u.renderer.LevenshteinChange<T> ({ kind: 'add'; item: T; index: number; } | { kind: 'delete'; item: T; index: number; } | { kind: 'change'; from: T; to: T; index: number; })
 --- @private
 --- @generic T
 --- @param x `T`[]
 --- @param y T[]
 --- @param cost? { of_delete?: fun(x: T): number; of_add?: fun(x: T): number; of_change?: fun(x: T, y: T): number; }
---- @return u.renderer.LevenshteinChange<T>[] The changes, from last (greatest index) to first (smallest index).
+--- @return LevenshteinChange<T>[]
 function H.levenshtein(x, y, cost)
   -- At the moment, this whole `cost` plumbing is not used. Deletes have the
   -- same cost as Adds or Changes. I can imagine a future, however, where
@@ -779,10 +465,10 @@ function H.levenshtein(x, y, cost)
       if x[i] == y[j] then
         dp[i][j] = dp[i - 1][j - 1] -- no cost if items are the same
       else
-        local cost_delete = dp[i - 1][j] + cost_of_delete_f(x[i])
+        local costDelete = dp[i - 1][j] + cost_of_delete_f(x[i])
-        local cost_add = dp[i][j - 1] + cost_of_add_f(y[j])
+        local costAdd = dp[i][j - 1] + cost_of_add_f(y[j])
-        local cost_change = dp[i - 1][j - 1] + cost_of_change_f(x[i], y[j])
+        local costChange = dp[i - 1][j - 1] + cost_of_change_f(x[i], y[j])
-        dp[i][j] = math.min(cost_delete, cost_add, cost_change)
+        dp[i][j] = math.min(costDelete, costAdd, costChange)
       end
     end
   end
@@ -790,7 +476,7 @@ function H.levenshtein(x, y, cost)
   -- Backtrack to find the changes
   local i = m
   local j = n
-  --- @type u.renderer.LevenshteinChange[]
+  --- @type LevenshteinChange[]
   local changes = {}
 
   while i > 0 or j > 0 do
@@ -807,7 +493,7 @@ function H.levenshtein(x, y, cost)
     if is_first_min(cost_of_change, cost_of_add, cost_of_delete) then
       -- potential change
       if x[i] ~= y[j] then
-        --- @type u.renderer.LevenshteinChange
+        --- @type LevenshteinChange
         local change = { kind = 'change', from = x[i], index = i, to = y[j] }
         table.insert(changes, change)
       end
@@ -815,13 +501,13 @@ function H.levenshtein(x, y, cost)
       j = j - 1
     elseif is_first_min(cost_of_add, cost_of_change, cost_of_delete) then
       -- addition
-      --- @type u.renderer.LevenshteinChange
+      --- @type LevenshteinChange
       local change = { kind = 'add', item = y[j], index = i + 1 }
       table.insert(changes, change)
       j = j - 1
     elseif is_first_min(cost_of_delete, cost_of_change, cost_of_add) then
       -- deletion
-      --- @type u.renderer.LevenshteinChange
+      --- @type LevenshteinChange
       local change = { kind = 'delete', item = x[i], index = i }
       table.insert(changes, change)
       i = i - 1

lua/u/tracker.lua

@@ -6,19 +6,19 @@ M.debug = false
 -- class Signal
 --------------------------------------------------------------------------------
 
---- @class u.Signal<T>
+--- @class u.Signal
 --- @field name? string
 --- @field private changing boolean
---- @field private value T
+--- @field private value any
 --- @field private subscribers table<function, boolean>
 --- @field private on_dispose_callbacks function[]
 local Signal = {}
 M.Signal = Signal
 Signal.__index = Signal
 
---- @param value `T`
+--- @param value any
 --- @param name? string
---- @return u.Signal<T>
+--- @return u.Signal
 function Signal:new(value, name)
   local obj = setmetatable({
     name = name,
@@ -30,17 +30,14 @@ function Signal:new(value, name)
   return obj
 end
 
---- @param value T
+--- @param value any
 function Signal:set(value)
   self.value = value
 
   -- We don't handle cyclic updates:
   if self.changing then
     if M.debug then
-      vim.notify(
+      vim.notify('circular dependency detected' .. (self.name and (' in ' .. self.name) or ''), vim.log.levels.WARN)
-        'circular dependency detected' .. (self.name and (' in ' .. self.name) or ''),
-        vim.log.levels.WARN
-      )
     end
     return
   end
@@ -67,12 +64,11 @@ function Signal:set(value)
   end
 end
 
---- @param value T
 function Signal:schedule_set(value)
   vim.schedule(function() self:set(value) end)
 end
 
---- @return T
+--- @return any
 function Signal:get()
   local ctx = M.ExecutionContext.current()
   if ctx then ctx:track(self) end
@@ -86,8 +82,8 @@ function Signal:update(fn) self:set(fn(self.value)) end
 function Signal:schedule_update(fn) self:schedule_set(fn(self.value)) end
 
 --- @generic U
---- @param fn fun(value: T): `U`
+--- @param fn fun(value: T): U
---- @return u.Signal<U>
+--- @return u.Signal --<U>
 function Signal:map(fn)
   local mapped_signal = M.create_memo(function()
     local value = self:get()
@@ -96,13 +92,13 @@ function Signal:map(fn)
   return mapped_signal
 end
 
---- @return u.Signal<T>
+--- @return u.Signal
 function Signal:clone()
   return self:map(function(x) return x end)
 end
 
 --- @param fn fun(value: T): boolean
---- @return u.Signal<T>
+--- @return u.Signal -- <T>
 function Signal:filter(fn)
   local filtered_signal = M.create_signal(nil, self.name and self.name .. ':filtered' or nil)
   local unsubscribe_from_self = self:subscribe(function(value)
@@ -113,10 +109,10 @@ function Signal:filter(fn)
 end
 
 --- @param ms number
---- @return u.Signal<T>
+--- @return u.Signal -- <T>
 function Signal:debounce(ms)
   local function set_timeout(timeout, callback)
-    local timer = assert((vim.uv or vim.loop).new_timer(), 'could not create new timer')
+    local timer = (vim.uv or vim.loop).new_timer()
     timer:start(timeout, 0, function()
       timer:stop()
       timer:close()
@@ -128,7 +124,7 @@ function Signal:debounce(ms)
   local filtered = M.create_signal(self.value, self.name and self.name .. ':debounced' or nil)
 
   --- @diagnostic disable-next-line: undefined-doc-name
-  --- @type { queued: { value: T, ts: number }[], timer?: uv.uv_timer_t }
+  --- @type { queued: { value: T, ts: number }[]; timer?: uv_timer_t; }
   local state = { queued = {}, timer = nil }
   local function clear_timeout()
     if state.timer == nil then return end
@@ -147,10 +143,7 @@ function Signal:debounce(ms)
     local now_ms = (vim.uv or vim.loop).hrtime() / 1e6
 
     -- If there is anything older than `ms` in our queue, emit it:
-    local older_than_ms = vim
+    local older_than_ms = vim.iter(state.queued):filter(function(item) return now_ms - item.ts > ms end):totable()
-      .iter(state.queued)
-      :filter(function(item) return now_ms - item.ts > ms end)
-      :totable()
     local last_older_than_ms = older_than_ms[#older_than_ms]
     if last_older_than_ms then
       filtered:set(last_older_than_ms.value)
@@ -203,8 +196,7 @@ end
 -- class ExecutionContext
 --------------------------------------------------------------------------------
 
---- @type u.ExecutionContext|nil
+CURRENT_CONTEXT = nil
-local CURRENT_CONTEXT = nil
 
 --- @class u.ExecutionContext
 --- @field signals table<u.Signal, boolean>
@@ -213,7 +205,7 @@ M.ExecutionContext = ExecutionContext
 ExecutionContext.__index = ExecutionContext
 
 --- @return u.ExecutionContext
-function ExecutionContext.new()
+function ExecutionContext:new()
   return setmetatable({
     signals = {},
     subscribers = {},
@@ -224,7 +216,7 @@ function ExecutionContext.current() return CURRENT_CONTEXT end
 
 --- @param fn function
 --- @param ctx u.ExecutionContext
-function ExecutionContext.run(fn, ctx)
+function ExecutionContext:run(fn, ctx)
   local oldCtx = CURRENT_CONTEXT
   CURRENT_CONTEXT = ctx
   local result
@@ -264,18 +256,16 @@ end
 -- Helpers
 --------------------------------------------------------------------------------
 
---- @generic T
+--- @param value any
---- @param value `T`
 --- @param name? string
---- @return u.Signal<T>
+--- @return u.Signal
 function M.create_signal(value, name) return Signal:new(value, name) end
 
---- @generic T
+--- @param fn function
---- @param fn fun(): `T`
 --- @param name? string
 --- @return u.Signal
 function M.create_memo(fn, name)
-  --- @type u.Signal<T> | nil
+  --- @type u.Signal
   local result
   local unsubscribe = M.create_effect(function()
     local value = fn()
@@ -286,15 +276,15 @@ function M.create_memo(fn, name)
       result = M.create_signal(value, name and ('m.s:' .. name) or nil)
     end
   end, name)
-  assert(result):on_dispose(unsubscribe)
+  result:on_dispose(unsubscribe)
-  return assert(result)
+  return result
 end
 
 --- @param fn function
 --- @param name? string
 function M.create_effect(fn, name)
-  local ctx = M.ExecutionContext.new()
+  local ctx = M.ExecutionContext:new()
-  M.ExecutionContext.run(fn, ctx)
+  M.ExecutionContext:run(fn, ctx)
   return ctx:subscribe(function()
     if name and M.debug then
       local deps = vim

lua/u/utils.lua

@@ -4,63 +4,14 @@ local M = {}
 -- Types
 --
 
---- @class u.utils.QfItem
+--- @alias QfItem { col: number, filename: string, kind: string, lnum: number, text: string }
---- @field col number
+--- @alias KeyMaps table<string, fun(): any | string> }
---- @field filename string
+--- @alias CmdArgs { args: string; bang: boolean; count: number; fargs: string[]; line1: number; line2: number; mods: string; name: string; range: 0|1|2; reg: string; smods: any; info: u.Range|nil }
---- @field kind string
---- @field lnum number
---- @field text string
 
---- @class u.utils.RawCmdArgs
---- @field args string
---- @field bang boolean
---- @field count number
---- @field fargs string[]
---- @field line1 number
---- @field line2 number
---- @field mods string
---- @field name string
---- @field range 0|1|2
---- @field reg string
---- @field smods any
-
---- @class u.utils.CmdArgs: u.utils.RawCmdArgs
---- @field info u.Range|nil
-
---- @class u.utils.UcmdArgs
---- @field nargs? 0|1|'*'|'?'|'+'
---- @field range? boolean|'%'|number
---- @field count? boolean|number
---- @field addr? string
---- @field completion? string
---- @field force? boolean
---- @field preview? fun(opts: u.utils.UcmdArgs, ns: integer, buf: integer):0|1|2
-
---
--- Functions
---
-
---- Debug utility that prints a value and returns it unchanged.
---- Useful for debugging in the middle of expressions or function chains.
----
 --- @generic T
---- @param x `T` The value to debug print
+--- @param x `T`
---- @param message? string Optional message to print alongside the value
+--- @param message? string
---- @return T The original value, unchanged
+--- @return T
----
---- @usage
---- ```lua
---- -- Debug a value in the middle of a chain:
---- local result = some_function()
----   :map(utils.dbg)  -- prints the intermediate value
----   :filter(predicate)
----
---- -- Debug with a custom message:
---- local config = utils.dbg(get_config(), "Current config:")
----
---- -- Debug return values:
---- return utils.dbg(calculate_result(), "Final result")
---- ```
 function M.dbg(x, message)
   local t = {}
   if message ~= nil then table.insert(t, message) end
@@ -69,37 +20,21 @@ function M.dbg(x, message)
   return x
 end
 
---- Creates a user command with enhanced argument processing.
+--- A utility for creating user commands that also pre-computes useful information
---- Automatically computes range information and attaches it as `args.info`.
+--- and attaches it to the arguments.
 ---
---- @param name string The command name (without the leading colon)
---- @param cmd string | fun(args: u.utils.CmdArgs): any Command implementation
---- @param opts? u.utils.UcmdArgs Command options (nargs, range, etc.)
----
---- @usage
 --- ```lua
---- -- Create a command that works with visual selections:
+--- -- Example:
---- utils.ucmd('MyCmd', function(args)
+--- ucmd('MyCmd', function(args)
----   -- Print the visually selected text:
+---   -- print the visually selected text:
 ---   vim.print(args.info:text())
----   -- Or get the selection as an array of lines:
+---   -- or get the vtext as an array of lines:
 ---   vim.print(args.info:lines())
 --- end, { nargs = '*', range = true })
----
---- -- Create a command that processes the current line:
---- utils.ucmd('ProcessLine', function(args)
----   local line_text = args.info:text()
----   -- Process the line...
---- end, { range = '%' })
----
---- -- Create a command with arguments:
---- utils.ucmd('SearchReplace', function(args)
----   local pattern, replacement = args.fargs[1], args.fargs[2]
----   local text = args.info:text()
----   -- Perform search and replace...
---- end, { nargs = 2, range = true })
 --- ```
--- luacheck: ignore
+--- @param name string
+--- @param cmd string | fun(args: CmdArgs): any
+--- @param opts? { nargs?: 0|1|'*'|'?'|'+'; range?: boolean|'%'|number; count?: boolean|number, addr?: string; completion?: string }
 function M.ucmd(name, cmd, opts)
   local Range = require 'u.range'
 
@@ -111,81 +46,9 @@ function M.ucmd(name, cmd, opts)
       return cmd(args)
     end
   end
-  vim.api.nvim_create_user_command(name, cmd2, opts or {} --[[@as any]])
+  vim.api.nvim_create_user_command(name, cmd2, opts or {})
 end
 
---- Creates command arguments for delegating from one command to another.
---- Preserves all relevant context (range, modifiers, bang, etc.) when
---- implementing a derived command in terms of a base command.
----
---- @param current_args vim.api.keyset.create_user_command.command_args|u.utils.RawCmdArgs The arguments from the current command
---- @return vim.api.keyset.cmd Arguments suitable for vim.cmd() calls
----
---- @usage
---- ```lua
---- -- Implement :MyEdit in terms of :edit, preserving all context:
---- utils.ucmd('MyEdit', function(args)
----   local delegated_args = utils.create_delegated_cmd_args(args)
----   -- Add custom logic here...
----   vim.cmd.edit(delegated_args)
---- end, { nargs = '*', range = true, bang = true })
----
---- -- Implement :MySubstitute that delegates to :substitute:
---- utils.ucmd('MySubstitute', function(args)
----   -- Pre-process arguments
----   local pattern = preprocess_pattern(args.fargs[1])
----
----   local delegated_args = utils.create_delegated_cmd_args(args)
----   delegated_args.args = { pattern, args.fargs[2] }
----
----   vim.cmd.substitute(delegated_args)
---- end, { nargs = 2, range = true, bang = true })
---- ```
-function M.create_delegated_cmd_args(current_args)
-  --- @type vim.api.keyset.cmd
-  local args = {
-    range = current_args.range == 1 and { current_args.line1 }
-      or current_args.range == 2 and { current_args.line1, current_args.line2 }
-      or nil,
-    count = (current_args.count ~= -1 and current_args.range == 0) and current_args.count or nil,
-    reg = current_args.reg ~= '' and current_args.reg or nil,
-    bang = current_args.bang or nil,
-    args = #current_args.fargs > 0 and current_args.fargs or nil,
-    mods = current_args.smods,
-  }
-  return args
-end
-
---- Gets the current editor dimensions.
---- Useful for positioning floating windows or calculating layout sizes.
----
---- @return { width: number, height: number } The editor dimensions in columns and lines
----
---- @usage
---- ```lua
---- -- Center a floating window:
---- local dims = utils.get_editor_dimensions()
---- local win_width = 80
---- local win_height = 20
---- local col = math.floor((dims.width - win_width) / 2)
---- local row = math.floor((dims.height - win_height) / 2)
----
---- vim.api.nvim_open_win(bufnr, true, {
----   relative = 'editor',
----   width = win_width,
----   height = win_height,
----   col = col,
----   row = row,
---- })
----
---- -- Check if editor is wide enough for side-by-side layout:
---- local dims = utils.get_editor_dimensions()
---- if dims.width >= 160 then
----   -- Use side-by-side layout
---- else
----   -- Use stacked layout
---- end
---- ```
 function M.get_editor_dimensions() return { width = vim.go.columns, height = vim.go.lines } end
 
 return M

lux.toml

@@ -0,0 +1,19 @@
+package = "u.nvim"
+version = "0.1.0"
+lua = ">=5.1"
+
+[description]
+summary = ""
+maintainer = "jrop"
+labels = [ "library", "neovim", "neovim-plugin", "range", "utility" ]
+
+
+[dependencies]
+# Add your dependencies here
+# `busted = ">=2.0"`
+
+[run]
+args = [ "src/main.lua" ]
+
+[build]
+type = "builtin"

selene.toml

@@ -0,0 +1,4 @@
+std = "vim"
+
+[lints]
+multiple_statements = "allow"

shell.nix

@@ -1,23 +0,0 @@
-{
-  pkgs ?
-    import
-      # nixos-25.05 (neovim@0.11.2):
-      (fetchTarball {
-        url = "https://github.com/nixos/nixpkgs/archive/1c1c9b3f5ec0421eaa0f22746295466ee6a8d48f.tar.gz";
-        sha256 = "0szvq1swpzyjmyyw929ngxy1khdnd9ba96qds2bm6l6kg4iq3cq0";
-      })
-      { },
-}:
-pkgs.mkShell {
-  packages = [
-    pkgs.git
-    pkgs.gnumake
-    pkgs.lua-language-server
-    pkgs.lua51Packages.busted
-    pkgs.lua51Packages.luacov
-    pkgs.lua51Packages.luarocks
-    pkgs.neovim
-    pkgs.stylua
-    pkgs.watchexec
-  ];
-}

spec/range_spec.lua

@@ -1,5 +1,5 @@
-local Pos = require 'u.pos'
 local Range = require 'u.range'
+local Pos = require 'u.pos'
 local withbuf = loadfile './spec/withbuf.lua'()
 
 describe('Range', function()
@@ -238,128 +238,6 @@ describe('Range', function()
     end)
   end)
 
-  it('from_tsquery_caps', function()
-    withbuf({
-      '-- a comment',
-      '',
-      'function foo(bar) end',
-      '',
-      '-- a middle comment',
-      '',
-      'function bar(baz) end',
-      '',
-      '-- another comment',
-    }, function()
-      vim.cmd.setfiletype 'lua'
-
-      --- @param contains_cursor? boolean
-      local function get_caps(contains_cursor)
-        if contains_cursor == nil then contains_cursor = true end
-        return (Range.from_tsquery_caps(
-          0,
-          '(function_declaration) @f',
-          { contains_cursor = contains_cursor }
-        )).f or {}
-      end
-
-      local caps = get_caps(false)
-      assert.are.same(#caps, 2)
-      assert.are.same(vim.iter(caps):map(function(c) return c:text() end):totable(), {
-        'function foo(bar) end',
-        'function bar(baz) end',
-      })
-
-      Pos.new(0, 1, 1):save_to_pos '.'
-      caps = get_caps()
-      assert.are.same(#caps, 0)
-
-      Pos.new(0, 3, 18):save_to_pos '.'
-      caps = get_caps()
-      assert.are.same(#caps, 1)
-      assert.are.same(caps[1]:text(), 'function foo(bar) end')
-
-      Pos.new(0, 5, 1):save_to_pos '.'
-      caps = get_caps()
-      assert.are.same(#caps, 0)
-
-      Pos.new(0, 7, 1):save_to_pos '.'
-      caps = get_caps()
-      assert.are.same(#caps, 1)
-      assert.are.same(caps[1]:text(), 'function bar(baz) end')
-    end)
-  end)
-
-  it('from_tsquery_caps with string array filter', function()
-    withbuf({
-      '{',
-      '  sample_key1 = "sample-value1",',
-      '  sample_key2 = "sample-value2",',
-      '}',
-    }, function()
-      vim.cmd.setfiletype 'lua'
-
-      -- Place cursor in "sample-value1"
-      Pos.new(0, 2, 25):save_to_pos '.'
-
-      -- Query that captures both keys and values in pairs
-      local query = [[
-        (field
-          name: _ @key
-          value: _ @value)
-      ]]
-
-      local ranges = Range.from_line(0, 2):tsquery(query)
-
-      -- Should have both @key and @value captures for the first pair only
-      -- (since cursor is in sample-value1)
-      assert(ranges, 'Range should not be nil')
-      assert(ranges.key, 'Range.key should not be nil')
-      assert(ranges.value, 'Range.value should not be nil')
-
-      -- Should have exactly one key and one value
-      assert.are.same(#ranges.key, 1)
-      assert.are.same(#ranges.value, 1)
-
-      -- Check that we got sample-key1 and sample-value1
-      assert.are.same(ranges.key[1]:text(), 'sample_key1')
-      assert.are.same(ranges.value[1]:text(), '"sample-value1"')
-    end)
-
-    -- Make sure this works when the match is on the last line:
-    withbuf({
-      '{sample_key1= "sample-value1",',
-      'sample_key2= "sample-value2"}',
-    }, function()
-      vim.cmd.setfiletype 'lua'
-
-      -- Place cursor in "sample-value1"
-      Pos.new(0, 2, 25):save_to_pos '.'
-
-      -- Query that captures both keys and values in pairs
-      local query = [[
-        (field
-          name: _ @key
-          value: _ @value)
-      ]]
-
-      local ranges = Range.from_line(0, 2):tsquery(query)
-
-      -- Should have both @key and @value captures for the first pair only
-      -- (since cursor is in sample-value1)
-      assert(ranges, 'Range should not be nil')
-      assert(ranges.key, 'Range.key should not be nil')
-      assert(ranges.value, 'Range.value should not be nil')
-
-      -- Should have exactly one key and one value
-      assert.are.same(#ranges.key, 1)
-      assert.are.same(#ranges.value, 1)
-
-      -- Check that we got sample-key2 and sample-value2
-      assert.are.same(ranges.key[1]:text(), 'sample_key2')
-      assert.are.same(ranges.value[1]:text(), '"sample-value2"')
-    end)
-  end)
-
   it('should get nearest block', function()
     withbuf({
       'this is a {',
@@ -440,89 +318,18 @@ describe('Range', function()
     end)
   end)
 
-  it('from_cmd_args: range=0', function()
+  it('from_cmd_args', function()
-    local args = { range = 0 }
+    local args = { range = 1 }
-    withbuf(
-      { 'line one', 'and line two' },
-      function() assert.are.same(Range.from_cmd_args(args), nil) end
-    )
-  end)
-
-  it('from_cmd_args: range=1', function()
-    local args = { range = 1, line1 = 1 }
     withbuf({ 'line one', 'and line two' }, function()
       local a = Pos.new(nil, 1, 1)
-      local b = Pos.new(nil, 1, Pos.MAX_COL)
+      local b = Pos.new(nil, 2, 2)
-
-      local range = Range.from_cmd_args(args) --[[@as u.Range]]
-      assert.are.same(range.start, a)
-      assert.are.same(range.stop, b)
-      assert.are.same(range.mode, 'V')
-      assert.are.same(range:text(), 'line one')
-    end)
-  end)
-
-  it('from_cmd_args: range=2: no-visual', function()
-    local args = { range = 2, line1 = 1, line2 = 2 }
-    withbuf({ 'line one', 'and line two' }, function()
-      local range = Range.from_cmd_args(args) --[[@as u.Range]]
-      assert.are.same(range.start, Pos.new(nil, 1, 1))
-      assert.are.same(range.stop, Pos.new(nil, 2, Pos.MAX_COL))
-      assert.are.same(range.mode, 'V')
-      assert.are.same(range:text(), 'line one\nand line two')
-    end)
-  end)
-
-  it('from_cmd_args: range=2: visual: linewise', function()
-    local args = { range = 2, line1 = 1, line2 = 2 }
-    withbuf({ 'line one', 'and line two' }, function()
-      local a = Pos.new(nil, 1, 1)
-      local b = Pos.new(nil, 2, Pos.MAX_COL)
       a:save_to_pos "'<"
       b:save_to_pos "'>"
-      local range = Range.from_cmd_args(args) --[[@as u.Range]]
-      assert.are.same(range.start, a)
-      assert.are.same(range.stop, b)
-      assert.are.same(range.mode, 'V')
-      assert.are.same(range:text(), 'line one\nand line two')
-    end)
-  end)
 
-  it('from_cmd_args: range=2: visual: charwise', function()
+      local range = Range.from_cmd_args(args)
-    local args = { range = 2, line1 = 1, line2 = 1 }
-    withbuf({ 'line one', 'and line two' }, function()
-      -- Simulate a visual selection:
-      local a = Pos.new(nil, 1, 1)
-      local b = Pos.new(nil, 1, 4)
-      a:save_to_pos "'<"
-      b:save_to_pos "'>"
-      Range.new(a, b, 'v'):set_visual_selection()
-      assert.are.same(vim.fn.mode(), 'v')
-
-      -- In this simulated setup, we need to force visualmode() to return
-      -- 'v' and histget() to return [['<,'>]]:
-
-      -- visualmode()
-      local orig_visualmode = vim.fn.visualmode
-      --- @diagnostic disable-next-line: duplicate-set-field
-      function vim.fn.visualmode() return 'v' end
-      assert.are.same(vim.fn.visualmode(), 'v')
-
-      -- histget()
-      local orig_histget = vim.fn.histget
-      --- @diagnostic disable-next-line: duplicate-set-field
-      function vim.fn.histget(x, y) return [['<,'>]] end
-
-      -- Now run the test:
-      local range = Range.from_cmd_args(args) --[[@as u.Range]]
       assert.are.same(range.start, a)
       assert.are.same(range.stop, b)
       assert.are.same(range.mode, 'v')
-      assert.are.same(range:text(), 'line')
-
-      -- Reset visualmode() and histget():
-      vim.fn.visualmode = orig_visualmode
-      vim.fn.histget = orig_histget
     end)
   end)
 
@@ -615,52 +422,6 @@ describe('Range', function()
     end)
   end)
 
-  it('difference', function()
-    withbuf({ 'line one', 'and line two' }, function()
-      local range_outer = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 2, 12), 'v')
-      local range_inner = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 2, 8), 'v')
-
-      assert.are.same(range_outer:text(), 'and line two')
-      assert.are.same(range_inner:text(), 'line')
-
-      local left, right = range_outer:difference(range_inner)
-      assert.are.same(left:text(), 'and ')
-      assert.are.same(right:text(), ' two')
-
-      left, right = range_inner:difference(range_outer)
-      assert.are.same(left:text(), 'and ')
-      assert.are.same(right:text(), ' two')
-
-      left, right = range_outer:difference(range_outer)
-      assert.are.same(left:is_empty(), true)
-      assert.are.same(left:text(), '')
-      assert.are.same(right:is_empty(), true)
-      assert.are.same(right:text(), '')
-    end)
-  end)
-
-  it('length', function()
-    withbuf({ 'line one', 'and line two' }, function()
-      local range = Range.new(Pos.new(nil, 2, 4), Pos.new(nil, 2, 9), 'v')
-      assert.are.same(range:length(), #range:text())
-
-      range = Range.new(Pos.new(nil, 1, 4), Pos.new(nil, 2, 9), 'v')
-      assert.are.same(range:length(), #range:text())
-    end)
-  end)
-
-  it('sub', function()
-    withbuf({ 'line one', 'and line two' }, function()
-      local range = Range.new(Pos.new(nil, 2, 4), Pos.new(nil, 2, 9), 'v')
-      assert.are.same(range:text(), ' line ')
-      assert.are.same(range:sub(1, -1):text(), ' line ')
-      assert.are.same(range:sub(2, -2):text(), 'line')
-      assert.are.same(range:sub(1, 5):text(), ' line')
-      assert.are.same(range:sub(2, 5):text(), 'line')
-      assert.are.same(range:sub(20, 25):text(), '')
-    end)
-  end)
-
   it('shrink', function()
     withbuf({ 'line one', 'and line two' }, function()
       local range = Range.new(Pos.new(nil, 2, 3), Pos.new(nil, 3, 5), 'v')
@@ -677,10 +438,7 @@ describe('Range', function()
       assert.are.same(shrunk.start, Pos.new(nil, 2, 4))
       assert.are.same(shrunk.stop, Pos.new(nil, 3, 4))
 
-      assert.has.error(
+      assert.has.error(function() range:must_shrink(100) end, 'error in Range:must_shrink: Range:shrink() returned nil')
-        function() range:must_shrink(100) end,
-        'error in Range:must_shrink: Range:shrink() returned nil'
-      )
     end)
   end)
 
@@ -718,16 +476,10 @@ describe('Range', function()
       local r = Range.new(Pos.new(b, 1, 5), Pos.new(b, 1, 9), 'v')
 
       r:replace 'bleh1'
-      assert.are.same(
+      assert.are.same({ 'The bleh1 brown fox jumps over the lazy dog' }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
-        { 'The bleh1 brown fox jumps over the lazy dog' },
-        vim.api.nvim_buf_get_lines(b, 0, -1, false)
-      )
 
       r:replace 'bleh2'
-      assert.are.same(
+      assert.are.same({ 'The bleh2 brown fox jumps over the lazy dog' }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
-        { 'The bleh2 brown fox jumps over the lazy dog' },
-        vim.api.nvim_buf_get_lines(b, 0, -1, false)
-      )
     end)
   end)
 
@@ -741,17 +493,11 @@ describe('Range', function()
       assert.are.same({ 'jumps', 'over' }, r:lines())
 
       r:replace 'bleh1'
-      assert.are.same(
+      assert.are.same({ 'The quick brown fox bleh1 the lazy dog' }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
-        { 'The quick brown fox bleh1 the lazy dog' },
-        vim.api.nvim_buf_get_lines(b, 0, -1, false)
-      )
       assert.are.same({ 'bleh1' }, r:lines())
 
       r:replace 'blehGoo2'
-      assert.are.same(
+      assert.are.same({ 'The quick brown fox blehGoo2 the lazy dog' }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
-        { 'The quick brown fox blehGoo2 the lazy dog' },
-        vim.api.nvim_buf_get_lines(b, 0, -1, false)
-      )
     end)
   end)
 
@@ -810,86 +556,4 @@ describe('Range', function()
       }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
     end)
   end)
-
-  it('can save to extmark', function()
-    withbuf({
-      'The quick brown',
-      'fox',
-      'jumps',
-      'over',
-      'the lazy dog',
-    }, function()
-      -- Construct a range over 'fox jumps'
-      local r = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 3, 5), 'v')
-      local extrange = r:save_to_extmark()
-      assert.are.same({ 'fox', 'jumps' }, extrange:range():lines())
-      -- change 'jumps' to 'leaps':
-      vim.api.nvim_buf_set_text(extrange.bufnr, 2, 0, 2, 4, { 'leap' })
-      assert.are.same({
-        'The quick brown',
-        'fox',
-        'leaps',
-        'over',
-        'the lazy dog',
-      }, vim.api.nvim_buf_get_lines(extrange.bufnr, 0, -1, false))
-      assert.are.same({ 'fox', 'leaps' }, extrange:range():lines())
-    end)
-  end)
-
-  it('can save linewise extmark', function()
-    withbuf({
-      'The quick brown',
-      'fox',
-      'jumps',
-      'over',
-      'the lazy dog',
-    }, function()
-      -- Construct a range over 'fox jumps'
-      local r = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 3, Pos.MAX_COL), 'V')
-      local extrange = r:save_to_extmark()
-      assert.are.same({ 'fox', 'jumps' }, extrange:range():lines())
-
-      local extmark = vim.api.nvim_buf_get_extmark_by_id(
-        extrange.bufnr,
-        vim.api.nvim_create_namespace 'u.range',
-        extrange.id,
-        { details = true }
-      )
-      local row0, col0, details = unpack(extmark)
-      assert.are.same({ 1, 0 }, { row0, col0 })
-      assert.are.same({ 3, 0 }, { details.end_row, details.end_col })
-    end)
-  end)
-
-  it('discerns range bounds from extmarks beyond the end of the buffer', function()
-    local Buffer = require 'u.buffer'
-
-    vim.cmd.vnew()
-    local left = Buffer.current()
-    left:set_tmp_options()
-    vim.cmd.vnew()
-    local right = Buffer.current()
-    right:set_tmp_options()
-
-    left:all():replace {
-      'one',
-      'two',
-      'three',
-    }
-    local left_all_ext = left:all():save_to_extmark()
-
-    right:all():replace {
-      'foo',
-      'bar',
-    }
-
-    vim.api.nvim_set_current_buf(right.bufnr)
-    vim.cmd [[normal! ggyG]]
-    vim.api.nvim_set_current_buf(left.bufnr)
-    vim.cmd [[normal! ggVGp]]
-
-    assert.are.same({ 'foo', 'bar' }, left_all_ext:range():lines())
-    vim.api.nvim_buf_delete(left.bufnr, { force = true })
-    vim.api.nvim_buf_delete(right.bufnr, { force = true })
-  end)
 end)

spec/renderer_spec.lua

@@ -83,13 +83,13 @@ describe('Renderer', function()
   end)
 
   --
-  -- get_tags_at
+  -- get_pos_infos
   --
 
   it('should return no extmarks for an empty buffer', function()
     withbuf({}, function()
       local r = R.Renderer.new(0)
-      local pos_infos = r:get_tags_at { 0, 0 }
+      local pos_infos = r:get_pos_infos { 0, 0 }
       assert.are.same(pos_infos, {})
     end)
   end)
@@ -102,28 +102,12 @@ describe('Renderer', function()
         R.h('text', { hl = 'HighlightGroup2' }, ' World'),
       }
 
-      local pos_infos = r:get_tags_at { 0, 2 }
+      local pos_infos = r:get_pos_infos { 0, 2 }
+
       assert.are.same(#pos_infos, 1)
       assert.are.same(pos_infos[1].tag.attributes.hl, 'HighlightGroup1')
       assert.are.same(pos_infos[1].extmark.start, { 0, 0 })
       assert.are.same(pos_infos[1].extmark.stop, { 0, 5 })
-      pos_infos = r:get_tags_at { 0, 4 }
-      assert.are.same(#pos_infos, 1)
-      assert.are.same(pos_infos[1].tag.attributes.hl, 'HighlightGroup1')
-      assert.are.same(pos_infos[1].extmark.start, { 0, 0 })
-      assert.are.same(pos_infos[1].extmark.stop, { 0, 5 })
-
-      pos_infos = r:get_tags_at { 0, 5 }
-      assert.are.same(#pos_infos, 1)
-      assert.are.same(pos_infos[1].tag.attributes.hl, 'HighlightGroup2')
-      assert.are.same(pos_infos[1].extmark.start, { 0, 5 })
-      assert.are.same(pos_infos[1].extmark.stop, { 0, 11 })
-
-      -- In insert mode, bounds are eagerly included:
-      pos_infos = r:get_tags_at({ 0, 5 }, 'i')
-      assert.are.same(#pos_infos, 2)
-      assert.are.same(pos_infos[1].tag.attributes.hl, 'HighlightGroup1')
-      assert.are.same(pos_infos[2].tag.attributes.hl, 'HighlightGroup2')
     end)
   end)
 
@@ -133,165 +117,15 @@ describe('Renderer', function()
       r:render {
         R.h('text', { hl = 'HighlightGroup1' }, {
           'Hello',
-          R.h(
+          R.h('text', { hl = 'HighlightGroup2', extmark = { hl_group = 'HighlightGroup2' } }, ' World'),
-            'text',
-            { hl = 'HighlightGroup2', extmark = { hl_group = 'HighlightGroup2' } },
-            ' World'
-          ),
         }),
       }
 
-      local pos_infos = r:get_tags_at { 0, 5 }
+      local pos_infos = r:get_pos_infos { 0, 5 }
 
       assert.are.same(#pos_infos, 2)
       assert.are.same(pos_infos[1].tag.attributes.hl, 'HighlightGroup2')
       assert.are.same(pos_infos[2].tag.attributes.hl, 'HighlightGroup1')
     end)
   end)
-
-  it('repeated patch_lines calls should not change the buffer content', function()
-    local lines = {
-      [[{ {]],
-      [[    bounds = {]],
-      [[      start1 = { 1, 1 },]],
-      [[      stop1 = { 4, 1 }]],
-      [[    },]],
-      [[    end_right_gravity = true,]],
-      [[    id = 1,]],
-      [[    ns_id = 623,]],
-      [[    ns_name = "my.renderer:91",]],
-      [[    right_gravity = false]],
-      [[  } }]],
-      [[]],
-    }
-    withbuf(lines, function()
-      local Buffer = require 'u.buffer'
-      R.Renderer.patch_lines(0, nil, lines)
-      assert.are.same(Buffer.current():all():lines(), lines)
-
-      R.Renderer.patch_lines(0, lines, lines)
-      assert.are.same(Buffer.current():all():lines(), lines)
-
-      R.Renderer.patch_lines(0, lines, lines)
-      assert.are.same(Buffer.current():all():lines(), lines)
-    end)
-  end)
-
-  it('should fire text-changed events', function()
-    withbuf({}, function()
-      local Buffer = require 'u.buffer'
-      local buf = Buffer.current()
-      local r = R.Renderer.new(0)
-      local captured_changed_text = ''
-      r:render {
-        R.h('text', {
-          on_change = function(txt) captured_changed_text = txt end,
-        }, {
-          'one\n',
-          'two\n',
-          'three\n',
-        }),
-      }
-
-      vim.fn.setreg('"', 'bleh')
-      vim.cmd [[normal! ggVGp]]
-      -- For some reason, the autocmd does not fire in the busted environment.
-      -- We'll call the handler ourselves:
-      r:_on_text_changed()
-
-      assert.are.same(buf:all():text(), 'bleh')
-      assert.are.same(captured_changed_text, 'bleh')
-
-      vim.fn.setreg('"', '')
-      vim.cmd [[normal! ggdG]]
-      -- We'll call the handler ourselves:
-      r:_on_text_changed()
-
-      assert.are.same(buf:all():text(), '')
-      assert.are.same(captured_changed_text, '')
-    end)
-
-    withbuf({}, function()
-      local Buffer = require 'u.buffer'
-      local buf = Buffer.current()
-      local r = R.Renderer.new(0)
-      --- @type string?
-      local captured_changed_text = nil
-      r:render {
-        'prefix:',
-        R.h('text', {
-          on_change = function(txt) captured_changed_text = txt end,
-        }, {
-          'one',
-        }),
-        'suffix',
-      }
-
-      vim.fn.setreg('"', 'bleh')
-      vim.api.nvim_win_set_cursor(0, { 1, 9 })
-      vim.cmd [[normal! vhhd]]
-      -- For some reason, the autocmd does not fire in the busted environment.
-      -- We'll call the handler ourselves:
-      r:_on_text_changed()
-
-      assert.are.same(buf:all():text(), 'prefix:suffix')
-      assert.are.same(captured_changed_text, '')
-    end)
-  end)
-
-  it('should find tags by position', function()
-    withbuf({}, function()
-      local r = R.Renderer.new(0)
-      r:render {
-        'pre',
-        R.h('text', {
-          id = 'outer',
-        }, {
-          'inner-pre',
-          R.h('text', {
-            id = 'inner',
-          }, {
-            'inner-text',
-          }),
-          'inner-post',
-        }),
-        'post',
-      }
-
-      local tags = r:get_tags_at { 0, 11 }
-      assert.are.same(#tags, 1)
-      assert.are.same(tags[1].tag.attributes.id, 'outer')
-
-      tags = r:get_tags_at { 0, 12 }
-      assert.are.same(#tags, 2)
-      assert.are.same(tags[1].tag.attributes.id, 'inner')
-      assert.are.same(tags[2].tag.attributes.id, 'outer')
-    end)
-  end)
-
-  it('should find tags by id', function()
-    withbuf({}, function()
-      local r = R.Renderer.new(0)
-      r:render {
-        R.h('text', {
-          id = 'outer',
-        }, {
-          'inner-pre',
-          R.h('text', {
-            id = 'inner',
-          }, {
-            'inner-text',
-          }),
-          'inner-post',
-        }),
-        'post',
-      }
-
-      local bounds = r:get_tag_bounds 'outer'
-      assert.are.same(bounds, { start = { 0, 0 }, stop = { 0, 29 } })
-
-      bounds = r:get_tag_bounds 'inner'
-      assert.are.same(bounds, { start = { 0, 9 }, stop = { 0, 19 } })
-    end)
-  end)
 end)

spec/tracker_spec.lua

@@ -58,66 +58,66 @@ describe('Signal', function()
 
   describe('Signal:map', function()
     it('should transform the signal value', function()
-      local test_signal = Signal:new(5)
+      local signal = Signal:new(5)
-      local mapped_signal = test_signal:map(function(value) return value * 2 end)
+      local mapped_signal = signal:map(function(value) return value * 2 end)
 
       assert.is.equal(mapped_signal:get(), 10) -- Initial transformation
-      test_signal:set(10)
+      signal:set(10)
       assert.is.equal(mapped_signal:get(), 20) -- Updated transformation
     end)
 
     it('should handle empty transformations', function()
-      local test_signal = Signal:new(nil)
+      local signal = Signal:new(nil)
-      local mapped_signal = test_signal:map(function(value) return value or 'default' end)
+      local mapped_signal = signal:map(function(value) return value or 'default' end)
 
       assert.is.equal(mapped_signal:get(), 'default') -- Return default
-      test_signal:set 'new value'
+      signal:set 'new value'
       assert.is.equal(mapped_signal:get(), 'new value') -- Return new value
     end)
   end)
 
   describe('Signal:filter', function()
     it('should only emit values that pass the filter', function()
-      local test_signal = Signal:new(5)
+      local signal = Signal:new(5)
-      local filtered_signal = test_signal:filter(function(value) return value > 10 end)
+      local filtered_signal = signal:filter(function(value) return value > 10 end)
 
       assert.is.equal(filtered_signal:get(), nil) -- Initial value should not pass
-      test_signal:set(15)
+      signal:set(15)
       assert.is.equal(filtered_signal:get(), 15) -- Now filtered
-      test_signal:set(8)
+      signal:set(8)
       assert.is.equal(filtered_signal:get(), 15) -- Does not pass the filter
     end)
 
     it('should handle empty initial values', function()
-      local test_signal = Signal:new(nil)
+      local signal = Signal:new(nil)
-      local filtered_signal = test_signal:filter(function(value) return value ~= nil end)
+      local filtered_signal = signal:filter(function(value) return value ~= nil end)
 
       assert.is.equal(filtered_signal:get(), nil) -- Should be nil
-      test_signal:set(10)
+      signal:set(10)
       assert.is.equal(filtered_signal:get(), 10) -- Should pass now
     end)
   end)
 
   describe('create_memo', function()
     it('should compute a derived value and update when dependencies change', function()
-      local test_signal = Signal:new(2)
+      local signal = Signal:new(2)
-      local memoized_signal = tracker.create_memo(function() return test_signal:get() * 2 end)
+      local memoized_signal = tracker.create_memo(function() return signal:get() * 2 end)
 
       assert.is.equal(memoized_signal:get(), 4) -- Initially compute 2 * 2
 
-      test_signal:set(3)
+      signal:set(3)
       assert.is.equal(memoized_signal:get(), 6) -- Update to 3 * 2 = 6
 
-      test_signal:set(5)
+      signal:set(5)
       assert.is.equal(memoized_signal:get(), 10) -- Update to 5 * 2 = 10
     end)
 
     it('should not recompute if the dependencies do not change', function()
       local call_count = 0
-      local test_signal = Signal:new(10)
+      local signal = Signal:new(10)
       local memoized_signal = tracker.create_memo(function()
         call_count = call_count + 1
-        return test_signal:get() + 1
+        return signal:get() + 1
       end)
 
       assert.is.equal(memoized_signal:get(), 11) -- Compute first value
@@ -126,11 +126,11 @@ describe('Signal', function()
       memoized_signal:get() -- Call again, should use memoized value
       assert.is.equal(call_count, 1) -- Still should only be one call
 
-      test_signal:set(10) -- Set the same value
+      signal:set(10) -- Set the same value
       assert.is.equal(memoized_signal:get(), 11)
       assert.is.equal(call_count, 2)
 
-      test_signal:set(20)
+      signal:set(20)
       assert.is.equal(memoized_signal:get(), 21)
       assert.is.equal(call_count, 3)
     end)
@@ -138,31 +138,31 @@ describe('Signal', function()
 
   describe('create_effect', function()
     it('should track changes and execute callback', function()
-      local test_signal = Signal:new(5)
+      local signal = Signal:new(5)
       local call_count = 0
 
       tracker.create_effect(function()
-        test_signal:get() -- track as a dependency
+        signal:get() -- track as a dependency
         call_count = call_count + 1
       end)
 
       assert.is.equal(call_count, 1)
-      test_signal:set(10)
+      signal:set(10)
       assert.is.equal(call_count, 2)
     end)
 
     it('should clean up signals and not call after dispose', function()
-      local test_signal = Signal:new(5)
+      local signal = Signal:new(5)
       local call_count = 0
 
       local unsubscribe = tracker.create_effect(function()
         call_count = call_count + 1
-        return test_signal:get() * 2
+        return signal:get() * 2
       end)
 
       assert.is.equal(call_count, 1) -- Initially calls
       unsubscribe() -- Unsubscribe the effect
-      test_signal:set(10) -- Update signal value
+      signal:set(10) -- Update signal value
       assert.is.equal(call_count, 1) -- Callback should not be called again
     end)
   end)

spec/withbuf.lua

@@ -1,4 +1,3 @@
-require 'luacov'
 local function withbuf(lines, f)
   vim.go.swapfile = false
 

stylua.toml

@@ -1,10 +1,6 @@
-syntax = "LuaJIT"
 call_parentheses = "None"
 collapse_simple_statement = "Always"
-column_width = 100
+column_width = 120
 indent_type = "Spaces"
 indent_width = 2
 quote_style = "AutoPreferSingle"
-
-[sort_requires]
-enabled = true

vim.yml

@@ -0,0 +1,36 @@
+---
+base: lua51
+globals:
+  vim:
+    any: true
+  assert.are.same:
+    args:
+      - type: any
+      - type: any
+  assert.are_not.same:
+    args:
+      - type: any
+      - type: any
+  assert.has.error:
+    args:
+      - type: any
+      - type: any
+  assert.is_true:
+    args:
+      - type: any
+      - type: any
+  assert.is_false:
+    args:
+      - type: any
+      - type: any
+  describe:
+    args:
+      - type: string
+      - type: function
+  it:
+    args:
+      - type: string
+      - type: function
+  before_each:
+    args:
+      - type: function