commit ecee72e2475c5ca4ccce98d5b7e59fe30d2daa2c · pyrox.dev/nixpkgs

+6 -1

doc/languages-frameworks/vim.section.md

···

       264
       264
        
       Alternatively, set the number of processes to a lower count to avoid rate-limiting.

     

       265
       265
        
       

     

       266
       266
        
       ```sh

     

       267
       267
       +
       nix-shell -p vimPluginsUpdater --run 'vim-plugins-updater --proc 1'

     

       268
       268
       +
       ```

     

       269
       269
       +
       

     

       270
       270
       +
       If you want to update only certain plugins, you can specify them after the `update` command. Note that you must use the same plugin names as the `pkgs/applications/editors/vim/plugins/vim-plugin-names` file.

     

       267
       271
        
       

     

       268
       268
       -
       nix-shell -p vimPluginsUpdater --run 'vim-plugins-updater --proc 1'

     

       272
       272
       +
       ```sh

     

       273
       273
       +
       nix-shell -p vimPluginsUpdater --run 'vim-plugins-updater update "nvim-treesitter" "LazyVim"'

     

       269
       274
        
       ```

     

       270
       275
        
       

     

       271
       276
        
       ## How to maintain an out-of-tree overlay of vim plugins ? {#vim-out-of-tree-overlays}

+145 -12

maintainers/scripts/pluginupdate-py/pluginupdate.py

