danymat / neogen

A better annotation generator. Supports multiple languages and annotation conventions.

Neogen - Your Annotation Toolkit

Table Of Contents

• Features
• Requirements
• Installation
• Usage
• Configuration
• Supported Languages
• Adding Languages
• GIFS
• Credits
• Support

Features

• Create annotations with one keybind, and jump your cursor in the inserted annotation
• Defaults for multiple languages and annotation conventions
• Extremely customizable and extensible
• Written in lua (and uses Tree-sitter)

Requirements

Have Tree-sitter parsers installed on your system. For more information, check out the :treesitter-parsers neovim help page.

Installation

Use your favorite package manager to install Neogen, e.g:

Lazy

{ 
    "danymat/neogen", 
    config = true,
    -- Uncomment next line if you want to follow only stable versions
    -- version = "*" 
}

Packer

use {
    "danymat/neogen",
    config = function()
        require('neogen').setup {}
    end,
    -- Uncomment next line if you want to follow only stable versions
    -- tag = "*"
}

Usage

• If you want to keep it simple, you can use the :Neogen command:

" will generate annotation for the function, class or other relevant type you're currently in
:Neogen
" or you can force a certain type of annotation with `:Neogen <TYPE>`
" It'll find the next upper node that matches the type `TYPE`
" E.g if you're on a method of a class and do `:Neogen class`, it'll find the class declaration and generate the annotation.
:Neogen func|class|type|...

• If you like to use the lua API, I exposed a function to generate the annotations.

require('neogen').generate()

You can bind it to your keybind of choice, like so:

local opts = { noremap = true, silent = true }
vim.api.nvim_set_keymap("n", "<Leader>nf", ":lua require('neogen').generate()<CR>", opts)

Calling the generate function without any parameters will try to generate annotations for the current function.

You can provide some options for the generate, like so:

require('neogen').generate({
    type = "func" -- the annotation type to generate. Currently supported: func, class, type, file
})

For example, I can add an other keybind to generate class annotations:

local opts = { noremap = true, silent = true }
vim.api.nvim_set_keymap("n", "<Leader>nc", ":lua require('neogen').generate({ type = 'class' })<CR>", opts)

Snippet support

We added snippet support, and we provide defaults for some snippet engines. And this is done via the snippet_engine option in neogen's setup:

• snippet_engine option will use provided engine to place the annotations:

Currently supported: luasnip, snippy, vsnip.

require('neogen').setup({ snippet_engine = "luasnip" })

That's all ! You can now use your favorite snippet engine to control the annotation, like jumping between placeholders.

Or, if you want to return the snippet as a string (to integrate with other snippet engines, for example), you can do it by using the return_snippet option in the generate function:

• return_snippet option will return the annotations as lsp snippets.

local snippet, row, col = require('neogen').generate({ snippet_engine = "luasnip" })

And then pass the snippet to the plugin's snippet expansion function.

Default cycling support

Note that this part is only useful if you don't use the snippets integration.

If you don't want to use a snippet engine with Neogen, you can leverage Neogen's native jumps between placeholders. To map some keys to the cycling feature, you can do like so:

local opts = { noremap = true, silent = true }
vim.api.nvim_set_keymap("i", "<C-l>", ":lua require('neogen').jump_next<CR>", opts)
vim.api.nvim_set_keymap("i", "<C-h>", ":lua require('neogen').jump_prev<CR>", opts)

Or, if you want to use a key that's already used for completion purposes, take a look at the code snippet here:

nvim-cmp

local cmp = require('cmp')
local neogen = require('neogen')

cmp.setup {
    ...

    -- You must set mapping if you want.
    mapping = {
        ["<tab>"] = cmp.mapping(function(fallback)
            if neogen.jumpable() then
                neogen.jump_next()
            else
                fallback()
            end
        end, {
            "i",
            "s",
        }),
        ["<S-tab>"] = cmp.mapping(function(fallback)
            if neogen.jumpable(true) then
                neogen.jump_prev()
            else
                fallback()
            end
        end, {
            "i",
            "s",
        }),
    },
    ...
}

Configuration

