commit 351cec5db3b7ca839779316a8b7c524ea8941f0f · pyrox.dev/nixpkgs

+10 -5

doc/languages-frameworks/lua.section.md

···

       129
       129
        
       ### Packaging a library on luarocks {#packaging-a-library-on-luarocks}

     

       130
       130
        
       

     

       131
       131
        
       [Luarocks.org](https://luarocks.org/) is the main repository of lua packages.

     

       132
       132
       -
       The site proposes two types of packages, the rockspec and the src.rock

     

       132
       132
       +
       The site proposes two types of packages, the `rockspec` and the `src.rock`

     

       133
       133
        
       (equivalent of a [rockspec](https://github.com/luarocks/luarocks/wiki/Rockspec-format) but with the source).

     

       134
       134
       -
       These packages can have different build types such as `cmake`, `builtin` etc .

     

       134
       134
       +
       

     

       135
       135
       +
       Luarocks-based packages are generated in [pkgs/development/lua-modules/generated-packages.nix](https://github.com/NixOS/nixpkgs/tree/master/pkgs/development/lua-modules/generated-packages.nix) from

     

       136
       136
       +
       the whitelist maintainers/scripts/luarocks-packages.csv and updated by running

     

       137
       137
       +
       the script

     

       138
       138
       +
       [maintainers/scripts/update-luarocks-packages](https://github.com/NixOS/nixpkgs/tree/master/maintainers/scripts/update-luarocks-packages):

     

       135
       139
        
       

     

       136
       136
       -
       Luarocks-based packages are generated in pkgs/development/lua-modules/generated-packages.nix from

     

       137
       137
       -
       the whitelist maintainers/scripts/luarocks-packages.csv and updated by running maintainers/scripts/update-luarocks-packages.

     

       140
       140
       +
       ```sh

     

       141
       141
       +
       ./maintainers/scripts/update-luarocks-packages update

     

       142
       142
       +
       ```

     

       138
       143
        
       

     

       139
       144
        
       [luarocks2nix](https://github.com/nix-community/luarocks) is a tool capable of generating nix derivations from both rockspec and src.rock (and favors the src.rock).

     

       140
       145
        
       The automation only goes so far though and some packages need to be customized.

     

       141
       141
       -
       These customizations go in `pkgs/development/lua-modules/overrides.nix`.

     

       146
       146
       +
       These customizations go in [pkgs/development/lua-modules/overrides.nix](https://github.com/NixOS/nixpkgs/tree/master/pkgs/development/lua-modules/overrides.nix).

     

       142
       147
        
       For instance if the rockspec defines `external_dependencies`, these need to be manually added to the overrides.nix.

     

       143
       148
        
       

     

       144
       149
        
       You can try converting luarocks packages to nix packages with the command `nix-shell -p luarocks-nix` and then `luarocks nix PKG_NAME`.

+2 -2

doc/languages-frameworks/vim.section.md

···

212
212

213
213

## Adding new plugins to nixpkgs {#adding-new-plugins-to-nixpkgs}

214
214

215
215
-
Nix expressions for Vim plugins are stored in [pkgs/applications/editors/vim/plugins](https://github.com/NixOS/nixpkgs/tree/master/pkgs/applications/editors/vim/plugins). For the vast majority of plugins, Nix expressions are automatically generated by running [`./update.py`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/update.py). This creates a [generated.nix](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/generated.nix) file based on the plugins listed in [vim-plugin-names](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/vim-plugin-names). Plugins are listed in alphabetical order in `vim-plugin-names` using the format `[github username]/[repository]@[gitref]`. For example https://github.com/scrooloose/nerdtree becomes `scrooloose/nerdtree`.

215
215
+
Nix expressions for Vim plugins are stored in [pkgs/applications/editors/vim/plugins](https://github.com/NixOS/nixpkgs/tree/master/pkgs/applications/editors/vim/plugins). For the vast majority of plugins, Nix expressions are automatically generated by running [`./update.py`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/update.py). This creates a [generated.nix](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/generated.nix) file based on the plugins listed in [vim-plugin-names](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/vim-plugin-names).

216
216

217
217

After running `./update.py`, if nvim-treesitter received an update, also run [`nvim-treesitter/update.py`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/update.py) to update the tree sitter grammars for `nvim-treesitter`.

218
218

···

226
226

227
227

Sometimes plugins require an override that must be changed when the plugin is updated. This can cause issues when Vim plugins are auto-updated but the associated override isn't updated. For these plugins, the override should be written so that it specifies all information required to install the plugin, and running `./update.py` doesn't change the derivation for the plugin. Manually updating the override is required to update these types of plugins. An example of such a plugin is `LanguageClient-neovim`.

228
228

229
229
-
To add a new plugin, run `./update.py --add "[owner]/[name]"`. **NOTE**: This script automatically commits to your git repository. Be sure to check out a fresh branch before running.

229
229
+
To add a new plugin, run `./update.py add "[owner]/[name]"`. **NOTE**: This script automatically commits to your git repository. Be sure to check out a fresh branch before running.

230
230

231
231

Finally, there are some plugins that are also packaged in nodePackages because they have Javascript-related build steps, such as running webpack. Those plugins are not listed in `vim-plugin-names` or managed by `update.py` at all, and are included separately in `overrides.nix`. Currently, all these plugins are related to the `coc.nvim` ecosystem of the Language Server Protocol integration with Vim/Neovim.

232
232

+90 -37

maintainers/scripts/pluginupdate.py

···

       1
       1
       -
       # Used by pkgs/applications/editors/vim/plugins/update.py and pkgs/applications/editors/kakoune/plugins/update.py

     

       1
       1
       +
       # python library used to update plugins:

     

       2
       2
       +
       # - pkgs/applications/editors/vim/plugins/update.py

     

       3
       3
       +
       # - pkgs/applications/editors/kakoune/plugins/update.py

     

       4
       4
       +
       # - maintainers/scripts/update-luarocks-packages

     

       2
       5
        
       

     

       3
       6
        
       # format:

     

       4
       7
        
       # $ nix run nixpkgs.python3Packages.black -c black update.py

     
···

       315
       318
        
           with CleanEnvironment():

     

       316
       319
        
               cmd = ["nix", "eval", "--extra-experimental-features",

     

       317
       320
        
                       "nix-command", "--impure", "--json", "--expr", expr]

     

       318
       318
       -
               log.debug("Running command %s", cmd)

     

       321
       321
       +
               log.debug("Running command %s", " ".join(cmd))

     

       319
       322
        
               out = subprocess.check_output(cmd)

     

       320
       320
       -
           data = json.loads(out)

     

       321
       321
       -
           return data

     

       323
       323
       +
               data = json.loads(out)

     

       324
       324
       +
               return data

     

       322
       325
        
       

     

       323
       326
        
       

     

       324
       327
        
       class Editor:

     
···

       344
       347
        
               self.cache_file = cache_file or f"{name}-plugin-cache.json"

     

       345
       348
        
               self.nixpkgs_repo = None

     

       346
       349
        
       

     

       350
       350
       +
           def add(self, args):

     

       351
       351
       +
               '''CSV spec'''

     

       352
       352
       +
               log.debug("called the 'add' command")

     

       353
       353
       +
               fetch_config = FetchConfig(args.proc, args.github_token)

     

       354
       354
       +
               editor = self

     

       355
       355
       +
               for plugin_line in args.add_plugins:

     

       356
       356
       +
                   log.debug("using plugin_line", plugin_line)

     

       357
       357
       +
                   pdesc = PluginDesc.load_from_string(fetch_config, plugin_line)

     

       358
       358
       +
                   log.debug("loaded as pdesc", pdesc)

     

       359
       359
       +
                   append = [ pdesc ]

     

       360
       360
       +
                   editor.rewrite_input(fetch_config, args.input_file, editor.deprecated, append=append)

     

       361
       361
       +
                   plugin, _ = prefetch_plugin(pdesc, )

     

       362
       362
       +
                   autocommit = not args.no_commit

     

       363
       363
       +
                   if autocommit:

     

       364
       364
       +
                       commit(

     

       365
       365
       +
                           editor.nixpkgs_repo,

     

       366
       366
       +
                           "{drv_name}: init at {version}".format(

     

       367
       367
       +
                               drv_name=editor.get_drv_name(plugin.normalized_name),

     

       368
       368
       +
                               version=plugin.version

     

       369
       369
       +
                           ),

     

       370
       370
       +
                           [args.outfile, args.input_file],

     

       371
       371
       +
                       )

     

       372
       372
       +
       

     

       373
       373
       +
           # Expects arguments generated by 'update' subparser

     

       374
       374
       +
           def update(self, args ):

     

       375
       375
       +
               '''CSV spec'''

     

       376
       376
       +
               print("the update member function should be overriden in subclasses")

     

       377
       377
       +
       

     

       347
       378
        
           def get_current_plugins(self) -> List[Plugin]:

     

       348
       379
        
               """To fill the cache"""

     

       349
       380
        
               data = run_nix_expr(self.get_plugins)

     

       350
       381
        
               plugins = []

     

       351
       382
        
               for name, attr in data.items():

     

       352
       352
       -
                   print("get_current_plugins: name %s" % name)

     

       353
       383
        
                   p = Plugin(name, attr["rev"], attr["submodules"], attr["sha256"])

     

       354
       384
        
                   plugins.append(p)

     

       355
       385
        
               return plugins

     
···

       358
       388
        
               '''CSV spec'''

     

       359
       389
        
               return load_plugins_from_csv(config, plugin_file)

     

       360
       390
        
       

     

       361
       361
       -
           def generate_nix(self, plugins, outfile: str):

     

       391
       391
       +
           def generate_nix(self, _plugins, _outfile: str):

     

       362
       392
        
               '''Returns nothing for now, writes directly to outfile'''

     

       363
       393
        
               raise NotImplementedError()

     

       364
       394
        
       

     
···

       395
       425
        
               return rewrite_input(*args, **kwargs)

     

       396
       426
        
       

     

       397
       427
        
           def create_parser(self):

     

       398
       398
       -
               parser = argparse.ArgumentParser(

     

       428
       428
       +
               common = argparse.ArgumentParser(

     

       429
       429
       +
                   add_help=False,

     

       399
       430
        
                   description=(f"""

     

       400
       431
        
                       Updates nix derivations for {self.name} plugins.\n

     

       401
       432
        
                       By default from {self.default_in} to {self.default_out}"""

     

       402
       433
        
                   )

     

       403
       434
        
               )

     

       404
       404
       -
               parser.add_argument(

     

       405
       405
       -
                   "--add",

     

       406
       406
       -
                   dest="add_plugins",

     

       407
       407
       -
                   default=[],

     

       408
       408
       -
                   action="append",

     

       409
       409
       -
                   help=f"Plugin to add to {self.attr_path} from Github in the form owner/repo",

     

       410
       410
       -
               )

     

       411
       411
       -
               parser.add_argument(

     

       435
       435
       +
               common.add_argument(

     

       412
       436
        
                   "--input-names",

     

       413
       437
        
                   "-i",

     

       414
       438
        
                   dest="input_file",

     

       415
       439
        
                   default=self.default_in,

     

       416
       440
        
                   help="A list of plugins in the form owner/repo",

     

       417
       441
        
               )

     

       418
       418
       -
               parser.add_argument(

     

       442
       442
       +
               common.add_argument(

     

       419
       443
        
                   "--out",

     

       420
       444
        
                   "-o",

     

       421
       445
        
                   dest="outfile",

     

       422
       446
        
                   default=self.default_out,

     

       423
       447
        
                   help="Filename to save generated nix code",

     

       424
       448
        
               )

     

       425
       425
       -
               parser.add_argument(

     

       449
       449
       +
               common.add_argument(

     

       426
       450
        
                   "--proc",

     

       427
       451
        
                   "-p",

     

       428
       452
        
                   dest="proc",

     
···

       430
       454
        
                   default=30,

     

       431
       455
        
                   help="Number of concurrent processes to spawn. Setting --github-token allows higher values.",

     

       432
       456
        
               )

     

       433
       433
       -
               parser.add_argument(

     

       457
       457
       +
               common.add_argument(

     

       434
       458
        
                   "--github-token",

     

       435
       459
        
                   "-t",

     

       436
       460
        
                   type=str,

     
···

       438
       462
        
                   help="""Allows to set --proc to higher values.

     

       439
       463
        
                   Uses GITHUB_API_TOKEN environment variables as the default value.""",

     

       440
       464
        
               )

     

       441
       441
       -
               parser.add_argument(

     

       465
       465
       +
               common.add_argument(

     

       442
       466
        
                   "--no-commit", "-n", action="store_true", default=False,

     

       443
       467
        
                   help="Whether to autocommit changes"

     

       444
       468
        
               )

     

       445
       445
       -
               parser.add_argument(

     

       469
       469
       +
               common.add_argument(

     

       446
       470
        
                   "--debug", "-d", choices=LOG_LEVELS.keys(),

     

       447
       471
        
                   default=logging.getLevelName(logging.WARN),

     

       448
       472
        
                   help="Adjust log level"

     

       449
       473
        
               )

     

       450
       450
       -
               return parser

     

       474
       474
       +
       

     

       475
       475
       +
               main = argparse.ArgumentParser(

     

       476
       476
       +
                   parents=[common],

     

       477
       477
       +
                   description=(f"""

     

       478
       478
       +
                       Updates nix derivations for {self.name} plugins.\n

     

       479
       479
       +
                       By default from {self.default_in} to {self.default_out}"""

     

       480
       480
       +
                   )

     

       481
       481
       +
               )

     

       482
       482
       +
       

     

       483
       483
       +
               subparsers = main.add_subparsers(dest="command", required=False)

     

       484
       484
       +
               padd = subparsers.add_parser(

     

       485
       485
       +
                   "add", parents=[],

     

       486
       486
       +
                   description="Add new plugin",

     

       487
       487
       +
                   add_help=False,

     

       488
       488
       +
               )

     

       489
       489
       +
               padd.set_defaults(func=self.add)

     

       490
       490
       +
               padd.add_argument(

     

       491
       491
       +
                   "add_plugins",

     

       492
       492
       +
                   default=None,

     

       493
       493
       +
                   nargs="+",

     

       494
       494
       +
                   help=f"Plugin to add to {self.attr_path} from Github in the form owner/repo",

     

       495
       495
       +
               )

     

       496
       496
       +
       

     

       497
       497
       +
               pupdate = subparsers.add_parser(

     

       498
       498
       +
                   "update",

     

       499
       499
       +
                   description="Update all or a subset of existing plugins",

     

       500
       500
       +
                   add_help=False,

     

       501
       501
       +
               )

     

       502
       502
       +
               pupdate.set_defaults(func=self.update)

     

       503
       503
       +
               return main

     

       504
       504
       +
       

     

       505
       505
       +
           def run(self,):

     

       506
       506
       +
               '''

     

       507
       507
       +
               Convenience function

     

       508
       508
       +
               '''

     

       509
       509
       +
               parser = self.create_parser()

     

       510
       510
       +
               args = parser.parse_args()

     

       511
       511
       +
               command = args.command or "update"

     

       512
       512
       +
               log.setLevel(LOG_LEVELS[args.debug])

     

       513
       513
       +
               log.info("Chose to run command: %s", command)

     

       514
       514
       +
       

     

       515
       515
       +
               if not args.no_commit:

     

       516
       516
       +
                   self.nixpkgs_repo = git.Repo(self.root, search_parent_directories=True)

     

       517
       517
       +
       

     

       518
       518
       +
               getattr(self, command)(args)

     

       519
       519
       +
       

     

       451
       520
        
       

     

       452
       521
        
       

     

       453
       522
        
       

     
···

       661
       730
        
       def update_plugins(editor: Editor, args):

     

       662
       731
        
           """The main entry function of this module. All input arguments are grouped in the `Editor`."""

     

       663
       732
        
       

     

       664
       664
       -
           log.setLevel(LOG_LEVELS[args.debug])

     

       665
       733
        
           log.info("Start updating plugins")

     

       666
       734
        
           fetch_config = FetchConfig(args.proc, args.github_token)

     

       667
       735
        
           update = editor.get_update(args.input_file, args.outfile, fetch_config)

     
···

       684
       752
        
                       [args.outfile, args.input_file, editor.deprecated],

     

       685
       753
        
                   )

     

       686
       754
        
       

     

       687
       687
       -
           for plugin_line in args.add_plugins:

     

       688
       688
       -
               pdesc = PluginDesc.load_from_string(fetch_config, plugin_line)

     

       689
       689
       -
               append = [ pdesc ]

     

       690
       690
       -
               editor.rewrite_input(fetch_config, args.input_file, editor.deprecated, append=append)

     

       691
       691
       -
               update()

     

       692
       692
       -
               plugin, _ = prefetch_plugin(pdesc, )

     

       693
       693
       -
               if autocommit:

     

       694
       694
       -
                   commit(

     

       695
       695
       -
                       editor.nixpkgs_repo,

     

       696
       696
       -
                       "{drv_name}: init at {version}".format(

     

       697
       697
       -
                           drv_name=editor.get_drv_name(plugin.normalized_name),

     

       698
       698
       -
                           version=plugin.version

     

       699
       699
       -
                       ),

     

       700
       700
       -
                       [args.outfile, args.input_file],

     

       701
       701
       -
                   )

+1 -5

maintainers/scripts/update-luarocks-packages

···

       203
       203
        
               default_out = ROOT.joinpath(GENERATED_NIXFILE)

     

       204
       204
        
               )

     

       205
       205
        
       

     

       206
       206
       -
           parser = editor.create_parser()

     

       207
       207
       -
           args = parser.parse_args()

     

       208
       208
       -
       

     

       209
       209
       -
           update_plugins(editor, args)

     

       210
       210
       -
       

     

       206
       206
       +
       	editor.run()

     

       211
       207
        
       

     

       212
       208
        
       if __name__ == "__main__":

     

       213
       209

+1 -4

pkgs/applications/editors/kakoune/plugins/update.py

···

       81
       81
        
       

     

       82
       82
        
       def main():

     

       83
       83
        
           editor = KakouneEditor("kakoune", ROOT, GET_PLUGINS)

     

       84
       84
       -
           parser = editor.create_parser()

     

       85
       85
       -
           args = parser.parse_args()

     

       86
       86
       -
       

     

       87
       87
       -
           pluginupdate.update_plugins(editor, args)

     

       84
       84
       +
           editor.run()

     

       88
       85
        
       

     

       89
       86
        
       

     

       90
       87
        
       if __name__ == "__main__":

+19

pkgs/applications/editors/vim/plugins/get-plugins.nix

···

       1
       1
       +
       with import <localpkgs> {};

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (vimUtils.override {inherit vim;}) buildVimPluginFrom2Nix;

     

       4
       4
       +
         inherit (neovimUtils) buildNeovimPluginFrom2Nix;

     

       5
       5
       +
       

     

       6
       6
       +
         generated = callPackage <localpkgs/pkgs/applications/editors/vim/plugins/generated.nix> {

     

       7
       7
       +
           inherit buildNeovimPluginFrom2Nix buildVimPluginFrom2Nix;

     

       8
       8
       +
         } {} {};

     

       9
       9
       +
         hasChecksum = value:

     

       10
       10
       +
           lib.isAttrs value && lib.hasAttrByPath ["src" "outputHash"] value;

     

       11
       11
       +
         getChecksum = name: value:

     

       12
       12
       +
           if hasChecksum value then {

     

       13
       13
       +
             submodules = value.src.fetchSubmodules or false;

     

       14
       14
       +
             sha256 = value.src.outputHash;

     

       15
       15
       +
             rev = value.src.rev;

     

       16
       16
       +
           } else null;

     

       17
       17
       +
         checksums = lib.mapAttrs getChecksum generated;

     

       18
       18
       +
       in

     

       19
       19
       +
         lib.filterAttrs (n: v: v != null) checksums

+27 -36

pkgs/applications/editors/vim/plugins/update.py

···

       42
       42
        
       import pluginupdate

     

       43
       43
        
       from pluginupdate import run_nix_expr, PluginDesc

     

       44
       44
        
       

     

       45
       45
       -
       GET_PLUGINS = f"""(with import <localpkgs> {{}};

     

       46
       46
       -
       let

     

       47
       47
       -
         inherit (vimUtils.override {{inherit vim;}}) buildNeovimPluginFrom2Nix buildVimPluginFrom2Nix;

     

       48
       48
       -
         generated = callPackage {ROOT}/generated.nix {{

     

       49
       49
       -
           inherit buildNeovimPluginFrom2Nix buildVimPluginFrom2Nix;

     

       50
       50
       -
         }};

     

       51
       51
       -
         hasChecksum = value: lib.isAttrs value && lib.hasAttrByPath ["src" "outputHash"] value;

     

       52
       52
       -
         getChecksum = name: value:

     

       53
       53
       -
           if hasChecksum value then {{

     

       54
       54
       -
             submodules = value.src.fetchSubmodules or false;

     

       55
       55
       -
             sha256 = value.src.outputHash;

     

       56
       56
       -
             rev = value.src.rev;

     

       57
       57
       -
           }} else null;

     

       58
       58
       -
         checksums = lib.mapAttrs getChecksum generated;

     

       59
       59
       -
       in lib.filterAttrs (n: v: v != null) checksums)"""

     

       45
       45
       +
       

     

       60
       46
        
       

     

       61
       47
        
       GET_PLUGINS_LUA = """

     

       62
       48
        
       with import <localpkgs> {};

     

       63
       49
        
       lib.attrNames lua51Packages"""

     

       64
       50
        
       

     

       65
       51
        
       HEADER = (

     

       66
       66
       -
           "# This file has been generated by ./pkgs/applications/editors/vim/plugins/update.py. Do not edit!"

     

       52
       52
       +
           "# GENERATED by ./pkgs/applications/editors/vim/plugins/update.py. Do not edit!"

     

       67
       53
        
       )

     

       68
       54
        
       

     

       69
       55
        
       def isNeovimPlugin(plug: pluginupdate.Plugin) -> bool:

     
···

       118
       104
        
       

     

       119
       105
        
       """.format(

     

       120
       106
        
               buildFn="buildNeovimPluginFrom2Nix" if isNeovim else "buildVimPluginFrom2Nix", plugin=plugin, src_nix=src_nix, repo=repo)

     

       121
       121
       -
               print(content)

     

       107
       107
       +
               log.debug(content)

     

       122
       108
        
               return content

     

       109
       109
       +
       

     

       110
       110
       +
       

     

       111
       111
       +
           def update(self, args):

     

       112
       112
       +
               pluginupdate.update_plugins(self, args)

     

       113
       113
       +
       

     

       114
       114
       +
               if self.nvim_treesitter_updated:

     

       115
       115
       +
                   print("updating nvim-treesitter grammars")

     

       116
       116
       +
                   nvim_treesitter_dir = ROOT.joinpath("nvim-treesitter")

     

       117
       117
       +
                   subprocess.check_call([nvim_treesitter_dir.joinpath("update.py")])

     

       118
       118
       +
       

     

       119
       119
       +
                   if self.nixpkgs_repo:

     

       120
       120
       +
                       index = self.nixpkgs_repo.index

     

       121
       121
       +
                       for diff in index.diff(None):

     

       122
       122
       +
                           if diff.a_path == "pkgs/applications/editors/vim/plugins/nvim-treesitter/generated.nix":

     

       123
       123
       +
                               msg = "vimPlugins.nvim-treesitter: update grammars"

     

       124
       124
       +
                               print(f"committing to nixpkgs: {msg}")

     

       125
       125
       +
                               index.add([str(nvim_treesitter_dir.joinpath("generated.nix"))])

     

       126
       126
       +
                               index.commit(msg)

     

       127
       127
       +
                               return

     

       128
       128
       +
                       print("no updates to nvim-treesitter grammars")

     

       129
       129
       +
       

     

       123
       130
        
       

     

       124
       131
        
       def main():

     

       125
       132
        
       

     

       126
       133
        
           global luaPlugins

     

       127
       134
        
           luaPlugins = run_nix_expr(GET_PLUGINS_LUA)

     

       128
       135
        
       

     

       136
       136
       +
           with open(f"{ROOT}/get-plugins.nix") as f:

     

       137
       137
       +
               GET_PLUGINS = f.read()

     

       129
       138
        
           editor = VimEditor("vim", ROOT, GET_PLUGINS)

     

       130
       130
       -
           parser = editor.create_parser()

     

       131
       131
       -
           args = parser.parse_args()

     

       132
       132
       -
           pluginupdate.update_plugins(editor, args)

     

       133
       133
       -
       

     

       134
       134
       -
           if editor.nvim_treesitter_updated:

     

       135
       135
       -
               print("updating nvim-treesitter grammars")

     

       136
       136
       -
               nvim_treesitter_dir = ROOT.joinpath("nvim-treesitter")

     

       137
       137
       -
               subprocess.check_call([nvim_treesitter_dir.joinpath("update.py")])

     

       138
       138
       -
       

     

       139
       139
       -
               if editor.nixpkgs_repo:

     

       140
       140
       -
                   index = editor.nixpkgs_repo.index

     

       141
       141
       -
                   for diff in index.diff(None):

     

       142
       142
       -
                       if diff.a_path == "pkgs/applications/editors/vim/plugins/nvim-treesitter/generated.nix":

     

       143
       143
       -
                           msg = "vimPlugins.nvim-treesitter: update grammars"

     

       144
       144
       -
                           print(f"committing to nixpkgs: {msg}")

     

       145
       145
       -
                           index.add([str(nvim_treesitter_dir.joinpath("generated.nix"))])

     

       146
       146
       -
                           index.commit(msg)

     

       147
       147
       -
                           return

     

       148
       148
       -
                   print("no updates to nvim-treesitter grammars")

     

       139
       139
       +
           editor.run()

     

       149
       140
        
       

     

       150
       141
        
       

     

       151
       142
        
       if __name__ == "__main__":