···

       388
       388
        
                       fetch_config, args.input_file, editor.deprecated, append=append

     

       389
       389
        
                   )

     

       390
       390
        
                   plugin, _ = prefetch_plugin(pdesc)

     

       391
       391
       +
       

     

       392
       392
       +
                   if (  # lua updater doesn't support updating individual plugin

     

       393
       393
       +
                       self.name != "lua"

     

       394
       394
       +
                   ):

     

       395
       395
       +
                       # update generated.nix

     

       396
       396
       +
                       update = self.get_update(

     

       397
       397
       +
                           args.input_file,

     

       398
       398
       +
                           args.outfile,

     

       399
       399
       +
                           fetch_config,

     

       400
       400
       +
                           [plugin.normalized_name],

     

       401
       401
       +
                       )

     

       402
       402
       +
                       update()

     

       403
       403
       +
       

     

       391
       404
        
                   autocommit = not args.no_commit

     

       392
       405
        
                   if autocommit:

     

       393
       406
        
                       commit(

     
···

       404
       417
        
               """CSV spec"""

     

       405
       418
        
               print("the update member function should be overridden in subclasses")

     

       406
       419
        
       

     

       407
       407
       -
           def get_current_plugins(self, nixpkgs: str) -> List[Plugin]:

     

       420
       420
       +
           def get_current_plugins(

     

       421
       421
       +
               self, config: FetchConfig, nixpkgs: str

     

       422
       422
       +
           ) -> List[Tuple[PluginDesc, Plugin]]:

     

       408
       423
        
               """To fill the cache"""

     

       409
       424
        
               data = run_nix_expr(self.get_plugins, nixpkgs)

     

       410
       425
        
               plugins = []

     

       411
       426
        
               for name, attr in data.items():

     

       412
       412
       -
                   p = Plugin(name, attr["rev"], attr["submodules"], attr["sha256"])

     

       413
       413
       -
                   plugins.append(p)

     

       427
       427
       +
                   checksum = attr["checksum"]

     

       428
       428
       +
       

     

       429
       429
       +
                   # https://github.com/NixOS/nixpkgs/blob/8a335419/pkgs/applications/editors/neovim/build-neovim-plugin.nix#L36

     

       430
       430
       +
                   # https://github.com/NixOS/nixpkgs/pull/344478#discussion_r1786646055

     

       431
       431
       +
                   version = re.search(r"\d\d\d\d-\d\d?-\d\d?", attr["version"])

     

       432
       432
       +
                   if version is None:

     

       433
       433
       +
                       raise ValueError(f"Cannot parse version: {attr['version']}")

     

       434
       434
       +
                   date = datetime.strptime(version.group(), "%Y-%m-%d")

     

       435
       435
       +
       

     

       436
       436
       +
                   pdesc = PluginDesc.load_from_string(config, f'{attr["homePage"]} as {name}')

     

       437
       437
       +
                   p = Plugin(

     

       438
       438
       +
                       attr["pname"],

     

       439
       439
       +
                       checksum["rev"],

     

       440
       440
       +
                       checksum["submodules"],

     

       441
       441
       +
                       checksum["sha256"],

     

       442
       442
       +
                       date,

     

       443
       443
       +
                   )

     

       444
       444
       +
       

     

       445
       445
       +
                   plugins.append((pdesc, p))

     

       414
       446
        
               return plugins

     

       415
       447
        
       

     

       416
       448
        
           def load_plugin_spec(self, config: FetchConfig, plugin_file) -> List[PluginDesc]:

     
···

       421
       453
        
               """Returns nothing for now, writes directly to outfile"""

     

       422
       454
        
               raise NotImplementedError()

     

       423
       455
        
       

     

       424
       424
       -
           def get_update(self, input_file: str, outfile: str, config: FetchConfig):

     

       425
       425
       -
               cache: Cache = Cache(self.get_current_plugins(self.nixpkgs), self.cache_file)

     

       456
       456
       +
           def filter_plugins_to_update(

     

       457
       457
       +
               self, plugin: PluginDesc, to_update: List[str]

     

       458
       458
       +
           ) -> bool:

     

       459
       459
       +
               """Function for filtering out plugins, that user doesn't want to update.

     

       460
       460
       +
       

     

       461
       461
       +
               It is mainly used for updating only specific plugins, not all of them.

     

       462
       462
       +
               By default it filters out plugins not present in `to_update`,

     

       463
       463
       +
               assuming `to_update` is a list of plugin names (the same as in the

     

       464
       464
       +
               result expression).

     

       465
       465
       +
       

     

       466
       466
       +
               This function is never called if `to_update` is empty.

     

       467
       467
       +
               Feel free to override this function in derived classes.

     

       468
       468
       +
       

     

       469
       469
       +
               Note:

     

       470
       470
       +
                   Known bug: you have to use a deprecated name, instead of new one.

     

       471
       471
       +
                   This is because we resolve deprecations later and can't get new

     

       472
       472
       +
                   plugin URL before we request info about it.

     

       473
       473
       +
       

     

       474
       474
       +
                   Although, we could parse deprecated.json, but it's a whole bunch

     

       475
       475
       +
                   of spaghetti code, which I don't want to write.

     

       476
       476
       +
       

     

       477
       477
       +
               Arguments:

     

       478
       478
       +
                   plugin: Plugin on which you decide whether to ignore or not.

     

       479
       479
       +
                   to_update:

     

       480
       480
       +
                       List of strings passed to via the `--update` command line parameter.

     

       481
       481
       +
                       By default, we assume it is a list of URIs identical to what

     

       482
       482
       +
                       is in the input file.

     

       483
       483
       +
       

     

       484
       484
       +
               Returns:

     

       485
       485
       +
                   True if we should update plugin and False if not.

     

       486
       486
       +
               """

     

       487
       487
       +
               return plugin.name.replace(".", "-") in to_update

     

       488
       488
       +
       

     

       489
       489
       +
           def get_update(

     

       490
       490
       +
               self,

     

       491
       491
       +
               input_file: str,

     

       492
       492
       +
               output_file: str,

     

       493
       493
       +
               config: FetchConfig,

     

       494
       494
       +
               to_update: Optional[List[str]],

     

       495
       495
       +
           ):

     

       496
       496
       +
               if to_update is None:

     

       497
       497
       +
                   to_update = []

     

       498
       498
       +
       

     

       499
       499
       +
               current_plugins = self.get_current_plugins(config, self.nixpkgs)

     

       500
       500
       +
               current_plugin_specs = self.load_plugin_spec(config, input_file)

     

       501
       501
       +
       

     

       502
       502
       +
               cache: Cache = Cache(

     

       503
       503
       +
                   [plugin for _description, plugin in current_plugins], self.cache_file

     

       504
       504
       +
               )

     

       426
       505
        
               _prefetch = functools.partial(prefetch, cache=cache)

     

       427
       506
        
       

     

       428
       428
       -
               def update() -> dict:

     

       429
       429
       -
                   plugins = self.load_plugin_spec(config, input_file)

     

       507
       507
       +
               plugins_to_update = (

     

       508
       508
       +
                   current_plugin_specs

     

       509
       509
       +
                   if len(to_update) == 0

     

       510
       510
       +
                   else [

     

       511
       511
       +
                       description

     

       512
       512
       +
                       for description in current_plugin_specs

     

       513
       513
       +
                       if self.filter_plugins_to_update(description, to_update)

     

       514
       514
       +
                   ]

     

       515
       515
       +
               )

     

       516
       516
       +
       

     

       517
       517
       +
               def update() -> Redirects:

     

       518
       518
       +
                   if len(plugins_to_update) == 0:

     

       519
       519
       +
                       log.error(

     

       520
       520
       +
                           "\n\n\n\nIt seems like you provided some arguments to `--update`:\n"

     

       521
       521
       +
                           + ", ".join(to_update)

     

       522
       522
       +
                           + "\nBut after filtering, the result list of plugins is empty\n"

     

       523
       523
       +
                           "\n"

     

       524
       524
       +
                           "Are you sure you provided the same URIs as in your input file?\n"

     

       525
       525
       +
                           "(" + str(input_file) + ")\n\n"

     

       526
       526
       +
                       )

     

       527
       527
       +
                       return {}

     

       430
       528
        
       

     

       431
       529
        
                   try:

     

       432
       530
        
                       pool = Pool(processes=config.proc)

     

       433
       433
       -
                       results = pool.map(_prefetch, plugins)

     

       531
       531
       +
                       results = pool.map(_prefetch, plugins_to_update)

     

       434
       532
        
                   finally:

     

       435
       533
        
                       cache.store()

     

       436
       534
        
       

     

       535
       535
       +
                   print(f"{len(results)} of {len(current_plugins)} were checked")

     

       536
       536
       +
                   # Do only partial update of out file

     

       537
       537
       +
                   if len(results) != len(current_plugins):

     

       538
       538
       +
                       results = self.merge_results(current_plugins, results)

     

       437
       539
        
                   plugins, redirects = check_results(results)

     

       438
       540
        
       

     

       439
       541
        
                   plugins = sorted(plugins, key=lambda v: v[1].normalized_name)

     

       440
       440
       -
                   self.generate_nix(plugins, outfile)

     

       542
       542
       +
                   self.generate_nix(plugins, output_file)

     

       441
       543
        
       

     

       442
       544
        
                   return redirects

     

       443
       545
        
       

     

       444
       546
        
               return update

     

       445
       547
        
       

     

       548
       548
       +
           def merge_results(

     

       549
       549
       +
               self,

     

       550
       550
       +
               current: list[Tuple[PluginDesc, Plugin]],

     

       551
       551
       +
               fetched: List[Tuple[PluginDesc, Union[Exception, Plugin], Optional[Repo]]],

     

       552
       552
       +
           ) -> List[Tuple[PluginDesc, Union[Exception, Plugin], Optional[Repo]]]:

     

       553
       553
       +
               # transforming this to dict, so lookup is O(1) instead of O(n) (n is len(current))

     

       554
       554
       +
               result: Dict[

     

       555
       555
       +
                   str, Tuple[PluginDesc, Union[Exception, Plugin], Optional[Repo]]

     

       556
       556
       +
               ] = {

     

       557
       557
       +
                   # also adding redirect (third item in the result tuple)

     

       558
       558
       +
                   pl.normalized_name: (pdesc, pl, None)

     

       559
       559
       +
                   for pdesc, pl in current

     

       560
       560
       +
               }

     

       561
       561
       +
       

     

       562
       562
       +
               for plugin_desc, plugin, redirect in fetched:

     

       563
       563
       +
                   result[plugin.normalized_name] = (plugin_desc, plugin, redirect)

     

       564
       564
       +
       

     

       565
       565
       +
               return list(result.values())

     

       566
       566
       +
       

     

       446
       567
        
           @property

     

       447
       568
        
           def attr_path(self):

     

       448
       569
        
               return self.name + "Plugins"

     
···

       544
       665
        
                   description="Update all or a subset of existing plugins",

     

       545
       666
        
                   add_help=False,

     

       546
       667
        
               )

     

       668
       668
       +
               pupdate.add_argument(

     

       669
       669
       +
                   "update_only",

     

       670
       670
       +
                   default=None,

     

       671
       671
       +
                   nargs="*",

     

       672
       672
       +
                   help="Plugin URLs to update (must be the same as in the input file)",

     

       673
       673
       +
               )

     

       547
       674
        
               pupdate.set_defaults(func=self.update)

     

       548
       675
        
               return main

     

       549
       676
        
       

     
