Merge master into staging-next

maintainers/maintainer-list.nix

···
       fingerprint = "B956 C6A4 22AF 86A0 8F77  A8CA DE3B ADFE CD31 A89D";
     }];
   };
+  nitsky = {
+    name = "nitsky";
+    email = "[e-mail]";
+    github = "nitsky";
+    githubId = 492793;
+  };
   nkpvk = {
     email = "[e-mail]";
     github = "nkpvk";

nixos/doc/manual/from_md/release-notes/rl-2111.section.xml

···
       </listitem>
       <listitem>
         <para>
+          <link xlink:href="https://www.isc.org/kea/">Kea</link>, ISCs
+          2nd generation DHCP and DDNS server suite. Available at
+          <link xlink:href="options.html#opt-services.kea">services.kea</link>.
+        </para>
+      </listitem>
+      <listitem>
+        <para>
           <link xlink:href="https://sr.ht">sourcehut</link>, a
           collection of tools useful for software development. Available
           as

nixos/doc/manual/release-notes/rl-2111.section.md

···
 
 - [geoipupdate](https://github.com/maxmind/geoipupdate), a GeoIP database updater from MaxMind. Available as [services.geoipupdate](options.html#opt-services.geoipupdate.enable).
 
+- [Kea](https://www.isc.org/kea/), ISCs 2nd generation DHCP and DDNS server suite. Available at [services.kea](options.html#opt-services.kea).
+
 - [sourcehut](https://sr.ht), a collection of tools useful for software development. Available as [services.sourcehut](options.html#opt-services.sourcehut.enable).
 
 - [ucarp](https://download.pureftpd.org/pub/ucarp/README), an userspace implementation of the Common Address Redundancy Protocol (CARP). Available as [networking.ucarp](options.html#opt-networking.ucarp.enable).

nixos/modules/module-list.nix

···
   ./services/networking/iwd.nix
   ./services/networking/jicofo.nix
   ./services/networking/jitsi-videobridge.nix
+  ./services/networking/kea.nix
   ./services/networking/keepalived/default.nix
   ./services/networking/keybase.nix
   ./services/networking/kippo.nix

nixos/modules/services/monitoring/prometheus/exporters.nix

···
         serviceConfig.PrivateTmp = mkDefault true;
         serviceConfig.WorkingDirectory = mkDefault /tmp;
         serviceConfig.DynamicUser = mkDefault enableDynamicUser;
-        serviceConfig.User = conf.user;
+        serviceConfig.User = mkDefault conf.user;
         serviceConfig.Group = conf.group;
       } serviceOpts ]);
   };

nixos/modules/services/monitoring/prometheus/exporters/kea.nix

···
   };
   serviceOpts = {
     serviceConfig = {
+      User = "kea";
       ExecStart = ''
         ${pkgs.prometheus-kea-exporter}/bin/kea-exporter \
           --address ${cfg.listenAddress} \

nixos/modules/services/networking/kea.nix

···
+{ config
+, lib
+, pkgs
+, ...
+}:
+
+with lib;
+
+let
+  cfg = config.services.kea;
+
+  format = pkgs.formats.json {};
+
+  ctrlAgentConfig = format.generate "kea-ctrl-agent.conf" {
+    Control-agent = cfg.ctrl-agent.settings;
+  };
+  dhcp4Config = format.generate "kea-dhcp4.conf" {
+    Dhcp4 = cfg.dhcp4.settings;
+  };
+  dhcp6Config = format.generate "kea-dhcp6.conf" {
+    Dhcp6 = cfg.dhcp6.settings;
+  };
+  dhcpDdnsConfig = format.generate "kea-dhcp-ddns.conf" {
+    DhcpDdns = cfg.dhcp-ddns.settings;
+  };
+
+  package = pkgs.kea;
+in
+{
+  options.services.kea = with types; {
+    ctrl-agent = mkOption {
+      description = ''
+        Kea Control Agent configuration
+      '';
+      default = {};
+      type = submodule {
+        options = {
+          enable = mkEnableOption "Kea Control Agent";
+
+          extraArgs = mkOption {
+            type = listOf str;
+            default = [];
+            description = ''
+              List of additonal arguments to pass to the daemon.
+            '';
+          };
+
+          settings = mkOption {
+            type = format.type;
+            default = null;
+            description = ''
+              Kea Control Agent configuration as an attribute set, see <link xlink:href="https://kea.readthedocs.io/en/kea-${package.version}/arm/agent.html"/>.
+            '';
+          };
+        };
+      };
+    };
+
+    dhcp4 = mkOption {
+      description = ''
+        DHCP4 Server configuration
+      '';
+      default = {};
+      type = submodule {
+        options = {
+          enable = mkEnableOption "Kea DHCP4 server";
+
+          extraArgs = mkOption {
+            type = listOf str;
+            default = [];
+            description = ''
+              List of additonal arguments to pass to the daemon.
+            '';
+          };
+
+          settings = mkOption {
+            type = format.type;
+            default = null;
+            example = {
+              valid-lifetime = 4000;
+              renew-timer = 1000;
+              rebind-timer = 2000;
+              interfaces-config = {
+                interfaces = [
+                  "eth0"
+                ];
+              };
+              lease-database = {
+                type = "memfile";
+                persist = true;
+                name = "/var/lib/kea/dhcp4.leases";
+              };
+              subnet4 = [ {
+                subnet = "192.0.2.0/24";
+                pools = [ {
+                  pool = "192.0.2.100 - 192.0.2.240";
+                } ];
+              } ];
+            };
+            description = ''
+              Kea DHCP4 configuration as an attribute set, see <link xlink:href="https://kea.readthedocs.io/en/kea-${package.version}/arm/dhcp4-srv.html"/>.
+            '';
+          };
+        };
+      };
+    };
+
+    dhcp6 = mkOption {
+      description = ''
+        DHCP6 Server configuration
+      '';
+      default = {};
+      type = submodule {
+        options = {
+          enable = mkEnableOption "Kea DHCP6 server";
+
+          extraArgs = mkOption {
+            type = listOf str;
+            default = [];
+            description = ''
+              List of additonal arguments to pass to the daemon.
+            '';
+          };
+
+          settings = mkOption {
+            type = format.type;
+            default = null;
+            example = {
+              valid-lifetime = 4000;
+              renew-timer = 1000;
+              rebind-timer = 2000;
+              preferred-lifetime = 3000;
+              interfaces-config = {
+                interfaces = [
+                  "eth0"
+                ];
+              };
+              lease-database = {
+                type = "memfile";
+                persist = true;
+                name = "/var/lib/kea/dhcp6.leases";
+              };
+              subnet6 = [ {
+                subnet = "2001:db8:1::/64";
+                pools = [ {
+                  pool = "2001:db8:1::1-2001:db8:1::ffff";
+                } ];
+              } ];
+            };
+            description = ''
+              Kea DHCP6 configuration as an attribute set, see <link xlink:href="https://kea.readthedocs.io/en/kea-${package.version}/arm/dhcp6-srv.html"/>.
+            '';
+          };
+        };
+      };
+    };
+
+    dhcp-ddns = mkOption {
+      description = ''
+        Kea DHCP-DDNS configuration
+      '';
+      default = {};
+      type = submodule {
+        options = {
+          enable = mkEnableOption "Kea DDNS server";
+
+          extraArgs = mkOption {
+            type = listOf str;
+            default = [];
+            description = ''
+              List of additonal arguments to pass to the daemon.
+            '';
+          };
+
+          settings = mkOption {
+            type = format.type;
+            default = null;
+            example = {
+              ip-address = "127.0.0.1";
+              port = 53001;
+              dns-server-timeout = 100;
+              ncr-protocol = "UDP";
+              ncr-format = "JSON";
+              tsig-keys = [ ];
+              forward-ddns = {
+                ddns-domains = [ ];
+              };
+              reverse-ddns = {
+                ddns-domains = [ ];
+              };
+            };
+            description = ''
+              Kea DHCP-DDNS configuration as an attribute set, see <link xlink:href="https://kea.readthedocs.io/en/kea-${package.version}/arm/ddns.html"/>.
+            '';
+          };
+        };
+      };
+    };
+  };
+
+  config = let
+    commonServiceConfig = {
+      ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+      DynamicUser = true;
+      User = "kea";
+      ConfigurationDirectory = "kea";
+      RuntimeDirectory = "kea";
+      StateDirectory = "kea";
+      UMask = "0077";
+    };
+  in mkIf (cfg.ctrl-agent.enable || cfg.dhcp4.enable || cfg.dhcp6.enable || cfg.dhcp-ddns.enable) (mkMerge [
+  {
+    environment.systemPackages = [ package ];
+  }
+
+  (mkIf cfg.ctrl-agent.enable {
+
+    environment.etc."kea/ctrl-agent.conf".source = ctrlAgentConfig;
+
+    systemd.services.kea-ctrl-agent = {
+      description = "Kea Control Agent";
+      documentation = [
+        "man:kea-ctrl-agent(8)"
+        "https://kea.readthedocs.io/en/kea-${package.version}/arm/agent.html"
+      ];
+
+      after = [
+        "network-online.target"
+        "time-sync.target"
+      ];
+      wantedBy = [
+        "kea-dhcp4-server.service"
+        "kea-dhcp6-server.service"
+        "kea-dhcp-ddns-server.service"
+      ];
+
+      environment = {
+        KEA_PIDFILE_DIR = "/run/kea";
+      };
+
+      serviceConfig = {
+        ExecStart = "${package}/bin/kea-ctrl-agent -c /etc/kea/ctrl-agent.conf ${lib.escapeShellArgs cfg.dhcp4.extraArgs}";
+        KillMode = "process";
+        Restart = "on-failure";
+      } // commonServiceConfig;
+    };
+  })
+
+  (mkIf cfg.dhcp4.enable {
+
+    environment.etc."kea/dhcp4-server.conf".source = dhcp4Config;
+
+    systemd.services.kea-dhcp4-server = {
+      description = "Kea DHCP4 Server";
+      documentation = [
+        "man:kea-dhcp4(8)"
+        "https://kea.readthedocs.io/en/kea-${package.version}/arm/dhcp4-srv.html"
+      ];
+
+      after = [
+        "network-online.target"
+        "time-sync.target"
+      ];
+      wantedBy = [
+        "multi-user.target"
+      ];
+
+      environment = {
+        KEA_PIDFILE_DIR = "/run/kea";
+      };
+
+      serviceConfig = {
+        ExecStart = "${package}/bin/kea-dhcp4 -c /etc/kea/dhcp4-server.conf ${lib.escapeShellArgs cfg.dhcp4.extraArgs}";
+        # Kea does not request capabilities by itself
+        AmbientCapabilities = [
+          "CAP_NET_BIND_SERVICE"
+          "CAP_NET_RAW"
+        ];
+        CapabilityBoundingSet = [
+          "CAP_NET_BIND_SERVICE"
+          "CAP_NET_RAW"
+        ];
+      } // commonServiceConfig;
+    };
+  })
+
+  (mkIf cfg.dhcp6.enable {
+
+    environment.etc."kea/dhcp6-server.conf".source = dhcp6Config;
+
+    systemd.services.kea-dhcp6-server = {
+      description = "Kea DHCP6 Server";
+      documentation = [
+        "man:kea-dhcp6(8)"
+        "https://kea.readthedocs.io/en/kea-${package.version}/arm/dhcp6-srv.html"
+      ];
+
+      after = [
+        "network-online.target"
+        "time-sync.target"
+      ];
+      wantedBy = [
+        "multi-user.target"
+      ];
+
+      environment = {
+        KEA_PIDFILE_DIR = "/run/kea";
+      };
+
+      serviceConfig = {
+        ExecStart = "${package}/bin/kea-dhcp6 -c /etc/kea/dhcp6-server.conf ${lib.escapeShellArgs cfg.dhcp6.extraArgs}";
+        # Kea does not request capabilities by itself
+        AmbientCapabilities = [
+          "CAP_NET_BIND_SERVICE"
+        ];
+        CapabilityBoundingSet = [
+          "CAP_NET_BIND_SERVICE"
+        ];
+      } // commonServiceConfig;
+    };
+  })
+
+  (mkIf cfg.dhcp-ddns.enable {
+
+    environment.etc."kea/dhcp-ddns.conf".source = dhcpDdnsConfig;
+
+    systemd.services.kea-dhcp-ddns-server = {
+      description = "Kea DHCP-DDNS Server";
+      documentation = [
+        "man:kea-dhcp-ddns(8)"
+        "https://kea.readthedocs.io/en/kea-${package.version}/arm/ddns.html"
+      ];
+
+      after = [
+        "network-online.target"
+        "time-sync.target"
+      ];
+      wantedBy = [
+        "multi-user.target"
+      ];
+
+      environment = {
+        KEA_PIDFILE_DIR = "/run/kea";
+      };
+
+      serviceConfig = {
+        ExecStart = "${package}/bin/kea-dhcp-ddns -c /etc/kea/dhcp-ddns.conf ${lib.escapeShellArgs cfg.dhcp-ddns.extraArgs}";
+        AmbientCapabilites = [
+          "CAP_NET_BIND_SERVICE"
+        ];
+        CapabilityBoundingSet = [
+          "CAP_NET_BIND_SERVICE"
+        ];
+      } // commonServiceConfig;
+    };
+  })
+
+  ]);
+
+  meta.maintainers = with maintainers; [ hexa ];
+}

nixos/tests/all-tests.nix

···
   k3s = handleTest ./k3s.nix {};
   kafka = handleTest ./kafka.nix {};
   kbd-setfont-decompress = handleTest ./kbd-setfont-decompress.nix {};
+  kea = handleTest ./kea.nix {};
   keepalived = handleTest ./keepalived.nix {};
   keepassxc = handleTest ./keepassxc.nix {};
   kerberos = handleTest ./kerberos/default.nix {};

nixos/tests/kea.nix

···
+import ./make-test-python.nix ({ pkgs, lib, ...}: {
+  meta.maintainers = with lib.maintainers; [ hexa ];
+
+  nodes = {
+    router = { config, pkgs, ... }: {
+      virtualisation.vlans = [ 1 ];
+
+      networking = {
+        useNetworkd = true;
+        useDHCP = false;
+        firewall.allowedUDPPorts = [ 67 ];
+      };
+
+      systemd.network = {
+        networks = {
+          "01-eth1" = {
+            name = "eth1";
+            networkConfig = {
+              Address = "10.0.0.1/30";
+            };
+          };
+        };
+      };
+
+      services.kea.dhcp4 = {
+        enable = true;
+        settings = {
+          valid-lifetime = 3600;
+          renew-timer = 900;
+          rebind-timer = 1800;
+
+          lease-database = {
+            type = "memfile";
+            persist = true;
+            name = "/var/lib/kea/dhcp4.leases";
+          };
+
+          interfaces-config = {
+            dhcp-socket-type = "raw";
+            interfaces = [
+              "eth1"
+            ];
+          };
+
+          subnet4 = [ {
+            subnet = "10.0.0.0/30";
+            pools = [ {
+              pool = "10.0.0.2 - 10.0.0.2";
+            } ];
+          } ];
+        };
+      };
+    };
+
+    client = { config, pkgs, ... }: {
+      virtualisation.vlans = [ 1 ];
+      systemd.services.systemd-networkd.environment.SYSTEMD_LOG_LEVEL = "debug";
+      networking = {
+        useNetworkd = true;
+        useDHCP = false;
+        firewall.enable = false;
+        interfaces.eth1.useDHCP = true;
+      };
+    };
+  };
+  testScript = { ... }: ''
+    start_all()
+    router.wait_for_unit("kea-dhcp4-server.service")
+    client.wait_for_unit("systemd-networkd-wait-online.service")
+    client.wait_until_succeeds("ping -c 5 10.0.0.1")
+    router.wait_until_succeeds("ping -c 5 10.0.0.2")
+  '';
+})

nixos/tests/prometheus-exporters.nix

···
       '';
     };
 
-    kea = {
+    kea = let
+      controlSocketPath = "/run/kea/dhcp6.sock";
+    in
+    {
       exporterConfig = {
         enable = true;
         controlSocketPaths = [
-          "/run/kea/kea-dhcp6.sock"
+          controlSocketPath
         ];
       };
       metricProvider = {
-        users.users.kea = {
-          isSystemUser = true;
-        };
-        users.groups.kea = {};
-
-        systemd.services.prometheus-kea-exporter.after = [ "kea-dhcp6.service" ];
+        systemd.services.prometheus-kea-exporter.after = [ "kea-dhcp6-server.service" ];
 
-        systemd.services.kea-dhcp6 = let
-          configFile = pkgs.writeText "kea-dhcp6.conf" (builtins.toJSON {
-            Dhcp6 = {
-              "control-socket" = {
-                "socket-type" = "unix";
-                "socket-name" = "/run/kea/kea-dhcp6.sock";
+        services.kea = {
+          enable = true;
+          dhcp6 = {
+            enable = true;
+            settings = {
+              control-socket = {
+                socket-type = "unix";
+                socket-name = controlSocketPath;
               };
             };
-          });
-        in
-        {
-          after = [ "network.target" ];
-          wantedBy = [ "multi-user.target" ];
-
-          serviceConfig = {
-            DynamicUser = false;
-            User = "kea";
-            Group = "kea";
-            ExecStart = "${pkgs.kea}/bin/kea-dhcp6 -c ${configFile}";
-            StateDirectory = "kea";
-            RuntimeDirectory = "kea";
-            UMask = "0007";
           };
         };
       };
+
       exporterTest = ''
-        wait_for_unit("kea-dhcp6.service")
-        wait_for_file("/run/kea/kea-dhcp6.sock")
+        wait_for_unit("kea-dhcp6-server.service")
+        wait_for_file("${controlSocketPath}")
         wait_for_unit("prometheus-kea-exporter.service")
         wait_for_open_port(9547)
         succeed(

pkgs/applications/blockchains/chia/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "chia";
-  version = "1.2.1";
+  version = "1.2.2";
 
   src = fetchFromGitHub {
     owner = "Chia-Network";
     repo = "chia-blockchain";
     rev = version;
-    sha256 = "sha256-ZNSNROWl6RR4GZnoRGAXrdw48wH9OOgrsoKz0RNIIcs=";
+    sha256 = "sha256-ZYncyaX9gqBhDKiC87A2xI7VeU0zGsmm3Sx45lwgnrg=";
   };
 
   patches = [

pkgs/applications/blockchains/ethabi/default.nix

···
     homepage = "https://github.com/rust-ethereum/ethabi";
     maintainers = [ maintainers.dbrock ];
     license = licenses.asl20;
-    inherit version;
   };
 }

pkgs/applications/blockchains/nano-wallet/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Wallet for Nano cryptocurrency";
     homepage = "https://nano.org/en/wallet/";
     license = lib.licenses.bsd2;

pkgs/applications/editors/sublime/4/packages.nix

···
 in
   {
     sublime4 = common {
-      buildVersion = "4107";
-      x64sha256 = "05ar7qd1d880442bx4w32mapsib7j27g9l96q2v2s7591r9fgnf7";
-      aarch64sha256 = "4MzwhZ17c6cYtlwPA+SBiey6GiVruADXOLJAeJlMrgM=";
+      buildVersion = "4113";
+      x64sha256 = "13679mnmigy1sgj355zs4si6gnx42rgjl4rn5d6gqgj5qq7zj3lh";
+      aarch64sha256 = "0hg6g3cichma1x82963m7xwazmpdvv5zmz8rpwxs337zq7j3dmb3";
     } {};
 
     sublime4-dev = common {
-      buildVersion = "4106";
+      buildVersion = "4112";
       dev = true;
-      x64sha256 = "09jnn52zb0mjxpj5xz4sixl34cr6j60x46c2dj1m0dlgxap0sh8x";
-      aarch64sha256 = "7blbeSZI0V6q89jMM+zi2ODEdoc1b3Am8F2b2jLr5O8=";
+      x64sha256 = "1yy8wzcphsk3ji2sv2vjcw8ybn62yibzsv9snmm01gvkma16p9dl";
+      aarch64sha256 = "12bl235rxgw3q99yz9x4nfaryb32a2vzyam88by6p1s1zw2fxnp9";
     } {};
   }

pkgs/applications/graphics/qiv/default.nix

···
   meta = with lib; {
     description = "Quick image viewer";
     homepage = "http://spiegl.de/qiv/";
-    inherit version;
     license = licenses.gpl2;
     platforms = platforms.linux;
   };

pkgs/applications/graphics/xfractint/default.nix

···
   makeFlags = ["PREFIX=$(out)"];
 
   meta = {
-    inherit version;
     description = "";
     # Code cannot be used in commercial programs
     # Looks like the definition hinges on the price, not license

pkgs/applications/misc/1password-gui/default.nix

···
 , nss
 , pango
 , systemd
+, udev
 , xdg-utils
 }:
 stdenv.mkDerivation rec {
   pname = "1password";
-  version = "8.0.34";
+  version = "8.1.1";
 
   src = fetchurl {
     url = "https://downloads.1password.com/linux/tar/stable/x86_64/1password-${version}.x64.tar.gz";
-    sha256 = "0mp119v5vgsva7pnxpsbq4xhh4vbhwv7ga9b5b7f6slx3biy1wmh";
+    sha256 = "0y39sfhj9xrgprh01i9apzfkqzm6pdhjc8x59x5p5djjjvxbcwmy";
   };
 
   nativeBuildInputs = [ makeWrapper ];
···
         patchelf --set-rpath ${rpath}:$out/share/1password $file
       done
 
+      # Electron is trying to open udev via dlopen()
+      # and for some reason that doesn't seem to be impacted from the rpath.
+      # Adding udev to LD_LIBRARY_PATH fixes that.
       makeWrapper $out/share/1password/1password $out/bin/1password \
-        --prefix PATH : ${xdg-utils}/bin
+        --prefix PATH : ${lib.makeBinPath [ xdg-utils ]} \
+        --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ udev ]}
 
       runHook postInstall
     '';

pkgs/applications/misc/diffpdf/default.nix

···
     license = lib.licenses.gpl2Plus;
     maintainers = with lib.maintainers; [ tstrobel ];
     platforms = with lib.platforms; linux;
-    inherit version;
   };
 }

pkgs/applications/misc/gcalcli/default.nix

···
     homepage = "https://github.com/insanum/gcalcli";
     license = licenses.mit;
     maintainers = with maintainers; [ nocoolnametom ];
-    inherit version;
   };
 }

pkgs/applications/misc/getxbook/default.nix

···
     license     = licenses.isc;
     maintainers = with maintainers; [ obadz ];
     platforms   = platforms.all;
-    inherit version;
   };
 }