require('neogen').setup {
    enabled = true,             --if you want to disable Neogen
    input_after_comment = true, -- (default: true) automatic jump (with insert mode) on inserted annotation
    -- jump_map = "<C-e>"       -- (DROPPED SUPPORT, see [here](#cycle-between-annotations) !) The keymap in order to jump in the annotation fields (in insert mode)
}

If you're not satisfied with the default configuration for a language, you can change the defaults like this:

require('neogen').setup {
    enabled = true,
    languages = {
        lua = {
            template = {
                annotation_convention = "emmylua" -- for a full list of annotation_conventions, see supported-languages below,
                ... -- for more template configurations, see the language's configuration file in configurations/{lang}.lua
                }
        },
        ...
    }
}

For example, if you want to quickly add support for new filetypes based around existing ones, you can do like this:

require('neogen').setup({
    languages = {
        ['cpp.doxygen'] = require('neogen.configurations.cpp')
    }
})

Supported Languages

There is a list of supported languages and fields, with their annotation style

Languages	Annotation Conventions	Supported annotation types
sh	Google Style Guide ("google_bash")	func, file
c	Doxygen ("doxygen")	func, file, type
cs	Xmldoc ("xmldoc") Doxygen ("doxygen")	func, file, class
cpp	Doxygen ("doxygen")	func, file, class
go	GoDoc ("godoc")	func, type
java	Javadoc ("javadoc)	func, class
javascript	JSDoc ("jsdoc")	func, class, type, file
javascriptreact	JSDoc ("jsdoc")	func, class, type, file
kotlin	KDoc ("kdoc")	func, class
lua	Emmylua ("emmylua") Ldoc ("ldoc")	func, class, type, file
php	Php-doc ("phpdoc")	func, type, class
python	Google docstrings ("google_docstrings") Numpydoc ("numpydoc") reST ("reST")	func, class, type, file
ruby	YARD ("yard") Rdoc ("rdoc") Tomdoc ("tomdoc")	func, type, class
rust	RustDoc ("rustdoc") Alternative ("rust_alternative")	func, file, class
typescript	JSDoc ("jsdoc") TSDoc ("tsdoc")	func, class, type, file
typescriptreact	JSDoc ("jsdoc") TSDoc ("tsdoc")	func, class, type, file
vue	JSDoc ("jsdoc")	func, class, type, file

Adding Languages

1. Using the defaults to generate a new language support: Adding Languages
2. (advanced) Only if the defaults aren't enough, please see here: Advanced Integration

Tip: Take a look at this beatiful diagram, showing a representation of the codebase. You can then take a first understanding of what is under the hood. For more details, you can see :h neogen-develop.

GIFS

Credits

• Binx, for making that gorgeous logo for free!
  • Github
  • Reddit

Support

You like my plugin and want to express your gratitude 👼 ? You can suppport me by donating the equivalent of my morning coffee (no minimum required). I would really appreciate your support as it can motivate me to continue this journey 💝

• Donate here

neogen's Issues

functions inside of table receive improper doc placement

It appears that, when attempting to use Neogen on a function inside of a table in Lua, the function documentation is placed above the table itself

Support file-level annotations

ie require('neogen').generate({type='file'})

• https://www.doxygen.nl/manual/commands.html#cmdfile
• https://google.github.io/styleguide/pyguide.html#382-modules

Update vim help!

Update vim help.

c# not work

A few days ago I could use it with C# but after updating it doesn't work it tells me that "Language cs not supported."

python `google_docstring` broken

For the following code

def get_all_files(directory: str) -> List[str]:

Currently generating

    """
    	directory (str): 

    Returns: 
    	
    """

It misses the Args: line before directory.

Weird behavior when calling different types

I'm getting a weird behavior (javascript for example), when I try these steps:

function test() {}

1. require('neogen').generate({ type = "func" })

/* */
function test() {}

2. require('neogen').generate({ type = "class" })

/**
 * 
 * @class
 */
function test() {}

But if I try the other way around (after relaunching nvim):

1. require('neogen').generate({ type = "class" })

/**
 * 
 * @class
 * @classdesc
 */
function test() {}

2. require('neogen').generate({ type = "func" })

function test() {}

Add custom cursor placement in template

I want to be able to customize the cursor placement where I would want it to be:

If I have a template like this:

        numpydoc = {
            { nil, '"""' },
            { nil, '""" """', { no_results = true } },
            { "parameters", "%s: ", { before_first_item = { "", "Parameters", "----------" } } },
            { "attributes", "%s: ", { before_first_item = { "", "Attributes", "----------" } } },
            { "return_statement", "", { before_first_item = { "", "Returns", "-------" } } },
            { nil, "" },
            { nil, '"""' },
        },

I would want to add a cursor configuration in field 3 of the template, that could be able to insert the cursor at the annotation position I would want, for example:

• First found item in template, after the generated annotation (e.g first param field)
• First line in generated annotation

def test(param1):
    """ <-- CURSOR HERE ?

    Parameters
    -----------
    param1: <-- CURSOR HERE ?
    """
    pass

This raises the question of creating a feature to add support for tabs to cycle between insert positions

Add support for recursive find for node_type

At the moment, the tree used to match the nodes is only composed of fixed positioning. I want to have an option to go to each children and recursively find all members that match a node_type.

This could add support for multiple pointers in c.

neogen doesn't work correctly for C

The following example only creates parameter documentation for bool from_cmdline.

/**
 * @brief
 *
 * @param[in] from_cmdline
 * @returns
 */
static bool set_logfile(TALLOC_CTX *mem_ctx,
                        struct loadparm_context *lp_ctx,
                        const char *log_basename,
                        const char *process_name,
                        bool from_cmdline)
{
}

Return to previous cursor position after last annotation cycling

Neogen sync/update [feature request]

Sometimes the source material for a generated annotation might be changed after the annotation has been generated. In these cases, it would be very useful to have a command (neogen.sync()?) to update an existing annotation. For example:

def foo(bar):
     return bar

Run neogen.generate():

def foo(bar):
    """

    Args:
        bar (): 

    Returns:
        
    """
    return bar

But now suppose I add type annotations so the top line reads:

def foo(bar: int):

Then the hypothetical neogen.sync() would do this:

def foo(bar: int):
    """

    Args:
        bar (int): 

    Returns:
        
    """
    return bar

C++ template function yields doc with multiple return statements

Simple test.cpp with:

template<typename A, typename B>
void f(A a, B b){}

results in:

/**
 * @brief 
 *
 * @tparam A 
 * @tparam B 
 * @param a 
 * @param b 
 * @return 
 * @return 
 */
template<typename A, typename B>
void f(A a, B b){}

It shouldn't generate the two @return statements.
If it helps, it seems like the number of `@return statements is connected to the amount of template parameters.
e.g.:

template<typename A, typename B, typename C, typename D>
void f(A a, B b, C c, D d){}

will yield:

/**
 * @brief 
 *
 * @tparam A 
 * @tparam B 
 * @tparam C 
 * @tparam D 
 * @param a 
 * @param b 
 * @param c 
 * @param d 
 * @return 
 * @return 
 * @return 
 * @return 
 */
template<typename A, typename B, typename C, typename D>
void f(A a, B b, C c, D d){}

TSPlayground of the first example:

template_declaration [0, 0] - [1, 18]
  parameters: template_parameter_list [0, 9] - [0, 33]
    type_parameter_declaration [0, 10] - [0, 20]
      type_identifier [0, 19] - [0, 20]
    type_parameter_declaration [0, 22] - [0, 32]
      type_identifier [0, 31] - [0, 32]
  function_definition [1, 0] - [1, 18]
    type: primitive_type [1, 0] - [1, 4]
    declarator: function_declarator [1, 5] - [1, 16]
      declarator: identifier [1, 5] - [1, 6]
      parameters: parameter_list [1, 6] - [1, 16]
        parameter_declaration [1, 7] - [1, 10]
          type: type_identifier [1, 7] - [1, 8]
          declarator: identifier [1, 9] - [1, 10]
        parameter_declaration [1, 12] - [1, 15]
          type: type_identifier [1, 12] - [1, 13]
          declarator: identifier [1, 14] - [1, 15]
    body: compound_statement [1, 16] - [1, 18]

bug: python return annotations

class Test:
  def __str__(self) -> str:
      """
  
      Parameters
      ----------
      self: 
          
  
      Returns
      -------
      config_str : 
          
      strip : 
          
      """
      config_str = ""
      for row in self.tile:
          row_str = "".join(row)
          config_str += row_str + "\n"
      return config_str.strip()

return config_str.strip() should be anonymous, and the self should not be a parameter, as it is a method.
This is what I expect:

class Test:
  def __str__(self) -> str:
      """
      Returns
      -------
      str:
          
      """
      config_str = ""
      for row in self.tile:
          row_str = "".join(row)
          config_str += row_str + "\n"
      return config_str.strip()

C++: Function doesn't recognized sometimes

Example:

class Shortcut
{
public:
    void processEvent(const XKeyEvent &event) const;
};

Annotation generation for processEvent results to nothing.

Better display of Support Languages

I want to change this table already present here: https://github.com/danymat/neogen#supported-languages

With a table more minimalist and pleasant for the eyes.

If you have any ideas, feel free to feedback.

Python file docstring after imports

Using numpydoc and require("neogen").generate({ type = "file" }) the docstring is placed after the imports instead of at the top of the file. Seems related to having the comment line in this example:

import time


# comment
def sum(a, b):
    return a + b

Arrow Functions Do Not Work - JS/TS

Awesome plugin, seems way faster than vim-doge.

I'm not sure if it's my setup or if there actually is not support for arrow functions. I followed all the setup instructions, but nothing happens when I try it on the following

const x = (test) => {
  returns test;
}

[typescript] Add support for TSdoc

• Link: https://tsdoc.org

(py) Add support for reST template

• https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html

Do not add offset when specified

I would want the template to jump on a new line without adding the offset lines.

For it, I thought about this idea: when specifying nil instead of a string (in template content), it will create a blank line.

Refactoring codebase

It sounds harsh, but I like the idea of this plugin. If you don't mind, I will make a PR with help.

Show cursor TODO instead of nothing

The idea is basically to show a description for where we want to jump.
Ideally, this should be done with anti conceal (neovim/neovim#9496), but as it's progressing too slowly, we'll have to write to the buffer for the moment.

_Originally posted by @axieax in #34 (comment)

Bug in C++ template parsing

The current parsing of C++ template parameters has an issue. I think the current processing is looking for any parent node that is a template_declaration. However, if the function is within a class, the class itself can have a parent template_declaration which is then wrongfully used as the template declaration for the function.

Consider the following example:

template <typename D> class Foo {
public:
  float bar(float a) { return a; }
};

which has a tree like this:

template_declaration [0, 0] - [3, 2]
  parameters: template_parameter_list [0, 9] - [0, 21]
    type_parameter_declaration [0, 10] - [0, 20]
      type_identifier [0, 19] - [0, 20]
  class_specifier [0, 22] - [3, 1]
    name: type_identifier [0, 28] - [0, 31]
    body: field_declaration_list [0, 32] - [3, 1]
      access_specifier [1, 0] - [1, 7]
      function_definition [2, 2] - [2, 34]
        type: primitive_type [2, 2] - [2, 7]
        declarator: function_declarator [2, 8] - [2, 20]
          declarator: field_identifier [2, 8] - [2, 11]
          parameters: parameter_list [2, 11] - [2, 20]
            parameter_declaration [2, 12] - [2, 19]
              type: primitive_type [2, 12] - [2, 17]
              declarator: identifier [2, 18] - [2, 19]
        body: compound_statement [2, 21] - [2, 34]
          return_statement [2, 23] - [2, 32]
            identifier [2, 30] - [2, 31]

The parent template declaration is assigned to the function definition, even though it belongs to the class.

Annotating empty Python class throws an unhelpful error

When I try to annotate an empty Python class, e.g.

class Foo: 
  pass

I get

E5108: Error executing lua ...packer/start/neogen/lua/neogen/configurations/python.lua:89: bad argument #1 to 'pairs' (table expected, got nil)                                                                                                                              
stack traceback:                                                                                                                                                                                                                                                             
        [C]: in function 'pairs'                                                                                                                                                                                                                                             
        ...packer/start/neogen/lua/neogen/configurations/python.lua:89: in function 'extract'                                                                                                                                                                                
        ...k/packer/start/neogen/lua/neogen/granulators/default.lua:33: in function 'granulator'                                                                                                                                                                             
        .../share/nvim/site/pack/packer/start/neogen/lua/neogen.lua:49: in function 'generate'                                                                                                                                                                               
        /Users/dmiketa/.config/nvim/lua/config/mappings.lua:418: in function 'execute'                                                                                                                                                                                       
        [string ":lua"]:1: in main chunk  

The function works alright on

class Foo:
    def __init__(self, bar):
        self.bar = bar

    def baz(self):
        return None

and produces

class Foo:
    """

    Attributes: 
    	bar: 
    """
    def __init__(self, bar):
        self.bar = bar

    def baz(self):
        return None

It would be helpful if the function either

1. raised an appropriate error or
2. (preferred) just annotated the class with no attributes.

Only do jumping in annotation range

At the moment if you don’t jump all annotations and go back to your function , and you press tab it’ll go back to the annotation.

Exception on load

Version

NVIM v0.7.0-dev+863-g8f27c4a04

Issue

Exception as follows on load:

Error running config for neogen: ...al/share/nvim/site/pack                                                                                                                                                                       
↪ck/packer/opt/neogen/lua/neogen.lua:166: Vim(function):E81: Using <SID>                                                                                                                                                                       
> not in a script context

introduced with a6ea2c171853e207bb73a4e6fb07c9e4a02c2a6b.

Configuration

  require("neogen").setup({
    enabled = true,
    jump_map = "<Down>",
    languages = {
      c = {
        template = {
          annotation_convention = "doxygen_plus",
          use_default_comment = false,
          doxygen_plus = {
            { nil, "/* $1 */", { no_results = true } },
            { nil, "/**" },
            { nil, " * @brief: $1" },
            { nil, " *" },
            { "parameters", " * @param[in] %s: $1" },
            { "return_statement", " * @returns $1" },
            { nil, " */" },
          },
        },
      },
      python = {
        template = {
          annotation_convention = "rest",
          rest = {
            { nil, "\"\"\"$1" },
            { nil, "\"\"\" $1 \"\"\"", { no_results = true } },
            { nil, "" },
            { "parameters", ":param %s:" },
            { "return_statement", ":return:" },
            { nil, "\"\"\"" },
          },
        },
      },
    },
  })

Reproduce

Should come up as a result of simply loading the plugin. It might have something to do with the fact that I load it from opt, otherwise my setup is pretty standard. I manage neogen with packer.

Tabs inserted in numpydoc docstring

PEP8 recommends using spaces¹, however tabs are inserted when generating docstrings. For example,

def function(a: int, b: float) -> bool:
    """

    Parameters
    ----------
    a: int
<space><space><space><space><tab>
    b: float
<space><space><space><space><tab>

    Returns
    -------
    int
<space><space><space><space><tab>
    float
<space><space><space><space><tab>
    bool
<space><space><space><space><tab>
    """
    if a == int(b):
        c = False
    else:
        c = True
    return c

Is it possible to detect the indentation style from the file or add a configuration option to use spaces here?

(As a side-note, I don't know why three return values were generated when there's only one)

Footnotes

1. https://www.python.org/dev/peps/pep-0008/#tabs-or-spaces ↩

Add the ability to disable jump_map binding

Could you add the ability to disable jump_map binding? Useful you want to bind some custom logic like described here.
I would suggest to remove this default mapping at all.

Support for Vue Single-File Components

I'd love to have support for generating docs inside Vue single-file components. Thanks for your consideration!

Python - No spaces between google doccstring fields

At the moment, when generating docs, I can get the following:

def test(salt, salut2, test: int, salut: str):
    #test comment 2
    #tcomment
    """
    Args: 
    	salt: 
    	salut2: 
    	test: 
    	salut: 
    Returns: 
    
    """
    return "hello"

We can see that that there is no newlines between the starting comments and Args, and between the last parameter and Returns.

I want to be able to add newlines between them.

python: `typed_default_parameter` not generated

using default configuration

Change cpp doxygen style

Hi,

is there a way to configure Neogen to use the triple dash style instead of c-style comments?
Currently the doxygen looks like this:

/**
 * @brief 
 *
 * @param a 
 * @param b 
 * @return 
 */
int add(int a, int b);

My company code style is like this:

/// @brief 
/// @param a 
/// @param b 
/// @return 
int add(int a, int b);

Thank you for this great plugin!

cursor jumpable if jumping before annotation

def test(salut: int):
    """
    salut: int
    	
    """
    pass

If my cursor is on test, and I generate the annotations, and if I jump until the previous cursor position, I can still jump back to the annotations. (try with python)

Add support for java

Auto-detect annotation types

vim-doge doesn't need to specify the type to annotate.
Could we have similar features?

input_after_comment doesn't work

input_after_comment = true doesn't work for me.

https://github.com/danymat/neogen/blob/main/lua/neogen.lua#L59 #data is 0 when I generate the documentation for C. And it is already 0 at https://github.com/danymat/neogen/blob/main/lua/neogen.lua#L45

Allow generation for types after cursor

For example, if the cursor is at the beginning of a line starts with some whitespace:

    int foo();

I'll need to move the cursor to int or further to call Neogen.

An inline forward search may solve this problem.

support for tsx files

not sure if I'm missing some configuration, but the plugin does not seem to work with tsx files (filetype=typescriptreact).

If I manually change the filetype to typescript it correctly adds an annotation.

treesitter is working correctly on both filetypes.

Add support for automatic types in generated doc (typescript)

At the moment I have this:

/**
 * @param {any} obj 
 * @param {any} salut 
 * @returns {}
 */
function wrapInArray(obj: string | string[], salut?:string) {
  if (typeof obj === "string") {
    return [obj];
            
  }
  return obj;
}

I want to have the types found with tree sitter in the annotation, like so:

/**
 * @param {string|string[]} obj 
 * @param {string} salut 
 * @returns {string}
 */

I'm exposing tree-sitter to help in developing this feature

Add template type for cpp

Quick example for testing: https://github.com/crow-translate/crow-> translate/blob/400c2432e37f64e7c65b5fd87add02ce5b34a005/src/mainwindow.h#L159>

Should contains tparam.

Is it supposed to supercharge a function ?

I get this from Treesitter:

If it's a type by it's own, I can create a new type for this, called template (see https://github.com/danymat/neogen#usage for more details about types in neogen)

Originally posted by @danymat in #19 (comment)

Command API

I would suggest to add :Generate command with possibility to pass an argument for type, like func.

Return types in C++

Issue description

Currently the plugin generates @returns for return_statement. But sometimes it doesn't work.

Examples

No return type:

    /**
     * @brief Cancel translation operation (if any).
     */
    void abort();

Return type present.

    /**
     * @brief Check translation progress
     *
     * @return `true` when the translation is still processing and has not finished or was aborted yet.
     */
    bool isRunning() const;

Additional notes

Doxygen understands @return and @returns. But I would suggest to go with @return, since @returns is just an alias to @return.

cpp: struct not treathed as class

In c++ language the struct is basically class with all members marked as public by default.

But neogen doesn't annotate struct as class.

Treesitter parse structs as struct_specifier but neogen annotates only class_specifier nodes as classes.
For c++ languages neogen should threat also struct_specifier nodes as classes.

Sorry for my cryptic english but I suppose you got a point here :D

Thank you.

Add more languages support !

Hello, in effort to target more users and improve the plugin, I will add more languages support than those currently in place.

I use this survey to prioritize support: https://insights.stackoverflow.com/survey/2021#technology-most-popular-technologies

This is currently in TODO:

• Rust (new support)
• JavaScript/Typescript (add support for missing types)
• Java (add support for missing types)
• C# (new support)
• Python (add support for missing types)
• C++ (add support for missing types)
• PHP (new support)
• C (add support for missing types)
• Go (new support)
• Ruby (new support)
• Bash (new support)
• Kotlin (new support kdoc)
• Groovy (new support)

Add support for multiple cursor position on same line

At the moment I support only a single cursor position on each line. I want to be able to support as many as I want in a line.

Add support for C++

The plugin is currently supports C, can we enable it for C++?

Rust support

It would be nice to support it.

Add support for S-TAB

Error while using custom options

Hey, I'm getting the following error when trying to use neogen.

E5108: Error executing lua ...m/site/pack/packer/start/neogen/lua/neogen/generator.lua:170: attempt to index field 'parent' (a nil value)            
stack traceback:
        ...m/site/pack/packer/start/neogen/lua/neogen/generator.lua:170: in function <...m/site/pack/packer/start/neogen/lua/neogen/generator.lua:158>
        ...e/nvim/site/pack/packer/start/neogen/lua/neogen/init.lua:133: in function 'generate'
        [string ":lua"]:1: in main chunk

I'm not sure if it's a bug or an issue with my config.

lua configuration: function annotation doesn't work for all cases

:Neogen func currently only works in this case for me

local a = function(b, c)
end

I added function_declaration to the list in https://github.com/danymat/neogen/blob/main/lua/neogen/configurations/lua.lua and make theses work

local function a(b,c)
end

function a(b, c)
end

The last case is a = function(b,c) end also doesn't work. The node for it is function_definition but in the configuration file it is limited to 'local' type only. Is this intentional?

For context, I'm using Neovim v0.6.1 and TreeSitter v0.20.4 in Alpine. I'm not familiar with Treesitter so this issue might be just my confusion. Sorry if that is the case!