···

       637
       764
        
                       new_pdesc = PluginDesc(redirect, pdesc.branch, pdesc.alias)

     

       638
       765
        
                   plugins.append((new_pdesc, result))

     

       639
       766
        
       

     

       640
       640
       -
           print(f"{len(results) - len(failures)} plugins were checked", end="")

     

       641
       767
        
           if len(failures) == 0:

     

       642
       768
        
               return plugins, redirects

     

       643
       769
        
           else:

     

       644
       644
       -
               log.error(f", {len(failures)} plugin(s) could not be downloaded:\n")

     

       770
       770
       +
               log.error(f"{len(failures)} plugin(s) could not be downloaded:\n")

     

       645
       771
        
       

     

       646
       772
        
               for plugin, exception in failures:

     

       647
       773
        
                   print_download_error(plugin, exception)

     
···

       802
       928
        
               )

     

       803
       929
        
       

     

       804
       930
        
           fetch_config = FetchConfig(args.proc, args.github_token)

     

       805
       805
       -
           update = editor.get_update(args.input_file, args.outfile, fetch_config)

     

       931
       931
       +
           update = editor.get_update(

     

       932
       932
       +
               input_file=args.input_file,

     

       933
       933
       +
               output_file=args.outfile,

     

       934
       934
       +
               config=fetch_config,

     

       935
       935
       +
               to_update=getattr(  # if script was called without arguments

     

       936
       936
       +
                   args, "update_only", None

     

       937
       937
       +
               ),

     

       938
       938
       +
           )

     

       806
       939
        
       

     

       807
       940
        
           start_time = time.time()

     

       808
       941
        
           redirects = update()