pkgs/applications/misc/gummi/default.nix

···
     license = lib.licenses.mit;
     maintainers = with lib.maintainers; [ flokli ];
     platforms = with lib.platforms; linux;
-    inherit version;
   };
 }

pkgs/applications/misc/scli/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "scli";
-  version = "0.6.3";
+  version = "0.6.4";
 
   src = fetchFromGitHub {
     owner = "isamert";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-QGVBJKTBo2RckGwW1deM2toRPT73PYDLvr7YVepkQvg=";
+    sha256 = "0fx9ig08whl7bsii9m1h9wp361ngf1szd8v8yqglgl0x8044fwrk";
   };
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/applications/misc/tpmmanager/default.nix

···
     license = lib.licenses.gpl2;
     maintainers = with lib.maintainers; [ tstrobel ];
     platforms = with lib.platforms; linux;
-    inherit version;
   };
 }

pkgs/applications/misc/vifm/default.nix

···
     license = licenses.gpl2;
     downloadPage = "https://vifm.info/downloads.shtml";
     homepage = "https://vifm.info/";
-    inherit version;
     updateWalker = true;
     changelog = "https://github.com/vifm/vifm/blob/v${version}/ChangeLog";
   };

pkgs/applications/misc/visidata/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Interactive terminal multitool for tabular data";
     license = lib.licenses.gpl3;
     maintainers = [ lib.maintainers.raskin ];

pkgs/applications/misc/wofi-emoji/default.nix

···
+{ stdenv, lib, fetchFromGitHub, jq }:
+
+let
+  emojiJSON = fetchFromGitHub {
+    owner = "github";
+    repo = "gemoji";
+    sha256 = "sha256-Tn0vba129LPlX+MRcCBA9qp2MU1ek1jYzVCqoNxCL/w=";
+    rev = "v4.0.0.rc2";
+  };
+
+in stdenv.mkDerivation rec {
+  pname = "wofi-emoji";
+  version = "unstable-2021-05-24";
+
+  src = fetchFromGitHub {
+    owner = "dln";
+    repo = pname;
+    rev = "bfe35c1198667489023109f6843217b968a35183";
+    sha256 = "sha256-wMIjTUCVn4uF0cpBkPfs76NRvwS0WhGGJRy9vvtmVWQ=";
+  };
+
+  nativeBuildInputs = [ jq ];
+
+  postPatch = ''
+    cp "${emojiJSON}/db/emoji.json" .
+    substituteInPlace build.sh \
+      --replace 'curl https://raw.githubusercontent.com/github/gemoji/master/db/emoji.json' 'cat emoji.json'
+  '';
+
+  buildPhase = ''
+    runHook preBuild
+
+    bash build.sh
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/bin
+    cp wofi-emoji $out/bin
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Simple emoji selector for Wayland using wofi and wl-clipboard";
+    homepage = "https://github.com/dln/wofi-emoji";
+    license = licenses.mit;
+    maintainers = [ maintainers.ymarkus ];
+    platforms = platforms.all;
+  };
+}

pkgs/applications/networking/instant-messengers/baresip/default.nix

···
     platforms = with lib.platforms; linux;
     maintainers = with lib.maintainers; [raskin];
     license = lib.licenses.bsd3;
-    inherit version;
     downloadPage = "http://www.creytiv.com/pub/";
     updateWalker = true;
     downloadURLRegexp = "/baresip-.*[.]tar[.].*";

pkgs/applications/networking/instant-messengers/mirage/default.nix

···
     maintainers = with maintainers; [ colemickens ];
     broken = stdenv.isDarwin;
     inherit (qtbase.meta) platforms;
-    inherit version;
   };
 }

pkgs/applications/networking/instant-messengers/oysttyer/default.nix

···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "Perl Console Twitter Client";
     homepage    = "http://oysttyer.github.io/";
     maintainers = with maintainers; [ woffs ];

pkgs/applications/networking/instant-messengers/quaternion/default.nix

···
     license = licenses.gpl3;
     maintainers = with maintainers; [ peterhoeg ];
     inherit (qtbase.meta) platforms;
-    inherit version;
   };
 }

pkgs/applications/networking/instant-messengers/tensor/default.nix

···
     license = licenses.gpl3;
     maintainers = with maintainers; [ peterhoeg ];
     inherit (qtbase.meta) platforms;
-    inherit version;
   };
 }

pkgs/applications/networking/mailreaders/mailcheck/default.nix

···
     license     = lib.licenses.gpl2;
     maintainers = with lib.maintainers; [ kovirobi ];
     platforms   = lib.platforms.linux;
-    inherit version;
-
     longDescription = ''
       A simple command line tool to check for new mail in local mbox and
       maildir and remote POP3 and IMAP mailboxes.

pkgs/applications/science/geometry/tetgen/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Quality Tetrahedral Mesh Generator and 3D Delaunay Triangulator";
     homepage = "http://tetgen.org/";
     license = lib.licenses.agpl3Plus;

pkgs/applications/science/logic/potassco/clingcon.nix

···
   ];
 
   meta = {
-    inherit version;
     description = "Extension of clingo to handle constraints over integers";
     license = lib.licenses.gpl3; # for now GPL3, next version MIT!
     platforms = lib.platforms.unix;

pkgs/applications/science/logic/potassco/clingo.nix

···
   cmakeFlags = [ "-DCLINGO_BUILD_WITH_PYTHON=OFF" ];
 
   meta = {
-    inherit version;
     description = "ASP system to ground and solve logic programs";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/logic/satallax/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Automated theorem prover for higher-order logic";
     license = lib.licenses.mit ;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/logic/z3/tptp.nix

···
   '';
 
   meta = {
-    inherit version;
     inherit (z3.meta) license homepage platforms;
     description = "TPTP wrapper for Z3 prover";
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/math/gfan/default.nix

···
   buildInputs = [ gmp mpir cddlib ];
 
   meta = {
-    inherit version;
     description = "A software package for computing Gröbner fans and tropical varieties";
     license = lib.licenses.gpl2 ;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/math/nauty/default.nix

···
   '';
   checkTarget = "checks";
   meta = with lib; {
-    inherit version;
     description = "Programs for computing automorphism groups of graphs and digraphs";
     license = licenses.asl20;
     maintainers = teams.sage.members;

pkgs/applications/science/math/pcalc/default.nix

···
     license = licenses.gpl2;
     maintainers = with lib.maintainers; [ ftrvxmtrx ];
     platforms = lib.platforms.linux;
-    inherit version;
   };
 }

pkgs/applications/science/math/polymake/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Software for research in polyhedral geometry";
     license = lib.licenses.gpl2 ;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/math/ratpoints/default.nix

···
   preInstall = ''mkdir -p "$out"/{bin,share,lib,include}'';
 
   meta = {
-    inherit version;
     description = "A program to find rational points on hyperelliptic curves";
     license = lib.licenses.gpl2Plus;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/misc/golly/beta.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Cellular automata simulation program";
     license = lib.licenses.gpl2;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/misc/golly/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Cellular automata simulation program";
     license = lib.licenses.gpl2;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/science/programming/fdr/default.nix

···
     zlib
   ];
 
-  phases = [ "unpackPhase" "installPhase" ];
+  dontConfigure = true;
   installPhase = ''
     mkdir -p "$out"
 

pkgs/applications/version-management/mercurial/default.nix

···
     passthru.tests = {};
 
     meta = with lib; {
-      inherit version;
       description = "A fast, lightweight SCM system for very large distributed projects";
       homepage = "https://www.mercurial-scm.org";
       downloadPage = "https://www.mercurial-scm.org/release/";

pkgs/applications/version-management/monotone-viz/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Monotone ancestry visualiser";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];

pkgs/applications/version-management/nbstripout/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Strip output from Jupyter and IPython notebooks";
     homepage = "https://github.com/kynan/nbstripout";
     license = lib.licenses.mit;

pkgs/applications/virtualization/podman/default.nix

···
 
 buildGoModule rec {
   pname = "podman";
-  version = "3.2.2";
+  version = "3.2.3";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = "podman";
     rev = "v${version}";
-    sha256 = "sha256-D1gtKaDZ7/SyySYWmDa3eDHbh2f5B3q1VEYKgl1pXCE=";
+    sha256 = "sha256-P8/4jehfcjM+r/pwW6fxrwquMVUqXxvvTur7Tesjmnc=";
   };
 
   vendorSha256 = null;

pkgs/applications/window-managers/wmii-hg/default.nix

···
     description = "A small window manager controlled by a 9P filesystem";
     maintainers = with lib.maintainers; [ kovirobi ];
     license = lib.licenses.mit;
-    inherit version;
     platforms = with lib.platforms; linux;
   };
 }

pkgs/data/fonts/noto-fonts/default.nix

···
     '';
 
     meta = with lib; {
-      inherit version;
       description = "Color and Black-and-White emoji fonts";
       homepage = "https://github.com/googlefonts/noto-emoji";
       license = with licenses; [ ofl asl20 ];

pkgs/data/fonts/unscii/default.nix

···
   outputs = [ "out" "extra" ];
 
   meta = {
-    inherit version;
     description = "Bitmapped character-art-friendly Unicode fonts";
     # Basically GPL2+ with font exception — because of the Unifont-augmented
     # version. The reduced version is public domain.

pkgs/data/machine-learning/mnist/default.nix

···
       ln -s "${srcs.test-images}" "$out/${srcs.test-images.name}"
       ln -s "${srcs.test-labels}" "$out/${srcs.test-labels.name}"
     '';
-    phases = [ "installPhase" ];
+    dontUnpack = true;
     meta = with lib; {
       description = "A large database of handwritten digits";
       longDescription = ''

pkgs/data/misc/scowl/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Spell checker oriented word lists";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];

pkgs/data/misc/xorg-rgb/default.nix

···
   nativeBuildInputs = [pkg-config];
   buildInputs = [xorgproto];
   meta = {
-    inherit version;
     description = "X11 colorname to RGB mapping database";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];

pkgs/development/compilers/abcl/default.nix

···
   '';
   buildInputs = [jre ant jdk jre];
   meta = {
-    inherit version;
     description = "A JVM-based Common Lisp implementation";
     license = lib.licenses.gpl3 ;
     maintainers = [lib.maintainers.raskin];

pkgs/development/compilers/clasp/default.nix

···
   CLASP_SRC_DONTTOUCH = "true";
 
   meta = {
-    inherit version;
     description = "A Common Lisp implementation based on LLVM with C++ integration";
     license = lib.licenses.lgpl21Plus ;
     maintainers = [lib.maintainers.raskin];

pkgs/development/compilers/dmd/binary.nix

···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "Digital Mars D Compiler Package";
     # As of 2.075 all sources and binaries use the boost license
     license = licenses.boost;

pkgs/development/compilers/fpc/default.nix

···
     maintainers = [ maintainers.raskin ];
     license = with licenses; [ gpl2 lgpl2 ];
     platforms = platforms.linux;
-    inherit version;
   };
 }

pkgs/development/compilers/julia/1.6-bin.nix

···
 
 stdenv.mkDerivation rec {
   pname = "julia-bin";
-  version = "1.6.1";
+  version = "1.6.2";
 
   src = {
     x86_64-linux = fetchurl {
       url = "https://julialang-s3.julialang.org/bin/linux/x64/${lib.versions.majorMinor version}/julia-${version}-linux-x86_64.tar.gz";
-      sha256 = "01i5sm4vqb0y5qznql571zap19b42775drrcxnzsyhpaqgg8m23w";
+      sha256 = "0h1jh8gbvxb0pl1an0fbbg4lbd0sa24yj2f4yqwavw8dbdvvbd1y";
     };
   }.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
 

pkgs/development/compilers/ldc/binary.nix

···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "The LLVM-based D Compiler";
     homepage = "https://github.com/ldc-developers/ldc";
     # from https://github.com/ldc-developers/ldc/blob/master/LICENSE

pkgs/development/compilers/llvm/12/compiler-rt/X86-support-extension.patch

···
 index 3a66dd9c3fb..7efc85d9f9f 100644
 --- a/lib/builtins/CMakeLists.txt
 +++ b/lib/builtins/CMakeLists.txt
-@@ -301,6 +301,10 @@ if (NOT MSVC)
-     i386/umoddi3.S
-   )
+@@ -345,4 +345,8 @@ if (NOT MSVC)
  
 +  set(i486_SOURCES ${i386_SOURCES})
 +  set(i586_SOURCES ${i386_SOURCES})

pkgs/development/compilers/obliv-c/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "A GCC wrapper that makes it easy to embed secure computation protocols inside regular C programs";
     license = lib.licenses.bsd3;
     maintainers = [lib.maintainers.raskin];

pkgs/development/compilers/sbcl/common.nix

···
   '');
 
   meta = sbclBootstrap.meta // {
-    inherit version;
     updateWalker = true;
   };
 }

pkgs/development/compilers/solc/default.nix

···
       homepage = "https://github.com/ethereum/solidity";
       license = licenses.gpl3;
       maintainers = with maintainers; [ dbrock akru lionello sifmelcara ];
-      inherit version;
     };
   };
 in

pkgs/development/interpreters/clojure/clooj.nix

···
 
   nativeBuildInputs = [ makeWrapper ];
 
-  phases = "installPhase";
+  dontUnpack = true;
 
   installPhase = ''
     mkdir -p $out/share/java

pkgs/development/libraries/audio/libgme/default.nix

···
 { lib, stdenv, fetchFromBitbucket, cmake, removeReferencesTo }:
-let
+
+stdenv.mkDerivation rec {
+  pname = "libgme";
   version = "0.6.3";
-in stdenv.mkDerivation {
-  pname = "libgme";
-  inherit version;
 
   meta = with lib; {
     description = "A collection of video game music chip emulators";

pkgs/development/libraries/avro-c++/default.nix

···
 { lib, stdenv, fetchurl, cmake, boost, python2}:
 
-let version = "1.8.2"; in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "avro-c++";
-  inherit version;
+  version = "1.8.2";
 
   src = fetchurl {
     url = "mirror://apache/avro/avro-${version}/cpp/avro-cpp-${version}.tar.gz";

pkgs/development/libraries/avro-c/default.nix

···
 { lib, stdenv, cmake, fetchurl, pkg-config, jansson, zlib }:
 
-let
-  version = "1.10.2";
-in stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "avro-c";
-  inherit version;
+  version = "1.10.2";
 
   src = fetchurl {
     url = "mirror://apache/avro/avro-${version}/c/avro-c-${version}.tar.gz";

pkgs/development/libraries/bearssl/default.nix

···
 { lib, stdenv, fetchurl }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "bearssl";
   version = "0.6";
-  sha256 = "057zhgy9w4y8z2996r0pq5k2k39lpvmmvz4df8db8qa9f6hvn1b7";
-
-in
-stdenv.mkDerivation {
-  pname = "bearssl";
-  inherit version;
 
   src = fetchurl {
     url = "https://www.bearssl.org/bearssl-${version}.tar.gz";
-    inherit sha256;
+    sha256 = "057zhgy9w4y8z2996r0pq5k2k39lpvmmvz4df8db8qa9f6hvn1b7";
   };
 
   outputs = [ "bin" "lib" "dev" "out" ];

pkgs/development/libraries/boringssl/default.nix

···
 # reference: https://boringssl.googlesource.com/boringssl/+/2661/BUILDING.md
 buildGoModule {
   pname = "boringssl";
-  version = "2021-04-18";
+  version = "2021-07-09";
 
   src = fetchgit {
     url    = "https://boringssl.googlesource.com/boringssl";
-    rev    = "468cde90ca58421d63f4dfeaebcf8bb3fccb4127";
-    sha256 = "0gaqcbvp6r5fq265mckmg0i0rjab0bhxkxcvfxp3ar5dm7q88w39";
+    rev    = "268a4a6ff3bd656ae65fe41ef1185daa85cfae21";
+    sha256 = "04fja4fdwhc69clmvg8i12zm6ks3sfl3r8i5bxn4x63b9dj5znlx";
   };
 
   nativeBuildInputs = [ cmake ninja perl ];
 
-  vendorSha256 = "sha256-pQpattmS9VmO3ZIQUFn66az8GSmB4IvYhTTCFn6SUmo=";
+  vendorSha256 = "0sjjj9z1dhilhpc8pq4154czrb79z9cm044jvn75kxcjv6v5l2m5";
 
   # hack to get both go and cmake configure phase
   # (if we use postConfigure then cmake will loop runHook postConfigure)

pkgs/development/libraries/cddlib/default.nix

···
   # Requested here: https://github.com/cddlib/cddlib/issues/25
   doCheck = true;
   meta = with lib; {
-    inherit version;
     description = "An implementation of the Double Description Method for generating all vertices of a convex polyhedron";
     license = licenses.gpl2Plus;
     maintainers = teams.sage.members;

pkgs/development/libraries/classads/default.nix

···
 { lib, stdenv, fetchurl, pcre }:
 
-let version = "1.0.10"; in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "classads";
-  inherit version;
+  version = "1.0.10";
 
   src = fetchurl {
     url = "ftp://ftp.cs.wisc.edu/condor/classad/c++/classads-${version}.tar.gz";

pkgs/development/libraries/clfft/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, fftw, fftwFloat, boost166, opencl-clhpp, ocl-icd }:
 
-let
-  version = "2.12.2";
-in stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "clfft";
-  inherit version;
+  version = "2.12.2";
 
   src = fetchFromGitHub {
     owner = "clMathLibraries";
···
     homepage = "http://clmathlibraries.github.io/clFFT/";
     platforms = [ "i686-linux" "x86_64-linux" ];
     maintainers = with maintainers; [ chessai ];
-    inherit version;
   };
 }

pkgs/development/libraries/eclib/default.nix

···
   ];
   doCheck = true;
   meta = with lib; {
-    inherit version;
     description = "Elliptic curve tools";
     homepage = "https://github.com/JohnCremona/eclib";
     license = licenses.gpl2Plus;

pkgs/development/libraries/exiv2/default.nix

···
 , doxygen
 , graphviz
 , libxslt
+, libiconv
 }:
 
 stdenv.mkDerivation rec {
···
     graphviz
     libxslt
   ];
+
+  buildInputs = lib.optional stdenv.isDarwin libiconv;
 
   propagatedBuildInputs = [
     expat

pkgs/development/libraries/fflas-ffpack/default.nix

···
   doCheck = true;
 
   meta = with lib; {
-    inherit version;
     description = "Finite Field Linear Algebra Subroutines";
     license = licenses.lgpl21Plus;
     maintainers = teams.sage.members;

pkgs/development/libraries/fox/fox-1.6.nix

···
 , libXrandr, libGLU, libGL, libXft, libXfixes, xinput
 , CoreServices }:
 
-let
-  version = "1.6.57";
-in
-
 stdenv.mkDerivation rec {
   pname = "fox";
-  inherit version;
+  version = "1.6.57";
 
   src = fetchurl {
     url = "ftp://ftp.fox-toolkit.org/pub/${pname}-${version}.tar.gz";

pkgs/development/libraries/freenect/default.nix

···
 
   meta = {
     description = "Drivers and libraries for the Xbox Kinect device on Windows, Linux, and macOS";
-    inherit version;
     homepage = "http://openkinect.org";
     license = with lib.licenses; [ gpl2 asl20 ];
     maintainers = with lib.maintainers; [ bennofs ];

pkgs/development/libraries/givaro/3.7.nix

···
   nativeBuildInputs = [ autoreconfHook ];
   buildInputs = [autoconf automake libtool gmpxx];
   meta = {
-    inherit version;
     description = "A C++ library for arithmetic and algebraic computations";
     license = lib.licenses.cecill-b;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/givaro/3.nix

···
   nativeBuildInputs = [ autoreconfHook ];
   buildInputs = [autoconf automake libtool gmpxx];
   meta = {
-    inherit version;
     description = "A C++ library for arithmetic and algebraic computations";
     license = lib.licenses.cecill-b;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/givaro/default.nix

···
   doCheck = false;
 
   meta = {
-    inherit version;
     description = "A C++ library for arithmetic and algebraic computations";
     license = lib.licenses.cecill-b;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/goocanvas/2.x.nix

···
 { lib, stdenv, fetchurl, pkg-config, gettext, gtk-doc, gobject-introspection, python2, gtk3, cairo, glib }:
 
-let
-  version = "2.0.4";
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
   pname = "goocanvas";
-  inherit version;
+  version = "2.0.4";
 
   outputs = [ "out" "dev" "devdoc" ];
 

pkgs/development/libraries/http-parser/default.nix

···
 { lib, stdenv, fetchFromGitHub }:
 
-let
-  version = "2.9.4";
-in stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "http-parser";
-  inherit version;
+  version = "2.9.4";
 
   src = fetchFromGitHub {
     owner = "nodejs";

pkgs/development/libraries/iml/default.nix

···
     "--with-cblas=-lblas"
   ];
   meta = {
-    inherit version;
     description = "Algorithms for computing exact solutions to dense systems of linear equations over the integers";
     license = lib.licenses.gpl2Plus;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/java/rhino/default.nix

···
 { fetchurl, lib, stdenv, unzip, ant, javac, jvm }:
 
 let
-  version = "1.7R2";
-
   xbeans  = fetchurl {
     url = "http://archive.apache.org/dist/xmlbeans/binaries/xmlbeans-2.2.0.zip";
     sha256 = "1pb08d9j81d0wz5wj31idz198iwhqb7mch872n08jh1354rjlqwk";
   };
 in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "rhino";
-  inherit version;
+  version = "1.7R2";
 
   src = fetchurl {
     url = "mirror://mozilla/js/rhino1_7R2.zip";

pkgs/development/libraries/jsoncpp/default.nix

···
   ];
 
   meta = with lib; {
-    inherit version;
     homepage = "https://github.com/open-source-parsers/jsoncpp";
     description = "A C++ library for interacting with JSON";
     maintainers = with maintainers; [ ttuegel cpages ];

pkgs/development/libraries/libb64/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "ANSI C routines for fast base64 encoding/decoding";
     license = lib.licenses.publicDomain;
     platforms = lib.platforms.unix;

pkgs/development/libraries/libewf/default.nix

···
     license = lib.licenses.lgpl3;
     maintainers = [ lib.maintainers.raskin ] ;
     platforms = lib.platforms.unix;
-    inherit version;
   };
 }

pkgs/development/libraries/libgxps/default.nix

···
 
   mesonFlags = [
     "-Denable-test=false"
+  ] ++ lib.optionals (stdenv.buildPlatform != stdenv.hostPlatform) [
+    "-Ddisable-introspection=true"
   ];
 
   passthru = {

pkgs/development/libraries/libixp-hg/default.nix

···
     description = "Portable, simple C-language 9P client and server libary";
     maintainers = with lib.maintainers; [ kovirobi ];
     license = lib.licenses.mit;
-    inherit version;
     platforms = with lib.platforms; unix;
   };
 }

pkgs/development/libraries/libofa/default.nix

···
 { lib, stdenv, fetchurl, expat, curl, fftw }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "libofa";
   version = "0.9.3";
   deb_patch = "5";
-in
-stdenv.mkDerivation rec {
-  pname = "libofa";
-  inherit version;
 
   src = fetchurl {
     url = "https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/musicip-libofa/${pname}-${version}.tar.gz";

pkgs/development/libraries/libpar2/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, libsigcxx }:
 
-let version = "0.4"; in
-
 stdenv.mkDerivation rec {
   pname = "libpar2";
-  inherit version;
+  version = "0.4";
 
   src = fetchurl {
     url = "https://launchpad.net/libpar2/trunk/${version}/+download/${pname}-${version}.tar.gz";

pkgs/development/libraries/libre/default.nix

···
     platforms = with lib.platforms; linux;
     maintainers = with lib.maintainers; [raskin];
     license = lib.licenses.bsd3;
-    inherit version;
     downloadPage = "http://www.creytiv.com/pub/";
     updateWalker = true;
     downloadURLRegexp = "/re-.*[.]tar[.].*";

pkgs/development/libraries/libxklavier/default.nix

···
 { lib, stdenv, fetchgit, autoreconfHook, pkg-config, gtk-doc, xkeyboard_config, libxml2, xorg, docbook_xsl
 , glib, isocodes, gobject-introspection }:
 
-let
-  version = "5.4";
-in
 stdenv.mkDerivation rec {
   pname = "libxklavier";
-  inherit version;
+  version = "5.4";
 
   src = fetchgit {
     url = "git://anongit.freedesktop.org/git/libxklavier";

pkgs/development/libraries/libxsmm/default.nix

···
 , enableStatic ? stdenv.hostPlatform.isStatic
 }:
 
-let
-  version = "1.16.1";
-in stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "libxsmm";
-  inherit version;
+  version = "1.16.1";
 
   src = fetchFromGitHub {
     owner = "hfp";

pkgs/development/libraries/linbox/default.nix

···
   enableParallelBuilding = true;
 
   meta = with lib; {
-    inherit version;
     description = "C++ library for exact, high-performance linear algebra";
     license = licenses.lgpl21Plus;
     maintainers = teams.sage.members;

pkgs/development/libraries/mdds/default.nix

···
   checkInputs = [ boost ];
 
   meta = with lib; {
-    inherit version;
     homepage = "https://gitlab.com/mdds/mdds";
     description = "A collection of multi-dimensional data structure and indexing algorithm";
     platforms = platforms.all;

pkgs/development/libraries/mpfi/default.nix

···
   buildInputs = [ mpfr ];
 
   meta = {
-    inherit version;
     description = "A multiple precision interval arithmetic library based on MPFR";
     homepage = "https://gforge.inria.fr/projects/mpfi/";
     license = lib.licenses.lgpl21Plus;

pkgs/development/libraries/mpir/default.nix

···
     ++ lib.optionals stdenv.isLinux [ "--enable-fat" ];
 
   meta = {
-    inherit version;
     description = "A highly optimised library for bignum arithmetic forked from GMP";
     license = lib.licenses.lgpl3Plus;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/ndpi/default.nix

···
 { lib, stdenv, fetchFromGitHub, which, autoconf, automake, libtool, libpcap
 , pkg-config }:
 
-let version = "3.4"; in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "ndpi";
-  inherit version;
+  version = "3.4";
 
   src = fetchFromGitHub {
     owner = "ntop";

pkgs/development/libraries/nix-plugins/default.nix

···
 { lib, stdenv, fetchFromGitHub, nix, cmake, pkg-config, boost }:
-let version = "6.0.0"; in
-stdenv.mkDerivation {
+
+stdenv.mkDerivation rec {
   pname = "nix-plugins";
-  inherit version;
+  version = "6.0.0";
 
   src = fetchFromGitHub {
     owner = "shlevy";

pkgs/development/libraries/nss/3.53.nix

···
     url = "http://dev.gentoo.org/~polynomial-c/mozilla/nss-3.15.4-pem-support-20140109.patch.xz";
     sha256 = "10ibz6y0hknac15zr6dw4gv9nb5r5z9ym6gq18j3xqx7v7n3vpdw";
   };
-  version = "3.53.1";
-  underscoreVersion = builtins.replaceStrings ["."] ["_"] version;
-
 in stdenv.mkDerivation rec {
   pname = "nss";
-  inherit version;
+  version = "3.53.1";
 
   src = fetchurl {
-    url = "mirror://mozilla/security/nss/releases/NSS_${underscoreVersion}_RTM/src/${pname}-${version}.tar.gz";
+    url = "mirror://mozilla/security/nss/releases/NSS_${lib.replaceStrings ["."] ["_"] version}_RTM/src/${pname}-${version}.tar.gz";
     sha256 = "05jk65x3zy6q8lx2djj8ik7kg741n88iy4n3bblw89cv0xkxxk1d";
   };
 

pkgs/development/libraries/ntrack/default.nix

···
 { lib, stdenv, fetchurl, qt4, pkg-config, libnl, python }:
 
-let
-  version = "016";
-in
-
 stdenv.mkDerivation rec {
   pname = "ntrack";
-  inherit version;
+  version = "016";
 
   src = fetchurl {
     url = "https://launchpad.net/ntrack/main/${version}/+download/${pname}-${version}.tar.gz";

pkgs/development/libraries/opencore-amr/default.nix

···
 { lib, stdenv, fetchurl }:
 
-let
-    version = "0.1.5";
-in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "opencore-amr";
-  inherit version;
+  version = "0.1.5";
   src = fetchurl {
     url = "https://vorboss.dl.sourceforge.net/project/opencore-amr/opencore-amr/opencore-amr-${version}.tar.gz";
     sha256 = "0hfk9khz3by0119h3jdwgdfd7jgkdbzxnmh1wssvylgnsnwnq01c";

pkgs/development/libraries/openwsman/default.nix

···
     license      = licenses.bsd3;
     maintainers  = with maintainers; [ deepfire ];
     platforms    = platforms.linux; # PAM is not available on Darwin
-    inherit version;
   };
 }

pkgs/development/libraries/osip/default.nix

···
     description = "The GNU oSIP library, an implementation of the Session Initiation Protocol (SIP)";
     maintainers = with lib.maintainers; [ raskin ];
     platforms = lib.platforms.all;
-    inherit version;
   };
 }

pkgs/development/libraries/pmix/default.nix

···
 , libtool, flex, libevent, hwloc, munge, zlib, pandoc
 } :
 
-let
+stdenv.mkDerivation rec {
+  pname = "pmix";
   version = "3.2.3";
-
-in stdenv.mkDerivation {
-  pname = "pmix";
-  inherit version;
 
   src = fetchFromGitHub {
     repo = "openpmix";

pkgs/development/libraries/safefile/default.nix

···
   };
 
   meta = {
-    inherit version;
     description = "File open routines to safely open a file when in the presence of an attack";
     license = lib.licenses.asl20 ;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/sblim-sfcc/default.nix

···
     license     = licenses.cpl10;
     maintainers = with maintainers; [ deepfire ];
     platforms   = platforms.unix;
-    inherit version;
   };
 }

pkgs/development/libraries/science/astronomy/wcslib/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "wcslib";
-  version = "7.6";
+  version = "7.7";
 
   src = fetchurl {
     url = "ftp://ftp.atnf.csiro.au/pub/software/wcslib/${pname}-${version}.tar.bz2";
-    sha256 = "sha256-VLuMkhZ6fxP4qnP8S4oJeFJW0smCE0Z968eigqQxMYs=";
+    sha256 = "sha256-pwjmtOkOLNZCdDRxW1kbucPUAFyZcl7ElLjgvtLeU1U=";
   };
 
   nativeBuildInputs = [ flex ];

pkgs/development/libraries/science/math/liblapack/default.nix

···
 }:
 let
   inherit (lib) optional;
-  version = "3.9.1";
 in
 
 stdenv.mkDerivation rec {
   pname = "liblapack";
-  inherit version;
+  version = "3.9.1";
 
   src = fetchFromGitHub {
     owner = "Reference-LAPACK";
···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "Linear Algebra PACKage";
     homepage = "http://www.netlib.org/lapack/";
     license = licenses.bsd3;

pkgs/development/libraries/science/math/lrs/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Implementation of the reverse search algorithm for vertex enumeration/convex hull problems";
     license = lib.licenses.gpl2 ;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/sfml/default.nix

···
 , IOKit, Foundation, AppKit, OpenAL
 }:
 
-let
-  version = "2.5.1";
-in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "sfml";
-  inherit version;
+  version = "2.5.1";
 
   src = fetchzip {
     url = "https://github.com/SFML/SFML/archive/${version}.tar.gz";

pkgs/development/libraries/startup-notification/default.nix

···
 {lib, stdenv, fetchurl, libX11, libxcb, pkg-config, xcbutil}:
 
-let
+stdenv.mkDerivation rec {
+  pname = "libstartup-notification";
   version = "0.12";
-in
-stdenv.mkDerivation {
-  pname = "libstartup-notification";
-  inherit version;
   src = fetchurl {
     url = "https://www.freedesktop.org/software/startup-notification/releases/startup-notification-${version}.tar.gz";
     sha256 = "3c391f7e930c583095045cd2d10eb73a64f085c7fde9d260f2652c7cb3cfbe4a";

pkgs/development/libraries/tachyon/default.nix

···
     cp -r scenes "$out/share/tachyon/scenes"
   '';
   meta = {
-    inherit version;
     description = "A Parallel / Multiprocessor Ray Tracing System";
     license = lib.licenses.bsd3;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/uthash/default.nix

···
 { lib, stdenv, fetchurl, perl }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "uthash";
   version = "2.1.0";
-in
-stdenv.mkDerivation {
-  pname = "uthash";
-  inherit version;
 
   src = fetchurl {
     url = "https://github.com/troydhanson/uthash/archive/v${version}.tar.gz";

pkgs/development/libraries/volume-key/default.nix

···
 , buildPackages
 }:
 
-let
-  version = "0.3.11";
-in stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "volume_key";
-  inherit version;
+  version = "0.3.11";
 
   src = fetchgit {
     url = "https://pagure.io/volume_key.git";

pkgs/development/libraries/wxwidgets/2.9/default.nix

···
 
 with lib;
 
-let
+stdenv.mkDerivation rec {
+  pname = "wxwidgets";
   version = "2.9.4";
-in
-stdenv.mkDerivation {
-  pname = "wxwidgets";
-  inherit version;
 
   src = fetchurl {
     url = "mirror://sourceforge/wxwindows/wxWidgets-${version}.tar.bz2";

pkgs/development/libraries/xmlsec/default.nix

···
 , openssl, nss_3_53, lib, runCommandCC, writeText }:
 
 lib.fix (self:
-let
+stdenv.mkDerivation rec {
+  pname = "xmlsec";
   version = "1.2.31";
-in
-stdenv.mkDerivation {
-  pname = "xmlsec";
-  inherit version;
 
   src = fetchurl {
     url = "https://www.aleksey.com/xmlsec/download/xmlsec1-${version}.tar.gz";

pkgs/development/misc/avr/libc/default.nix

···
 { lib, stdenv, fetchurl, automake, autoconf }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "avr-libc";
   version = "2.0.0";
-in
-stdenv.mkDerivation {
-  pname = "avr-libc";
-  inherit version;
 
   src = fetchurl {
     url = "https://download.savannah.gnu.org/releases/avr-libc/avr-libc-2.0.0.tar.bz2";

pkgs/development/misc/stm32/betaflight/default.nix

···
   "OMNINXT"    # 3.4.0-rc4: has not specified a valid STM group, must be one of F1, F3, F405, F411 or F7x5. Have you prepared a valid target.mk?
 ]}:
 
-let
-
-  version = "3.4.0-rc4";
-
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
 
   pname = "betaflight";
-  inherit version;
+  version = "3.4.0-rc4";
 
   src = fetchFromGitHub {
     owner = "betaflight";

pkgs/development/misc/stm32/inav/default.nix

···
 , gcc-arm-embedded, binutils-arm-embedded, ruby
 }:
 
-let
-
-  version = "2.0.0-rc2";
-
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
 
   pname = "inav";
-  inherit version;
+  version = "2.0.0-rc2";
 
   src = fetchFromGitHub {
     owner = "iNavFlight";

pkgs/development/mobile/abootimg/default.nix

···
 { lib, stdenv, fetchFromGitHub, coreutils, cpio, findutils, gzip, makeWrapper, util-linux }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "abootimg";
   version = "0.6";
-in
-stdenv.mkDerivation {
-  pname = "abootimg";
-  inherit version;
 
   src = fetchFromGitHub {
     owner = "ggrandou";

pkgs/development/node-packages/default.nix

···
-{ pkgs, nodejs, stdenv, fetchFromGitHub }:
+{ pkgs, nodejs, stdenv, applyPatches, fetchFromGitHub, fetchpatch }:
 
 let
   since = (version: pkgs.lib.versionAtLeast nodejs.version version);
···
 
     node2nix = super.node2nix.override {
       buildInputs = [ pkgs.makeWrapper ];
+      # We need to apply a patch to the source, but buildNodePackage doesn't allow patches.
+      # So we pin the patched commit instead. The commit actually contains two other newer commits
+      # since the last (1.9.0) release, but actually this is a good thing since one of them is a
+      # Hydra-specific fix.
+      src = applyPatches {
+        src = fetchFromGitHub {
+          owner = "svanderburg";
+          repo = "node2nix";
+          rev = "node2nix-1.9.0";
+          sha256 = "0l4wp1131nhl9c14cn8bwawb8f77h1nfbnswgi5lp5m3kzkb27jn";
+        };
+
+        patches = [
+          # remove node_ name prefix
+          (fetchpatch {
+            url = "https://github.com/svanderburg/node2nix/commit/b54d45207427ff46e90f16f2f32771fdc8bff5a4.patch";
+            sha256 = "03cg2xwryvdlvg299dg91qxicrw2r43grja80an9zkb875ps8jxh";
+          })
+          # set meta platform
+          (fetchpatch {
+            url = "https://github.com/svanderburg/node2nix/commit/58736093161f2d237c17e75a96529b018cd0ac64.patch";
+            sha256 = "1c91qfqa6p4hzyafv5pq6rpgnny2805n007b1443gbqwrz5awz6n";
+          })
+        ];
+      };
       postInstall = ''
         wrapProgram "$out/bin/node2nix" --prefix PATH : ${pkgs.lib.makeBinPath [ pkgs.nix ]}
       '';

pkgs/development/node-packages/node-env.nix

···
     , dontStrip ? true
     , unpackPhase ? "true"
     , buildPhase ? "true"
+    , meta ? {}
     , ... }@args:
 
     let
-      extraArgs = removeAttrs args [ "name" "dependencies" "buildInputs" "dontStrip" "dontNpmInstall" "preRebuild" "unpackPhase" "buildPhase" ];
+      extraArgs = removeAttrs args [ "name" "dependencies" "buildInputs" "dontStrip" "dontNpmInstall" "preRebuild" "unpackPhase" "buildPhase" "meta" ];
     in
     stdenv.mkDerivation ({
-      name = "node_${name}-${version}";
+      name = "${name}-${version}";
       buildInputs = [ tarWrapper python nodejs ]
         ++ lib.optional (stdenv.isLinux) utillinux
         ++ lib.optional (stdenv.isDarwin) libtool
···
         # Run post install hook, if provided
         runHook postInstall
       '';
+
+      meta = {
+        # default to Node.js' platforms
+        platforms = nodejs.meta.platforms;
+      } // meta;
     } // extraArgs);
 
   # Builds a node environment (a node_modules folder and a set of binaries)

pkgs/development/python-modules/blocksat-cli/default.nix

···
+{ buildPythonPackage
+, fetchPypi
+, lib
+, distro
+, pysnmp
+, python-gnupg
+, qrcode
+, requests
+, sseclient-py
+, zfec
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "blocksat-cli";
+  version = "0.3.2";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "06ky5kahh8dm1d7ckid3fdwizvkh3g4aycm39r00kwxdlfca7bgf";
+  };
+
+  propagatedBuildInputs = [
+    distro
+    pysnmp
+    python-gnupg
+    qrcode
+    requests
+    sseclient-py
+    zfec
+  ];
+
+  checkInputs = [ pytestCheckHook ];
+
+  pytestFlagsArray = [
+    # disable tests which require being connected to the satellite
+    "--ignore=blocksatcli/test_satip.py"
+    "--ignore=blocksatcli/api/test_net.py"
+    # disable tests which require being online
+    "--ignore=blocksatcli/api/test_order.py"
+  ];
+
+  meta = with lib; {
+    description = "Blockstream Satellite CLI";
+    homepage = "https://github.com/Blockstream/satellite";
+    license = licenses.gpl3Only;
+    maintainers = with maintainers; [ prusnak ];
+  };
+}

pkgs/development/python-modules/editables/default.nix

···
   # Tests not included in archive.
   doCheck = false;
 
-  meta = {
+  pythonImportsCheck = [ "editables" ];
+
+  meta = with lib; {
     description = "Editable installations";
-    homepage = https://github.com/pfmoore/editables;
-    license = lib.licenses.mit;
+    maintainers = with maintainers; [ ];
+    homepage = "https://github.com/pfmoore/editables";
+    license = licenses.mit;
   };
 }

pkgs/development/python-modules/ev3dev2/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, python
+, pillow
+}:
+
+buildPythonPackage rec {
+  pname = "ev3dev2";
+  version = "2.1.0";
+
+  src = fetchFromGitHub {
+    owner = "ev3dev";
+    repo = "ev3dev-lang-python";
+    rev = version;
+    sha256 = "XxsiQs3k5xKb+3RewARbvBbxaztdvdq3w5ZMgTq+kRc=";
+    fetchSubmodules = true;
+  };
+
+  postPatch = ''
+    echo "${version}\n" > RELEASE-VERSION
+  '';
+
+  propagatedBuildInputs = [ pillow ];
+
+  checkPhase = ''
+    chmod -R g+rw ./tests/fake-sys/devices/**/*
+    ${python.interpreter} -W ignore::ResourceWarning tests/api_tests.py
+  '';
+
+  meta = with lib; {
+    description = "Python language bindings for ev3dev";
+    homepage = "https://github.com/ev3dev/ev3dev-lang-python";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ angustrau ];
+  };
+}

pkgs/development/python-modules/python-wifi/default.nix

···
   };
 
   meta = with lib; {
-    inherit version;
     description = "Read & write wireless card capabilities using the Linux Wireless Extensions";
     homepage = "http://pythonwifi.tuxfamily.org/";
     # From the README: "pythonwifi is licensed under LGPLv2+, however, the

pkgs/development/python-modules/pyutil/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
-, setuptoolsDarcs
-, setuptoolsTrial
 , simplejson
+, mock
 , twisted
 , isPyPy
 }:
···
     sha256 = "8c4d4bf668c559186389bb9bce99e4b1b871c09ba252a756ccaacd2b8f401848";
   };
 
-  buildInputs = [ setuptoolsDarcs setuptoolsTrial ] ++ (if doCheck then [ simplejson ] else []);
-  propagatedBuildInputs = [ twisted ];
+  propagatedBuildInputs = [ simplejson ];
 
-  # Tests fail because they try to write new code into the twisted
-  # package, apparently some kind of plugin.
-  doCheck = false;
+  checkInputs = [ mock twisted ];
 
   prePatch = lib.optionalString isPyPy ''
     grep -rl 'utf-8-with-signature-unix' ./ | xargs sed -i -e "s|utf-8-with-signature-unix|utf-8|g"
···
       we're not alone in wanting tools like these.
     '';
 
-    homepage = "http://allmydata.org/trac/pyutil";
+    homepage = "https://github.com/tpltnt/pyutil";
     license = licenses.gpl2Plus;
+    maintainers = with maintainers; [ prusnak ];
   };
 
 }

pkgs/development/python-modules/pyvicare/default.nix

···
 { lib
 , buildPythonPackage
-, fetchPypi
+, fetchFromGitHub
 , pythonOlder
 , requests_oauthlib
 , simplejson
+, pkce
+, pytestCheckHook
 }:
 
 buildPythonPackage rec {
   pname = "pyvicare";
-  version = "0.2.5";
+  version = "1.0.0";
   disabled = pythonOlder "3.7";
 
-  src = fetchPypi {
-    pname = "PyViCare";
-    inherit version;
-    sha256 = "16wqqjs238ad6znlz2gjadqj8891226bd02a1106xyz6vbbk2gdk";
+  src = fetchFromGitHub {
+    owner = "somm15";
+    repo = "PyViCare";
+    rev = version;
+    sha256 = "05dlasx18fkmh4z1w8550yrb26fmsb5bc73wr9whmkasm32gpfl1";
   };
 
+  SETUPTOOLS_SCM_PRETEND_VERSION = version;
+
   propagatedBuildInputs = [
     requests_oauthlib
     simplejson
+    pkce
   ];
 
-  # The published tarball on PyPI is incomplete and there are GitHub releases
-  doCheck = false;
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  postPatch = ''
+    substituteInPlace setup.py \
+      --replace "version_config=True," 'version="${version}",' \
+      --replace "'setuptools-git-versioning'" " "
+  '';
+
   pythonImportsCheck = [ "PyViCare" ];
 
   meta = with lib; {

pkgs/development/python-modules/zfec/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
-, setuptoolsDarcs
 , pyutil
+, setuptoolsTrial
+, twisted
 }:
 
 buildPythonPackage rec {
···
     sha256 = "6033b2f3cc3edacf3f7eeed5f258c1ebf8a1d7e5e35b623db352512ce564e5ca";
   };
 
-  buildInputs = [ setuptoolsDarcs ];
   propagatedBuildInputs = [ pyutil ];
 
+  checkInputs = [ setuptoolsTrial twisted ];
+
   # argparse is in the stdlib but zfec doesn't know that.
   postPatch = ''
     sed -i -e '/argparse/d' setup.py
   '';
 
   meta = with lib; {
-    homepage = "http://allmydata.org/trac/zfec";
+    homepage = "https://github.com/tahoe-lafs/zfec";
     description = "Zfec, a fast erasure codec which can be used with the command-line, C, Python, or Haskell";
     longDescription = ''
       Fast, portable, programmable erasure coding a.k.a. "forward
···
       and Haskell API.
     '';
     license = licenses.gpl2Plus;
+    maintainers = with maintainers; [ prusnak ];
   };
 
 }

pkgs/development/ruby-modules/bundix/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "Creates Nix packages from Gemfiles";
     longDescription = ''
       This is a tool that converts Gemfile.lock files to nix expressions.

pkgs/development/tools/analysis/radare2/default.nix

···
     license = lib.licenses.gpl2Plus;
     maintainers = with lib.maintainers; [ raskin makefu mic92 ];
     platforms = with lib.platforms; linux;
-    inherit version;
   };
 }

pkgs/development/tools/build-managers/apache-ant/1.9.nix

···
 { fetchurl, lib, stdenv, coreutils, makeWrapper }:
 
-let version = "1.9.15"; in
+let version = "1.9.16"; in
 
 stdenv.mkDerivation {
   pname = "ant";
···
 
   src = fetchurl {
     url = "mirror://apache/ant/binaries/apache-ant-${version}-bin.tar.bz2";
-    sha256 = "0yfx5qsvrg12lar4908ndbnlpppy7g7qk8ay41y4sz9g873v07mr";
+    sha256 = "0rif9kj6njajy951w3aapk27y1mbaxb08whs126v533h96rb1kjp";
   };
 
   contrib = fetchurl {

pkgs/development/tools/build-managers/apache-ant/default.nix

···
 { fetchurl, lib, stdenv, coreutils, makeWrapper }:
 
-let version = "1.10.9"; in
+let version = "1.10.11"; in
 
 stdenv.mkDerivation {
   pname = "ant";
···
 
   src = fetchurl {
     url = "mirror://apache/ant/binaries/apache-ant-${version}-bin.tar.bz2";
-    sha256 = "1ab8ybczvk12501dnj450a3d4v43ca0pjhk33s175hax46s58z47";
+    sha256 = "19m8xb7h6xm4jykzb79kakbx1pa4awaglw6z31pbfg8m5pmwkipz";
   };
 
   contrib = fetchurl {

pkgs/development/tools/build-managers/gnumake/default.nix

···
-{ lib, stdenv, fetchurl, guileSupport ? false, pkg-config ? null , guile ? null }:
-
-assert guileSupport -> ( pkg-config != null && guile != null );
+{ lib, stdenv, fetchurl, guileSupport ? false, pkg-config, guile }:
 
 let
   version = "4.3";

pkgs/development/tools/butane/default.nix

···
 
 buildGoModule rec {
   pname = "butane";
-  version = "0.12.1";
+  version = "0.13.0";
 
   src = fetchFromGitHub {
     owner = "coreos";
     repo = "butane";
     rev = "v${version}";
-    sha256 = "1bgh7h3hwrgjkw72233qzqpkshzbizhdapa0lalzj1xnclq3rqlp";
+    sha256 = "0z1cq43dnj73k0idjhc310h00a1mryk2297w3yy6k1sa95swlz9m";
   };
 
   vendorSha256 = null;

pkgs/development/tools/gopls/default.nix

···
 
 buildGoModule rec {
   pname = "gopls";
-  version = "0.6.10";
+  version = "0.7.0";
 
   src = fetchgit {
     rev = "gopls/v${version}";
     url = "https://go.googlesource.com/tools";
-    sha256 = "13mv6rvqlmgn1shx0hnlqxgqiiiz1ij37j30jz1jkr9kcrbxpacr";
+    sha256 = "0vylrsmpszij23yngk7mfysp8rjbf29nyskbrwwysf63r9xbrwbi";
   };
 
   modRoot = "gopls";
-  vendorSha256 = "01apsvkds8f3m88inb37z4lgalrbjp12xr2jikwx7n10hjddgbqi";
+  vendorSha256 = "1mnc84nvl7zhl4pzf90cd0gvid9g1jph6hcxk6lrlnfk2j2m75mj";
 
   doCheck = false;
 

pkgs/development/tools/misc/debugedit/default.nix

···
+#TODO@deliciouslytyped The tool seems to unnecessarily force mutable access for the debugedit `-l` feature
+{fetchgit, lib, stdenv, autoreconfHook, pkg-config, elfutils, help2man, util-linux}:
+stdenv.mkDerivation {
+  name = "debugedit";
+  version = "unstable-2021-07-05";
+
+  nativeBuildInputs = [ autoreconfHook pkg-config help2man ];
+  buildInputs = [ elfutils ];
+  checkInputs = [ util-linux ]; # Tests use `rev`
+
+  src = fetchgit {
+    url = "git://sourceware.org/git/debugedit.git";
+    rev = "e04296ddf34cbc43303d7af32ab3a73ac20af51a";
+    sha256 = "19cjkpzhdn2z6fl7xw8556m6kyrb7nxwbz2rmiv2rynyp74yg44z";
+  };
+
+  preBuild = ''
+    patchShebangs scripts/find-debuginfo.in
+  '';
+
+  doCheck = true;
+
+  meta = with lib; {
+    description = "Provides programs and scripts for creating debuginfo and source file distributions, collect build-ids and rewrite source paths in DWARF data for debugging, tracing and profiling";
+    homepage = "https://sourceware.org/debugedit/";
+    license = licenses.gpl3Plus;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ deliciouslytyped ];
+  };
+}

pkgs/development/tools/mold/default.nix

···
+{ stdenv
+, fetchFromGitHub
+, lib
+, autoPatchelfHook
+, cmake
+, tbb
+, llvmPackages_latest
+, xxHash
+, zlib
+, openssl
+}:
+
+stdenv.mkDerivation rec {
+  pname = "mold";
+  version = "0.9.2";
+
+  src = fetchFromGitHub {
+    owner = "rui314";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "sha256-2LXOPirhjAifKYPgngUJwEdGrKMYsRySr5TL2x2p8J0=";
+  };
+
+  buildInputs = [ tbb zlib openssl ];
+  nativeBuildInputs = [ autoPatchelfHook cmake xxHash ];
+
+  dontUseCmakeConfigure = true;
+  EXTRA_LDFLAGS = "-fuse-ld=${llvmPackages_latest.lld}/bin/ld.lld";
+  LTO = 1;
+  makeFlags = [ "PREFIX=${placeholder "out"}" ];
+
+  meta = with lib; {
+    description = "A high performance drop-in replacement for existing unix linkers";
+    homepage = "https://github.com/rui314/mold";
+    license = lib.licenses.agpl3Plus;
+    maintainers = with maintainers; [ nitsky ];
+    broken = stdenv.isAarch64;
+  };
+}

pkgs/games/fairymax/default.nix

···
     cp fmax.ini "$out/share/fairymax"
   '';
   meta = {
-    inherit version;
     description = "A small chess engine supporting fairy pieces";
     longDescription = ''
        A version of micro-Max that reads the piece description

pkgs/games/fish-fillets-ng/default.nix

···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "A puzzle game";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ raskin ];

pkgs/games/xsok/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "A generic Sokoban game for X11";
     license = lib.licenses.gpl2Plus;
     maintainers = [lib.maintainers.raskin];

pkgs/misc/screensavers/xscreensaver/default.nix

···
     license = lib.licenses.mit;
     maintainers = with lib.maintainers; [ raskin ];
     platforms = lib.platforms.unix; # Once had cygwin problems
-    inherit version;
     downloadPage = "https://www.jwz.org/xscreensaver/download.html";
     updateWalker = true;
   };

pkgs/misc/vim-plugins/generated.nix

···
     meta.homepage = "https://github.com/eikenb/acp/";
   };
 
+  aerial-nvim = buildVimPluginFrom2Nix {
+    pname = "aerial-nvim";
+    version = "2021-07-17";
+    src = fetchFromGitHub {
+      owner = "stevearc";
+      repo = "aerial.nvim";
+      rev = "e641878818c5545afd09b093a368f2d03f169273";
+      sha256 = "1zykpbd42nwvpkgbq0hh52micyybxyvia6558fp6nlcs56bdmqf4";
+    };
+    meta.homepage = "https://github.com/stevearc/aerial.nvim/";
+  };
+
   agda-vim = buildVimPluginFrom2Nix {
     pname = "agda-vim";
     version = "2020-11-23";
···
 
   ale = buildVimPluginFrom2Nix {
     pname = "ale";
-    version = "2021-07-14";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "dense-analysis";
       repo = "ale";
-      rev = "d8f4e8b7081724c0b9ff2491dd68409b3da69b0f";
-      sha256 = "0rwj9rhkzg004jv9q8wr86l9xak4wqf7l5skq1nf8k0xis9aw6d3";
+      rev = "f83a1f70d542ac885b72d1161140d6d999e2d7b2";
+      sha256 = "0mx9g2j32hbpg5gyxn4apkfm28myzpasj4w7dpq6p61c90hwhgq4";
     };
     meta.homepage = "https://github.com/dense-analysis/ale/";
   };
···
 
   aurora = buildVimPluginFrom2Nix {
     pname = "aurora";
-    version = "2021-06-06";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "ray-x";
       repo = "aurora";
-      rev = "6a77e8ecf38b0e7a547df58f499cecc1c50cd444";
-      sha256 = "1yh88v6p1ingwydzr40jcva9gw58ihmgjndaf7h3sp0ldvl75ci2";
+      rev = "af110b7f6080bdc4685cdd5551ba1f79a81910f1";
+      sha256 = "1h2czb183lliib95jn4dxq8cn713s22dc4hd1cj19bzqy4j39qhi";
     };
     meta.homepage = "https://github.com/ray-x/aurora/";
   };
···
 
   chadtree = buildVimPluginFrom2Nix {
     pname = "chadtree";
-    version = "2021-07-15";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "chadtree";
-      rev = "8ed122e474a0316f8b967bb6c35a47e8dd383453";
-      sha256 = "0zk12wd1xs668j3wfdd5vyj685irnjsksrmn2dln6vsyb7xpq3r5";
+      rev = "fa78312b378a7d3a6cb1222d1df05c28238f888b";
+      sha256 = "05j42c3h374hyqqb5m7dddyh4sn08cw64nji3fnv3rk63gm2r4if";
     };
     meta.homepage = "https://github.com/ms-jpq/chadtree/";
   };
···
 
   coc-lua = buildVimPluginFrom2Nix {
     pname = "coc-lua";
-    version = "2021-07-09";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "josa42";
       repo = "coc-lua";
-      rev = "0b3967864c7d5cf94682f07d1cdb8afec3c8753f";
-      sha256 = "0jpjarg6fjlkwwk69pl44f1r8racb0fzf5dqr58fgn31l7zcvrak";
+      rev = "75b97dfdd641d530b86dee603308aea0079736e9";
+      sha256 = "1rmlz74ssf9mpg4fbxinrmxnqcb4p37wi4pz96d6niiii0vj71b2";
     };
     meta.homepage = "https://github.com/josa42/coc-lua/";
   };
···
 
   coc-nvim = buildVimPluginFrom2Nix {
     pname = "coc-nvim";
-    version = "2021-07-15";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "neoclide";
       repo = "coc.nvim";
-      rev = "3c3f118f8d48707f1890c2c212c083228aeac596";
-      sha256 = "0nim2hd0pn910ymm87zwfcw5b7x64h3dsnqhc20yj0r3s5xjg6qi";
+      rev = "9c3c84735c9bcfd62507d6e2a137f90b1ddaa98a";
+      sha256 = "0g479ffpiqz15wwam4vwi8x0w7hbdnk2dxcwzryaf1cqnn6ip6in";
     };
     meta.homepage = "https://github.com/neoclide/coc.nvim/";
   };
···
 
   compe-tmux = buildVimPluginFrom2Nix {
     pname = "compe-tmux";
-    version = "2021-07-09";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "andersevenrud";
       repo = "compe-tmux";
-      rev = "d2837688cb0de46712b602eb9fbd17c6c0a8047b";
-      sha256 = "089vcjqhdbzld89w5rfw6rx2fnybc0xbaa3q6abpckyir175d7a7";
+      rev = "fcb7c80bc6b3df11d5c0d8cde4f12aa9d3653cdd";
+      sha256 = "18v1g8l11caqlag3d55vvn1v7k99600jzlzzmp6bv5pmi4lmhq0g";
     };
     meta.homepage = "https://github.com/andersevenrud/compe-tmux/";
   };
···
 
   gentoo-syntax = buildVimPluginFrom2Nix {
     pname = "gentoo-syntax";
-    version = "2021-04-28";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "gentoo";
       repo = "gentoo-syntax";
-      rev = "9b016fd42ba37395d9299e1e811b282b29effb63";
-      sha256 = "0x3rg1pxildm2mrfr28f4d41z4zzf6v2jng41nzylwm5r4c5r1gd";
+      rev = "14aec3bde121c797f9131da0d4b18a932598bb8f";
+      sha256 = "1mcn4dhwjay5c0y650y2rxz9acxwfsninwrvp20ssgi4gcw2vg76";
     };
     meta.homepage = "https://github.com/gentoo/gentoo-syntax/";
   };
···
 
   gitsigns-nvim = buildVimPluginFrom2Nix {
     pname = "gitsigns-nvim";
-    version = "2021-07-09";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "lewis6991";
       repo = "gitsigns.nvim";
-      rev = "acbf54d357ddb2c558d7f536a8da409d6e357dff";
-      sha256 = "0kvgfvabgg992309xw15slpk0klvzlcjdlnbvgva0bkwkybagnja";
+      rev = "f29e8a461e05881c69953b41784a1aeb4b70a422";
+      sha256 = "1nda02nd9v17yv6fawidg8c3haijysb9zc04sjy0v708h2nw8qhj";
     };
     meta.homepage = "https://github.com/lewis6991/gitsigns.nvim/";
   };
···
 
   lightspeed-nvim = buildVimPluginFrom2Nix {
     pname = "lightspeed-nvim";
-    version = "2021-07-12";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "ggandor";
       repo = "lightspeed.nvim";
-      rev = "a3c62fc1d2bb9fffa14b42b97c100f148e96f15b";
-      sha256 = "0mp4p5d2m51f716938pzm8xifh8nxlmspdxpwbzqgnkf1b1rcvz0";
+      rev = "62f02aabce3b5af190cf113d5bdf4a8271a966c3";
+      sha256 = "1cckxvr035vsall3891j60yc1a12p8q63rjnm7ac1wzdhh7d8c38";
     };
     meta.homepage = "https://github.com/ggandor/lightspeed.nvim/";
   };
···
 
   lsp_signature-nvim = buildVimPluginFrom2Nix {
     pname = "lsp_signature-nvim";
-    version = "2021-07-10";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "ray-x";
       repo = "lsp_signature.nvim";
-      rev = "27fa218ca099a07eefbe9d5b5e57f06887b48b5f";
-      sha256 = "0yi35p05f28dm6l1qk93chizachnk2ciybrnvqcnx0ry0cipd727";
+      rev = "29e685953d362c723c55417eea2b795b5bcc2ef5";
+      sha256 = "183511fy34sazpkaxcpr250id4zyxhs5mqws49b516sh0d875fjj";
     };
     meta.homepage = "https://github.com/ray-x/lsp_signature.nvim/";
   };
···
 
   minimap-vim = buildVimPluginFrom2Nix {
     pname = "minimap-vim";
-    version = "2021-07-13";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "wfxr";
       repo = "minimap.vim";
-      rev = "1db8e5588bfd2038efb690de5991746c8bf03543";
-      sha256 = "00mpza33p3yybr3fgigx7gy8faj8f5ypdws9aymxs30a12p67d1q";
+      rev = "2d61b880aba6e4e0b730303e0e980bf0afd73961";
+      sha256 = "01az8gkhhvndnrjavk7jzi5wy03ybca97cbxpdimx2wpvxly484j";
     };
     meta.homepage = "https://github.com/wfxr/minimap.vim/";
   };
···
 
   neorg = buildVimPluginFrom2Nix {
     pname = "neorg";
-    version = "2021-07-15";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "vhyrro";
       repo = "neorg";
-      rev = "4a6eb9d52d544d378c82f17c448eb9c697cf448c";
-      sha256 = "14hsyy23xb5p8lfna3kiarr0na1n1bykr8scwslczhpi9fwcgq85";
+      rev = "7f9f1d328c218b041ce899def4923334a5355c14";
+      sha256 = "1f7acjy3xhiz2yzkdp5x5f4p28zz583h7snyzrc2l8w7fwz600x9";
     };
     meta.homepage = "https://github.com/vhyrro/neorg/";
   };
···
     meta.homepage = "https://github.com/kassio/neoterm/";
   };
 
+  neovim-ayu = buildVimPluginFrom2Nix {
+    pname = "neovim-ayu";
+    version = "2021-07-17";
+    src = fetchFromGitHub {
+      owner = "Shatur";
+      repo = "neovim-ayu";
+      rev = "755b4a379ef4812f9656fb3f59220cf3a45c2070";
+      sha256 = "0irjjpfrl6i7hfvay6b187i7dkkjq40fdcrx53xxfk9qq47l1z13";
+    };
+    meta.homepage = "https://github.com/Shatur/neovim-ayu/";
+  };
+
   neovim-fuzzy = buildVimPluginFrom2Nix {
     pname = "neovim-fuzzy";
     version = "2021-07-02";
···
 
   nord-nvim = buildVimPluginFrom2Nix {
     pname = "nord-nvim";
-    version = "2021-07-10";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "shaunsingh";
       repo = "nord.nvim";
-      rev = "05814232c4369ef36961123de6ff3826936e9784";
-      sha256 = "16z7kk8cvf52xnpkw8jvaaskd6zmah14va8cfgi52ckfl482w2pd";
+      rev = "44ae0a84087135e23fb5a90c9726f8b161277652";
+      sha256 = "0zhv06arl7x3wx20r26v3vc1i4909h657syrqbyh5k93n1hmc21j";
     };
     meta.homepage = "https://github.com/shaunsingh/nord.nvim/";
   };
···
 
   nterm-nvim = buildVimPluginFrom2Nix {
     pname = "nterm-nvim";
-    version = "2021-07-16";
+    version = "2021-07-15";
     src = fetchFromGitHub {
       owner = "jlesquembre";
       repo = "nterm.nvim";
···
 
   nvim-bufferline-lua = buildVimPluginFrom2Nix {
     pname = "nvim-bufferline-lua";
-    version = "2021-07-15";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "akinsho";
       repo = "nvim-bufferline.lua";
-      rev = "cebafb95622205a414a6c10bf0e40d197cc652b1";
-      sha256 = "1qd8gaigkyhkz5nrizc3jhwa69v4fcymd2446l0s24pv3kxc2an3";
+      rev = "b90cbdef2d7eab5fa8b3693bb321305e4455f329";
+      sha256 = "16n168z9gdy0p0yljpx3lv958ix1369qgqc65pjs9ib5sij03q2s";
     };
     meta.homepage = "https://github.com/akinsho/nvim-bufferline.lua/";
   };
···
 
   nvim-compe = buildVimPluginFrom2Nix {
     pname = "nvim-compe";
-    version = "2021-07-14";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "hrsh7th";
       repo = "nvim-compe";
-      rev = "29879b29b63fcd315e247a110a505e6a337b584a";
-      sha256 = "18ybvc2l07l91gkl3w63l58pm9q7bx2p0fmkyxpqb48cii98n4yj";
+      rev = "ef97a9b17c655d8b603c5fa9abf6fbb623a1dad4";
+      sha256 = "0lrna8ryw391dpvi64x3q2gj484mf5s6wlqqg6a52a5s3ganh41n";
     };
     meta.homepage = "https://github.com/hrsh7th/nvim-compe/";
   };
···
 
   nvim-hlslens = buildVimPluginFrom2Nix {
     pname = "nvim-hlslens";
-    version = "2021-06-12";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "kevinhwang91";
       repo = "nvim-hlslens";
-      rev = "dd688e37458a6fdeb050942da8c1260389c2a99a";
-      sha256 = "0q4bmp3wy0miaysldpfm6646r8c0llygfnlbmk5brs4la321hjld";
+      rev = "1df774df358e70cbc9f74f34d38a82e756ceb001";
+      sha256 = "1zf5i30g49f7ks6hhvr84ac3ka57lv96c124cpr1d4h9xld1n9q8";
     };
     meta.homepage = "https://github.com/kevinhwang91/nvim-hlslens/";
   };
···
 
   nvim-lspconfig = buildVimPluginFrom2Nix {
     pname = "nvim-lspconfig";
-    version = "2021-07-15";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "neovim";
       repo = "nvim-lspconfig";
-      rev = "9d49032a64d8a275123ad7f84e9c699d279307fe";
-      sha256 = "18z22v8qn6jhg16hsrldqaqqp987w1nnqz0lhn0byzbsac62xwga";
+      rev = "1729b502fa00df2fdcbfa118b404b8b8a8a2d6a3";
+      sha256 = "1r4ajaxvf9kpfq42b81c08ixfqakiq8fibn89qar7sd4a7634dsg";
     };
     meta.homepage = "https://github.com/neovim/nvim-lspconfig/";
   };
···
 
   nvim-ts-rainbow = buildVimPluginFrom2Nix {
     pname = "nvim-ts-rainbow";
-    version = "2021-07-13";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "p00f";
       repo = "nvim-ts-rainbow";
-      rev = "15e8a45517c596b9acd9406bcb6f650d6bfdb339";
-      sha256 = "1m1bc5w1qw8cxjnhhanh7rw78d3zkdxm6vgldh22zhmvgj1cb7zl";
+      rev = "4887eb7526004e069bd8898041a714c7eaad72e7";
+      sha256 = "1abdjkiyyzgaw3lskjfb0lcilkp8qqlaqj8kyfmzf4w4mz9ijh4d";
     };
     meta.homepage = "https://github.com/p00f/nvim-ts-rainbow/";
   };
···
 
   onedark-nvim = buildVimPluginFrom2Nix {
     pname = "onedark-nvim";
-    version = "2021-06-18";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "olimorris";
       repo = "onedark.nvim";
-      rev = "1304235686bc682e744ba9691c7545e0b27762ea";
-      sha256 = "0ygy9hl171qa9zp8gmj80azp4vxxn5ba3v19mgy36qf390jgrwc4";
+      rev = "df80982b43ced71a286933e830b26faabb9a36e9";
+      sha256 = "1hddmi543js7z77383ppvdray2dri5jn8lcqivk9xm5l8maz52cz";
     };
     meta.homepage = "https://github.com/olimorris/onedark.nvim/";
   };
···
 
   packer-nvim = buildVimPluginFrom2Nix {
     pname = "packer-nvim";
-    version = "2021-07-15";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "wbthomason";
       repo = "packer.nvim";
-      rev = "d693133efb4a1f171d581dad8d399d6a3cd4b90a";
-      sha256 = "1avcdfsq14nqbqrvlgz7cslaxi1ni5lsvz78dj5xc35ppgwyr1ci";
+      rev = "b6a904b341c56c5386bdd5c991439a834d061874";
+      sha256 = "1ja6k5cw6v5nhi91s643r6c38a15rgi4n8cb0k5pc5q252q8km04";
     };
     meta.homepage = "https://github.com/wbthomason/packer.nvim/";
   };
···
 
   rust-tools-nvim = buildVimPluginFrom2Nix {
     pname = "rust-tools-nvim";
-    version = "2021-07-14";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "simrat39";
       repo = "rust-tools.nvim";
-      rev = "da8fb66af44fe2472b58fbf0b83ad4fe2243aaea";
-      sha256 = "0mkjb42ff0w80kbik6hwdx1hvhxlihq17fqypdagmxk58wn71z9y";
+      rev = "a22eec84aaa5b31b5c708eed24a5c09f21ca46c0";
+      sha256 = "14lwhdbpjrq2xyy9kfihjasvqg83bb13fl0r7aw95hngayx69l7k";
     };
     meta.homepage = "https://github.com/simrat39/rust-tools.nvim/";
   };
···
 
   splitjoin-vim = buildVimPluginFrom2Nix {
     pname = "splitjoin-vim";
-    version = "2021-06-28";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "AndrewRadev";
       repo = "splitjoin.vim";
-      rev = "03af68c1ecec4a01b4fe713393c1b3fa4dd21e77";
-      sha256 = "15qja2ywi83qv365b19xrcw02j693bhrdn0wanxdhbqzpp9kwsb9";
+      rev = "e5c60658d9aca5af479ef6371037cc6453a6b1eb";
+      sha256 = "07l7acnhp9nwwkmybjs2fdprql5nanyxxn9z3wl59y8jx2ca44p7";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/AndrewRadev/splitjoin.vim/";
···
 
   sql-nvim = buildVimPluginFrom2Nix {
     pname = "sql-nvim";
-    version = "2021-04-13";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "tami5";
       repo = "sql.nvim";
-      rev = "afd60eef9edff543d4d05ac51d518fd501f2e413";
-      sha256 = "115l3dp1i7pmfsqyqir5c73bprvsnnm737sbbz0dwibnlr5sd2q3";
+      rev = "76277236829ca77dd41d285c794ab8878129e3f8";
+      sha256 = "1vqxn02xy8j7ij4zm7x55zzch1bl8k6313l06mb60zxvw77i5a81";
     };
     meta.homepage = "https://github.com/tami5/sql.nvim/";
   };
···
     meta.homepage = "https://github.com/nvim-telescope/telescope-frecency.nvim/";
   };
 
+  telescope-fzf-native-nvim = buildVimPluginFrom2Nix {
+    pname = "telescope-fzf-native-nvim";
+    version = "2021-07-06";
+    src = fetchFromGitHub {
+      owner = "nvim-telescope";
+      repo = "telescope-fzf-native.nvim";
+      rev = "fe8c8d8cf7ff215ac83e1119cba87c016070b27e";
+      sha256 = "0kzxf3kzw45mlccp8z5zl3cfda4n5afymmdyir3kd248ll904jy1";
+    };
+    meta.homepage = "https://github.com/nvim-telescope/telescope-fzf-native.nvim/";
+  };
+
   telescope-fzf-writer-nvim = buildVimPluginFrom2Nix {
     pname = "telescope-fzf-writer-nvim";
     version = "2021-04-16";
···
 
   telescope-z-nvim = buildVimPluginFrom2Nix {
     pname = "telescope-z-nvim";
-    version = "2021-03-09";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "nvim-telescope";
       repo = "telescope-z.nvim";
-      rev = "c14b6335f42bdda5100f135f18632bf6421c5f0e";
-      sha256 = "01y3b41ff00qi4g11pry73nd851dc5hjl039symhd2y0lf447j7h";
+      rev = "27694fa19bc00cc24b436d671951f516a4a966a1";
+      sha256 = "0g12nfmv2hllw0ylsy362mp1gyaf4ldyiza3jg74c66xwi2jj8i9";
     };
     meta.homepage = "https://github.com/nvim-telescope/telescope-z.nvim/";
   };
 
   telescope-nvim = buildVimPluginFrom2Nix {
     pname = "telescope-nvim";
-    version = "2021-07-14";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "nvim-telescope";
       repo = "telescope.nvim";
-      rev = "37a3a68a78e15900254ae5d9d4f9f0b5100a1735";
-      sha256 = "1a5hsjsz62nb5hlrd0k8wbcnyxa3574jgipphs9s2llf6qfwkfh1";
+      rev = "5b597e7709eec08331ce71b45193117f6fb5626b";
+      sha256 = "1lwr3gayqj6h0ha749p5dfgihjlqydgaidcnblcvvj8vi10ick35";
     };
     meta.homepage = "https://github.com/nvim-telescope/telescope.nvim/";
   };
···
 
   tlib_vim = buildVimPluginFrom2Nix {
     pname = "tlib_vim";
-    version = "2019-09-28";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "tomtom";
       repo = "tlib_vim";
-      rev = "a071b6d41b20069a3520e0d101194a752968973b";
-      sha256 = "05swfvjyai32cbdpg10m3k2frkv017i1avf0nzilqavskvg04vi3";
+      rev = "70c4e222464020edc2809c932b488daaf891eeef";
+      sha256 = "1amx220nbh1s51z35pkhvl3110pbha5qj2rdgxvg8dbqha7py9fx";
     };
     meta.homepage = "https://github.com/tomtom/tlib_vim/";
   };
···
 
   trouble-nvim = buildVimPluginFrom2Nix {
     pname = "trouble-nvim";
-    version = "2021-06-24";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "trouble.nvim";
-      rev = "7de8bc46164ec1f787dee34b6843b61251b1ea91";
-      sha256 = "1ybv7vdvyvyx09zwwx1vw91ids13g24as0ag0jnw6ck95f12r7mn";
+      rev = "059ea2b999171f50019291ee776dd496799fdf3a";
+      sha256 = "06v2jvlw8rjlarx89kfb7ys8y0jkm1f7c4vnws60nfbqgp9c9k98";
     };
     meta.homepage = "https://github.com/folke/trouble.nvim/";
   };
···
 
   twilight-nvim = buildVimPluginFrom2Nix {
     pname = "twilight-nvim";
-    version = "2021-07-13";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "twilight.nvim";
-      rev = "f5718ddbd9bba3184493a4fc11cd38342966904f";
-      sha256 = "1j532h0imw782rvhg75ryqmy5lm0clg32fs3a1cm84srx97l05fp";
+      rev = "f722fa24411d0423a3d2daf6f1b5f8b11df9db2b";
+      sha256 = "0k2vbhs960h346w37ky2mpv1syzjxi19zl9zmnvlsy6annqd892x";
     };
     meta.homepage = "https://github.com/folke/twilight.nvim/";
   };
···
 
   vim-clap = buildVimPluginFrom2Nix {
     pname = "vim-clap";
-    version = "2021-07-11";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "liuchengxu";
       repo = "vim-clap";
-      rev = "e8fda02cd9ee8cbd4955a387cce3752584b85ac0";
-      sha256 = "1l88pxfxjjfc0wfgkr2nj2x3dp3sj2xghyjzihafdp4nrynvygb8";
+      rev = "ee390feaa3bc40de2afa32910ab09de287181146";
+      sha256 = "0q2bnmi6yz7i7lx8i59gzk39fqzjc3y325qjhhyyahwb2xsazzcz";
     };
     meta.homepage = "https://github.com/liuchengxu/vim-clap/";
   };
···
 
   vim-devicons = buildVimPluginFrom2Nix {
     pname = "vim-devicons";
-    version = "2021-05-13";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "ryanoasis";
       repo = "vim-devicons";
-      rev = "4c2df59e37b6680e0ec17b543b11a405dc40262c";
-      sha256 = "0knpfl0lwiy0w2f9qd3gz3yl03dqzn6fllv0isl0iz24csya6v2h";
+      rev = "0a11dae811e6c8b939fe80aeb750469f8ca44d67";
+      sha256 = "07lgjzi10h1gfvr2ij1pc4qxj63n4bg3jvj01ilj6yas56a3hk09";
     };
     meta.homepage = "https://github.com/ryanoasis/vim-devicons/";
   };
···
 
   vim-fugitive = buildVimPluginFrom2Nix {
     pname = "vim-fugitive";
-    version = "2021-07-12";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "tpope";
       repo = "vim-fugitive";
-      rev = "1c2663f516c32f8453f542be10192a49ee844a93";
-      sha256 = "01gh4p2d41khx5cb7hcpjp9gs5fkgil838rnik1gawiw7w83hnaa";
+      rev = "58516a13c623e6b21be6fed1f6067eed67005949";
+      sha256 = "0gzdsp1gz1wpw8z47v3sr9b0ma41qnz0r4iiq0jr84srr3817zpl";
     };
     meta.homepage = "https://github.com/tpope/vim-fugitive/";
   };
···
 
   vim-maktaba = buildVimPluginFrom2Nix {
     pname = "vim-maktaba";
-    version = "2021-05-29";
+    version = "2021-07-17";
     src = fetchFromGitHub {
       owner = "google";
       repo = "vim-maktaba";
-      rev = "2b5565881b31ed4e7ac32b4903827ec9c164216d";
-      sha256 = "13nzkqhyz8jydrwprw06jqcx3w37xv0qdq0809gx748kfvh1dznw";
+      rev = "4e4404dffbd99159af9cfe816d13a6e69aadcee2";
+      sha256 = "1a1k27gvsd2ssnw3w8b29z3q8z2w2jxgcwpx5gd6djk1id26rhb6";
     };
     meta.homepage = "https://github.com/google/vim-maktaba/";
   };
···
 
   vim-rhubarb = buildVimPluginFrom2Nix {
     pname = "vim-rhubarb";
-    version = "2021-04-15";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "tpope";
       repo = "vim-rhubarb";
-      rev = "2590324d7fdaf0c6311fad4ee2a2878acaaec42d";
-      sha256 = "0ljlkzy2r8dzqkcl9pbgshr7swdcdbbxcgfvvmyxrw7swfx1srk9";
+      rev = "b4aad6dc43660db554bba2942026fb9965f1a45e";
+      sha256 = "04ckpl3q1k4l530fhf5srbklfqdz4rfrcapwsa92n4bwskfxbnsp";
     };
     meta.homepage = "https://github.com/tpope/vim-rhubarb/";
   };
···
 
   vim-snippets = buildVimPluginFrom2Nix {
     pname = "vim-snippets";
-    version = "2021-07-11";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "honza";
       repo = "vim-snippets";
-      rev = "e77399e64d6f54a623c52797973a23ecfe28b813";
-      sha256 = "13c90zq8pxd1kfrk5f0zj6r48v86j4fnijss71j7ilb38mj4dyxq";
+      rev = "f1b72d866d6564075a8b0da1f179c0b7de723131";
+      sha256 = "1vfpf0mjwk519gdly44f0ixc5y4609j33fsjsfzwgcmp3xgmf081";
     };
     meta.homepage = "https://github.com/honza/vim-snippets/";
   };
···
 
   vim-twiggy = buildVimPluginFrom2Nix {
     pname = "vim-twiggy";
-    version = "2021-03-19";
+    version = "2021-07-16";
     src = fetchFromGitHub {
       owner = "sodapopcan";
       repo = "vim-twiggy";
-      rev = "cf8aa913329991bfeaa1cabab4bbd8889b0f0790";
-      sha256 = "0j0h95xhb5c59qyx8gc1yrcnsjxffbnycya6wnl7axd71iawwgh8";
+      rev = "cd7286702319d676c622a5f5891dc68563bf6ad5";
+      sha256 = "1xmcnhbny74hr0zciy55gq8c8agds2x1xvdsr1wrghkcr2k15w46";
     };
     meta.homepage = "https://github.com/sodapopcan/vim-twiggy/";
   };
···
     src = fetchFromGitHub {
       owner = "lervag";
       repo = "vimtex";
-      rev = "431f520553bfe721d1ef5db0bb23ec03a86c00a0";
-      sha256 = "1a9j27404hi8s3v7h9kghl7xwgmcblbranlp6kclvvrl7wahvnhg";
+      rev = "13fac7d1d820ee4d72196841800705f149af9868";
+      sha256 = "0k9325pdh5fscj8nhqwj36vdz6lvcgf14r7mmimc7g6i7bxxfpmb";
     };
     meta.homepage = "https://github.com/lervag/vimtex/";
   };

pkgs/misc/vim-plugins/overrides.nix

···
     dependencies = with self; [ telescope-nvim ];
   });
 
+  telescope-fzf-native-nvim = super.telescope-fzf-native-nvim.overrideAttrs (old: {
+    dependencies = with self; [ telescope-nvim ];
+    buildPhase = "make";
+    meta.platforms = lib.platforms.all;
+  });
+
   telescope-fzy-native-nvim = super.telescope-fzy-native-nvim.overrideAttrs (old: {
     dependencies = with self; [ telescope-nvim ];
     preFixup =
···
             libiconv
           ];
 
-          cargoSha256 = "sha256-hcbNjp9KLJO0RANOvtopvdiK0w9ESUXk0KOTPvVcCX4=";
+          cargoSha256 = "sha256-D54R7LK4CH5S7x0g+3K1EJ4b10P7wRAIkHYwCOFJtfg=";
         };
       in
       ''

pkgs/misc/vim-plugins/vim-plugin-names

···
 nvim-lua/popup.nvim
 nvim-telescope/telescope-dap.nvim
 nvim-telescope/telescope-frecency.nvim
+nvim-telescope/telescope-fzf-native.nvim@main
 nvim-telescope/telescope-fzf-writer.nvim
 nvim-telescope/telescope-fzy-native.nvim
 nvim-telescope/telescope-symbols.nvim
···
 sbdchd/neoformat
 sebastianmarkow/deoplete-rust
 SevereOverfl0w/deoplete-github
+Shatur/neovim-ayu
 shaunsingh/moonlight.nvim@pure-lua
 shaunsingh/nord.nvim
 sheerun/vim-polyglot
···
 steelsojka/pears.nvim
 stefandtw/quickfix-reflector.vim
 stephpy/vim-yaml
+stevearc/aerial.nvim
 sunaku/vim-dasht
 sunjon/Shade.nvim
 svermeulen/vim-subversive

pkgs/os-specific/linux/atop/default.nix

···
     longDescription = ''
       Atop is an ASCII full-screen performance monitor that is capable of reporting the activity of all processes (even if processes have finished during the interval), daily logging of system and process activity for long-term analysis, highlighting overloaded system resources by using colors, etc. At regular intervals, it shows system-level activity related to the CPU, memory, swap, disks and network layers, and for every active process it shows the CPU utilization, memory growth, disk utilization, priority, username, state, and exit code.
     '';
-    inherit version;
     license = licenses.gpl2Plus;
     downloadPage = "http://atoptool.nl/downloadatop.php";
   };

pkgs/os-specific/linux/iio-sensor-proxy/default.nix

···
     license = licenses.gpl3 ;
     maintainers = with maintainers; [ peterhoeg ];
     platforms = platforms.linux;
-    inherit version;
   };
 }

pkgs/os-specific/linux/iptables/default.nix

···
     license = licenses.gpl2;
     downloadPage = "https://www.netfilter.org/projects/iptables/files/";
     updateWalker = true;
-    inherit version;
   };
 }

