Merge master into staging-next

- `cargo-tauri.hook` was introduced to help users build [Tauri](https://tauri.app/) projects. It is meant to be used alongside

  `rustPlatform.buildRustPackage` and Node hooks such as `npmConfigHook`, `pnpm.configHook`, and the new `yarnConfig`

- `power.ups` now powers off UPSs during a power outage event.

  This saves UPS battery and ensures that host(s) get back up again when power comes back, even in the scenario when the UPS would have had enough capacity to keep power on during the whole power outage.

  If you like the old behaviour of keeping the UPSs on (and emptying the battery) after the host(s) have shut down, and risk not getting a power cycle event to get the host(s) back up, set `power.ups.upsmon.settings.POWERDOWNFLAG = null;`.

- Support for *runner registration tokens* has been [deprecated](https://gitlab.com/gitlab-org/gitlab/-/issues/380872)

  in `gitlab-runner` 15.6 and is expected to be removed in `gitlab-runner` 18.0. Configuration of existing runners

  should be changed to using *runner authentication tokens* by configuring

        defaultText = lib.literalMD ''

          {

            MINSUPPLIES = 1;

            RUN_AS_USER = "root";

            MONITOR = <generated from config.power.ups.upsmon.monitor>

            NOTIFYCMD = "''${pkgs.nut}/bin/upssched";

            POWERDOWNFLAG = "/run/killpower";

            RUN_AS_USER = "root";

            SHUTDOWNCMD = "''${pkgs.systemd}/bin/shutdown now";

          }

        '';

    config = {

      enable = lib.mkDefault (lib.elem cfg.mode [ "standalone" "netserver" "netclient" ]);

      settings = {

        RUN_AS_USER = "root"; # TODO: replace 'root' by another username.

        MINSUPPLIES = lib.mkDefault 1;

        MONITOR = lib.flip lib.mapAttrsToList cfg.upsmon.monitor (name: monitor: with monitor; [ system powerValue user "\"@upsmon_password_${name}@\"" type ]);

        NOTIFYCMD = lib.mkDefault "${pkgs.nut}/bin/upssched";

        POWERDOWNFLAG = lib.mkDefault "/run/killpower";

        RUN_AS_USER = "root"; # TODO: replace 'root' by another username.

        SHUTDOWNCMD = lib.mkDefault "${pkgs.systemd}/bin/shutdown now";

        MONITOR = lib.flip lib.mapAttrsToList cfg.upsmon.monitor (name: monitor: with monitor; [ system powerValue user "\"@upsmon_password_${name}@\"" type ]);

      };

    };

  };

      ];

    };

    systemd.services.ups-killpower = lib.mkIf (cfg.upsmon.settings.POWERDOWNFLAG != null) {

      enable = cfg.upsd.enable;

      description = "UPS Kill Power";

      wantedBy = [ "shutdown.target" ];

      after = [ "shutdown.target" ];

      before = [ "final.target" ];

      unitConfig = {

        ConditionPathExists = cfg.upsmon.settings.POWERDOWNFLAG;

        DefaultDependencies = "no";

      };

      environment = envVars;

      serviceConfig = {

        Type = "oneshot";

        ExecStart = "${pkgs.nut}/bin/upsdrvctl shutdown";

        Slice = "system-ups.slice";

      };

    };

    environment.etc = {

      "nut/nut.conf".source = pkgs.writeText "nut.conf"

        ''

in

rustPlatform.buildRustPackage {

  pname = "lspce-module";

  version = "1.1.0-unstable-2024-07-29";

  version = "1.1.0-unstable-2024-09-07";

  src = fetchFromGitHub {

    owner = "zbelial";

    repo = "lspce";

    rev = "e954e4d77aeb45deb14182631f3d5aa9bcc9e587";

    hash = "sha256-9AUffkdgvVbHRIrHQPVl36plIfGxf3vsN9JCuFe0P6Q=";

    rev = "4bf1fa9d3d8b17eb6ae628e93018ee8f020565ba";

    hash = "sha256-OeDUQXqVBUfKjYt5oSmfl2N/19PFYIbPXfFqloai0LQ=";

  };

  cargoHash = "sha256-wrrdXX/rEVxmHdyblm4I9iHD3bPoDd1KlBe3ODeGFeM=";

  cargoHash = "sha256-VMGdB4dF3Ccxl6DifdXFH4+XVT7RoeqI/l/AR/epg4o=";

  checkFlags = [

    # flaky test

  ### neovim tests

  ##################

  nvim_with_plugins = wrapNeovim2 "-with-plugins" nvimConfNix;

  nvim_singlelines = wrapNeovim2 "-single-lines" nvimConfSingleLines;

  singlelinesconfig = runTest (wrapNeovim2 "-single-lines" nvimConfSingleLines) ''

  # test that passthru.initRc hasn't changed

  passthruInitRc = runTest nvim_singlelines ''

    INITRC=${pkgs.writeTextFile { name = "initrc"; text = nvim_singlelines.passthru.initRc; }}

    assertFileContent \

      $INITRC \

      "${./init-single-lines.vim}"

  '';

  # test single line concatenation

  singlelinesconfig = runTest nvim_singlelines ''

      assertFileContains \

        "$luarcGeneric" \

        "vim.cmd.source \"/nix/store/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-init.vim"

    viAlias = true;

  };

  # test it still works with vim-plug

  nvim_with_plug = neovim.override {

    extraName = "-with-plug";

    configure.packages.plugins = with pkgs.vimPlugins; {

let

  inherit (vimUtils) toVimPlugin;

   /* returns everything needed for the caller to wrap its own neovim:

   - the generated content of the future init.vim

   - the arguments to wrap neovim with

   The caller is responsible for writing the init.vim and adding it to the wrapped

   arguments (["-u" writeText "init.vim" GENERATEDRC)]).

   This makes it possible to write the config anywhere: on a per-project basis

   .nvimrc or in $XDG_CONFIG_HOME/nvim/init.vim to avoid sideeffects.

   Indeed, note that wrapping with `-u init.vim` has sideeffects like .nvimrc wont be loaded

   anymore, $MYVIMRC wont be set etc

  /* transform all plugins into an attrset

   { optional = bool; plugin = package; }

  */

  makeNeovimConfig =

    { withPython3 ? true

    /* the function you would have passed to python3.withPackages */

    , extraPython3Packages ? (_: [ ])

    , withNodeJs ? false

    , withRuby ? true

    /* the function you would have passed to lua.withPackages */

    , extraLuaPackages ? (_: [ ])

    # expects a list of plugin configuration

    # expects { plugin=far-vim; config = "let g:far#source='rg'"; optional = false; }

    , plugins ? []

    # custom viml config appended after plugin-specific config

    , customRC ? ""

    # for forward compability, when adding new environments, haskell etc.

    , ...

    }@args:

  normalizePlugins = plugins:

      let

      rubyEnv = bundlerEnv {

        name = "neovim-ruby-env";

        gemdir = ./ruby_provider;

        postBuild = ''

          ln -sf ${ruby}/bin/* $out/bin

        '';

      };

      # transform all plugins into an attrset

      # { optional = bool; plugin = package; }

      pluginsNormalized = let

        defaultPlugin = {

          plugin = null;

          config = null;

      in

        map (x: defaultPlugin // (if (x ? plugin) then x else { plugin = x; })) plugins;

      pluginRC = lib.foldl (acc: p: if p.config != null then acc ++ [p.config] else acc) []  pluginsNormalized;

      pluginsPartitioned = lib.partition (x: x.optional == true) pluginsNormalized;

      requiredPlugins = vimUtils.requiredPluginsForPackage myVimPackage;

      getDeps = attrname: map (plugin: plugin.${attrname} or (_: [ ]));

      myVimPackage = {

  /* accepts a list of normalized plugins and convert themn

  */

  normalizedPluginsToVimPackage = normalizedPlugins:

    let

      pluginsPartitioned = lib.partition (x: x.optional == true) normalizedPlugins;

    in {

        start = map (x: x.plugin) pluginsPartitioned.wrong;

        opt = map (x: x.plugin) pluginsPartitioned.right;

      };

      pluginPython3Packages = getDeps "python3Dependencies" requiredPlugins;

      python3Env = python3Packages.python.withPackages (ps:

        [ ps.pynvim ]

        ++ (extraPython3Packages ps)

        ++ (lib.concatMap (f: f ps) pluginPython3Packages));

   /* returns everything needed for the caller to wrap its own neovim:

   - the generated content of the future init.vim

   - the arguments to wrap neovim with

   The caller is responsible for writing the init.vim and adding it to the wrapped

   arguments (["-u" writeText "init.vim" GENERATEDRC)]).

   This makes it possible to write the config anywhere: on a per-project basis

   .nvimrc or in $XDG_CONFIG_HOME/nvim/init.vim to avoid sideeffects.

   Indeed, note that wrapping with `-u init.vim` has sideeffects like .nvimrc wont be loaded

   anymore, $MYVIMRC wont be set etc

   */

   makeNeovimConfig = {

      customRC ? ""

      /* the function you would have passed to lua.withPackages */

      , extraLuaPackages ? (_: [ ])

      , ...}@attrs: let

        luaEnv = neovim-unwrapped.lua.withPackages extraLuaPackages;

      # as expected by packdir

      packpathDirs.myNeovimPackages = myVimPackage;

      ## Here we calculate all of the arguments to the 1st call of `makeWrapper`

      # We start with the executable itself NOTE we call this variable "initial"

      # because if configure != {} we need to call makeWrapper twice, in order to

      # avoid double wrapping, see comment near finalMakeWrapperArgs

      makeWrapperArgs =

        let

          binPath = lib.makeBinPath (lib.optionals withRuby [ rubyEnv ] ++ lib.optionals withNodeJs [ nodejs ]);

        in

        [

          "--inherit-argv0"

        ] ++ lib.optionals withRuby [

          "--set" "GEM_HOME" "${rubyEnv}/${rubyEnv.ruby.gemPath}"

        ] ++ lib.optionals (binPath != "") [

          "--suffix" "PATH" ":" binPath

        ] ++ lib.optionals (luaEnv != null) [

     in attrs // {

     neovimRcContent = customRC;

     wrapperArgs = lib.optionals (luaEnv != null) [

          "--prefix" "LUA_PATH" ";" (neovim-unwrapped.lua.pkgs.luaLib.genLuaPathAbsStr luaEnv)

          "--prefix" "LUA_CPATH" ";" (neovim-unwrapped.lua.pkgs.luaLib.genLuaCPathAbsStr luaEnv)

      ];

      manifestRc = vimUtils.vimrcContent { customRC = ""; };

      # we call vimrcContent without 'packages' to avoid the init.vim generation

      neovimRcContent = vimUtils.vimrcContent {

        beforePlugins = "";

        customRC = lib.concatStringsSep "\n" (pluginRC ++ [customRC]);

        packages = null;

      };

    in

    builtins.removeAttrs args ["plugins"] // {

      wrapperArgs = makeWrapperArgs;

      inherit packpathDirs;

      inherit neovimRcContent;

      inherit manifestRc;

      inherit python3Env;

      inherit luaEnv;

      inherit withNodeJs;

    } // lib.optionalAttrs withRuby {

      inherit rubyEnv;

   };

    in

        lib.concatStringsSep ";" hostProviderLua;

  /* Converts a lua package into a neovim plugin.

    Does so by installing the lua package with a flat hierarchy of folders

  */

  buildNeovimPlugin = callPackage ./build-neovim-plugin.nix {

    inherit (vimUtils) toVimPlugin;

    inherit lua;

  inherit legacyWrapper;

  inherit grammarToPlugin;

  inherit packDir;

  inherit normalizePlugins normalizedPluginsToVimPackage;

  inherit buildNeovimPlugin;

  buildNeovimPluginFrom2Nix = lib.warn "buildNeovimPluginFrom2Nix was renamed to buildNeovimPlugin" buildNeovimPlugin;