+20 -18

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

···

       21
       21
        
       )

     

       22
       22
        
       import pluginupdate

     

       23
       23
        
       

     

       24
       24
       -
       GET_PLUGINS = f"""(

     

       25
       25
       -
       with import <localpkgs> {{ }};

     

       24
       24
       +
       GET_PLUGINS = f"""with import <localpkgs> {{ }};

     

       26
       25
        
       let

     

       27
       26
        
         inherit (kakouneUtils.override {{ }}) buildKakounePluginFrom2Nix;

     

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

     

       29
       29
       -
           inherit buildKakounePluginFrom2Nix;

     

       30
       30
       -
         }};

     

       27
       27
       +
         generated = callPackage {ROOT}/generated.nix {{ inherit buildKakounePluginFrom2Nix; }};

     

       28
       28
       +
       

     

       31
       29
        
         hasChecksum =

     

       32
       30
        
           value:

     

       33
       31
        
           lib.isAttrs value

     
···

       35
       33
        
             "src"

     

       36
       34
        
             "outputHash"

     

       37
       35
        
           ] value;

     

       38
       38
       -
         getChecksum =

     

       39
       39
       -
           name: value:

     

       40
       40
       -
           if hasChecksum value then

     

       41
       41
       -
             {{

     

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

     

       43
       43
       -
               sha256 = value.src.outputHash;

     

       44
       44
       -
               rev = value.src.rev;

     

       45
       45
       -
             }}

     

       46
       46
       -
           else

     

       47
       47
       -
             null;

     

       48
       48
       -
         checksums = lib.mapAttrs getChecksum generated;

     

       36
       36
       +
       

     

       37
       37
       +
         parse = name: value: {{

     

       38
       38
       +
           pname = value.pname;

     

       39
       39
       +
           version = value.version;

     

       40
       40
       +
           homePage = value.meta.homepage;

     

       41
       41
       +
           checksum =

     

       42
       42
       +
             if hasChecksum value then

     

       43
       43
       +
               {{

     

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

     

       45
       45
       +
                 sha256 = value.src.outputHash;

     

       46
       46
       +
                 rev = value.src.rev;

     

       47
       47
       +
               }}

     

       48
       48
       +
             else

     

       49
       49
       +
               null;

     

       50
       50
       +
         }};

     

       49
       51
        
       in

     

       50
       50
       -
       lib.filterAttrs (n: v: v != null) checksums

     

       51
       51
       -
       )"""

     

       52
       52
       +
       lib.mapAttrs parse generated"""

     

       52
       53
        
       

     

       53
       54
        
       HEADER = "# This file has been @generated by ./pkgs/applications/editors/kakoune/plugins/update.py. Do not edit!"

     

       55
       55
       +
       

     

       54
       56
        
       

     

       55
       57
        
       

     

       56
       58
        
       class KakouneEditor(pluginupdate.Editor):