pkgs/os-specific/linux/libnl/default.nix

···
   };
 
   meta = with lib; {
-    inherit version;
     homepage = "http://www.infradead.org/~tgr/libnl/";
     description = "Linux Netlink interface library suite";
     license = licenses.lgpl21;

pkgs/servers/ftp/bftpd/default.nix

···
   enableParallelBuilding = true;
 
   meta = with lib; {
-    inherit version;
     description = "A minimal ftp server";
     downloadPage = "http://bftpd.sf.net/download.html";
     homepage = "http://bftpd.sf.net/";

pkgs/servers/http/nix-binary-cache/default.nix

···
     '';
     maintainers = [lib.maintainers.raskin];
     license = lib.licenses.gpl2Plus;
-    inherit version;
     platforms = lib.platforms.all;
     hydraPlatforms = [];
   };

pkgs/shells/es/default.nix

···
 { lib, stdenv, fetchurl, readline, bison }:
 
-let
-  version = "0.9.1";
-in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
 
   pname = "es";
-  inherit version;
+  version = "0.9.1";
 
   src = fetchurl {
     url = "https://github.com/wryun/es-shell/releases/download/v${version}/es-${version}.tar.gz";

pkgs/shells/zsh/antigen/default.nix

···
     sha256 = "1bmp3qf14509swpxin4j9f98n05pdilzapjm0jdzbv0dy3hn20ix";
   };
 
-  phases = "installPhase";
+  dontUnpack = true;
 
   installPhase = ''
     outdir=$out/share/antigen

pkgs/shells/zsh/nix-zsh-completions/default.nix

···
 { lib, stdenv, fetchFromGitHub }:
 
-let
-  version = "0.4.4";
-in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "nix-zsh-completions";
-  inherit version;
+  version = "0.4.4";
 
   src = fetchFromGitHub {
     owner = "spwhitt";

pkgs/shells/zsh/zsh-command-time/default.nix

···
     sha256 = "1bvyjgz6bhgg1nwr56r50p6fblgah6yiql55pgm5abnn2h876fjq";
   };
 
-  phases = [ "installPhase" ];
+  dontUnpack = true;
 
   installPhase = ''
     install -Dm0444 $src/command-time.plugin.zsh --target-directory=$out/share/zsh/plugins/command-time

pkgs/tools/X11/autocutsel/default.nix

···
   '';
 
   meta = {
-    inherit version;
     homepage = "https://www.nongnu.org/autocutsel/";
     description = "Tracks changes in the server's cutbuffer and CLIPBOARD selection";
     license = lib.licenses.gpl2Plus;

pkgs/tools/X11/bumblebee/default.nix

···
 }:
 
 let
-  version = "3.2.1";
-
   nvidia_x11s = [ nvidia_x11 ]
                 ++ lib.optional nvidia_x11.useGLVND libglvnd
                 ++ lib.optionals (nvidia_x11_i686 != null)
···
 
 in stdenv.mkDerivation rec {
   pname = "bumblebee";
-  inherit version;
+  version = "3.2.1";
 
   src = fetchurl {
     url = "https://bumblebee-project.org/${pname}-${version}.tar.gz";

pkgs/tools/X11/nitrogen/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, glib, gtkmm2 }:
 
-let version = "1.6.1";
-in
 stdenv.mkDerivation rec {
   pname = "nitrogen";
-  inherit version;
+  version = "1.6.1";
 
   src = fetchurl {
     url = "http://projects.l3ib.org/nitrogen/files/${pname}-${version}.tar.gz";

pkgs/tools/X11/runningx/default.nix

···
 
   buildInputs = [ libX11 ];
 
-  phases = [ "buildPhase" "installPhase" ];
+  dontUnpack = true;
 
   buildPhase = ''
     cc -O2 -o RunningX $(pkg-config --cflags --libs x11) $src

pkgs/tools/X11/skippy-xd/default.nix

···
     sed -e "s@/etc/xdg@$out&@" -i Makefile
   '';
   meta = {
-    inherit version;
     description = "Expose-style compositing-based standalone window switcher";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/X11/wayv/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "A gesture control for X11";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/X11/xannotate/default.nix

···
   buildInputs = [ libX11 ];
 
   meta = {
-    inherit version;
     description = "A tool to scribble over X windows";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/X11/xautomation/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, libpng, libX11, libXext, libXi, libXtst }:
 
-let version = "1.09"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "xautomation";
-  inherit version;
+  version = "1.09";
   src = fetchurl {
     url = "https://www.hoopajoo.net/static/projects/xautomation-${version}.tar.gz";
     sha256 = "03azv5wpg65h40ip2kk1kdh58vix4vy1r9bihgsq59jx2rhjr3zf";

pkgs/tools/X11/xbindkeys/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, libX11, guile }:
 
-let version = "1.8.7"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "xbindkeys";
-  inherit version;
+  version = "1.8.7";
   src = fetchurl {
     url = "https://www.nongnu.org/xbindkeys/xbindkeys-${version}.tar.gz";
     sha256 = "1wl2vc5alisiwyk8m07y1ryq8w3ll9ym83j27g4apm4ixjl8d6x2";

pkgs/tools/X11/xwinmosaic/default.nix

···
   buildInputs = [ gtk2 libXdamage ];
 
   meta = {
-    inherit version;
     description = "X window switcher drawing a colourful grid";
     license = lib.licenses.bsd2 ;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/X11/xwinwrap/default.nix

···
 { lib, stdenv, fetchbzr, xlibsWrapper }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "xwinwrap";
   version = "4";
-in
-stdenv.mkDerivation {
-  pname = "xwinwrap";
-  inherit version;
 
   src = fetchbzr {
     url = "https://code.launchpad.net/~shantanu-goel/xwinwrap/devel";

pkgs/tools/X11/xzoom/default.nix

···
   installTargets = [ "install" "install.man" ];
 
   meta = {
-    inherit version;
     description = "An X11 screen zoom tool";
     license = lib.licenses.free ;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/admin/boulder/default.nix

···
 , lib
 }:
 
-let
-  version = "release-2019-10-13";
-
-in buildGoPackage {
+buildGoPackage rec{
 
   pname = "boulder";
-  inherit version;
+  version = "release-2019-10-13";
 
   goPackagePath = "github.com/letsencrypt/boulder";
 

pkgs/tools/admin/google-cloud-sdk/default.nix

···
   sources = name: system: {
     x86_64-darwin = {
       url = "${baseUrl}/${name}-darwin-x86_64.tar.gz";
-      sha256 = "0viiwimnk26jfi4ypkvclqqxw8anlmch10zscjw69d8x1pyqczcd";
+      sha256 = "1h02pywzjn2d4p07xic1936w5qjbaz33qny8afrgzvgbqnqx7dvs";
     };
 
     aarch64-darwin = {
       url = "${baseUrl}/${name}-darwin-arm.tar.gz";
-      sha256 = "sha256-EZbJgMzEZScvaqSKay5aDuayVaIK1zZUzqAHgT0czZk=";
+      sha256 = "0qrmrxzphslhq3xf01zh91v7fvqn0z4hv8rpd15qwq9q84d2c3gr";
     };
 
     x86_64-linux = {
       url = "${baseUrl}/${name}-linux-x86_64.tar.gz";
-      sha256 = "11113l8pyhq6vbsh79m5anh6ljss94zhnp33ghds9rn1gxa83hnb";
+      sha256 = "0lz14d9gs6k0zbnyvrl6zyj8w7f6a5z7q95y48jkizc822rajhc3";
     };
   }.${system};
 
 in stdenv.mkDerivation rec {
   pname = "google-cloud-sdk";
-  version = "347.0.0";
+  version = "348.0.0";
 
   src = fetchurl (sources "${pname}-${version}" stdenv.hostPlatform.system);
 

pkgs/tools/archivers/unar/default.nix

···
     homepage = "https://theunarchiver.com";
     description = "An archive unpacker program";
     longDescription = ''
-      The Unarchiver is an archive unpacker program with support for the popular \
-      zip, RAR, 7z, tar, gzip, bzip2, LZMA, XZ, CAB, MSI, NSIS, EXE, ISO, BIN, \
-      and split file formats, as well as the old Stuffit, Stuffit X, DiskDouble, \
-      Compact Pro, Packit, cpio, compress (.Z), ARJ, ARC, PAK, ACE, ZOO, LZH, \
+      The Unarchiver is an archive unpacker program with support for the popular
+      zip, RAR, 7z, tar, gzip, bzip2, LZMA, XZ, CAB, MSI, NSIS, EXE, ISO, BIN,
+      and split file formats, as well as the old Stuffit, Stuffit X, DiskDouble,
+      Compact Pro, Packit, cpio, compress (.Z), ARJ, ARC, PAK, ACE, ZOO, LZH,
       ADF, DMS, LZX, PowerPacker, LBR, Squeeze, Crunch, and other old formats.
     '';
     license = licenses.lgpl21Plus;
     maintainers = with maintainers; [ peterhoeg ];
-    platforms = with platforms; linux;
+    platforms = platforms.linux;
   };
 }

pkgs/tools/archivers/xarchiver/default.nix

···
 { lib, stdenv, fetchFromGitHub, gtk3, pkg-config, intltool, libxslt, makeWrapper,
-  coreutils, zip, unzip, p7zip, unrar, gnutar, bzip2, gzip, lhasa, wrapGAppsHook }:
+  coreutils, zip, unzip, p7zip, unar, gnutar, bzip2, gzip, lhasa, wrapGAppsHook }:
 
 stdenv.mkDerivation rec {
   version = "0.5.4.17";
···
 
   postFixup = ''
     wrapProgram $out/bin/xarchiver \
-    --prefix PATH : ${lib.makeBinPath [ zip unzip p7zip unrar gnutar bzip2 gzip lhasa coreutils ]}
+    --prefix PATH : ${lib.makeBinPath [ zip unzip p7zip unar gnutar bzip2 gzip lhasa coreutils ]}
   '';
 
   meta = {

pkgs/tools/archivers/zpaq/default.nix

···
     license = licenses.gpl3Plus ;
     maintainers = with maintainers; [ raskin ];
     platforms = platforms.linux;
-    inherit version;
   };
 }

pkgs/tools/backup/btrbk/default.nix

···
     license = licenses.gpl3;
     platforms = platforms.unix;
     maintainers = with maintainers; [ asymmetric ];
-    inherit version;
   };
 }

pkgs/tools/backup/lvmsync/default.nix

···
 
   buildInputs = [ makeWrapper ];
 
-  phases = ["installPhase"];
+  dontUnpack = true;
 
   installPhase = let
     env = bundlerEnv {

pkgs/tools/cd-dvd/lsdvd/default.nix

···
 { lib, stdenv, fetchurl, libdvdread, pkg-config }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "lsdvd";
   version = "0.17";
-in
-stdenv.mkDerivation {
-  pname = "lsdvd";
-  inherit version;
   src = fetchurl {
     url = "mirror://sourceforge/lsdvd/lsdvd-${version}.tar.gz";
     sha256 = "1274d54jgca1prx106iyir7200aflr70bnb1kawndlmcckcmnb3x";

pkgs/tools/compression/lrzip/default.nix

···
     homepage = "http://ck.kolivas.org/apps/lrzip/";
     description = "The CK LRZIP compression program (LZMA + RZIP)";
     license = lib.licenses.gpl2Plus;
-    inherit version;
     platforms = lib.platforms.unix;
   };
 }

pkgs/tools/compression/mozlz4a/default.nix

···
   buildInputs = [ python3 python3.pkgs.python-lz4 ];
 
   meta = {
-    inherit version;
     description = "A script to handle Mozilla's mozlz4 files";
     license = lib.licenses.bsd2;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/compression/pixz/default.nix

···
   '';
 
   meta = {
-    inherit version;
     description = "A parallel compressor/decompressor for xz format";
     license = lib.licenses.bsd2;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/filesystems/fatsort/default.nix

···
     description = "Sorts FAT partition table, for devices that don't do sorting of files";
     maintainers = [ maintainers.kovirobi ];
     license = licenses.gpl2;
-    inherit version;
     platforms = platforms.linux;
   };
 }

pkgs/tools/filesystems/smbnetfs/default.nix

···
     license = licenses.gpl2;
     downloadPage = "https://sourceforge.net/projects/smbnetfs/files/smbnetfs";
     updateWalker = true;
-    inherit version;
     homepage = "https://sourceforge.net/projects/smbnetfs/";
   };
 }

pkgs/tools/filesystems/yandex-disk/default.nix

···
   p = if stdenv.is64bit then {
       arch = "x86_64";
       gcclib = "${stdenv.cc.cc.lib}/lib64";
-      sha256 = "14bpc5ddhxvgfxkxhj5q9z443s7z4nn1zf4k1hxj7rbf13rcpg00";
+      sha256 = "e4f579963199f05476657f0066beaa32d1261aef2203382f3919e1ed4bc4594e";
     }
     else {
       arch = "i386";
       gcclib = "${stdenv.cc.cc.lib}/lib";
-      sha256 = "1s829q8gy9xgz0jm7w70aljqs2h49x402blqfr9zvn806aprmrm5";
+      sha256 = "69113bf33ba0c57a363305b76361f2866c3b8394b173eed0f49db1f50bfe0373";
     };
 in
 stdenv.mkDerivation rec {
 
   pname = "yandex-disk";
-  version = "0.1.5.1039";
+  version = "0.1.6.1074";
 
   src = fetchurl {
     url = "https://repo.yandex.ru/yandex-disk/rpm/stable/${p.arch}/${pname}-${version}-1.fedora.${p.arch}.rpm";

pkgs/tools/graphics/argyllcms/default.nix

···
 { stdenv, fetchzip, jam, unzip, libX11, libXxf86vm, libXrandr, libXinerama
 , libXrender, libXext, libtiff, libjpeg, libpng, libXScrnSaver, writeText
 , libXdmcp, libXau, lib, openssl }:
-let
-  version = "2.1.2";
- in
+
 stdenv.mkDerivation rec {
   pname = "argyllcms";
-  inherit version;
+  version = "2.1.2";
 
   src = fetchzip {
     # Kind of flacky URL, it was reaturning 406 and inconsistent binaries for a

pkgs/tools/graphics/briss/default.nix

···
 
 { lib, stdenv, fetchurl, jre, makeWrapper }:
 
-let
-
+stdenv.mkDerivation rec {
+  pname = "briss";
   version = "0.9";
-  sha256 = "45dd668a9ceb9cd59529a9fefe422a002ee1554a61be07e6fc8b3baf33d733d9";
-
-in stdenv.mkDerivation {
-  pname = "briss";
-  inherit version;
   src = fetchurl {
     url = "mirror://sourceforge/briss/briss-${version}.tar.gz";
-    inherit sha256;
+    sha256 = "45dd668a9ceb9cd59529a9fefe422a002ee1554a61be07e6fc8b3baf33d733d9";
   };
 
   nativeBuildInputs = [makeWrapper];

pkgs/tools/graphics/convchain/default.nix

···
   '';
   buildInputs = [mono];
   meta = {
-    inherit version;
     description = "Bitmap generation from a single example with convolutions and MCMC";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/graphics/facedetect/default.nix

···
   buildInputs = [ python2Packages.python python2Packages.wrapPython ];
   pythonPath = [ python2Packages.numpy python2Packages.opencv4 ];
 
-  phases = [ "unpackPhase" "patchPhase" "installPhase" ];
+  dontConfigure = true;
 
   patchPhase = ''
     substituteInPlace facedetect \

pkgs/tools/graphics/mscgen/default.nix

···
 , zlib
 }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "mscgen";
   version = "0.20";
-in
-stdenv.mkDerivation {
-  pname = "mscgen";
-  inherit version;
 
   src = fetchurl {
     url = "http://www.mcternan.me.uk/mscgen/software/mscgen-src-${version}.tar.gz";

pkgs/tools/graphics/pgf/default.nix

···
 { lib, stdenv, fetchurl, autoconf, automake, libtool, dos2unix, libpgf, freeimage, doxygen }:
 
 with lib;
-
-let
-  version = "6.14.12";
-in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "pgf";
-  inherit version;
+  version = "6.14.12";
 
   src = fetchurl {
     url = "mirror://sourceforge/libpgf/pgf-console-src-${version}.tar.gz";

pkgs/tools/graphics/syntex/default.nix

···
   '';
   buildInputs = [mono];
   meta = {
-    inherit version;
     description = "Texture synthesis from examples";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/graphics/twilight/default.nix

···
 { lib, stdenv, fetchFromGitHub
 , libGL, libGLU, freeglut, libX11 }:
 
-let
-  version = "2018-04-19";
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
   pname = "twilight";
-  inherit version;
+  version = "unstable-2018-04-19";
 
   src = fetchFromGitHub {
     owner = "tweakoz";

pkgs/tools/graphics/wavefunctioncollapse/default.nix

···
   '';
   buildInputs = [mono];
   meta = {
-    inherit version;
     description = "A generator of bitmaps that are locally similar to the input bitmap";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/graphics/zxing/default.nix

···
     cd "$out/lib/java"; for i in *.jar; do mv "$i" "''${i#*-}"; done
   '';
   meta = {
-    inherit version;
     description = "1D and 2D code reading library";
     license = lib.licenses.asl20;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/inputmethods/skk/skk-dicts/default.nix

···
   srcs = [ small medium large edict assoc ];
   nativeBuildInputs = [ skktools ] ++ lib.optional stdenv.isDarwin libiconv;
 
-  phases = [ "installPhase" ];
+  dontUnpack = true;
+
   installPhase = ''
     function dictname() {
       src=$1

pkgs/tools/misc/autorandr/default.nix

···
 , systemd
 , xrandr }:
 
-let
-  python = python3Packages.python;
+stdenv.mkDerivation rec {
+  pname = "autorandr";
   version = "1.11";
-in
-  stdenv.mkDerivation {
-    pname = "autorandr";
-    inherit version;
 
-    buildInputs = [ python ];
+  buildInputs = [ python3Packages.python ];
 
-    # no wrapper, as autorandr --batch does os.environ.clear()
-    buildPhase = ''
-      substituteInPlace autorandr.py \
-        --replace 'os.popen("xrandr' 'os.popen("${xrandr}/bin/xrandr' \
-        --replace '["xrandr"]' '["${xrandr}/bin/xrandr"]'
-    '';
+  # no wrapper, as autorandr --batch does os.environ.clear()
+  buildPhase = ''
+    substituteInPlace autorandr.py \
+      --replace 'os.popen("xrandr' 'os.popen("${xrandr}/bin/xrandr' \
+      --replace '["xrandr"]' '["${xrandr}/bin/xrandr"]'
+  '';
 
-    outputs = [ "out" "man" ];
+  outputs = [ "out" "man" ];
 
-    installPhase = ''
-      runHook preInstall
-      make install TARGETS='autorandr' PREFIX=$out
+  installPhase = ''
+    runHook preInstall
+    make install TARGETS='autorandr' PREFIX=$out
 
-      make install TARGETS='bash_completion' DESTDIR=$out/share/bash-completion/completions
+    make install TARGETS='bash_completion' DESTDIR=$out/share/bash-completion/completions
 
-      make install TARGETS='autostart_config' PREFIX=$out DESTDIR=$out
+    make install TARGETS='autostart_config' PREFIX=$out DESTDIR=$out
 
-      make install TARGETS='manpage' PREFIX=$man
+    make install TARGETS='manpage' PREFIX=$man
 
-      ${if systemd != null then ''
-        make install TARGETS='systemd udev' PREFIX=$out DESTDIR=$out \
-          SYSTEMD_UNIT_DIR=/lib/systemd/system \
-          UDEV_RULES_DIR=/etc/udev/rules.d
-        substituteInPlace $out/etc/udev/rules.d/40-monitor-hotplug.rules \
-          --replace /bin/systemctl "/run/current-system/systemd/bin/systemctl"
-      '' else ''
-        make install TARGETS='pmutils' DESTDIR=$out \
-          PM_SLEEPHOOKS_DIR=/lib/pm-utils/sleep.d
-        make install TARGETS='udev' PREFIX=$out DESTDIR=$out \
-          UDEV_RULES_DIR=/etc/udev/rules.d
-      ''}
+    ${if systemd != null then ''
+      make install TARGETS='systemd udev' PREFIX=$out DESTDIR=$out \
+        SYSTEMD_UNIT_DIR=/lib/systemd/system \
+        UDEV_RULES_DIR=/etc/udev/rules.d
+      substituteInPlace $out/etc/udev/rules.d/40-monitor-hotplug.rules \
+        --replace /bin/systemctl "/run/current-system/systemd/bin/systemctl"
+    '' else ''
+      make install TARGETS='pmutils' DESTDIR=$out \
+        PM_SLEEPHOOKS_DIR=/lib/pm-utils/sleep.d
+      make install TARGETS='udev' PREFIX=$out DESTDIR=$out \
+        UDEV_RULES_DIR=/etc/udev/rules.d
+    ''}
 
-      runHook postInstall
-    '';
+    runHook postInstall
+  '';
 
-    src = fetchFromGitHub {
-      owner = "phillipberndt";
-      repo = "autorandr";
-      rev = version;
-      sha256 = "0rmnqk2bi6bbd2if1rll37mlzlqxzmnazfffdhcpzskxwyaj4yn5";
-    };
+  src = fetchFromGitHub {
+    owner = "phillipberndt";
+    repo = "autorandr";
+    rev = version;
+    sha256 = "0rmnqk2bi6bbd2if1rll37mlzlqxzmnazfffdhcpzskxwyaj4yn5";
+  };
 
-    meta = with lib; {
-      homepage = "https://github.com/phillipberndt/autorandr/";
-      description = "Automatically select a display configuration based on connected devices";
-      license = licenses.gpl3Plus;
-      maintainers = with maintainers; [ coroa globin ];
-      platforms = platforms.unix;
-    };
-  }
+  meta = with lib; {
+    homepage = "https://github.com/phillipberndt/autorandr/";
+    description = "Automatically select a display configuration based on connected devices";
+    license = licenses.gpl3Plus;
+    maintainers = with maintainers; [ coroa globin ];
+    platforms = platforms.unix;
+  };
+}

pkgs/tools/misc/bcunit/default.nix

···
   };
 
   meta = with lib; {
-    inherit version;
     description = "A fork of CUnit test framework";
     homepage = "https://gitlab.linphone.org/BC/public/bcunit";
     license = licenses.lgpl2Plus;

pkgs/tools/misc/clac/default.nix

···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "Interactive stack-based calculator";
     homepage = "https://github.com/soveran/clac";
     license = licenses.bsd2;

pkgs/tools/misc/clasp/default.nix

···
 { lib, stdenv, fetchurl }:
 
-let
-  version = "3.1.4";
-in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "clasp";
-  inherit version;
+  version = "3.1.4";
 
   src = fetchurl {
     url = "mirror://sourceforge/project/potassco/clasp/${version}/clasp-${version}-source.tar.gz";

pkgs/tools/misc/cp437/default.nix

···
 { lib, stdenv, fetchFromGitHub }:
-let version = "0.6";
-in
-stdenv.mkDerivation {
+
+stdenv.mkDerivation rec {
   pname = "cp437";
-  inherit version;
+  version = "0.6";
 
   src = fetchFromGitHub {
     owner = "keaston";

pkgs/tools/misc/dijo/default.nix

···
 { stdenv, lib, rustPlatform, fetchFromGitHub, ncurses, CoreServices }:
-let version = "0.2.7"; in
-rustPlatform.buildRustPackage {
+
+rustPlatform.buildRustPackage rec {
   pname = "dijo";
-  inherit version;
+  version = "0.2.7";
   buildInputs = [ ncurses ] ++ lib.optional stdenv.isDarwin CoreServices;
   src = fetchFromGitHub {
     owner = "NerdyPepper";

pkgs/tools/misc/diskscan/default.nix

···
     description = "Scan HDD/SSD for failed and near failed sectors";
     platforms = with platforms; linux;
     maintainers = with maintainers; [ peterhoeg ];
-    inherit version;
     license = licenses.gpl3;
   };
 }

pkgs/tools/misc/edid-decode/default.nix

···
 { lib, stdenv, fetchgit }:
-let
-  version = "2018-12-06";
-in stdenv.mkDerivation {
+
+stdenv.mkDerivation rec {
   pname = "edid-decode-unstable";
-  inherit version;
+  version = "unstable-2018-12-06";
 
   src = fetchgit {
     url = "git://linuxtv.org/edid-decode.git";

pkgs/tools/misc/edid-generator/default.nix

···
 , zsh
 , modelines ? [] # Modeline "1280x800"   83.50  1280 1352 1480 1680  800 803 809 831 -hsync +vsync
 }:
-let
+
+stdenv.mkDerivation rec {
+  pname = "edid-generator";
   version = "unstable-2018-03-15";
-in stdenv.mkDerivation {
-  pname = "edid-generator";
-  inherit version;
 
   src = fetchFromGitHub {
     owner = "akatrevorjay";

pkgs/tools/misc/fend/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "fend";
-  version = "0.1.17";
+  version = "0.1.20";
 
   src = fetchFromGitHub {
     owner = "printfn";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Xq2UjeZiKy9BjNQ9xnC7tppEwrEtg8ZN5BVDz1bUOmw=";
+    sha256 = "sha256-2CzpPzUylzDiP9rbjneRR6joa9UEgnDfJ4Ffa/orhkk=";
   };
 
-  cargoSha256 = "sha256-Bf3fYHhpoX05AmTdwwdRU2YRfGVb1EmaGDm75i+Vs2w=";
+  cargoSha256 = "sha256-xDh7SF73Qnx/GeW43JDmF+qeljSHbWWq4unWdTmAO+c=";
 
   doInstallCheck = true;
 

pkgs/tools/misc/fsql/default.nix

···
     license = licenses.mit;
     maintainers = with maintainers; [ pSub ];
     platforms = platforms.unix;
-    inherit version;
   };
 
 }

pkgs/tools/misc/gringo/default.nix

···
   libcxx
 }:
 
-let
-  version = "4.5.4";
-in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "gringo";
-  inherit version;
+  version = "4.5.4";
 
   src = fetchurl {
     url = "mirror://sourceforge/project/potassco/gringo/${version}/gringo-${version}-source.tar.gz";

pkgs/tools/misc/hdaps-gl/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, freeglut, libGL, libGLU }:
 
-let version = "0.0.7"; in
-stdenv.mkDerivation {
-      pname = "hdaps-gl";
-      inherit version;
-      src = fetchFromGitHub {
-            owner = "linux-thinkpad";
-            repo = "hdaps-gl";
-            rev = version;
-            sha256 = "0jywsrcr1wzkjig5cvz014c3r026sbwscbkv7zh1014lkjm0kyyh";
-      };
+stdenv.mkDerivation rec {
+  pname = "hdaps-gl";
+  version = "0.0.7";
+  src = fetchFromGitHub {
+    owner = "linux-thinkpad";
+    repo = "hdaps-gl";
+    rev = version;
+    sha256 = "0jywsrcr1wzkjig5cvz014c3r026sbwscbkv7zh1014lkjm0kyyh";
+  };
 
-      nativeBuildInputs = [ autoreconfHook ];
-      buildInputs = [ freeglut libGL libGLU ];
+  nativeBuildInputs = [ autoreconfHook ];
+  buildInputs = [ freeglut libGL libGLU ];
 
-      meta = with lib; {
-            description = "GL-based laptop model that rotates in real-time via hdaps";
-            homepage = "https://github.com/linux-thinkpad/hdaps-gl";
-            license = licenses.gpl2;
-            platforms = platforms.linux;
-            maintainers = [ maintainers.symphorien ];
-      };
+  meta = with lib; {
+    description = "GL-based laptop model that rotates in real-time via hdaps";
+    homepage = "https://github.com/linux-thinkpad/hdaps-gl";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.symphorien ];
+  };
 }

pkgs/tools/misc/lbdb/default.nix

···
 }:
 
 let
-  version = "0.48.1";
   perl' = perl.withPackages (p: with p; [ ConvertASN1 perlldap AuthenSASL ]);
 in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "lbdb";
-  inherit version;
+  version = "0.48.1";
   src = fetchurl {
     url = "https://www.spinnaker.de/lbdb/download/lbdb_${version}.tar.gz";
     sha256 = "1gr5l2fr9qbdccga8bhsrpvz6jxigvfkdxrln9wyf2xpps5cdjxh";

pkgs/tools/misc/unclutter-xfixes/default.nix

···
     description = "Rewrite of unclutter using the X11 Xfixes extension";
     platforms = platforms.unix;
     license = lib.licenses.mit;
-    inherit version;
     maintainers = [ maintainers.globin ];
   };
 }

pkgs/tools/misc/yubikey-manager-qt/default.nix

···
   '';
 
   meta = with lib; {
-    inherit version;
     description = "Cross-platform application for configuring any YubiKey over all USB interfaces";
     homepage = "https://developers.yubico.com/yubikey-manager-qt/";
     license = licenses.bsd2;

pkgs/tools/networking/getmail/default.nix

···
     platforms = lib.platforms.linux;
 
     homepage = "http://pyropus.ca/software/getmail/";
-    inherit version;
     updateWalker = true;
     license = lib.licenses.gpl2Plus;
   };

pkgs/tools/networking/kea/default.nix

···
 , libmysqlclient
 , log4cplus
 , postgresql
-, python3 }:
+, python3
+, nixosTests
+}:
 
 stdenv.mkDerivation rec {
   pname = "kea";
···
 
   enableParallelBuilding = true;
 
+  passthru.tests = {
+    inherit (nixosTests) kea;
+  };
+
   meta = with lib; {
     homepage = "https://kea.isc.org/";
     description = "High-performance, extensible DHCP server by ISC";
     longDescription = ''
-      KEA is a new open source DHCPv4/DHCPv6 server being developed by
+      Kea is a new open source DHCPv4/DHCPv6 server being developed by
       Internet Systems Consortium. The objective of this project is to
       provide a very high-performance, extensible DHCP server engine for
       use by enterprises and service providers, either as is or with
···
     '';
     license = licenses.mpl20;
     platforms = platforms.unix;
-    maintainers = with maintainers; [ fpletz ];
+    maintainers = with maintainers; [ fpletz hexa ];
   };
 }

pkgs/tools/networking/wavemon/default.nix

···
   };
 
   meta = with lib; {
-    inherit version;
     description = "Ncurses-based monitoring application for wireless network devices";
     homepage = "https://github.com/uoaerg/wavemon";
     license = licenses.gpl3Plus;

pkgs/tools/package-management/nix-top/default.nix

···
     license = licenses.mit;
     maintainers = with maintainers; [ samueldr ];
     platforms = platforms.linux ++ platforms.darwin;
-    inherit version;
   };
 }

pkgs/tools/package-management/nixops/default.nix

···
 , fetchurl, fetchpatch
 }:
 
-let
+python2Packages.buildPythonApplication rec {
+  pname = "nixops";
   version = "1.7";
-
-in python2Packages.buildPythonApplication {
-  pname = "nixops";
-  inherit version;
 
   src = fetchurl {
     url = "https://nixos.org/releases/nixops/nixops-${version}/nixops-${version}.tar.bz2";

pkgs/tools/security/aws-okta/default.nix

···
   buildInputs = [ libusb1  libiconv ];
 
   meta = with lib; {
-    inherit version;
     description = "aws-vault like tool for Okta authentication";
     license = licenses.mit;
     maintainers = with maintainers; [imalsogreg Chili-Man];

pkgs/tools/security/sshuttle/default.nix

···
-{ lib, stdenv
+{ lib
+, stdenv
 , python3Packages
 , makeWrapper
 , coreutils
···
   };
 
   patches = [ ./sudo.patch ];
+
+  postPatch = ''
+    substituteInPlace setup.cfg \
+      --replace '--cov=sshuttle --cov-branch --cov-report=term-missing' ""
+  '';
 
   nativeBuildInputs = [ makeWrapper python3Packages.setuptools-scm ];
 
-  checkInputs = with python3Packages; [ mock pytest pytestcov pytestrunner flake8 ];
-
-  runtimeDeps = [ coreutils openssh procps ] ++ lib.optionals stdenv.isLinux [ iptables nettools ];
+  checkInputs = with python3Packages; [ mock pytestCheckHook flake8 ];
 
   postInstall = ''
     wrapProgram $out/bin/sshuttle \
-      --prefix PATH : "${lib.makeBinPath runtimeDeps}" \
+      --prefix PATH : "${lib.makeBinPath ([ coreutils openssh procps ] ++ lib.optionals stdenv.isLinux [ iptables nettools ])}" \
   '';
 
   meta = with lib; {
···
     '';
     license = licenses.gpl2;
     maintainers = with maintainers; [ domenkozar carlosdagos ];
-    platforms = platforms.unix;
   };
 }

pkgs/tools/security/sudolikeaboss/default.nix

···
   ];
 
   meta = with lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Get 1password access from iterm2";
     license = licenses.mit;

pkgs/tools/system/dd_rescue/default.nix

···
     platforms = platforms.linux;
     homepage = "http://www.garloff.de/kurt/linux/ddrescue/";
     license = licenses.gpl2Plus;
-    inherit version;
     updateWalker = true;
   };
 }

pkgs/tools/system/fancy-motd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fancy-motd";
-  version = "unstable-2021-07-04";
+  version = "unstable-2021-07-15";
 
   src = fetchFromGitHub {
     owner = "bcyran";
     repo = pname;
-    rev = "2cc3c3c164ef695c9dd465beca61716a364db32c";
-    sha256 = "003p5rsyl216xwldrk8slpnzw6wdrcm8hpfdgy9a0mja5g1xdqzr";
+    rev = "e8d2d2602d9b9fbc132ddc4f9fbf22428d715721";
+    sha256 = "10fxr1grsiwvdc5m2wd4n51lvz0zd4sldg9rzviaim18nw68gdq3";
   };
 
   buildInputs = [ bc curl figlet fortune gawk iproute2 ];

pkgs/tools/system/freeipmi/default.nix

···
     platforms = lib.platforms.gnu ++ lib.platforms.linux;  # arbitrary choice
 
     updateWalker = true;
-    inherit version;
   };
 }

pkgs/tools/system/ipmiutil/default.nix

···
     platforms = platforms.linux;
     license = licenses.bsd3;
     downloadPage = "https://sourceforge.net/projects/ipmiutil/files/ipmiutil/";
-    inherit version;
   };
 }

pkgs/tools/system/sleuthkit/default.nix

···
     maintainers = [ lib.maintainers.raskin ];
     platforms = lib.platforms.linux;
     license = lib.licenses.ipl10;
-    inherit version;
   };
 }

pkgs/tools/system/smartmontools/default.nix

···
 , IOKit, ApplicationServices }:
 
 let
-  version = "7.2";
-
   dbrev = "5171";
   drivedbBranch = "RELEASE_7_2_DRIVEDB";
   driverdb = fetchurl {
···
 
 in stdenv.mkDerivation rec {
   pname = "smartmontools";
-  inherit version;
+  version = "7.2";
 
   src = fetchurl {
     url = "mirror://sourceforge/smartmontools/${pname}-${version}.tar.gz";

pkgs/tools/system/tree/default.nix

···
 { lib, stdenv, fetchurl }:
 
 let
-  version = "1.8.0";
-
   # These settings are found in the Makefile, but there seems to be no
   # way to select one ore the other setting other than editing the file
   # manually, so we have to duplicate the know how here.
···
     '' else
     ""; # use linux flags by default
 in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "tree";
-  inherit version;
+  version = "1.8.0";
 
   src = fetchurl {
     url = "http://mama.indstate.edu/users/ice/tree/src/tree-${version}.tgz";

pkgs/tools/system/wsmancli/default.nix

···
     '';
     downloadPage = "https://github.com/Openwsman/wsmancli/releases";
     inherit (openwsman.meta) homepage license maintainers platforms;
-    inherit version;
   };
 }

pkgs/tools/text/mdcat/default.nix

···
 , Security
 , ansi2html
 , installShellFiles
+, fetchpatch
 }:
 
 rustPlatform.buildRustPackage rec {
···
     rev = "mdcat-${version}";
     sha256 = "sha256-aJ7rL+EKa5zWmCmekVuRmdeOwTmVo0IQ+GJ8Ga4iTI0=";
   };
+
+  patches = [
+    # detect wezterm through TERM again which was removed in 0.23.1
+    (fetchpatch {
+      url = "https://github.com/lunaryorn/mdcat/commit/a897b223904748a47c277f7c9a07d59e7d5c916b.patch";
+      sha256 = "sha256-tSeNyrlqoGvlfQ3xMRkvqZ7HajMvPCIk7kyt/sVjmTo=";
+    })
+  ];
 
   nativeBuildInputs = [ pkg-config asciidoctor installShellFiles ];
   buildInputs = [ openssl ]

pkgs/tools/text/namazu/default.nix

···
-{ fetchurl, lib, stdenv, perl }:
+{ fetchurl, lib, stdenv, perl, perlPackages, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "namazu-2.0.21";
+  pname = "namazu";
+  version = "2.0.21";
 
   src = fetchurl {
-    url = "http://namazu.org/stable/${name}.tar.gz";
+    url = "http://namazu.org/stable/${pname}-${version}.tar.gz";
     sha256 = "1xvi7hrprdchdpzhg3fvk4yifaakzgydza5c0m50h1yvg6vay62w";
   };
 
-  buildInputs = [ perl ];
+  buildInputs = [ perl perlPackages.FileMMagic ];
+  nativeBuildInputs = [ makeWrapper ];
 
-  # First install the `File::MMagic' Perl module.
-  preConfigure = ''
-    ( cd File-MMagic &&                              \
-      perl Makefile.PL                               \
-        LIB="$out/${perl.libPrefix}/${perl.version}" \
-        INSTALLSITEMAN3DIR="$out/man" &&             \
-      make && make install )
-    export PERL5LIB="$out/${perl.libPrefix}/${perl.version}:$PERL5LIB"
+  postInstall = ''
+    wrapProgram $out/bin/mknmz --set PERL5LIB ${perlPackages.makeFullPerlPath [ perlPackages.FileMMagic ]}
   '';
-
-  # FIXME: The `tests/namazu-6' test fails on GNU/Linux, presumably because
-  # phrase searching is broken somehow.  However, it doesn't fail on other
-  # platforms.
-  doCheck = !stdenv.isLinux;
 
   meta = {
     description = "Full-text search engine";
···
 
     platforms = lib.platforms.gnu ++ lib.platforms.linux;  # arbitrary choice
     maintainers = [ ];
-    broken = true; # File-MMagic is not compatible with our Perl version
   };
 }

pkgs/tools/typesetting/pdf2djvu/default.nix

···
     homepage = "https://jwilk.net/software/pdf2djvu";
     license = licenses.gpl2;
     maintainers = with maintainers; [ pSub ];
-    inherit version;
   };
 }

pkgs/tools/typesetting/pdf2odt/default.nix

···
     license     = licenses.mit;
     platforms   = platforms.all;
     maintainers = with maintainers; [ peterhoeg ];
-    inherit version;
   };
 }

pkgs/tools/virtualization/cloudmonkey/default.nix

···
-{ python2Packages, lib }:
-
-with python2Packages;
+{ buildGoModule, fetchFromGitHub, lib }:
 
-buildPythonApplication rec {
+buildGoModule rec {
   pname = "cloudmonkey";
-  version = "5.3.3";
+  version = "6.1.0";
 
-  propagatedBuildInputs = [ argcomplete pygments ];
+  src = fetchFromGitHub {
+    owner = "apache";
+    repo = "cloudstack-cloudmonkey";
+    rev = version;
+    sha256 = "sha256-OmVM6ayrtrLl+PADnkUnrssbsq1GZp2KiMBOXPgfi5Y=";
+  };
 
-  doCheck = false; # upstream has no tests defined
+  runVend = true;
 
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "064yk3lwl272nyn20xxrh0qxzh3r1rl9015qqf2i4snqdzwd5cf7";
-  };
+  vendorSha256 = null;
 
   meta = with lib; {
     description = "CLI for Apache CloudStack";
-    homepage = "https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+cloudmonkey+CLI";
+    homepage = "https://github.com/apache/cloudstack-cloudmonkey";
     license = [ licenses.asl20 ];
     maintainers = [ maintainers.womfoo ];
   };

pkgs/top-level/all-packages.nix

···
 
   blockbench-electron = callPackage ../applications/graphics/blockbench-electron { };
 
+  blocksat-cli = with python3Packages; toPythonApplication blocksat-cli;
+
   bmap-tools = callPackage ../tools/misc/bmap-tools { };
 
   bonnmotion = callPackage ../development/tools/misc/bonnmotion { };
···
   debian-devscripts = callPackage ../tools/misc/debian-devscripts { };
 
   debootstrap = callPackage ../tools/misc/debootstrap { };
+
+  debugedit-unstable = callPackage ../development/tools/misc/debugedit { };
 
   deer = callPackage ../shells/zsh/zsh-deer { };
 
···
   mockgen = callPackage ../development/tools/mockgen { };
 
   modd = callPackage ../development/tools/modd { };
+
+  mold = callPackage ../development/tools/mold {
+    stdenv = llvmPackages_latest.stdenv;
+  };
 
   msgpack-tools = callPackage ../development/tools/msgpack-tools { };
 
···
   wmii_hg = callPackage ../applications/window-managers/wmii-hg { };
 
   wofi = callPackage ../applications/misc/wofi { };
+
+  wofi-emoji = callPackage ../applications/misc/wofi-emoji { };
 
   wordnet = callPackage ../applications/misc/wordnet {
     inherit (darwin.apple_sdk.frameworks) Cocoa;

pkgs/top-level/python-packages.nix

···
 
   block-io = callPackage ../development/python-modules/block-io { };
 
+  blocksat-cli = callPackage ../development/python-modules/blocksat-cli { };
+
   blspy = callPackage ../development/python-modules/blspy { };
 
   bluepy = callPackage ../development/python-modules/bluepy { };
···
   eth-utils = callPackage ../development/python-modules/eth-utils { };
 
   et_xmlfile = callPackage ../development/python-modules/et_xmlfile { };
+
+  ev3dev2 = callPackage ../development/python-modules/ev3dev2 { };
 
   evdev = callPackage ../development/python-modules/evdev { };
 
···
 
   python-tado = callPackage ../development/python-modules/python-tado { };
 
+  pyutil = callPackage ../development/python-modules/pyutil { };
+
   pkutils = callPackage ../development/python-modules/pkutils { };
 
   plac = callPackage ../development/python-modules/plac { };
···
   zerorpc = callPackage ../development/python-modules/zerorpc { };
 
   zetup = callPackage ../development/python-modules/zetup { };
+
+  zfec = callPackage ../development/python-modules/zfec { };
 
   zha-quirks = callPackage ../development/python-modules/zha-quirks { };