Ask questions

[echasnovski]

Feel free to ask questions about mini.nvim which are not really suitable for an issue. Like "How do I setup ...?", etc.

Another approach is to create a separate discussion in Q&A category, if you have trouble working with this particular discussion (as it is quite populated already). This approach might be even more preferable as it will allow filtering questions by module.

[pyrox0]

Could you add docs on how I can use mini.pairs or mini.surround with completion plugins such as coq_nvim or cmp-nvim? The windwp/nvim-autopairs plugin provides instructions for using it with these plugins (see https://github.com/windwp/nvim-autopairs#mapping-cr). Is there any way to do this with mini.pairs and mini.surround? Thanks!

[echasnovski]

I am not sure if it will be specifically for coq_nvim, but i planned to document a possible way of mapping <CR>, <Tab>, and <S-Tab>. Are these mappings you are interested about?
Can't see how mini.surround and completion plugin can interfere with each other. What kind of troubles do you have here?

[pyrox0]

I'm not using mini.nvim right now, and I've never used something like mini.surround, so I wanted to make sure that it wouldn't conflict with my completion plugin. If you documented how to integrate mini.nvim with coq_nvim, then I would 100% switch to it so I could replace a bunch of plugins with just one!

[txtyash]

How to disable few mini.surround commands?

  mappings = {
    add = 'ys',           -- Add surrounding
    delete = 'ds',        -- Delete surrounding
    find = 'ysf',          -- Find surrounding (to the right)
    find_left = 'ysF',     -- Find surrounding (to the left)
    highlight = 'ysh',     -- Highlight surrounding
    replace = 'cs',       -- Replace surrounding
    update_n_lines = 'ysn' -- Update `n_lines`
  }

I don't want find_left, highlight, update_n_lines.. commands. I wanted to free
s but I still don't want to those commands with y.

[echasnovski]

To not create one or several mappings, use empty string ('') for them.

I put this information in the comment just above mappings section in default config (-- Mappings. Use `''` (empty string) to disable one.). Where do you expect this information to be put for better discoverability?

[Boggin]

Trying to set up on Windows 10 with packer.nvim and each time I try to use the commands, i.e. sa, it does a substitute instead.

nvim v0.5.0

init.vim

lua require('plugins')

plugins.lua

return require('packer').startup(function()  
  use 'wbthomason/packer.nvim'  
  use {   
	  'echasnovski/mini.nvim',  
	  branch = 'stable',  
	  setup = [[require('mini.surround')]],  
  }  
 end)  

Any ideas what I need to do would be gratefully received! Thanks.

[echasnovski]

In order to "activate" this module, you have to call its setup() function with your config table (or nothing to use default config). So in your case it should be enough to use this line instead of a posted one:

setup = [[require('mini.surround').setup()]],  

[Boggin]

Thanks for that. Working now!

It was also that I'd not read a note on packer.vim. I'll copy it here in case someone else has made the same mistake:
"If you are on Windows 10, you need developer mode enabled in order to use local plugins (creating symbolic links requires admin privileges on Windows - credit to @TimUntersberger for this note)"

[IlyaKisil]

How to make visual selection dot-repeatable with mini.surround? For example, with this mapping

vim.api.nvim_set_keymap('x', 'S', [[:<C-u>lua MiniSurround.add('visual')<CR>]], { noremap = true })

if I select some text in visual mode and then S" this will surround selection with double quotes. But I'd like to repeat this action with . for the other selection.

[echasnovski]

Unfortunately, not possible at the moment. Couple of reasons:

• In my experience, visual mode operations are not really intended to be dot-repeatable. Operations with text objects and motions - are. I understand that it is possible in the way that you describe, just doesn't seem to be widely implemented and used.
• If I remember correctly, originally it was somewhat difficult to make properly due to module design.

[IlyaKisil]

How to repeat jump mini.jump but backwards? For example, with vanilla config

• ; Repeat latest f, t, F or T [count] times
• , Repeat latest f, t, F or T in opposite direction [count] times
  mini.jump config exposes mapping for the forward jump

{
  mappings = {
    ...
    repeat_jump = ';',
  }
}

I've quickly looked through jump.lua and it doesn't look like there is such option or does it 🤷 ?)

[echasnovski]

Yes, there is no builtin option for that. Is it a real inconvenience to swap f (F) for t (T) manually?

There is a MiniJump.state that tracks state of recent jump. Should be possible to write one wrapper. Something like lua MiniJump.jump(nil, not MiniJump.state.backward), maybe?

[IlyaKisil]

Is it a real inconvenience to swap f (F) for t (T) manually?
It is not about swapping them in the config, it is about not re-initiating jumps if you overshoot.

For instance, let's say that you did fo;;;;;;; and then you realised that you over jumped by three positions and need to go three positions back.

vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.jump(nil, not MiniJump.state.backward)<CR>]], { noremap = true })
vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.smart_jump(not MiniJump.state.backward)<CR>]], { noremap = true })

This wouldn't work, as it will just get stuck in a loop, since update_state will be reusing state for subsequent jumps.

However, the following two mappings

vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.jump(nil, true)<CR>]], { noremap = true })
vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.smart_jump(true)<CR>]], { noremap = true })

kinda work, but they would break switch to ;. So in general, , should be considered in a sense of reversing direction of jumps. For instance:

• Instead of using ,,, (go 3 times backwards) it is better to do ,;; (, -> reverse direction and then ;; repeat 2 jumps in that reversed direction).
• Then if you over jumped backwards again, you would need to do , to start going forward and however many times ; to keep going forward, i.e. repeating jumps.

Note, that if you just use ,,, then you lose ability to go forward without re-initiating search with f, as ; will just continue to go to the reversed direction.

Since this is not ideal, so there is a need for wrapper. Here is what I came up with.

local M = {}

function M.repeat_in_oposite_direction()
  local state = {}
  for k, v in pairs(MiniJump.state) do
    state[k] = v
  end
  MiniJump.smart_jump(not MiniJump.state.backward)
  MiniJump.state = state
end

vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua require("<this-module>").repeat_in_oposite_direction()<CR>]], { noremap = true })

return M

This seems to work with f and F just fine, and it will also replicate revert in opposite directions for t or T like in the plain (N)Vim config. But assume that you do to;;; which will stop as shown below

aaaa o aaaaa o aaaa o aaaa o
    ^       ^      ^      ^

But if you over jump and want to go backwards, it will stop after o

aaaa o aaaaa o aaaa o aaaa o
      ^       ^      ^      ^

whereas, I'd like it to just go backwards of the same positions. However, I guess this is outside of scope of this plugin.

[echasnovski]

This wouldn't work, as it will just get stuck in a loop, since update_state will be reusing state for subsequent jumps.