+17 -12

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

···

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

     

       7
       7
        
           inherit buildNeovimPlugin buildVimPlugin;

     

       8
       8
        
         } { } { };

     

       9
       9
       +
       

     

       9
       10
        
         hasChecksum =

     

       10
       11
        
           value:

     

       11
       12
        
           lib.isAttrs value

     
···

       13
       14
        
             "src"

     

       14
       15
        
             "outputHash"

     

       15
       16
        
           ] value;

     

       16
       16
       -
         getChecksum =

     

       17
       17
       -
           name: value:

     

       18
       18
       -
           if hasChecksum value then

     

       19
       19
       -
             {

     

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

     

       21
       21
       -
               sha256 = value.src.outputHash;

     

       22
       22
       -
               rev = value.src.rev;

     

       23
       23
       -
             }

     

       24
       24
       -
           else

     

       25
       25
       -
             null;

     

       26
       26
       -
         checksums = lib.mapAttrs getChecksum generated;

     

       17
       17
       +
       

     

       18
       18
       +
         parse = name: value: {

     

       19
       19
       +
           pname = value.pname;

     

       20
       20
       +
           version = value.version;

     

       21
       21
       +
           homePage = value.meta.homepage;

     

       22
       22
       +
           checksum =

     

       23
       23
       +
             if hasChecksum value then

     

       24
       24
       +
               {

     

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

     

       26
       26
       +
                 sha256 = value.src.outputHash;

     

       27
       27
       +
                 rev = value.src.rev;

     

       28
       28
       +
               }

     

       29
       29
       +
             else

     

       30
       30
       +
               null;

     

       31
       31
       +
         };

     

       27
       32
        
       in

     

       28
       28
       -
       lib.filterAttrs (n: v: v != null) checksums

     

       33
       33
       +
       lib.mapAttrs parse generated

+15 -2

pkgs/by-name/lu/luarocks-packages-updater/updater.py

···

       25
       25
        
       log = logging.getLogger()

     

       26
       26
        
       log.addHandler(logging.StreamHandler())

     

       27
       27
        
       

     

       28
       28
       -
       ROOT = Path(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))).parent.parent  # type: ignore

     

       28
       28
       +
       ROOT = Path(

     

       29
       29
       +
           os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))

     

       30
       30
       +
       ).parent.parent  # type: ignore

     

       29
       31
        
       

     

       30
       32
        
       PKG_LIST = "maintainers/scripts/luarocks-packages.csv"

     

       31
       33
        
       TMP_FILE = "$(mktemp)"

     
···

       121
       123
        
           def attr_path(self):

     

       122
       124
        
               return "luaPackages"

     

       123
       125
        
       

     

       124
       124
       -
           def get_update(self, input_file: str, outfile: str, config: FetchConfig):

     

       126
       126
       +
           def get_update(

     

       127
       127
       +
               self,

     

       128
       128
       +
               input_file: str,

     

       129
       129
       +
               outfile: str,

     

       130
       130
       +
               config: FetchConfig,

     

       131
       131
       +
               # TODO: implement support for adding/updating individual plugins

     

       132
       132
       +
               to_update: Optional[List[str]],

     

       133
       133
       +
           ):

     

       134
       134
       +
               if to_update is not None:

     

       135
       135
       +
                   raise NotImplementedError(

     

       136
       136
       +
                       "For now, lua updater doesn't support updating individual packages."

     

       137
       137
       +
                   )

     

       125
       138
        
               _prefetch = generate_pkg_nix

     

       126
       139
        
       

     

       127
       140
        
               def update() -> dict: