How define code block text object for markdown

[asadzman]

Contributing guidelines

• I have read CODE_OF_CONDUCT.md

Module(s)

mini.ai

Question

I have currently this -->

      custom_textobjects = {
        c = ai.gen_spec.pair('```', '```'),
      }

But this also selects the lua part of

``` lua
-- something
```

I only want to select between ```+<code-name> and ```

[drowning-cat]

Treesitter approach

Caution

Make sure the markdown parser is installed (:TSInstall markdown) and treesitter is working correctly.

Tip

• Use :InspectTree to view the parsed syntax tree for the file.
• Use :EditQuery to test the captures shown below.

1. Define captures for mini.ai

; after/queries/markdown/textobjects.scm

; extends

((fenced_code_block) @code_block.outer)
((code_fence_content) @code_block.inner)

2. Extend mini.ai for the markdown filetype

-- after/ftplugin/markdown.lua

if MiniAi then
  vim.b.miniai_config = {
    custom_textobjects = {
      c = MiniAi.gen_spec.treesitter({ a = "@code_block.outer", i = "@code_block.inner" }),
    },
  }
end

Note there is no "inline" fenced code block. An error will be thrown for cases like:

```lua name ```

Pattern approach (preferred)

MiniAi.gen_spec.pair is not intended to be used with lua patterns, so instead we need to define a custom one. As in the previous example, this extends mini.ai for the markdown filetype and assumes that you have already called MiniAi.setup() in your configuration.

-- after/ftplugin/markdown.lua

if MiniAi then
  vim.b.miniai_config = {
    custom_textobjects = {
      c = { "```%w*().*()```" },
    },
  }
end

The downside is that newlines (\n) are included in the inner match, causing the code block to collapse into a single line:

```lua
|code block -> becomes -> ```lua|```
```

You can fix this by using a slightly more complex pattern, like:

Note

See the comment below for a better pattern implementation.

New!

vim.b.miniai_config = {
  custom_textobjects = {
    -- Better for `dic`: place cursor where `treesitter` approach does
    c = { { "```.*\n().*()```", "```().*()```" } },
    -- Better for `cic`: leave an empty line
    c = { { "```.*\n().*()\n.*```", "```().*()```" } },
  },
}

[echasnovski]

I'll mark this as the answer, since both approaches indeed work. My personal suggestions:

• Tree-sitter approach is usually more robust, but in this case it has some weird relations with indentation and leading whitespace.

• I'd go with Lua pattern approach, but a bit more concise and robust (accounts for indented code blocks):

  vim.b.miniai_config = {
    custom_textobjects = {
      -- Select `ic` as content from first to last non-blank characters
      -- Selection is charwise by default, so common usages are:
      -- - `cic` to "change inside codeblock";
      -- - `Vacd` to "select linewise around codeblock and delete".
      c = { '```[^\n]*\n%s*().-()\n%s*```' },
    },
  }

[asadzman]

Thanks, works flawlessly.