Yeah, you are right.

Basically, lack of intuitiveness (what should jumping in reverse three times be: ,,, or ,;;, etc.) and "symmetry" issues (it reverses direction, but there is also till) that "reverse jump" brings prompted me to not include it in module.

For instance, let's say that you did fo;;;;;;; and then you realised that you over jumped by three positions and need to go three positions back.

The designed way of doing this would be fofffffff and then going three times earlier with 3F.

Since this is not ideal, so there is a need for wrapper. Here is what I came up with.

Nice! Here is how I would write this:

function M.opposite_jump()
  MiniJump.state.backward = not MiniJump.state.backward
  MiniJump.smart_jump()
  MiniJump.state.backward = not MiniJump.state.backward
end

However, I guess this is outside of scope of this plugin.

It is indeed, yes.

[IlyaKisil]

For instance, let's say that you did fo;;;;;;; and then you realised that you over jumped by three positions and need to go three positions back.

The designed way of doing this would be fofffffff and then going three times earlier with 3F.

Ohhh... I didn't realise that fofffffff would work. Although I've watched show-case video but it still didn't settle in my head. I think, I like your design decision of first doing [fFtT]<letter> and then just using [fFtT] instead of ;, to repeat jumps

Initially, I thought this plugin is mainly to replicate default fFtT with default mappings for repeating actions, i.e. ; and ,

• With an option of going across lines
• Being written in Lua

I guess, I got confused by having this option customisable.

repeat_jump = ';',

What is the point of having this if you can essentially repeat jump with either ftTF after the initial fo?

[echasnovski]

Ironically, original author of module wasn't a fan of this option. My motivation behind this was twofold:

• It might be useful for people who don't want to "loose muscle memory of original Vim commands", which can be useful outside of Neovim (like in command line with vi keybindings). I initially used it myself, but after some time found myself using ftFT to repeat.
• It had natural implementation within current design and didn't add much complexity.

[shashanktomar]

Hi, thanks for an amazing plugin. Really appreciate the effort put into documenting everything.

What is the easiest way to map mini.ai function_call mapping to something other than f. Is this the only way to do this?

   custom_textobjects = {
    c = gen_spec.function_call({ name_pattern = '[%w_%.]' }),
    f = spec_treesitter({
      a = '@function.outer',
      i = '@function.inner',
    }),
  },

[echasnovski]

Thanks for kind words!

What is the easiest way to map mini.ai function_call mapping to something other than f. Is this the only way to do this?

Your example setup already uses c to select function call (based on Lua patterns; allows alphanumeric, underscore, and dot to be inside function name) and f to select function definition (based on tree-sitter).

Alternatively, you can use tree-sitter to select function call (has both pros and cons), which can be achieved with this:

local gen_spec = require('mini.ai').gen_spec
require('mini.ai').setup({
  custom_textobjects = {
    c = gen_spec.treesitter({ a = '@call.outer', i = '@call.inner' }),
    f = gen_spec.treesitter({ a = '@function.outer', i = '@function.inner' }),
  },
})

[shashanktomar]

Hi There Again,

I am currently using Comment.nvim but want to give mini.comment a try. The documentation says:
Not supported - Block and sub-line comments. This will only support per-line commenting.

Is there any plan to add block level commenting anytime in the future or it will never be supported.

[echasnovski]

... missing triple backticks in "mini.surround", etc. which make them unusable for me.

If you did mean 'mini.surround', then you can define them in config.custom_surroundings via something like { input = { '```().-()```' }, output = { left = '```', right = '```' } }.

If you meant 'mini.pairs', then yeah, I do at the moment think that it is not the place for this kind of functionality there. It is better suited for snippets, which I hope will be implemented in future 'mini.snippets'.

[txtyash]

Yea, i prolly meant mini.pairs. btw, the one major thing that is missing is gifs for every module in the readme. That'd be really great.

[echasnovski]

... the one major thing that is missing is gifs for every module in the readme. That'd be really great.

They were in README (well mp4, not gif) but file got too big to load which is bad for the main page of plugin. They now are in a separate DEMO.md with links to it inside every module's section in main README. I am currently in the process of reorganizing documentation, so there will be separate READMEs for every module with links to them in main one.

[gibfahn]

If you did mean 'mini.surround', then you can define them in config.custom_surroundings via something like { input = { '().-()' }, output = { left = '', right = '' } }.

Came here looking for a surround option for Markdown code blocks, does this handle newlines? e.g I want to surround the current line with backticks like:

Before:

foo()

After:

```
foo()
```

ideally with an optional codeblock syntax, or at least leaving the cursor at the end of the first set of backticks so you can easily type the language. For comparison here's how you do it in nvim-surround.

Fair enough if that's out of scope for the plugin, just wondered whether I was missing something looking at the setup docs.

[echasnovski]

Came here looking for a surround option for Markdown code blocks, does this handle newlines?

It can be made to, because new lines are respected (with a caveat).

I would do that by creating (in config directory) a 'after/filetype/markdown/lua' file with the following content:

vim.b.minisurround_config = {
  custom_surroundings = {
    c = { input = { '```\n().-()\n```' }, output = { left = '```\n', right = '\n```' } },
  },
}

The caveat here is that this will work only if first line has zero indent. If not, ``` will be inserted after that indent and the first line in code block will have zero indent. Not sure if this will change, as it works for majority of cases.

[konart]

Hi! Thanks for a great toolkit.

mini.surround question here:

Is it possible to surround en element (or by motion) with function call? Based on the readme I'd think I can do something like:

a := "so|me_string" //  `|` is the cursor position.

safW( and have is surrounded with () with cursor before the leftmost ( or something like that.

But I can't really figure this out.

[echasnovski]

Hello! Thanks!

Adding surrounding is done in three steps:

• Initiate "Add surrounding" action via sa.
• Tell what region you want to surround via textobject or motion. For example, in your example it can be "around "" which is a".
• Tell which surrounding you want to add via pressing single character surrounding identifier. For a function call, it is f. It will prompt you to insert function name: type it (if I understood correctly, you want W as a function name) and hit <CR> (Enter).

So, overall sequence on characters you need to press is: saa"fW<CR> (<CR> is single hit on Enter). This will result into following state:

a := W(|"some_string")

I am not sure I have 100% understanding of your question, though. Does this help you figure it out?

Here are some other examples.

[megalithic]

👋 hi @echasnovski; LOVE your work and plugins. Question regarding mini.pairs; I'm looking to move to mini.pairs instead of nvim-autopairs; one thing I'd love to ensure is possible, is the ability to handle endwise matches (aka, lua's then..end, or function() end, etc.; or ruby/elixir's do..end, etc.).

Hopefully this isn't too far out of the realm of possibility (oh, and of course, compatibility with nvim-cmcp).

Thanks!

[txtyash]

👋 hi @echasnovski; LOVE your work and plugins. Question regarding mini.pairs; I'm looking to move to mini.pairs instead of nvim-autopairs; one thing I'd love to ensure is possible, is the ability to handle endwise matches (aka, lua's then..end, or function() end, etc.; or ruby/elixir's do..end, etc.).

Hopefully this isn't too far out of the realm of possibility (oh, and of course, compatibility with nvim-cmcp).

Thanks!

U shudve mentioned triple backticks

[echasnovski]

@megalithic, as you already found a #9, my suggestion is to use snippet engine for these cases. 'mini.pairs' is designed to work with single character left and right parts, and it will be that way (at least, for a while).

[bangedorrunt]

Hi @echasnovski, I'm wondering why mini.completion doesn't come with LSP snippet support?

[echasnovski]

Hi! Mostly because it has complicated implementation. 'mini.completion' is already quite big and complex, so I don't want to overburden it.

[bangedorrunt]

Hi! Mostly because it has complicated implementation. 'mini.completion' is already quite big and complex, so I don't want to overburden it.

I'm aware of the purpose of mini.nvim, but at least for me, trying to make a minimalistic plugin doesn't mean we have to trip off essential features. I think snippet engine is very important and should be a complement to LSP servers. I understand that this means more burden on your shoulder. My suggestion is you might make other plugin such as mini.snip which is complement to mini.completion.

[echasnovski]

Thank you for your suggestion. It is already planned.

[bangedorrunt]

Awesome, couldn't wait! Thank you a tons

[GllmR]

Is there a way to have transparent background in mini.starter ?

[echasnovski]

The background in 'mini.starter' is the same as background in all other windows. It is a Normal highlight group. Usually needs a transparent terminal emulator and hi Normal guibg=NONE somewhere.

Do you have working transparent background for other windows but still have 'mini.starter' open without transparency? Or do you want only Starter buffer to be transparent?

[GllmR]

Ok, sorry, it's another plugin that make the background dark (drop-nvim)
🙇

[galli-miro]

Hi!

I've recently started using mini.comment instead of tpope implementation. The one thing annoying sometimes, is that when I'm trying to comment an entire paragraph with gcap, it also comments the empty line at the end of it. If I were to use dot repeat to revert the change, it instead comments the same paragraph again, as well as the next one.

nvim-comment solved this by adding an option to ignore empty lines. Is this something that mini.comment might also have someday?

[echasnovski]

Hi!

US there any reason to not use gcip? It doesn't select empty lines and can be reverted with ..

[galli-miro]

Aah, you are absolutely right. I don't know why I didn't think about that. Thanks :)

[madjxatw]

It is possible to set rules for mini.pairs like nvim-autopairs does? E.g. I probably don't expect a pair of quotes to be inserted when the cursor is right before a word (|word). I used https://github.com/jiangmiao/auto-pairs and https://github.com/tmsvg/pear-tree before with Vim and I prefer the latter as its default behavior makes more sense to me.

[echasnovski]

The only "rules" 'mini.pairs' supports is conditioning on cursor's neighborhood. So you can set up to insert pair only if cursor's neighborhood matches some two-character neigh_pattern Lua pattern. You can do this either inside config for built-in characters or inside MiniPairs.map() for manual mapping.

You case is thus can be supported with this setup:

require('mini.pairs').setup({
  mappings = {
    ['"'] = { neigh_pattern = '[^\\]%W' },
  }
})

Here it will insert "" only if previous character is not a \ and next character is not an alphanumeric character. See here for more special Lua patterns.

[madjxatw]

But how can I distinguish left neighbor and right neighbor?

[echasnovski]

It is a two-character pattern: first character matches left neighbor, second - right.

[madjxatw]

Got it, I misunderstood the concept of 2-chars a bit before, thanks a lot for the explanation with useful links!

[madjxatw]

Excuse me, another question is how to set up mini.pairs to correctly handle Markdown triple ticks. Now whenever I press ` twice, it produces four `.

[echasnovski]

Unfortunately, there is no way right now and probably won't be. The reason is that 'mini.pairs' is designed to work only for two-character neighborhood. Anything wider is a functionality more suited for snippets, in my opinion.

[RyanzpLee]

Dumb question, but how do I get mini.sessions to work? I've installed the module along with starter. Do I have to type in :lua MiniSessions.write({ name of my session }) or do I setup a keybind? What is a recommended approach to get up and running quickly please!

[echasnovski]

I usually use it like this:

• If I need to save a new session, I do indeed type :lua MiniSessions.write('new_session'). This happens not so often, so I don't have mapping for that.
• If I need to read session, at least 99% of the time it is listed in Starter buffer. If not, I type :lua MiniSessions.select() and it provides an interface to read any of the detected sessions. It can be used not only to read, but to (re)write and delete. See its help.

Couple of things worth mentioning:

• The 'mini.sessions' is basically a convenience wrapper for Neovim's built-in sessions mechanism. See :h mksession and :h sessionoptions.
• You can tell 'mini.sessions' about where to store non-local session files with directory option. I have it like this: require('mini.sessions').setup({ directory = '~/.config/nvim/misc/sessions' })

[RyanzpLee]

ooh I see, I'm able to create a session like that thank you so much.

I tried to make a keymap that would let me type in the session name, but the session name ended up being table: 0x0102e019283. Any ideas why it's not working? keymap("n", "<leader>msw", [[ :lua MiniSessions.write({ vim.fn.input("Session Name > ") })<CR> ]])

Also I tried doing :lua MiniSessions.detected() to see what sessions are available and expected a list to come back, but I get back this error. Am I using it wrong?

E5108: Error executing lua [string ":lua"]:1: attempt to call field 'detected' (a table value)
stack traceback:
        [string ":lua"]:1: in main chunk

Thanks for your awesome plugins btw

[echasnovski]

I tried to make a keymap that would let me type in the session name, but the session name ended up being table: 0x0102e019283. Any ideas why it's not working? keymap("n", "<leader>msw", [[ :lua MiniSessions.write({ vim.fn.input("Session Name > ") })<CR> ]])

The MiniSessions.write() takes a string as session name in first argument. You have { ... } which creates a table.
Try this: vim.keymap.set("n", "<leader>msw", '<Cmd>lua MiniSessions.write(vim.fn.input("Session Name > "))<CR>').

Also I tried doing :lua MiniSessions.detected() to see what sessions are available and expected a list to come back, but I get back this error. Am I using it wrong?

E5108: Error executing lua [string ":lua"]:1: attempt to call field 'detected' (a table value)
stack traceback:
        [string ":lua"]:1: in main chunk

The MiniSessions.detected is already a table with detected sessions. To see them, try :lua =MiniSessions.detected if you are on Neovim>=0.8.2 or :lua print(vim.inspect(MiniSessions.detected)) otherwise.

Thanks for your awesome plugins btw

❤️

[xixiaofinland]

I'm having trouble understanding how the cursor's position affects the indentation scope that is displayed. Despite trying various border settings like "both," "top," and "none," and reviewing the help page, I'm still unclear about how it works.

For instance, as shown in the screenshot below, when the cursor is on line #32, I expect the visual indentation to already highlight the scope of thread::spawn from line #32 to seven lines below, instead of pub fn new. Isn’t that a reasonable expectation?

However, when I move the cursor down to line #33, the visual indentation then displays what I anticipated.

[echasnovski]

Here is the definition. Line 32 has "indent at cursor" 8 (the smallest or line indent 8 and cursor column 9), hence its scope is all adjacent lines with indent 8 or more. What I think you expect can be achieved with config.options.try_as_border = true.

[xixiaofinland]

Not sure why the definition is hard for me to interpret... After reading multiple times, still confusing.
Nonetheless, the try_as_border works perfectly!

[Glyphack]

I am using the select_path(nil, { filter = "core" }) to view added paths to this label. How can I configure it to start in the normal mode instead of insert mode?

I tried switching to MiniExtra.pickers.visit_paths() and thought maybe there would be an option pass to MiniPick.start to start in the normal mode but I did not see any key in the config related to this.

I tried to search for an issue similar to this nvim-telescope/telescope.nvim#409 to open Mini.Pick in normal mode but could not find it.

[echasnovski]

I am using the select_path(nil, { filter = "core" }) to view added paths to this label. How can I configure it to start in the normal mode instead of insert mode?

I am assuming you use vim.ui.select = MiniPick.ui_select, right? If this is the case, then 'mini.pick' simply does not have concept of Normal or Insert mode. It implements its own key query process in order to implement "one window UI". Query displayed at the top is not a separate buffer/window, but a window title which is updated after every key press. This design also allows synchronous execution that returns the chosen item.

So I guess the answer here is "unfortunately, there is no way to do that and it is by design".

[RiteshChepuri]

How do i show the indent line for entire file not just the block where the cursor is?

[echasnovski]

The 'mini.indentscope' module is designed only to visualize scope at cursor. There is no functionality in 'mini.nvim' to show indent lines for all buffer and it is not planned.

[gilijev]

I would like to try setting up robust support for tags within jsx/tsx files in mini.surround and mini.ai. My motivation is that I very frequently use surround to e.g. replace the parent HTML element / React component with another one, add a new element wrapping an existing one etc.

Here is a specific, but simplified, example of an issue I encounter with mini.surround. Let's say I want to replace the div wrapping the two inner divs with a different element:

Using sht inside one of the inner divs will correctly highlight the inner div:

Using sht inside the outer div skips one level and highlights the nav above it:

As will using 2sht inside the inner div. It skips the outer, containing, div straight to nav one level above:

I am aware of the reply to this discussion as well as these three issues regarding nested tags. The recommendation is to go with a tree-sitter based approach. Could I ask for a little help setting up the mini.surround and mini.ai config following that advice?

Based on the mini.surround and mini.ai documentation (btw. is it intentional that one is .gen_spec.input.treesitter() while the other is gen_spec.treesitter()?) the setup of a tree-sitter based textobject should go something like this:

Mini.surround

  local ts_input = require('mini.surround').gen_spec.input.treesitter
  require('mini.surround').setup({
    custom_textobjects = {
      t = ts_input({ outer = '@call.outer', inner = '@call.inner' }),
    }
  })

Mini.ai

  local spec_treesitter = require('mini.ai').gen_spec.treesitter
  require('mini.ai').setup({
    custom_textobjects = {
      F = spec_treesitter({ a = '@function.outer', i = '@function.inner' }),
    }
  })

I tried specifying outer / inner and a / i a few different ways but with limited success so far.

Here's an :InspectTree of a very simple .tsx example:

If I understood the documentation correctly then the two most common cases should be:

1. An outer @jsx_element with one or more inner @jsx_elements

(jsx_element ; [4, 4] - [7, 10]
  open_tag: (jsx_opening_element ; [4, 4] - [4, 9]
    name: (identifier)) ; [4, 5] - [4, 8]
  (jsx_element ... )
  (jsx_element ... )
  close_tag: (jsx_closing_element ; [7, 4] - [7, 10]
    name: (identifier))) ; [7, 6] - [7, 9]

2. An outer @jsx_element with an inner @jsx_text

  (jsx_element ; [5, 6] - [5, 43]
    open_tag: (jsx_opening_element ; [5, 6] - [5, 31]
      name: (identifier) ; [5, 7] - [5, 8]
    (jsx_text) ; [5, 31] - [5, 39]
    close_tag: (jsx_closing_element ; [5, 39] - [5, 43]
      name: (identifier))) ; [5, 41] - [5, 42]

How would I accurately represent this in custom_textobjects?

[echasnovski]

Based on the mini.surround and mini.ai documentation (btw. is it intentional that one is .gen_spec.input.treesitter() while the other is gen_spec.treesitter()?) the setup of a tree-sitter based textobject should go something like this:

Yes, indeed, using tree-sitter textobjects and surroundings is a recommended approach.

Yes, it is intentional that 'mini.surround' has gen_spec.input while 'mini.ai' has gen_spec directly. The reason for this is that 'mini.surround' has two parts of surrounding specification: input for defining how surrounding behaves in "input" operations (delete, find; i.e. when surrounding is the object being operated upon) and output for "output" operations (add and second step of replace; i.e. when surrounding is put in the buffer).

Here is an example for "(" built-in surrounding: for "input" it is a nested pattern for how parenthesis should be found, for "output" - parts which should be put on the left and right of target region.

... the setup of a tree-sitter based textobject should go something like this:

The 'mini.ai' example is syntactically correct, while 'mini.surround' one is not, which look like a cope paste error more than anything. Here is the reference example. Use custom_surroundings instead of custom_textobjects and have extra nesting with "input"`.

How would I accurately represent this in custom_textobjects?

In general, the process is described in help. It involves having a specific "textobject" query reachable from your setup (help describes how to check it).

You'd have to follow exactly the names of captures (things that start with @) in some 'textobjects.scm' query file. The easiest way to have those captures defined indeed proved to be installing 'nvim-treesitter/nvim-treesitter-textobjects' plugin (just make it reachable from current session, no need to use its functionality).

This is where things get complicated. It seems that TSX and JSX do not have already defined queries with tag captures there. Now, if you'd want to select attribute using tree-sitter parsing, it should have been "parameter.outer" and "paramter.inner", as those are defined captures.

So, as far as I understand (I am no expert in both tree-sitter and TSX/JSX), there is currently no way to select tags with tree-sitter and 'nvim-treesitter/nvim-treesitter-textobjects' queries. You'd have to either find another appropriate queries out there or write your own (and PR to 'nvim-treesitter-textobjects' ;) ).

[gilijev]

Thank you for the detailed reply @echasnovski!

Regarding the queries with tag captures, my first thought was to try reusing (some part of) the queries defined in highlights.scm for jsx in 'nvim-treesitter/nvim-treesitter'. I'm very new to tree-sitter queries, though, so I'll have to do some reading before I understand how to write the ones needed in textobjects.scm. : )

[gallo-s-chingon]

recently updated to neovim 0.10 and it seems to have broken/changed how mini.hipatterns works for me. now it only highlights TODO and NOTE, the letters not a background.
here's a part of my mini.lua

local hipatterns = require("mini.hipatterns")
require("mini.hipatterns").setup({
	highlighters = {
		find = { pattern = "%f[%w]()FIND()%f[%W]", group = "MiniHipatternsFixme" },
		idea = { pattern = "%f[%w]()IDEA()%f[%W]", group = "MiniHipatternsHack" },
		todo = { pattern = "%f[%w]()TODO()%f[%W]", group = "MiniHipatternsTodo" },
		note = { pattern = "%f[%w]()NOTE()%f[%W]", group = "MiniHipatternsNote" },
		hex_color = hipatterns.gen_highlighter.hex_color(),
	},
})

here's the link to my nvim config in case it helps to solve the issue.

I read the Help for hipatterns.config, setup & examples but I'm prose writer so lua, tables, etc. are greek to me the devil.

[echasnovski]

Neovim 0.10 has an updated default color scheme which might affect how your color scheme behaves.

By default highlight groups of 'mini.hipatterns' link to similar built-in Diagnostic* groups which might have affected how they are displayed for you now.

The way to ensure that module's highlight groups are the way you want them to, is to define them as any other highlight group. For example, with :highlight command (see :h hi) or vim.api.nvim_set_hl() Lua function (see :h nvim_set_hl()). Or use color scheme which explicitly defines those highlight groups (like 'mini.hues').

[gallo-s-chingon]

thanks for tho quick reply @echasnovski ! and thanks for NOT just giving me the answer. reading the link to Diagnostics groups I changed MiniHiPaternsFixme to RedrawDebugRecompose and other colors to fit what I like.

too bad I can't just replace group = … with guifg=… , guibg=…

[swahpy]

Hi, I have a question regarding mini.sessions. Let me give some context first.

Let's assume we have two sessions, each has its own working directory, different from each other. Then I open nvim without any parameters from the third directory and let it load the last session. I can select and open files in the directory the session associated with using oil.nvim, but when I switch to another session, which has a different dir, and open telescope, it is still the same directory, which is the former one. This is fine to use oil to choose files. But it doesn't work with telescope. I also tried mini.pick, same behavior.

So my question would be is it possible to change cwd of the session when switching sessions? Thank you in advance.

Now I'm trying to migrate as many of my plugins to mini ones as possible. I really like them, thank you for your efforts and sharing.

[swahpy]

hi echasnovski, thank you for your reply. I was indeed in my dotfiles repo. I set the git repo to $HOME/.dotfiles and current buffer is the diff.lua file(and other lua files, which are used to set neovim). Not sure why mini.diff not be able to enable for them.
Now I set the source to Minidiff.gen_source.save() as a workaround. And I think it's fine to use this source, too.

[echasnovski]

I was indeed in my dotfiles repo. I set the git repo to $HOME/.dotfiles and current buffer is the diff.lua file(and other lua files, which are used to set neovim). Not sure why mini.diff not be able to enable for them.

Sorry, but I can not reproduce this. Buffers for files in Git repo are auto enabled as expected, even in symlinked directory.

[swahpy]

I was indeed in my dotfiles repo. I set the git repo to $HOME/.dotfiles and current buffer is the diff.lua file(and other lua files, which are used to set neovim). Not sure why mini.diff not be able to enable for them.

Sorry, but I can not reproduce this. Buffers for files in Git repo are auto enabled as expected, even in symlinked directory.

No worries, in former comment I just didn't put it clear. I mean I set --git-dir to $HOME/.dotfiles and set --work-tree to $HOME, and config not to show untracked files. And I also setup a alias like alias dotfiles='/usr/bin/git --git-dir=$HOME/.dotfiles/ --work-tree=$HOME'. Because there is no .git directory, it doesn't treat the files as those in a git repo. I think it's this that affect mini.diff's behaviour.
I tested in other normal git repos it works as expected.

[swahpy]

hi, one quick question, is it possible to enable multiple sources at the same time, like enabling diff of git and last save? Thank you~

[echasnovski]

At the same time for the same buffer - no and won't be.
Having some mechanism that allows to choose the best suitable among fixed set - not yet, see #949.

[postelrich]

With mini.pairs, how can I configure it to only open if its not next to other characters? I'm often adding missing quotes/brackets and it gets annoying to delete the closing pair. I tried neigh_pattern with [^\\+w'"]. with no luck.

[echasnovski]

It is indeed intended to be done with neigh_pattern, which uses Lua patterns (see :h lua-patterns).

Something like this will setup 'mini.pairs' to add only single character if it is added directly after \ or any alphanumeric character (%w):

require('mini.pairs').setup({
  mappings = {
    ['('] = { neigh_pattern = '[^\\%w].' },
    ['['] = { neigh_pattern = '[^\\%w].' },
    ['{'] = { neigh_pattern = '[^\\%w].' },
    ['"'] = { neigh_pattern = '[^\\%w].' },
    ["'"] = { neigh_pattern = '[^\\%w].' },
    ['`'] = { neigh_pattern = '[^\\%w].' },
  }
})

[postelrich]

Thanks!

[timsofteng]

@echasnovski Hey!
What if I nedd mini.diff just from time to time. Do we have any ability to toggle plugin?

[echasnovski]

Other issue gh and gH don't work with this code or without. I get into insert mode after h key. How to debug it?

Execute :nmap gh and/or :nmap gH and see what mapping are present for those keys (in Normal mode). If everything is set up correctly, it should come form 'mini.diff' and have appropriate description (like "Apply hunks" and "Reset hunks").

[timsofteng]

Yeah looks like mini.diff use different model to view hunks diff. I've figured out. Is it possible olways open minidiff with overlay according to my function from previous message?
Is it possible to previou only one hunk?

[echasnovski]

Yeah looks like mini.diff use different model to view hunks diff. I've figured out. Is it possible olways open minidiff with overlay according to my function from previous message?

You can set up calling toggle_overlay() when every buffer is created.

Is it possible to previou only one hunk?

No, overlay works only for the whole buffer.

[timsofteng]

You can set up calling toggle_overlay() when every buffer is created.

What is the best way to do it?

[echasnovski]

By creating and autocommand (see :h autocommand, :h vim.api.nvim_create_autocmd(), :h lua-guide-autocommands) for an appropriate event (for example, :h BufAdd).

[samghara]

Hi, I have a problem using mini.deps, when I put "mason.nvim", "nvim-cmp", and "nvim-lspconfig" into MiniDeps.later for initialization, neovim always fails to connect to the LSP for the first file opened. LspInfo outputs: "0 client(s) attached to this buffer". But when I switching to other files LSP works fine, this is the minimal configuration,

require("mini.deps").setup {}

MiniDeps.later(function()
    MiniDeps.add {
        source = "williamboman/mason.nvim",
    }
    MiniDeps.add {
        source = "hrsh7th/nvim-cmp",
        depends = { "hrsh7th/cmp-nvim-lsp" }
    }
    MiniDeps.add {
        source = "neovim/nvim-lspconfig",
    }

    require("mason").setup {}
    local lspservers = { "lua-language-server"}
    for _, lsp in ipairs(lspservers) do
        if not require("mason-registry").is_installed(lsp) then
            vim.api.nvim_command("MasonInstall " .. lsp)
        end
    end

    local cmp = require("cmp")
    cmp.setup {
        sources = cmp.config.sources {
            { name = "nvim_lsp" },
        }
    }

    require("lspconfig").lua_ls.setup {
        capabilities = require("cmp_nvim_lsp").default_capabilities(),
        settings = {}
    }
end)

[echasnovski]

I am afraid, this is how 'nvim-lspconfig' works: it needs to be set up prior to opening file. If you tend to use Neovim like nvim -- file1 file2, then using 'nvim-lspconfig' with later() is not a good idea. Use now() instead to not lazy load.

I use it with later() because I rarely open Neovim with file arguments instead relying on 'mini.starter'.

[samghara]

I tried setting capabilities first in later(), then use neovim init.lua and 'nvim-lspconfig' works fine, I am not sure of the principle, but thank you for your answer.

local lspconfig = require("lspconfig")
local capabilities = require("cmp_nvim_lsp").default_capabilities()

lspconfig.lua_ls.setup {
    capabilities = capabilities
}
lspconfig.lua_ls.setup {
    settings = {}
}

[abeldekat]

My approach:

-- ...

later(load) -- load lsp related

if vim.fn.argc() > 0 then
  later(function() -- The lsp does not attach when directly opening a file:
    local ft = vim.bo.filetype
    if ft and ft ~= "oil" then
      vim.api.nvim_exec_autocmds("FileType", {
        modeline = false,
        pattern = vim.bo.filetype,
      })
    end
  end)
end

[wroyca]

Hello /

Is there an appropriate approach to instruct hues to handle tokens differently? For example, I'd like to highlight Comment in a bright color, unlike the usual gray, as well as SpecialComment in a distinct, yet equally bright color all the while preserving the whole "perceived lightness, chroma and hue"

Crude example with Comment and SpecialComment in bright color:

e.g.

[pkazmier]

Here is how I define all my overrides for mini.hues. Then I define my own color scheme like this where I apply those overrides. This approach also gives me access to the existing palette of colors if I need it.

[wroyca]

Here is how I define all my overrides for mini.hues. Then I define my own color scheme like this where I apply those overrides. This approach also gives me access to the existing palette of colors if I need it.

Override is one way to go about it - but what I'm really looking for is a strict rule set to determine the appropriate color to apply based on the surrounding perception - that is, I don't want to decide whether it should be red, blue, green, or anything else. I guess an accent fits the bill - but here it would have to be individual accent per token.

Perhaps I'm thinking too much into it, barely awake as it's way past my bedtime. :)

[echasnovski]

I am afraid, overriding specific highlight groups with :highlight command or vim.api.nvim_set_hl() is the recommended approach. It is the most flexible one without the need to maintain anything.

If you specifically want non-grey colors, I can suggest linking to some Diagnostic* group. They represent 5 distinct colors from which you can choose appropriate one.

[timsofteng]

Hey!
How to properly install markdown-preview.nvim? I did it this way buy preview doesn't work.

	add({
		source = "iamcco/markdown-preview.nvim",
		hooks = {
			hooks = {
				post_install = function(spec)
					vim.fn.system("cd " .. spec.path)
					vim.fn["mkdp#util#install"]()
				end,
			},
		},
	})

another plugin which doesn't work is ts-comment

	add("folke/ts-comments.nvim")
	require("ts-comments").setup()

Should I open issue in their repos or something wrong with my config for mini.deps?

[echasnovski]

How to properly install markdown-preview.nvim? I did it this way buy preview doesn't work.

There are several issues here:

• Two nested hooks instead of one.
• post_install hook is executed right after plugin is installed but before its content is visible to current session. So delaying an execution of mkdp#util#install is the suggested solution here (I do it, anyways).

This is the full code I'd recommend using:

local add, now, later = MiniDeps.add, MiniDeps.now, MiniDeps.later

later(function()
	local build = function() vim.fn["mkdp#util#install"]() end
	add({
		source = "iamcco/markdown-preview.nvim",
		hooks = {
			post_install = function() later(build) end,
			post_checkout = build,
		},
	})
end)

another plugin which doesn't work is ts-comment

	add("folke/ts-comments.nvim")
	require("ts-comments").setup()

Adding these lines works for me. Here is the full config:

Full working config with 'folke/ts-comments'

-- Clone 'mini.nvim' manually in a way that it gets managed by 'mini.deps'
local path_package = vim.fn.stdpath("data") .. "/site/"
local mini_path = path_package .. "pack/deps/start/mini.nvim"
if not vim.loop.fs_stat(mini_path) then
	vim.cmd('echo "Installing `mini.nvim`" | redraw')
	local clone_cmd = { "git", "clone", "--filter=blob:none", "https://github.com/echasnovski/mini.nvim", mini_path }
	vim.fn.system(clone_cmd)
	vim.cmd("packadd mini.nvim | helptags ALL")
	vim.cmd('echo "Installed `mini.nvim`" | redraw')
end

-- Set up 'mini.deps' (customize to your liking)
require("mini.deps").setup({ path = { package = path_package } })

-- Use 'mini.deps'. `now()` and `later()` are helpers for a safe two-stage
-- startup and are optional.
local add, now, later = MiniDeps.add, MiniDeps.now, MiniDeps.later

-- vim.cmd([[
--   call print()
-- ]])

later(function()
	local build = function()
		vim.fn["mkdp#util#install"]()
	end
	add({
		source = "iamcco/markdown-preview.nvim",
		hooks = {
			post_install = function()
				later(build)
			end,
			post_checkout = build,
		},
	})
end)

add("folke/ts-comments.nvim")
require("ts-comments").setup()

[timsofteng]

Thank you for response. However both solutions don't work for me.

I see message Option 'commentstring' is empty when I try to comment .sql file.

And I even don't see any command related to :Markdown... in cmd line.

May you please take a loot at my plugins instalation config?
Maybe the problem is here.
*Note. I've tried to put ts-comment to now and to later but without success.

local add = MiniDeps.add
local now, later = MiniDeps.now, MiniDeps.later

-- Safely execute immediately
now(function()
	-- add("Wansmer/langmapper.nvim")
	-- require("config.langmapper")
	add("folke/ts-comments.nvim")
	require("ts-comments").setup()

	add("stevearc/oil.nvim")
	require("config.oil")

	add("ellisonleao/gruvbox.nvim")
	require("config.colorscheme")

	add("nvim-lualine/lualine.nvim")
	require("config.lualine")
end)

-- Safely execute later
later(function()
	add("echasnovski/mini.sessions")
	require("mini.sessions").setup()

	add("tpope/vim-sleuth")

	add("lewis6991/gitsigns.nvim")
	require("config.gitsigns")

	add("echasnovski/mini.diff")
	require("config.mini-diff")

	add("sindrets/diffview.nvim")
	require("config.diffview")

	-- add({
	-- 	source = "NeogitOrg/neogit",
	-- 	depends = { "plenary.nvim" },
	-- })
	-- require("neogit").setup()

	add("nvim-treesitter/nvim-treesitter")
	require("config.treesitter")

	add({
		source = "windwp/nvim-ts-autotag",
		depends = {
			"nvim-treesitter/nvim-treesitter",
		},
	})
	require("nvim-ts-autotag").setup()

	add({
		source = "neovim/nvim-lspconfig",
		depends = { "folke/neodev.nvim" },
	})
	require("config.lsp")

	add({
		source = "f3fora/nvim-texlabconfig",
		hooks = {
			post_install = function(spec)
				vim.fn.system("cd " .. spec.path .. " && go build -o ~/.local/bin/ .")
			end,
		},
	})
	require("texlabconfig").setup()

	-- add("folke/which-key.nvim")
	-- require("config.which-key")

	add("mbbill/undotree")
	require("config.undotree")

	add("kevinhwang91/nvim-bqf")
	require("config.bqf")

	add("arithran/vim-delete-hidden-buffers")

	add("folke/zen-mode.nvim")
	require("config.zen")

	add("dmmulroy/tsc.nvim")
	require("tsc").setup({
		flags = {
			incremental = true,
		},
	})

	add({
		source = "mfussenegger/nvim-dap",
		depends = {
			"rcarriga/nvim-dap-ui",
			"nvim-neotest/nvim-nio",
		},
	})
	require("config.dap")

	add("leoluz/nvim-dap-go")
	require("dap-go").setup()

	add({
		source = "stevearc/conform.nvim",
	})
	require("config.conform")

	add("tpope/vim-dispatch")

	add("mfussenegger/nvim-lint")
	require("config.nvim-lint")

	-- add("folke/trouble.nvim")
	-- require("trouble").setup({
	-- 	icons = false,
	-- })

	add("tpope/vim-abolish")
	--
	-- add({
	-- 	source = "echasnovski/mini.comment",
	-- 	depends = {
	-- 		"JoosepAlviste/nvim-ts-context-commentstring",
	-- 	},
	-- })
	-- require("config.mini-comment")
	-- require("ts_context_commentstring").setup({})

	add("FabijanZulj/blame.nvim")
	require("blame").setup()

	add({
		source = "nvim-telescope/telescope.nvim",
		depends = {
			"nvim-lua/plenary.nvim",
			"nvim-telescope/telescope-fzf-native.nvim",
		},
	})
	require("config.telescope")

	add({
		source = "nvim-telescope/telescope-fzf-native.nvim",
		hooks = {
			post_install = function()
				vim.fn["mkdp#util#install"]()
			end,
		},
	})

	add({
		source = "hrsh7th/nvim-cmp",
		depends = {
			"L3MON4D3/LuaSnip",
			"hrsh7th/cmp-buffer",
			"hrsh7th/cmp-nvim-lsp",
			"hrsh7th/cmp-cmdline",
			"hrsh7th/cmp-path",
			"andersevenrud/cmp-tmux",
		},
	})
	require("config.cmp")

	add({
		source = "L3MON4D3/LuaSnip",
		depends = {
			"rafamadriz/friendly-snippets",
			"saadparwaiz1/cmp_luasnip",
		},
	})
	require("config.luasnip")

	add("kylechui/nvim-surround")
	require("config.surround")

	add("echasnovski/mini.pairs")
	require("mini.pairs").setup()

	add("aserowy/tmux.nvim")
	require("config.tmux")

	add("tpope/vim-dadbod")
	add("kristijanhusak/vim-dadbod-ui")

	add({
		source = "williamboman/mason.nvim",
		depends = {
			"williamboman/mason-lspconfig.nvim",
		},
	})
	require("mason").setup()
	require("mason-lspconfig")

	add({
		source = "danymat/neogen",
		depends = { "nvim-treesitter/nvim-treesitter" },
	})
	require("neogen").setup({})

	-- add({
	-- 	source = "nvim-neorg/neorg",
	-- 	depends = { "luarocks.nvim" },
	-- })
	-- require("config.neorg")
	--
	add({ source = "echasnovski/mini.align", checkout = "stable" })
	require("mini.align").setup()

	add({ source = "echasnovski/mini.clue", checkout = "stable" })
	require("config.mini-clue")

	add({ source = "echasnovski/mini.ai", checkout = "stable" })
	require("mini.ai").setup()
end)

later(function()
	local buildMDPreview = function()
		vim.fn["mkdp#util#install"]()
	end
	add({
		source = "iamcco/markdown-preview.nvim",
		hooks = {
			post_install = function()
				later(buildMDPreview)
			end,
			post_checkout = buildMDPreview,
		},
	})
end)

[echasnovski]

The following trimmed down config works for me (which is mostly the same as mine previous example):

Working trimmed down config

-- Clone 'mini.nvim' manually in a way that it gets managed by 'mini.deps'
local path_package = vim.fn.stdpath("data") .. "/site/"
local mini_path = path_package .. "pack/deps/start/mini.nvim"
if not vim.loop.fs_stat(mini_path) then
	vim.cmd('echo "Installing `mini.nvim`" | redraw')
	local clone_cmd = { "git", "clone", "--filter=blob:none", "https://github.com/echasnovski/mini.nvim", mini_path }
	vim.fn.system(clone_cmd)
	vim.cmd("packadd mini.nvim | helptags ALL")
	vim.cmd('echo "Installed `mini.nvim`" | redraw')
end

-- Set up 'mini.deps' (customize to your liking)
require("mini.deps").setup({ path = { package = path_package } })

local add = MiniDeps.add
local now, later = MiniDeps.now, MiniDeps.later

-- Safely execute immediately
now(function()
	add("folke/ts-comments.nvim")
	require("ts-comments").setup()
end)

later(function()
	local buildMDPreview = function()
		vim.fn["mkdp#util#install"]()
	end
	add({
		source = "iamcco/markdown-preview.nvim",
		hooks = {
			post_install = function()
				later(buildMDPreview)
			end,
			post_checkout = buildMDPreview,
		},
	})
end)

I see message Option 'commentstring' is empty when I try to comment .sql file.

This is expected with built-in commenting because it 'commentstring' option is indeed not set for sql files. I can see that 'ts-comments' should have it covered, but all I can say is that this plugin seems to be loaded properly. I checked it commenting in 'vim' filetype and it commented with " %s commentstring when :echo &commentstring shows "%s.

And I even don't see any command related to :Markdown... in cmd line.

It is present only when you are currently in the buffer with 'markdown' filetype and it works as expected. One thing to note is that if you open that markdown file with nvim -- README.md, then it won't work because 'markdown-preview.nvim' is not yet loaded (as it uses later()). Either execute ;edit to reload the buffer (and MarkdownPreview command should be visible) or use now() to load the plugin.

[timsofteng]

Awesome. Thanks!

[timsofteng]

Can I invoke ‘mini.completion‘ with trigger? I like to manually invoke different completion sources with different keybinds.

[echasnovski]

Yes. Disable autocompletion and use either of mappings.

[timsofteng]

Thanks. Unfortunately it doesn't really suite my needs. I have more than one fallback. I have separate keybindings for completion for opened windows, completion for snipets. Is it posible?

[echasnovski]

Thanks. Unfortunately it doesn't really suite my needs. I have more than one fallback. I have separate keybindings for completion for opened windows, completion for snipets. Is it posible?

If I understood correctly, then the answer is "unfortunately, no".

'mini.completion' is designed to have only two stage completion with configurable sources out of scope.

[timsofteng]

Got it. I missed this details. I cannot go with mini.completion. But thank you anyway!

[proofer]

Does installing mini-nvim rather than individual components install 40+ modules, even if some or most need setup() calls to enable? (I'm using lazy.nvim.)

Each of the module's READMEs that I've looked at so far says it "can be installed as part of 'mini.nvim' library (recommended) or as a standalone Git repository." What is the basis of the recommendation of "as part of 'mini.nvim' library?

[echasnovski]

What is the basis of the recommendation of "as part of 'mini.nvim' library?

The main suggestion is to install 'mini.nvim' as a library and then call setup() only for modules that you want to use. Others will not be used, so no extra overhead. This will need one plugin installation entry in your plugin manager. Also you'll get access to information and updates from all modules (current and future new ones).

If you don't like extra help tags from plugins you're not using and/or want to go extra lightweight on disk usage, use standalone repositories. They will be updated after the change is merged into a main 'mini.nvim' plugin.

[proofer]

OK! Thanks. I said "some or most" because in the mini.nvim README it says, "Each module (if needed) should be setup separately..." The "if needed" is ambiguous between the module's need and the user's desire, and I initially took the wrong fork. Perhaps instead something like, "Each module that you want to use should be set up separately...". ( "Setup" is a noun and "set up" is the related verb phrase, although the majority of tech doc writers seem to use "setup" as a verb.) Also, the following sentence, "You can supply values which differ from defaults, which will be used for the rest ones" might be better as, "You need not supply the entire configuration table; you can specify only values that differ from defaults." Regardless, "rest" is not an adjective.

We native speakers of English are very fortunate that so many talented and productive programmers around the world have learned our language!

I have included the mini.nvim installation in my config; now onwards to individual setups...

[echasnovski]

"Each module (if needed) should be setup separately..."

Here the remark is present precisely because not all modules require calling their setup() for the functionality to be available. Like 'mini.misc' and 'mini.bufremove', which are mostly a collection of functions.

"You can supply values which differ from defaults, which will be used for the rest ones"

Yeah, this can be made better.

---

I'll reword those soon-ish. Thanks for the feedback!

[echasnovski]

I've reworded that README section based on your advice. Thanks again for the pointer!

[proofer]

EDIT: the problem is the curly braces that isolate the reference to mini.nvim; the fix is to remove them.

I've done something stupid that I'm not seeing. Using lazy.nvim, my mini-nvim.lua contains:

return {
    { 'echasnovski/mini.nvim', version = false },
    config = function()
        require('mini.ai').setup()
    end,
}

mini.nvim alone loads OK. But after adding the config = for mini.ai, at nvim startup I get:

Error detected while processing /Users/proofer/.config/nvim/init.lua:
Failed to load `plugins-mini-nvim`
...local/share/nvim/lazy/lazy.nvim/lua/lazy/core/plugin.lua:67: attempt to call method 'find' (a nil value)

This is line 67 of plugin.lua:
local is_ref = plugin[1] and not plugin[1]:find("/", 1, true)

[echasnovski]

Sorry, this looks like a 'lazy.nvim' question, not 'mini.nvim'.
My guess would be that config should go in the same table as `'echasnovski/mini.nvim' without extra nesting.

[savchenko]

Is there a way to select inside/around comment with mini.ai?
Assuming that ft is set and nVim / LSP are able to distinguish comments from the rest of the text.

[echasnovski]

There certainly is a way by manually defining callable specification. It should parse current buffer lines to and output a proper region.

This is not (and will not) be built-in in 'mini.ai' or 'mini.extra', because a suggest approach is to use gc textobject 'mini.comment' or the one from built-in commenting (requires Neovim>=0.10.

[savchenko]

I might be missing something obvious, but vgc uncomments line instead of selecting block.

nVim v0.10.0 started with --clean.

[echasnovski]

It does not work in Visual mode, only in Operator-pending mode (as in "after typing an operator", like dgc or gcgc).

There is no way to visually select comment block with built-in commenting (and defaults of 'mini.comment') by design: mostly because visual selection by itself is rarely an end goal, usually it is to perform some action on it. Hence "comment visual selection" is usually a more common action, it gets the preference for gc mapping in Visual mode.

With 'mini.comment' you can have ability to visually select comment block by configuring different mappings.textobject and mappings.comment_visual.