Merge master into staging-next

nixos/tests/kernel-generic.nix

···
   linux_5_4 = makeKernelTest "5.4" linuxPackages_5_4;
   linux_5_10 = makeKernelTest "5.10" linuxPackages_5_10;
   linux_5_12 = makeKernelTest "5.12" linuxPackages_5_12;
+  linux_5_13 = makeKernelTest "5.13" linuxPackages_5_13;
 
   linux_testing = makeKernelTest "testing" linuxPackages_testing;
 }

pkgs/applications/blockchains/polkadot/default.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "polkadot";
-  version = "0.9.6";
+  version = "0.9.7";
 
   src = fetchFromGitHub {
     owner = "paritytech";
     repo = "polkadot";
     rev = "v${version}";
-    sha256 = "sha256-waoNCEGHFjY91ted4oBtwxW6/beqW/8IwRIE4rG+fKQ=";
+    sha256 = "sha256-swPLJIcm8XD0+/e9pGK2bDqUb7AS/5FdQ3A7Ceh5dZc=";
   };
 
-  cargoSha256 = "17c45xi1wr77jbkcl1mkxflc8f9hilil02c43fihvlh2lm8kcs5j";
+  cargoSha256 = "sha256-4njx8T3kzyN63Jo0aHee5ImqcObiADvi+dHKWcRmbQw=";
 
   nativeBuildInputs = [ clang ];
 

pkgs/applications/editors/emacs/elisp-packages/ebuild-mode/default.nix

···
+{ lib, trivialBuild, fetchurl }:
+
+trivialBuild rec {
+  pname = "ebuild-mode";
+  version = "1.52";
+
+  src = fetchurl {
+    url = "https://dev.gentoo.org/~ulm/emacs/ebuild-mode-${version}.tar.xz";
+    sha256 = "10nikbbwh612qlnms2i31963a0h3ccyg85vrxlizdpsqs4cjpg6h";
+  };
+
+  meta = with lib; {
+    description = "Major modes for Gentoo package files";
+    license = licenses.gpl2Plus;
+    maintainers = with maintainers; [ qyliss ];
+  };
+}

pkgs/applications/editors/emacs/elisp-packages/manual-packages.nix

···
 
   # Packages made the classical callPackage way
 
+  ebuild-mode = callPackage ./ebuild-mode { };
+
   emacspeak = callPackage ./emacspeak { };
 
   ess-R-object-popup = callPackage ./ess-R-object-popup { };

pkgs/applications/editors/gophernotes/default.nix

···
 
 buildGoModule rec {
   pname = "gophernotes";
-  version = "0.7.2";
+  version = "0.7.3";
 
   src = fetchFromGitHub {
     owner = "gopherdata";
     repo = "gophernotes";
     rev = "v${version}";
-    sha256 = "sha256-EEMKV+k5qcep4z7J5r1nSLxmb0fbfpJOPmz5bE91cd8=";
+    sha256 = "sha256-LiYPos6Ic+se5bTTkvggmyxyS20uhgALkDU2LoXTci8=";
   };
 
-  vendorSha256 = "sha256-Wy4HcPlrlYUjRQHhw+UPAa+Rn1FvJobWGxgFiJKJTAg=";
+  vendorSha256 = "sha256-wDMx3B47Vv87/3YEPX8/70Q5/REJ7IPvw8dA/viJiSY=";
 
   meta = with lib; {
     description = "Go kernel for Jupyter notebooks";

pkgs/applications/graphics/imagej/default.nix

···
-{ lib, stdenv, fetchurl, jre, unzip, makeWrapper }:
-
-# Note:
-# - User config dir is hard coded by upstream to $HOME/.imagej on linux systems
-#   and to $HOME/Library/Preferences on macOS.
-#  (The current trend appears to be to use $HOME/.config/imagej
-#    on linux systems, but we here do not attempt to fix it.)
+{ lib
+, stdenv
+, fetchurl
+, jre
+, unzip
+, makeWrapper
+, makeDesktopItem
+, copyDesktopItems
+}:
 
 let
-  imagej150 = stdenv.mkDerivation {
-    pname = "imagej";
-    version = "150";
+  icon = fetchurl {
+    url = "https://imagej.net/media/icons/imagej.png";
+    sha256 = "sha256-nU2nWI1wxZB/xlOKsZzdUjj+qiCTjO6GwEKYgZ5Risg=";
+  };
+in stdenv.mkDerivation rec {
+  pname = "imagej";
+  version = "153";
 
-    src = fetchurl {
-      url = "https://wsr.imagej.net/distros/cross-platform/ij150.zip";
-      sha256 = "97aba6fc5eb908f5160243aebcdc4965726693cb1353d9c0d71b8f5dd832cb7b";
-    };
-    nativeBuildInputs = [ makeWrapper unzip ];
+  src = fetchurl {
+    url = "https://wsr.imagej.net/distros/cross-platform/ij${version}.zip";
+    sha256 = "sha256-MGuUdUDuW3s/yGC68rHr6xxzmYScUjdXRawDpc1UQqw=";
+  };
+  nativeBuildInputs = [ copyDesktopItems makeWrapper unzip ];
+  desktopItems = lib.optionals stdenv.isLinux [
+    (makeDesktopItem {
+      name = "ImageJ";
+      desktopName = "ImageJ";
+      icon = "imagej";
+      categories = "Science;Utility;Graphics;";
+      exec = "imagej";
+    })
+  ];
+
+  passthru = {
     inherit jre;
+  };
 
-    # JAR files that are intended to be used by other packages
-    # should go to $out/share/java.
-    # (Some uses ij.jar as a library not as a standalone program.)
-    installPhase = ''
-      mkdir -p $out/share/java
-      # Read permisssion suffices for the jar and others.
-      # Simple cp shall clear suid bits, if any.
-      cp ij.jar $out/share/java
-      cp -dR luts macros plugins $out/share
-      mkdir $out/bin
-      makeWrapper ${jre}/bin/java $out/bin/imagej \
-        --add-flags "-jar $out/share/java/ij.jar -ijpath $out/share"
+  # JAR files that are intended to be used by other packages
+  # should go to $out/share/java.
+  # (Some uses ij.jar as a library not as a standalone program.)
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/share/java $out/bin
+    # Read permisssion suffices for the jar and others.
+    # Simple cp shall clear suid bits, if any.
+    cp ij.jar $out/share/java
+    cp -dR luts macros plugins $out/share
+    makeWrapper ${jre}/bin/java $out/bin/imagej \
+      --add-flags "-jar $out/share/java/ij.jar -ijpath $out/share"
+
+    runHook postInstall
+  '';
+
+  postFixup = lib.optionalString stdenv.isLinux ''
+    install -Dm644 ${icon} $out/share/icons/hicolor/128x128/apps/imagej.png
+    substituteInPlace $out/share/applications/ImageJ.desktop \
+      --replace Exec=imagej Exec=$out/bin/imagej
+  '';
+
+  meta = with lib; {
+    homepage = "https://imagej.nih.gov/ij/";
+    description = "Image processing and analysis in Java";
+    longDescription = ''
+      ImageJ is a public domain Java image processing program
+      inspired by NIH Image for the Macintosh.
+      It runs on any computer with a Java 1.4 or later virtual machine.
     '';
-    meta = with lib; {
-      homepage = "https://imagej.nih.gov/ij/";
-      description = "Image processing and analysis in Java";
-      longDescription = ''
-        ImageJ is a public domain Java image processing program
-        inspired by NIH Image for the Macintosh.
-        It runs on any computer with a Java 1.4 or later virtual machine.
-      '';
-      license = licenses.publicDomain;
-      platforms = with platforms; linux ++ darwin;
-      maintainers = with maintainers; [ yuriaisaka ];
-    };
+    license = licenses.publicDomain;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ yuriaisaka ];
   };
-in
-  imagej150
+}

pkgs/applications/misc/fuzzel/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fuzzel";
-  version = "1.5.4";
+  version = "1.6.0";
 
   src = fetchzip {
     url = "https://codeberg.org/dnkl/fuzzel/archive/${version}.tar.gz";
-    sha256 = "sha256-Zg9KrRf2ntg2FU6lhllt/Fd63KJak6zB7hu4ujj/9AI=";
+    sha256 = "sha256-iTpUWvQszDtNc1gDqkPbhvgUVNWydpivhnOCHMJVtSw=";
   };
 
   nativeBuildInputs = [ pkg-config meson ninja scdoc git ];

pkgs/applications/networking/hyprspace/default.nix

···
 
 buildGoModule rec {
   pname = "hyprspace";
-  version = "0.1.4";
+  version = "0.1.5";
 
   propagatedBuildInputs = lib.optional stdenv.isDarwin iproute2mac;
 
···
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Rw82m0NJcWgtcXRIb1YNv+Kpe2YufKMNAn1Ph9RB3W8=";
+    sha256 = "sha256-aLODIaDbSLVEog/F0FVx6ykadCggE0Vebzwjw0sqYJ0=";
   };
 
-  vendorSha256 = "sha256-ErqK2jDTpqUyvll+epdGKRYCJvyvCa90W1GVbbhF0a4=";
+  vendorSha256 = "sha256-rw75xNBBV58F+HBVtD/EslPWxZxLbI3/mJVdJF4usKI=";
 
   meta = with lib; {
     description = "A Lightweight VPN Built on top of Libp2p for Truly Distributed Networks.";

pkgs/applications/video/kodi-packages/inputstream-adaptive/default.nix

···
 buildKodiBinaryAddon rec {
   pname = "inputstream-adaptive";
   namespace = "inputstream.adaptive";
-  version = "2.6.16";
+  version = "2.6.17";
 
   src = fetchFromGitHub {
     owner = "xbmc";
     repo = "inputstream.adaptive";
     rev = "${version}-${rel}";
-    sha256 = "0c9cy284crmki2pmg9gvf443hrg13x1cr4vzd4yjsnpk6xpifad6";
+    sha256 = "sha256-MHwLTSyMF7vYiVTof3xePW2eOySCr4/xYlPvWSzBZUg=";
   };
 
   extraNativeBuildInputs = [ gtest ];

pkgs/build-support/writers/default.nix

···
       name = last (builtins.split "/" nameOrPath);
     in
 
-    pkgs.runCommandLocal name (if types.path.check content then {
-      inherit interpreter;
-      contentPath = content;
-    } else {
+    pkgs.runCommandLocal name (if (types.str.check content) then {
       inherit content interpreter;
       passAsFile = [ "content" ];
+    } else {
+      inherit interpreter;
+      contentPath = content;
     }) ''
       # On darwin a script cannot be used as an interpreter in a shebang but
       # there doesn't seem to be a limit to the size of shebang and multiple

pkgs/desktops/gnome/games/atomix/default.nix

···
 { lib, stdenv, fetchurl, meson, ninja, pkg-config, wrapGAppsHook, python3
 , gettext, gnome, glib, gtk3, libgnome-games-support, gdk-pixbuf }:
 
-let
+stdenv.mkDerivation rec {
   pname = "atomix";
   version = "3.34.0";
-in stdenv.mkDerivation rec {
-  name = "${pname}-${version}";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${name}.tar.xz";
+    url = "mirror://gnome/sources/atomix/${lib.versions.majorMinor version}/atomix-${version}.tar.xz";
     sha256 = "0h909a4mccf160hi0aimyicqhq2b0gk1dmqp7qwf87qghfrw6m00";
   };
 

pkgs/desktops/gnome/games/gnome-klotski/default.nix

···
 , meson, ninja, python3
 }:
 
-let
+stdenv.mkDerivation rec {
   pname = "gnome-klotski";
   version = "3.38.2";
-in stdenv.mkDerivation rec {
-  name = "${pname}-${version}";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${name}.tar.xz";
+    url = "mirror://gnome/sources/gnome-klotski/${lib.versions.majorMinor version}/gnome-klotski-${version}.tar.xz";
     sha256 = "1qm01hdd5yp8chig62bj10912vclbdvywwczs84sfg4zci2phqwi";
   };
 

pkgs/development/compilers/smlnj/bootstrap.nix

···
+# This derivation should be redundant, now that regular smlnj works on Darwin,
+# and is preserved only for pre-existing direct usage. New use cases should
+# just use the regular smlnj derivation.
+
 { lib, stdenv, fetchurl, cpio, rsync, xar, makeWrapper }:
 
 stdenv.mkDerivation rec {

pkgs/development/compilers/smlnj/default.nix

···
-{ lib, stdenv, fetchurl }:
+{ lib, stdenv, fetchurl, Libsystem }:
 let
   version = "110.95";
   baseurl = "http://smlnj.cs.uchicago.edu/dist/working/${version}";
 
-  isArch64 = stdenv.system == "x86_64-linux";
-
-  arch = if isArch64
+  arch = if stdenv.is64bit
     then "64"
     else "32";
 
···
   boot64 = { url = "${baseurl}/boot.amd64-unix.tgz";
              sha256 = "1zn96a83kb6bn6228yfjsvb58m2qxw9k4j3qz0p9c8za479w4ch6"; };
 
-  bootBinary = if isArch64
+  bootBinary = if stdenv.is64bit
                then boot64
                else boot32;
 
···
     sed -i '/PATH=/d' config/_arch-n-opsys base/runtime/config/gen-posix-names.sh
     echo SRCARCHIVEURL="file:/$TMP" > config/srcarchiveurl
     patch --verbose config/_heap2exec ${./heap2exec.diff}
+  '' + lib.optionalString stdenv.isDarwin ''
+    # Locate standard headers like <unistd.h>
+    substituteInPlace base/runtime/config/gen-posix-names.sh \
+      --replace "\$SDK_PATH/usr" "${Libsystem}"
   '';
 
   unpackPhase = ''
···
     description = "Standard ML of New Jersey, a compiler";
     homepage    = "http://smlnj.org";
     license     = licenses.bsd3;
-    platforms   = [ "x86_64-linux" "i686-linux" ];
+    platforms   = [ "x86_64-linux" "i686-linux" "x86_64-darwin" ];
     maintainers = with maintainers; [ thoughtpolice ];
   };
 }

pkgs/development/libraries/gupnp/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gupnp";
-  version = "1.2.7";
+  version = "1.2.4";
 
   outputs = [ "out" "dev" "devdoc" ];
 
   src = fetchurl {
     url = "mirror://gnome/sources/gupnp/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-hEEnbxr9AXbm9ZUCajpQfu0YCav6BAJrrT8hYis1I+w=";
+    sha256 = "sha256-96AwfqUfXkTRuDL0k92QRURKOk4hHvhd/Zql3W6up9E=";
   };
+
+  patches = [
+    (fetchpatch {
+      name = "CVE-2021-33516.patch";
+      url = "https://gitlab.gnome.org/GNOME/gupnp/-/commit/ca6ec9dcb26fd7a2a630eb6a68118659b589afac.patch";
+      sha256 = "sha256-G7e/xNQB7Kp2fPzqVeD/cH3h1co9hZXh55QOUBnAnvU=";
+    })
+  ];
 
   nativeBuildInputs = [
     meson

pkgs/development/libraries/kde-frameworks/kimageformats.nix

···
 {
-  mkDerivation, lib,
+  mkDerivation, lib, fetchpatch,
   extra-cmake-modules,
   ilmbase, karchive, openexr, libavif, qtbase
 }:
···
 
 mkDerivation {
   name = "kimageformats";
+
+  patches = [
+    (fetchpatch { # included in kimageformats >= 5.83
+      name = "avif-0.9.2.diff";
+      url = "https://invent.kde.org/frameworks/kimageformats/-/commit/bf3f94da766d66a0470ab744dbe1ced4697b572d.diff";
+      sha256 = "18d67l5kj9sv88jdpi061k9rl3adzkx9l51ng7saylrkfddwc3ig";
+    })
+  ];
+
   nativeBuildInputs = [ extra-cmake-modules ];
   buildInputs = [ karchive openexr libavif qtbase ];
   outputs = [ "out" ]; # plugins only

pkgs/development/libraries/volk/default.nix

···
 { stdenv
 , lib
 , fetchFromGitHub
-, fetchpatch
 , cmake
-, cppunit
 , python3
 , enableModTool ? true
 , removeReferencesTo
···
 
 stdenv.mkDerivation rec {
   pname = "volk";
-  version = "2.4.1";
+  version = "2.5.0";
 
   src = fetchFromGitHub {
     owner = "gnuradio";
     repo = pname;
     rev = "v${version}";
-    sha256 = "fuHJ+p5VN4ThdbQFbzB08VCuy/Zo7m/I1Gs5EQGPeNY=";
+    sha256 = "XvX6emv30bSB29EFm6aC+j8NGOxWqHCNv0Hxtdrq/jc=";
     fetchSubmodules = true;
   };
 
-  patches = [
-    # Fixes a failing test: https://github.com/gnuradio/volk/pull/434
-    (fetchpatch {
-      url = "https://github.com/gnuradio/volk/pull/434/commits/bce8531b6f1a3c5abe946ed6674b283d54258281.patch";
-      sha256 = "OLW9uF6iL47z63kjvYqwsWtkINav8Xhs+Htqg6Kr4uI=";
-    })
-  ];
   cmakeFlags = lib.optionals (!enableModTool) [ "-DENABLE_MODTOOL=OFF" ];
-  postInstall = ''
+  postInstall = lib.optionalString (!stdenv.isDarwin) ''
     ${removeReferencesTo}/bin/remove-references-to -t ${stdenv.cc} $(readlink -f $out/lib/libvolk.so)
   '';
 

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

···
 
 buildPythonPackage rec {
   pname = "hstspreload";
-  version = "2021.6.21";
+  version = "2021.6.28";
   disabled = isPy27;
 
   src = fetchFromGitHub {
     owner = "sethmlarson";
     repo = pname;
     rev = version;
-    sha256 = "sha256-mo3DqEiuieCSM5d3Z+tKvtmazlh53pgsM4bkawSvuSM=";
+    sha256 = "sha256-SZGyn79R3+IwtoZ+khgFnl0WosRoCcKNk8efGxbOugc=";
   };
 
   # tests require network connection

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

···
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchFromGitHub
+, python-dateutil
+, requests
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "srpenergy";
+  version = "1.3.2";
+
+  disabled = pythonOlder "3.6";
+
+  src = fetchFromGitHub {
+    owner = "lamoreauxlab";
+    repo = "srpenergy-api-client-python";
+    rev = version;
+    sha256 = "03kldjk90mrnzf2hpd7xky0lpph853mjxc34kfa2m5mbpbpkxz9c";
+  };
+
+  propagatedBuildInputs = [
+    python-dateutil
+    requests
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "srpenergy.client" ];
+
+  meta = with lib; {
+    description = "Unofficial Python module for interacting with Srp Energy data";
+    homepage = "https://github.com/lamoreauxlab/srpenergy-api-client-python";
+    license = licenses.mit;
+    maintainers = with maintainers; [ dotlambda ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchPypi
+, aiohttp
+, requests
+}:
+
+buildPythonPackage rec {
+  pname = "starline";
+  version = "0.1.5";
+
+  disabled = pythonOlder "3.5";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1753f5fcd2a6976aed775afb03f8392159f040c673917cc0c634510d95c13cb9";
+  };
+
+  propagatedBuildInputs = [
+    aiohttp
+    requests
+  ];
+
+  # no tests implemented
+  doCheck = false;
+
+  pythonImportsCheck = [ "starline" ];
+
+  meta = with lib; {
+    description = "Unofficial python library for StarLine API";
+    homepage = "https://github.com/Anonym-tsk/starline";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ dotlambda ];
+  };
+}

pkgs/development/python-modules/yq/jq-path.patch

···
 diff --git a/test/test.py b/test/test.py
-index a81f41b..9e80f04 100755
+index f25dced..cd308c8 100755
 --- a/test/test.py
 +++ b/test/test.py
-@@ -112,7 +112,7 @@ class TestYq(unittest.TestCase):
+@@ -105,7 +105,7 @@ class TestYq(unittest.TestCase):
                  tf2.seek(0)
                  self.assertEqual(self.run_yq("", ["-y", arg, tf.name, self.fd_path(tf2)]), '1\n...\n')
- 
+
 -    @unittest.skipIf(subprocess.check_output(["jq", "--version"]) < b"jq-1.6", "Test options introduced in jq 1.6")
 +    @unittest.skipIf(subprocess.check_output(["@jq@", "--version"]) < b"jq-1.6", "Test options introduced in jq 1.6")
      def test_jq16_arg_passthrough(self):
          self.assertEqual(self.run_yq("{}", ["--indentless", "-y", ".a=$ARGS.positional", "--args", "a", "b"]),
                           "a:\n- a\n- b\n")
 diff --git a/yq/__init__.py b/yq/__init__.py
-index afeb42c..a0d7970 100755
+index 91212d0..ee5a799 100755
 --- a/yq/__init__.py
 +++ b/yq/__init__.py
 @@ -146,7 +146,7 @@ def yq(input_streams=None, output_stream=None, input_format="yaml", output_forma
- 
      try:
-         # Note: universal_newlines is just a way to induce subprocess to make stdin a text buffer and encode it for us
+         # Notes: universal_newlines is just a way to induce subprocess to make stdin a text buffer and encode it for us;
+         # close_fds must be false for command substitution to work (yq . t.yml --slurpfile t <(yq . t.yml))
 -        jq = subprocess.Popen(["jq"] + list(jq_args),
 +        jq = subprocess.Popen(["@jq@"] + list(jq_args),
                                stdin=subprocess.PIPE,
                                stdout=subprocess.PIPE if converting_output else None,
-                               universal_newlines=True)
+                               close_fds=False,

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

···
 { lib, stdenv, fetchurl, makeWrapper, jre }:
 
 stdenv.mkDerivation rec {
-  version = "8.43";
+  version = "8.44";
   pname = "checkstyle";
 
   src = fetchurl {
     url = "https://github.com/checkstyle/checkstyle/releases/download/checkstyle-${version}/checkstyle-${version}-all.jar";
-    sha256 = "sha256-jb864Kr5Hx/e2OIRYPLJGkRIsxT/cebLnOGGy1YtJY8=";
+    sha256 = "sha256-tXTU5A4mKQ0DDWCE3VUXB3fbanHyFNSIcTMJ3NRlj6A=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

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

···
 
 stdenv.mkDerivation rec {
   pname = "bear";
-  version = "3.0.12";
+  version = "3.0.13";
 
   src = fetchFromGitHub {
     owner = "rizsotto";
     repo = pname;
     rev = version;
-    sha256 = "0nalvmkl9iwbs4wbsacryrwr46vk3x6jzqj9v5wfyf6aim3s1szs";
+    sha256 = "sha256-oMrTH3GjxiLBKX0i3ZuV+bNqpA7PkoAQAb/08Q/uELs=";
   };
 
   nativeBuildInputs = [ cmake pkg-config ];

pkgs/development/tools/ginkgo/default.nix

···
 
 buildGoModule rec {
   pname = "ginkgo";
-  version = "1.16.3";
+  version = "1.16.4";
 
   src = fetchFromGitHub {
     owner = "onsi";
     repo = "ginkgo";
     rev = "v${version}";
-    sha256 = "sha256-MDxDDZaNgjZz98lAoIIpWbIg7Cr/6kohSh+WL/1Ljyo=";
+    sha256 = "sha256-p9kam1pRP0Am02o7vM+VzeAht+Qtn4DZ12NM8TaA/2Y=";
   };
   vendorSha256 = "sha256-tS8YCGVOsfQp02vY6brmE3pxi70GG9DYcp1JDkcVG9Y=";
   doCheck = false;

pkgs/development/tools/go-minimock/default.nix

···
 
 buildGoModule rec {
   pname = "go-minimock";
-  version = "3.0.8";
+  version = "3.0.9";
 
   src = fetchFromGitHub {
     owner = "gojuno";
     repo = "minimock";
     rev = "v${version}";
-    sha256 = "0r0krbwvx5w1z0yv2qqi92irbsfhkvwvaigy350cvcz9gmcppj4h";
+    sha256 = "sha256-l+ngvmTb9yVgQYT+OeaVd0zz/xNZeXWrjMpVkMpbQIw=";
   };
 
   buildFlagsArray = [
     "-ldflags=-s -w -X main.version=${version}"
   ];
 
-  vendorSha256 = "1macwm6hybjinwnx62v146yxydcn5k5r587nxwkf4ffy76s2m3jc";
+  vendorSha256 = "sha256-hn222ifKRYbASAHBJyMTCDwhykf2Jg9IqIUlK/GabJA=";
 
   doCheck = true;
 

pkgs/development/tools/rust/cargo-flash/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-flash";
-  version = "0.10.1";
+  version = "0.11.0";
 
   src = fetchFromGitHub {
     owner = "probe-rs";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-aQ5647woODs/A4fcxSsQoQHL6YQ0TpfQFegtXETqlHk=";
+    sha256 = "sha256-yTtnRdDy3wGBe0SlO0165uooWu6ZMhUQw3hdDUK1e8A=";
   };
 
-  cargoSha256 = "sha256-P7xyg9I1MhmiKlyAI9cvABcYKNxB6TSvTgMsMk5KxAQ=";
+  cargoSha256 = "sha256-f5vUMdyz3vDh2yE0pMKZiknsqTAKkuvTCtlgb6/gaLc=";
 
   nativeBuildInputs = [ pkg-config rustfmt ];
   buildInputs = [ libusb1 openssl ] ++ lib.optionals stdenv.isDarwin [ Security ];

pkgs/games/andyetitmoves/default.nix

···
 { lib, stdenv, fetchurl, libvorbis, libogg, libtheora, SDL, libXft, SDL_image, zlib, libX11, libpng, openal, runtimeShell, requireFile, commercialVersion ? false }:
 
-let plainName = "andyetitmoves";
-    version   = "1.2.2";
-in
-
-stdenv.mkDerivation {
-  name = "${plainName}-${version}";
+stdenv.mkDerivation rec {
+  pname = "andyetitmoves";
+  version   = "1.2.2";
 
   src = if stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux"
     then
       let postfix        = if stdenv.hostPlatform.system == "i686-linux" then "i386" else "x86_64";
-          commercialName = "${plainName}-${version}_${postfix}.tar.gz";
-          demoUrl        = "http://www.andyetitmoves.net/demo/${plainName}Demo-${version}_${postfix}.tar.gz";
+          commercialName = "${pname}-${version}_${postfix}.tar.gz";
+          demoUrl        = "http://www.andyetitmoves.net/demo/${pname}Demo-${version}_${postfix}.tar.gz";
       in
       if commercialVersion
         then requireFile {

pkgs/games/arena/default.nix

···
 
 in
 stdenv.mkDerivation rec {
-  name = "arena-3.10-beta";
+  pname = "arena";
+  version = "3.10-beta";
 
   src = fetchurl {
-    url = "http://www.playwitharena.de/downloads/arenalinux_64bit_3.10beta.tar.gz";
+    url = "http://www.playwitharena.de/downloads/arenalinux_64bit_${lib.replaceStrings ["-"] [""] version}.tar.gz";
     sha256 = "1pzb9sg4lzbbi4gbldvlb85p8xyl9xnplxwyb9pkk2mwzvvxkf0d";
   };
 
···
   unpackPhase = ''
     # This is is a tar bomb, i.e. it extract a dozen files and directories to
     # the top-level, so we must create a sub-directory first.
-    mkdir -p $out/lib/${name}
-    tar -C $out/lib/${name} -xf ${src}
+    mkdir -p $out/lib/${pname}-${version}
+    tar -C $out/lib/${pname}-${version} -xf ${src}
 
     # Remove executable bits from data files. This matters for the find command
     # we'll use below to find all bundled engines.
-    chmod -x $out/lib/${name}/Engines/*/*.{txt,bin,bmp,zip}
+    chmod -x $out/lib/${pname}-${version}/Engines/*/*.{txt,bin,bmp,zip}
   '';
 
   buildPhase = ''
     # Arena has (at least) two executables plus a couple of bundled chess
     # engines that we need to patch.
     exes=( $(find $out -name '*x86_64_linux')
-           $(find $out/lib/${name}/Engines -type f -perm /u+x)
+           $(find $out/lib/${pname}-${version}/Engines -type f -perm /u+x)
          )
     for i in "''${exes[@]}"; do
       # Arminius is statically linked.
···
 
   installPhase = ''
     mkdir -p $out/bin
-    ln -s $out/lib/${name}/Arena_x86_64_linux $out/bin/arena
+    ln -s $out/lib/${pname}-${version}/Arena_x86_64_linux $out/bin/arena
   '';
 
   dontStrip = true;

pkgs/games/asc/default.nix

···
 , libpng, libtiff, fluidsynth, libmikmod, libvorbis, flac, libogg }:
 
 stdenv.mkDerivation rec {
-  name = "asc-2.6.0.0";
+  pname = "asc";
+  version = "2.6.0.0";
 
   src = fetchurl {
-    url = "mirror://sourceforge/asc-hq/${name}.tar.bz2";
+    url = "mirror://sourceforge/asc-hq/asc-${version}.tar.bz2";
     sha256 = "1fybasb6srqfg6pqbvh0s0vvzjq9r0n6aq0z44hs7n68kmaam775";
   };
 

pkgs/games/ball-and-paddle/default.nix

···
 { fetchurl, lib, stdenv, SDL, SDL_image, SDL_mixer, SDL_ttf, guile, gettext }:
 
 stdenv.mkDerivation rec {
-  name = "ballandpaddle-0.8.1";
+  pname = "ballandpaddle";
+  version = "0.8.1";
 
   src = fetchurl {
-    url = "mirror://gnu/ballandpaddle/${name}.tar.gz";
+    url = "mirror://gnu/ballandpaddle/ballandpaddle-${version}.tar.gz";
     sha256 = "0zgpydad0mj7fbkippw3n9hlda6nac084dq5xfbsks9jn1xd30ny";
   };
 

pkgs/games/beret/default.nix

···
 { lib, stdenv, fetchurl, SDL, SDL_image, SDL_ttf, SDL_mixer }:
 
 stdenv.mkDerivation {
-  name = "beret-1.2.0";
+  pname = "beret";
+  version = "1.2.0";
 
   buildInputs = [ SDL SDL_image SDL_ttf SDL_mixer ];
 

pkgs/games/bitsnbots/default.nix

···
 { lib, stdenv, fetchurl, SDL, lua, libGLU, libGL }:
 
 stdenv.mkDerivation rec {
-  name = "bitsnbots-20111230";
+  pname = "bitsnbots";
+  version = "20111230";
 
   src = fetchurl {
     url = "http://moikmellah.org/downloads/bitsnbots/bitsnbots.source.tgz";
···
   NIX_LDFLAGS = "-lGL";
 
   installPhase = ''
-    mkdir -p $out/share/${name}
-    cp -R bitsnbots resource scripts README $out/share/${name}
+    mkdir -p $out/share/${pname}-${version}
+    cp -R bitsnbots resource scripts README $out/share/${pname}-${version}
     mkdir -p $out/bin
-    ln -s $out/share/${name}/bitsnbots $out/bin
+    ln -s $out/share/${pname}-${version}/bitsnbots $out/bin
   '';
 
   buildInputs = [ SDL lua libGLU libGL ];

pkgs/games/bsdgames/default.nix

···
 { lib, stdenv, fetchurl, ncurses, openssl, flex, bison, less, miscfiles }:
 
-stdenv.mkDerivation {
-  name = "bsd-games-2.17";
+stdenv.mkDerivation rec {
+  pname = "bsd-games";
+  version = "2.17";
 
   src = fetchurl {
-    url = "ftp://metalab.unc.edu/pub/Linux/games/bsd-games-2.17.tar.gz";
+    url = "ftp://metalab.unc.edu/pub/Linux/games/bsd-games-${version}.tar.gz";
     sha256 = "0q7zdyyfvn15y0w4g54kq3gza89h61py727m8slmw73cxx594vq6";
   };
 

pkgs/games/chessdb/default.nix

···
 { lib, stdenv, fetchurl, tcl, tk, libX11, makeWrapper }:
 
-stdenv.mkDerivation {
-  name = "chessdb-3.6.19-beta-1";
+stdenv.mkDerivation rec {
+  pname = "chessdb";
+  version = "3.6.19-beta-1";
 
   src = fetchurl {
-    url = "mirror://sourceforge/chessdb/ChessDB-3.6.19-beta-1.tar.gz";
+    url = "mirror://sourceforge/chessdb/ChessDB-${version}.tar.gz";
     sha256 = "0brc3wln3bxp979iqj2w1zxpfd0pch8zzazhdmwf7acww4hrsz62";
   };
 

pkgs/games/crack-attack/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gtk2, freeglut, SDL, SDL_mixer, libGLU, libGL, libXi, libXmu }:
 
-stdenv.mkDerivation {
-  name = "crack-attack-1.1.14";
+stdenv.mkDerivation rec {
+  pname = "crack-attack";
+  version = "1.1.14";
 
   src = fetchurl {
-    url = "mirror://savannah/crack-attack/crack-attack-1.1.14.tar.gz";
+    url = "mirror://savannah/crack-attack/crack-attack-${version}.tar.gz";
     sha256 = "1sakj9a2q05brpd7lkqxi8q30bccycdzd96ns00s6jbxrzjlijkm";
   };
 

pkgs/games/duckmarines/default.nix

···
 { lib, stdenv, fetchurl, love, lua, makeWrapper, makeDesktopItem }:
 
-let
+stdenv.mkDerivation rec {
   pname = "duckmarines";
   version = "1.0c";
 
···
     genericName = "duckmarines";
     categories = "Game;";
   };
-
-in
-
-stdenv.mkDerivation rec {
-  name = "${pname}-${version}";
 
   src = fetchurl {
     url = "https://github.com/SimonLarsen/${pname}/releases/download/v${version}/${pname}-1.0c.love";

pkgs/games/eboard/default.nix

···
 { lib, stdenv, fetchurl, perl, pkg-config, gtk2 }:
 
-stdenv.mkDerivation {
-  name = "eboard-1.1.1";
+stdenv.mkDerivation rec {
+  pname = "eboard";
+  version = "1.1.1";
 
   src = fetchurl {
-    url = "mirror://sourceforge/eboard/eboard-1.1.1.tar.bz2";
+    url = "mirror://sourceforge/eboard/eboard-${version}.tar.bz2";
     sha256 = "0vm25j1s2zg1lipwjv9qrcm877ikfmk1yh34i8f5l3bwd63115xd";
   };
 

pkgs/games/eduke32/default.nix

···
 , SDL2, SDL2_mixer }:
 
 let
-  version = "20200907";
-  rev = "9257";
-  revExtra = "93f62bbad";
-
   desktopItem = makeDesktopItem {
     name = "eduke32";
     exec = "@out@/bin/${wrapper}";
···
 
   wrapper = "eduke32-wrapper";
 
-in stdenv.mkDerivation {
+in stdenv.mkDerivation rec {
   pname = "eduke32";
-  inherit version;
+  version = "20200907";
+  rev = "9257";
+  revExtra = "93f62bbad";
 
   src = fetchurl {
     url = "http://dukeworld.duke4.net/eduke32/synthesis/latest/eduke32_src_${version}-${rev}-${revExtra}.tar.xz";

pkgs/games/endless-sky/default.nix

···
 , SDL2, libpng, libjpeg, glew, openal, scons, libmad
 }:
 
-let
-  version = "0.9.12";
-
-in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "endless-sky";
-  inherit version;
+  version = "0.9.12";
 
   src = fetchFromGitHub {
     owner = "endless-sky";

pkgs/games/exult/default.nix

···
 in
 
 stdenv.mkDerivation rec {
-  name = "exult-1.6";
+  pname = "exult";
+  version = "1.6";
 
   src = fetchurl {
-    url = "mirror://sourceforge/exult/${name}.tar.gz";
+    url = "mirror://sourceforge/exult/exult-${version}.tar.gz";
     sha256 = "1dm27qkxj30567zb70q4acddsizn0xyi3z87hg7lysxdkyv49s3s";
   };
 

pkgs/games/fsg/default.nix

···
 { lib, stdenv, fetchurl, gtk2, glib, pkg-config, libGLU, libGL, wxGTK, libX11, xorgproto
 , runtimeShell }:
 
-stdenv.mkDerivation {
-  name = "fsg-4.4";
+stdenv.mkDerivation rec {
+  pname = "fsg";
+  version = "4.4";
 
   src = fetchurl {
-    name = "fsg-src-4.4.tar.gz";
-    url = "https://github.com/ctrlcctrlv/wxsand/blob/master/fsg-src-4.4-ORIGINAL.tar.gz?raw=true";
+    name = "fsg-src-${version}.tar.gz";
+    url = "https://github.com/ctrlcctrlv/wxsand/blob/master/fsg-src-${version}-ORIGINAL.tar.gz?raw=true";
     sha256 = "1756y01rkvd3f1pkj88jqh83fqcfl2fy0c48mcq53pjzln9ycv8c";
   };
 

pkgs/games/gav/default.nix

···
 {lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer, SDL_net} :
 
-stdenv.mkDerivation {
-  name = "gav-0.9.0";
+stdenv.mkDerivation rec {
+  pname = "gav";
+  version = "0.9.0";
 
   src = fetchurl {
-    url = "mirror://sourceforge/gav/gav-0.9.0.tar.gz";
+    url = "mirror://sourceforge/gav/gav-${version}.tar.gz";
     sha256 = "8f0deb8b2cd775b339229054f4f282583a4cfbcba9d27a6213cf910bab944f3e";
   };
 

pkgs/games/gltron/default.nix

···
 {lib, stdenv, fetchurl, SDL, libGLU, libGL, zlib, libpng, libvorbis, libmikmod, SDL_sound } :
 
 stdenv.mkDerivation rec {
-  name = "gltron-0.70";
+  pname = "gltron";
+  version = "0.70";
   src = fetchurl {
-    url = "mirror://sourceforge/gltron/${name}-source.tar.gz";
+    url = "mirror://sourceforge/gltron/gltron-${version}-source.tar.gz";
     sha256 = "e0c8ebb41a18a1f8d7302a9c2cb466f5b1dd63e9a9966c769075e6b6bdad8bb0";
   };
 

pkgs/games/gmad/default.nix

···
 { lib, stdenv, fetchFromGitHub, premake4, bootil }:
 
 stdenv.mkDerivation rec {
-  name = "gmad-unstable-2015-04-16";
+  pname = "gmad";
+  version = "unstable-2015-04-16";
 
   meta = {
     description = "Garry's Mod Addon Creator and Extractor";

pkgs/games/gtetrinet/default.nix

···
 { fetchFromGitHub, lib, stdenv, autoreconfHook, intltool, pkg-config, libgnome, libgnomeui, GConf }:
 
 stdenv.mkDerivation {
-  name = "gtetrinet-0.7.11";
+  pname = "gtetrinet";
+  version = "0.7.11";
 
   src = fetchFromGitHub {
     owner = "GNOME";

pkgs/games/icbm3d/default.nix

···
 {lib, stdenv, fetchurl, libX11}:
 
-stdenv.mkDerivation {
-  name = "icbm3d-0.4";
+stdenv.mkDerivation rec {
+  pname = "icbm3d";
+  version = "0.4";
   src = fetchurl {
-    url = "ftp://ftp.tuxpaint.org/unix/x/icbm3d/icbm3d.0.4.tar.gz";
+    url = "ftp://ftp.tuxpaint.org/unix/x/icbm3d/icbm3d.${version}.tar.gz";
     sha256 = "1z9q01mj0v9qbwby5cajjc9wpvdw2ma5v1r639vraxpl9qairm4s";
   };
 

pkgs/games/kobodeluxe/default.nix

···
 {lib, stdenv, fetchurl, SDL, SDL_image, libGLU, libGL} :
 
-stdenv.mkDerivation {
-  name = "kobodeluxe-0.5.1";
+stdenv.mkDerivation rec {
+  pname = "kobodeluxe";
+  version = "0.5.1";
   src = fetchurl {
-    url = "http://olofson.net/kobodl/download/KoboDeluxe-0.5.1.tar.bz2";
+    url = "http://olofson.net/kobodl/download/KoboDeluxe-${version}.tar.bz2";
     sha256 = "0f7b910a399d985437564af8c5d81d6dcf22b96b26b01488d72baa6a6fdb5c2c";
   };
 

pkgs/games/macopix/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gtk, openssl }:
 
 stdenv.mkDerivation rec {
-  name = "macopix-1.7.4";
+  pname = "macopix";
+  version = "1.7.4";
 
   src = fetchurl {
-    url = "http://rosegray.sakura.ne.jp/macopix/${name}.tar.bz2";
+    url = "http://rosegray.sakura.ne.jp/macopix/macopix-${version}.tar.bz2";
     sha256 = "0sgnr0wrw3hglcnsyvipll7icfv69ssmyw584zfhk1rgramlkzyb";
   };
 

pkgs/games/neverball/default.nix

···
 , physfs }:
 
 stdenv.mkDerivation rec {
-  name = "neverball-1.6.0";
+  pname = "neverball";
+  version = "1.6.0";
   src = fetchurl {
-    url = "https://neverball.org/${name}.tar.gz";
+    url = "https://neverball.org/neverball-${version}.tar.gz";
     sha256 = "184gm36c6p6vaa6gwrfzmfh86klhnb03pl40ahsjsvprlk667zkk";
   };
 

pkgs/games/njam/default.nix

···
 {lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer, SDL_net }:
 
-stdenv.mkDerivation {
-  name = "njam-1.25";
+stdenv.mkDerivation rec {
+  pname = "njam";
+  version = "1.25";
 
   src = fetchurl {
-    url = "mirror://sourceforge/njam/njam-1.25-src.tar.gz";
+    url = "mirror://sourceforge/njam/njam-${version}-src.tar.gz";
     sha256 = "0ysvqw017xkvddj957pdfmbmji7qi20nyr7f0zxvcvm6c7d3cc7s";
   };
 

pkgs/games/openlierox/default.nix

···
 { lib, stdenv, fetchurl, libX11, xorgproto, gd, SDL, SDL_image, SDL_mixer, zlib
 , libxml2, pkg-config, curl, cmake, libzip }:
 
-stdenv.mkDerivation {
-  name = "openlierox-0.58rc3";
+stdenv.mkDerivation rec {
+  pname = "openlierox";
+  version = "0.58rc3";
 
   src = fetchurl {
     url = "mirror://sourceforge/openlierox/OpenLieroX_0.58_rc3.src.tar.bz2";

pkgs/games/openra/engine.nix

···
 with lib;
 
 stdenv.mkDerivation (recursiveUpdate packageAttrs rec {
-  name = "${pname}-${version}";
   pname = "openra";
   version = "${engine.name}-${engine.version}";
 

pkgs/games/orthorobot/default.nix

···
 { lib, stdenv, fetchurl, fetchFromGitHub, zip, love, lua, makeWrapper, makeDesktopItem }:
-
-let
+stdenv.mkDerivation rec {
   pname = "orthorobot";
   version = "1.1.1";
+
+  src = fetchFromGitHub {
+    owner = "Stabyourself";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1ca6hvd890kxmamsmsfiqzw15ngsvb4lkihjb6kabgmss61a6s5p";
+  };
 
   icon = fetchurl {
     url = "http://stabyourself.net/images/screenshots/orthorobot-5.png";
···
     desktopName = "Orthorobot";
     genericName = "orthorobot";
     categories = "Game;";
-  };
-
-in
-
-stdenv.mkDerivation {
-  name = "${pname}-${version}";
-
-  src = fetchFromGitHub {
-    owner = "Stabyourself";
-    repo = pname;
-    rev = "v${version}";
-    sha256 = "1ca6hvd890kxmamsmsfiqzw15ngsvb4lkihjb6kabgmss61a6s5p";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/games/pokerth/default.nix

···
 in
 
 mkDerivation rec {
-  name = "pokerth-${target}-${version}";
+  pname = "pokerth-${target}";
   version = "1.1.2";
 
   src = fetchFromGitHub {

pkgs/games/pong3d/default.nix

···
 {lib, stdenv, fetchurl, libX11}:
 
-stdenv.mkDerivation {
-  name = "3dpong-0.5";
+stdenv.mkDerivation rec {
+  pname = "3dpong";
+  version = "0.5";
   src = fetchurl {
-    url = "ftp://ftp.tuxpaint.org/unix/x/3dpong/src/3dpong-0.5.tar.gz";
+    url = "ftp://ftp.tuxpaint.org/unix/x/3dpong/src/3dpong-${version}.tar.gz";
     sha256 = "1ibb79sbzlbn4ra3n0qk22gqr6fg7q0jy6cm0wg2qj4z64c7hmdi";
   };
 

pkgs/games/prboom/default.nix

···
 assert useOpenGL -> libGL != null && libGLU != null;
 
 stdenv.mkDerivation rec {
-  name = "prboom-2.5.0";
+  pname = "prboom";
+  version = "2.5.0";
   src = fetchurl {
-    url = "mirror://sourceforge/prboom/prboom-2.5.0.tar.gz";
+    url = "mirror://sourceforge/prboom/prboom-${version}.tar.gz";
     sha256 = "1bjb04q8dk232956k30qlpq6q0hxb904yh1nflr87jcc1x3iqv12";
   };
 

pkgs/games/quake2/yquake2/games.nix

···
     inherit (data) id version description sha256;
     inherit title;
 
-    name = "yquake2-${title}-${version}";
+    pname = "yquake2-${title}";
 
     src = fetchFromGitHub {
       inherit sha256;

pkgs/games/racer/default.nix

···
 { fetchurl, lib, stdenv, allegro, libjpeg, makeWrapper }:
 
-stdenv.mkDerivation {
-  name = "racer-1.1";
+stdenv.mkDerivation rec {
+  pname = "racer";
+  version = "1.1";
 
   src = if stdenv.hostPlatform.system == "i686-linux" then fetchurl {
-    url = "http://hippo.nipax.cz/src/racer-1.1.tar.gz";
+    url = "http://hippo.nipax.cz/src/racer-${version}.tar.gz";
     sha256 = "0fll1qkqfcjq87k0jzsilcw701z92lfxn2y5ga1n038772lymxl9";
   } else if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {
-    url = "https://hippo.nipax.cz/src/racer-1.1.64.tar.gz";
+    url = "https://hippo.nipax.cz/src/racer-${version}.64.tar.gz";
     sha256 = "0rjy3gmlhwfkb9zs58j0mc0dar0livwpbc19r6zw5r2k6r7xdan0";
   } else
     throw "System not supported";

pkgs/games/rili/default.nix

···
 { lib, stdenv, fetchurl, SDL_mixer, SDL, autoreconfHook }:
 
-stdenv.mkDerivation {
-  name = "ri_li-2.0.1";
+stdenv.mkDerivation rec {
+  pname = "ri_li";
+  version = "2.0.1";
 
   src = fetchurl {
-    url = "mirror://sourceforge/ri-li/Ri-li-2.0.1.tar.bz2";
+    url = "mirror://sourceforge/ri-li/Ri-li-${version}.tar.bz2";
     sha256 = "f71ccc20c37c601358d963e087ac0d524de8c68e96df09c3aac1ae65edd38dbd";
   };
 

pkgs/games/rimshot/default.nix

···
 { lib, stdenv, fetchurl, unzip, love, lua, makeWrapper, makeDesktopItem }:
 
-let
+stdenv.mkDerivation rec {
   pname = "rimshot";
   version = "1.0";
+
+  src = fetchurl {
+    url = "https://stabyourself.net/dl.php?file=${pname}/${pname}-source.zip";
+    sha256 = "08pdkyvki92549605m9bqnr24ipkbwkp5nkr5aagdqnr8ai4rgmi";
+  };
 
   icon = fetchurl {
     url = "http://stabyourself.net/images/screenshots/rimshot-2.png";
···
     desktopName = "Rimshot";
     genericName = "rimshot";
     categories = "Audio;AudioVideo;Music";
-  };
-
-in
-
-stdenv.mkDerivation {
-  name = "${pname}-${version}";
-
-  src = fetchurl {
-    url = "http://stabyourself.net/dl.php?file=${pname}/${pname}-source.zip";
-    sha256 = "08pdkyvki92549605m9bqnr24ipkbwkp5nkr5aagdqnr8ai4rgmi";
   };
 
   nativeBuildInputs = [ makeWrapper unzip ];

pkgs/games/rocksndiamonds/default.nix

···
 { lib, stdenv, fetchurl, makeDesktopItem, SDL2, SDL2_image, SDL2_mixer, SDL2_net }:
 
 stdenv.mkDerivation rec {
-  name = "${project}-${version}";
-  project = "rocksndiamonds";
+  pname = "rocksndiamonds";
   version = "4.1.1.0";
 
   src = fetchurl {
-    url = "https://www.artsoft.org/RELEASES/unix/${project}/${name}.tar.gz";
+    url = "https://www.artsoft.org/RELEASES/unix/${pname}/rocksndiamonds-${version}.tar.gz";
     sha256 = "1k0m6l5g886d9mwwh6q0gw75qsb85mpf8i0rglh047app56nsk72";
   };
 

pkgs/games/rogue/default.nix

···
 {lib, stdenv, fetchurl, ncurses}:
 
-stdenv.mkDerivation {
-  name = "rogue-5.4.4";
+stdenv.mkDerivation rec {
+  pname = "rogue";
+  version = "5.4.4";
 
   src = fetchurl {
     urls = [
-      "https://src.fedoraproject.org/repo/pkgs/rogue/rogue5.4.4-src.tar.gz/033288f46444b06814c81ea69d96e075/rogue5.4.4-src.tar.gz"
-      "http://ftp.vim.org/ftp/pub/ftp/os/Linux/distr/slitaz/sources/packages-cooking/r/rogue5.4.4-src.tar.gz"
-      "http://rogue.rogueforge.net/files/rogue5.4/rogue5.4.4-src.tar.gz"
+      "https://src.fedoraproject.org/repo/pkgs/rogue/rogue${version}-src.tar.gz/033288f46444b06814c81ea69d96e075/rogue${version}-src.tar.gz"
+      "http://ftp.vim.org/ftp/pub/ftp/os/Linux/distr/slitaz/sources/packages-cooking/r/rogue${version}-src.tar.gz"
+      "http://rogue.rogueforge.net/files/rogue${lib.versions.majorMinor version}/rogue${version}-src.tar.gz"
     ];
     sha256 = "18g81274d0f7sr04p7h7irz0d53j6kd9j1y3zbka1gcqq0gscdvx";
   };

pkgs/games/scrolls/default.nix

···
 , libGLU, libX11, libXext, libXcursor, libpulseaudio
 }:
 stdenv.mkDerivation {
-  name = "scrolls-2015-10-13";
+  pname = "scrolls";
+  version = "2015-10-13";
 
   meta = {
     description = "A strategy collectible card game";

pkgs/games/sgt-puzzles/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "sgt-puzzles-r${version}";
+  pname = "sgt-puzzles";
   version = "20200610.9aa7b7c";
 
   src = fetchurl {

pkgs/games/sienna/default.nix

···
 { lib, stdenv, fetchurl, love, lua, makeWrapper, makeDesktopItem }:
 
-let
+stdenv.mkDerivation rec {
   pname = "sienna";
   version = "1.0c";
+  src = fetchurl {
+    url = "https://github.com/SimonLarsen/${pname}/releases/download/v${version}/${pname}-${version}.love";
+    sha256 = "1x15276fhqspgrrv8fzkp032i2qa8piywc0yy061x59mxhdndzj6";
+  };
 
   icon = fetchurl {
     url = "http://tangramgames.dk/img/thumb/sienna.png";
···
     desktopName = "Sienna";
     genericName = "sienna";
     categories = "Game;";
-  };
-
-in
-
-stdenv.mkDerivation {
-  name = "${pname}-${version}";
-
-  src = fetchurl {
-    url = "https://github.com/SimonLarsen/${pname}/releases/download/v${version}/${pname}-${version}.love";
-    sha256 = "1x15276fhqspgrrv8fzkp032i2qa8piywc0yy061x59mxhdndzj6";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/games/snake4/default.nix

···
 { lib, stdenv, fetchurl, shhmsg, shhopt, xorg }:
 
 stdenv.mkDerivation rec {
-  name = "snake4-1.0.14";
+  pname = "snake4";
+  version = "1.0.14";
 
   src = fetchurl {
-    url = "https://shh.thathost.com/pub-unix/files/${name}.tar.gz";
+    url = "https://shh.thathost.com/pub-unix/files/snake4-${version}.tar.gz";
     sha256 = "14cng9l857np42zixp440mbc8y5675frb6lhsds53j1cws9cncw9";
   };
 

pkgs/games/steam/fonts.nix

···
 { stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation {
-  name = "steam-fonts-1";
+  pname = "steam-fonts";
+  version = "1";
 
   src = fetchurl {
     url = "https://support.steampowered.com/downloads/1974-YFKL-4947/SteamFonts.zip";

pkgs/games/tcl2048/default.nix

···
 { lib, stdenv, fetchurl, tcl, tcllib, runtimeShell }:
 
-tcl.mkTclDerivation {
-  name = "tcl2048-0.4.0";
+tcl.mkTclDerivation rec {
+  pname = "tcl2048";
+  version = "0.4.0";
 
   src = fetchurl {
-    url = "https://raw.githubusercontent.com/dbohdan/2048.tcl/v0.4.0/2048.tcl";
+    url = "https://raw.githubusercontent.com/dbohdan/2048.tcl/v${version}/2048.tcl";
     sha256 = "53f5503efd7f029b2614b0f9b1e3aac6c0342735a3c9b811d74a5135fee3e89e";
   };
 

pkgs/games/teetertorture/default.nix

···
 { lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer }:
 
-stdenv.mkDerivation {
-  name = "teeter-torture-20051018";
+stdenv.mkDerivation rec {
+  pname = "teeter-torture";
+  version = "2005-10-18";
   src = fetchurl {
-    url = "ftp://ftp.tuxpaint.org/unix/x/teetertorture/source/teetertorture-2005-10-18.tar.gz";
+    url = "ftp://ftp.tuxpaint.org/unix/x/teetertorture/source/teetertorture-${version}.tar.gz";
     sha256 = "175gdbkx3m82icyzvwpyzs4v2fd69c695k5n8ca0lnjv81wnw2hr";
   };
 

pkgs/games/tennix/default.nix

···
 {lib, stdenv, fetchurl, SDL, SDL_mixer, SDL_image, SDL_ttf, SDL_net, python } :
 
 stdenv.mkDerivation rec {
-  name = "tennix-1.1";
+  pname = "tennix";
+  version = "1.1";
   src = fetchurl {
-    url = "https://icculus.org/tennix/downloads/${name}.tar.gz";
+    url = "https://icculus.org/tennix/downloads/tennix-${version}.tar.gz";
     sha256 = "0np5kw1y7i0z0dsqx4r2nvmq86qj8hv3mmgavm3hxraqnds5z8cm";
   };
 

pkgs/games/tibia/default.nix

···
 { lib, stdenv, fetchurl, glibc, libX11, runtimeShell, libGLU, libGL }:
 
-stdenv.mkDerivation {
-  name = "tibia-10.90";
+stdenv.mkDerivation rec {
+  pname = "tibia";
+  version = "10.90";
 
   src = fetchurl {
-    url = "http://static.tibia.com/download/tibia1090.tgz";
+    url = "http://static.tibia.com/download/tibia${lib.replaceStrings ["."] [""] version}.tgz";
     sha256 = "11mkh2dynmbpay51yfaxm5dmcys3rnpk579s9ypfkhblsrchbkhx";
   };
 

pkgs/games/tintin/default.nix

···
 assert tlsSupport -> gnutls != null;
 
 stdenv.mkDerivation rec {
-  name = "tintin-2.02.05";
+  pname = "tintin";
+  version = "2.02.05";
 
   src = fetchurl {
-    url    = "mirror://sourceforge/tintin/${name}.tar.gz";
+    url    = "mirror://sourceforge/tintin/tintin-${version}.tar.gz";
     sha256 = "sha256-Y6cAUhItJNade8ASOVdF8aBBLf/UVqjoqrhXBNRL1aE=";
   };
 

pkgs/games/tome4/default.nix

···
 { lib, stdenv, fetchurl, makeDesktopItem, makeWrapper, premake4, unzip
 , openal, libpng, libvorbis, libGLU, SDL2, SDL2_image, SDL2_ttf }:
 
-let
+stdenv.mkDerivation rec {
   pname = "tome4";
+  version = "1.6.7";
+
+  src = fetchurl {
+    url = "https://te4.org/dl/t-engine/t-engine4-src-${version}.tar.bz2";
+    sha256 = "0283hvms5hr29zr0grd6gq059k0hg8hcz3fsmwjmysiih8790i68";
+  };
 
   desktop = makeDesktopItem {
     desktopName = pname;
···
     type = "Application";
     categories = "Game;RolePlaying;";
     genericName = pname;
-  };
-
-in stdenv.mkDerivation rec {
-  name = "${pname}-${version}";
-  version = "1.6.7";
-
-  src = fetchurl {
-    url = "https://te4.org/dl/t-engine/t-engine4-src-${version}.tar.bz2";
-    sha256 = "0283hvms5hr29zr0grd6gq059k0hg8hcz3fsmwjmysiih8790i68";
   };
 
   prePatch = ''

pkgs/games/torcs/default.nix

···
 libpng, zlib, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "torcs-1.3.7";
+  pname = "torcs";
+  version = "1.3.7";
 
   src = fetchurl {
-    url = "mirror://sourceforge/torcs/${name}.tar.bz2";
+    url = "mirror://sourceforge/torcs/torcs-${version}.tar.bz2";
     sha256 = "0kdq0sc7dsfzlr0ggbxggcbkivc6yp30nqwjwcaxg9295s3b06wa";
   };
 

pkgs/games/torus-trooper/default.nix

···
   sha256 = hash;
 };
 
-in stdenv.mkDerivation {
+in stdenv.mkDerivation rec {
   pname = "torus-trooper";
   version = "0.22";
 
   src = fetchurl {
-    url = "http://abagames.sakura.ne.jp/windows/tt0_22.zip";
+    url = "http://abagames.sakura.ne.jp/windows/tt${lib.replaceStrings ["."] ["_"] version}.zip";
     sha256 = "1yhki1fdp3fi4y2iq12vca69f6k38dqjaw9z4lwcxky5kbgb7jvg";
   };
 

pkgs/games/tumiki-fighters/default.nix

···
   sha256 = hash;
 };
 
-in stdenv.mkDerivation {
+in stdenv.mkDerivation rec {
   pname = "tumiki-fighters";
   version = "0.21";
 
   src = fetchurl {
-    url = "http://abagames.sakura.ne.jp/windows/tf0_21.zip";
+    url = "http://abagames.sakura.ne.jp/windows/tf${lib.replaceStrings ["."] ["_"] version}.zip";
     sha256 = "0djykfc1r8ysapklm621h89ana1c4qzc1m5nr9bqw4iccnmvwk3p";
   };
 

pkgs/games/typespeed/default.nix

···
 { lib, stdenv, fetchurl, ncurses }:
 
-stdenv.mkDerivation {
-  name = "typespeed-0.6.5";
+stdenv.mkDerivation rec {
+  pname = "typespeed";
+  version = "0.6.5";
   buildInputs = [ ncurses ];
   src = fetchurl {
-    url = "http://typespeed.sourceforge.net/typespeed-0.6.5.tar.gz";
+    url = "http://typespeed.sourceforge.net/typespeed-${version}.tar.gz";
     sha256 = "5c860385ceed8a60f13217cc0192c4c2b4705c3e80f9866f7d72ff306eb72961";
   };
 

pkgs/games/ufoai/default.nix

···
 , curl, libjpeg, libpng, gettext, cunit, enableEditor?false }:
 
 stdenv.mkDerivation rec {
-  name = "ufoai-2.4";
+  pname = "ufoai";
+  version = "2.4";
   src = fetchurl {
-    url = "mirror://sourceforge/ufoai/${name}-source.tar.bz2";
+    url = "mirror://sourceforge/ufoai/ufoai-${version}-source.tar.bz2";
     sha256 = "0kxrbcjrharcwz319s90m789i4my9285ihp5ax6kfhgif2vn2ji5";
   };
 
   srcData = fetchurl {
-    url = "mirror://sourceforge/ufoai/${name}-data.tar";
+    url = "mirror://sourceforge/ufoai/ufoai-${version}-data.tar";
     sha256 = "1drhh08cqqkwv1yz3z4ngkplr23pqqrdx6cp8c3isy320gy25cvb";
   };
 

pkgs/games/uhexen2/default.nix

···
 { lib, fetchgit, SDL, stdenv, libogg, libvorbis, libmad, xdelta }:
 
 stdenv.mkDerivation rec {
-  name = "uhexen2";
+  pname = "uhexen2";
   version = "1.5.9";
 
   src = fetchgit {

pkgs/games/ultimatestunts/default.nix

···
 {lib, stdenv, fetchurl, SDL, libGLU, libGL, SDL_image, freealut, openal, libvorbis,
 pkg-config}:
 
-stdenv.mkDerivation {
-  name = "ultimate-stunts-0.7.6.1";
+stdenv.mkDerivation rec {
+  pname = "ultimate-stunts";
+  version = "0.7.6.1";
   src = fetchurl {
-    url = "mirror://sourceforge/ultimatestunts/ultimatestunts-srcdata-0761.tar.gz";
+    url = "mirror://sourceforge/ultimatestunts/ultimatestunts-srcdata-${lib.replaceStrings ["."] [""] version}.tar.gz";
     sha256 = "0rd565ml6l927gyq158klhni7myw8mgllhv0xl1fg9m8hlzssgrv";
   };
 

pkgs/games/vectoroids/default.nix

···
 {lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer}:
 
-stdenv.mkDerivation {
-  name = "vectoroids-1.1.0";
+stdenv.mkDerivation rec {
+  pname = "vectoroids";
+  version = "1.1.0";
   src = fetchurl {
-    url = "ftp://ftp.tuxpaint.org/unix/x/vectoroids/src/vectoroids-1.1.0.tar.gz";
+    url = "ftp://ftp.tuxpaint.org/unix/x/vectoroids/src/vectoroids-${version}.tar.gz";
     sha256 = "0bkvd4a1v496w0vlvqyi1a6p25ssgpkchxxxi8899sb72wlds54d";
   };
 

pkgs/games/vessel/default.nix

···
 { lib, stdenv, requireFile, SDL, libpulseaudio, alsa-lib, runtimeShell }:
 
 stdenv.mkDerivation rec {
-  name = "vessel-12082012";
+  pname = "vessel";
+  version = "12082012";
 
   goBuyItNow = ''
     We cannot download the full version automatically, as you require a license.
     Once you bought a license, you need to add your downloaded version to the nix store.
-    You can do this by using "nix-prefetch-url file://\$PWD/${name}-bin" in the
+    You can do this by using "nix-prefetch-url file://\$PWD/vessel-${version}-bin" in the
     directory where you saved it.
   '';
 
   src = if (stdenv.isi686) then
     requireFile {
       message = goBuyItNow;
-      name = "${name}-bin";
+      name = "vessel-${version}-bin";
       sha256 = "1vpwcrjiln2mx43h7ib3jnccyr3chk7a5x2bw9kb4lw8ycygvg96";
     } else throw "unsupported platform ${stdenv.hostPlatform.system} only i686-linux supported for now.";
 

pkgs/games/xbomb/default.nix

···
 { lib, stdenv, fetchurl, libX11, libXaw }:
 
 stdenv.mkDerivation rec {
-  name = "xbomb-2.2b";
+  pname = "xbomb";
+  version = "2.2b";
   src = fetchurl {
-    url    = "https://www.gedanken.org.uk/software/xbomb/download/${name}.tgz";
+    url    = "https://www.gedanken.org.uk/software/xbomb/download/xbomb-${version}.tgz";
     sha256 = "0692gjw28qvh8wj9l58scjw6kxj7jdyb3yzgcgs9wcznq11q839m";
   };
 

pkgs/games/xonotic/default.nix

···
     inherit version;
 
     src = fetchurl {
-      url = "https://dl.xonotic.org/${name}-source.zip";
+      url = "https://dl.xonotic.org/${pname}-${version}-source.zip";
       sha256 = "0axxw04fyz6jlfqd0kp7hdrqa0li31sx1pbipf2j5qp9wvqicsay";
     };
 
···
 
 in rec {
   xonotic-data = fetchzip {
-    name = "xonotic-data-${version}";
-    url = "https://dl.xonotic.org/${name}.zip";
+    name = "xonotic-data";
+    url = "https://dl.xonotic.org/xonotic-data-${version}.zip";
     sha256 = "1ygkh0v68y4sd1w5vpk8dgb65h5jm599hwszdfgjp3ax4d3ml81x";
     extraPostFetch = ''
       cd $out

pkgs/games/zandronum/sqlite.nix

···
 { lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation {
-  name = "sqlite-zandronum-3.0";
+  pname = "sqlite-zandronum";
+  version = "3.0";
 
   src = fetchurl {
     url = "https://www.sqlite.org/2017/sqlite-autoconf-3180000.tar.gz";

pkgs/games/zdoom/bcc-git.nix

···
 { lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation {
-  name = "doom-bcc-git-0.8.0.2018.01.04";
+  pname = "doom-bcc";
+  version = "unstable-2018-01-04";
 
   src = fetchFromGitHub {
     owner = "wormt";

pkgs/games/zod/default.nix

···
 , substituteAll
 }:
 let
+  name = "zod-engine";
   version = "2011-09-06";
-  name = "zod-engine-${version}";
   src = fetchzip {
     url = "mirror://sourceforge/zod/linux_releases/zod_linux-${version}.tar.gz";
     sha256 = "017v96aflrv07g8j8zk9mq8f8rqxl5228rjff5blq8dxpsv1sx7h";
···
   hardeningDisable = [ "format" ];
   NIX_LDFLAGS = "-L${libmysqlclient}/lib/mysql";
   zod_engine = stdenv.mkDerivation {
-    inherit name version src nativeBuildInputs buildInputs hardeningDisable NIX_LDFLAGS;
+    inherit version src nativeBuildInputs buildInputs hardeningDisable NIX_LDFLAGS;
     pname = "${name}-engine";
     enableParallelBuilding = true;
     preBuild = "cd zod_src";
···
     '';
   };
   zod_map_editor = stdenv.mkDerivation {
-    inherit name version src nativeBuildInputs buildInputs hardeningDisable NIX_LDFLAGS;
+    inherit version src nativeBuildInputs buildInputs hardeningDisable NIX_LDFLAGS;
     pname = "${name}-map_editor";
     enableParallelBuilding = true;
     preBuild = "cd zod_src";
···
     '';
   };
   zod_launcher = stdenv.mkDerivation {
-      inherit name version src nativeBuildInputs buildInputs zod_engine zod_map_editor;
+      inherit version src nativeBuildInputs buildInputs zod_engine zod_map_editor;
       pname = "${name}-launcher";
       # This is necessary because the zod_launcher has terrible fixed-width window
       # the Idea is to apply the scalingFactor to all positions and sizes and I tested 1,2,3 and 4

pkgs/games/zoom/default.nix

···
 # !!! assert freetype == xorg.freetype
 
 stdenv.mkDerivation rec {
-  name = "zoom-1.1.5";
+  pname = "zoom";
+  version = "1.1.5";
 
   src = fetchurl {
-    url = "https://www.logicalshift.co.uk/unix/zoom/${name}.tar.gz";
+    url = "https://www.logicalshift.co.uk/unix/zoom/zoom-${version}.tar.gz";
     sha256 = "1g6van7f7sg3zfcz80mncnnbccyg2hnm0hq4x558vpsm0lf7z5pj";
   };
 

pkgs/misc/uboot/default.nix

···
       mkdir -p ${installDir}
       cp ${lib.concatStringsSep " " filesToInstall} ${installDir}
 
+      mkdir -p "$out/nix-support"
+      ${lib.concatMapStrings (file: ''
+        echo "file binary-dist ${installDir}/${builtins.baseNameOf file}" >> "$out/nix-support/hydra-build-products"
+      '') filesToInstall}
+
       runHook postInstall
     '';
 

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

···
     homepage = "http://dpdk.org/";
     license = with licenses; [ lgpl21 gpl2 bsd2 ];
     platforms =  platforms.linux;
-    maintainers = with maintainers; [ magenbluten orivej ];
+    maintainers = with maintainers; [ magenbluten orivej mic92 ];
   };
 }

pkgs/pkgs-lib/formats.nix

···
         int
         float
         str
+        path
         (attrsOf valueType)
         (listOf valueType)
       ]) // {
···
         int
         float
         str
+        path
         (attrsOf valueType)
         (listOf valueType)
       ] // {

pkgs/pkgs-lib/tests/formats.nix

···
       str = "foo";
       attrs.foo = null;
       list = [ null null ];
+      path = ./formats.nix;
     };
     expected = ''
       {
···
           null
         ],
         "null": null,
+        "path": "${./formats.nix}",
         "str": "foo",
         "true": true
       }
···
       str = "foo";
       attrs.foo = null;
       list = [ null null ];
+      path = ./formats.nix;
     };
     expected = ''
       {
···
           null
         ],
         "null": null,
+        "path": "${./formats.nix}",
         "str": "foo",
         "true": true
       }

pkgs/servers/home-assistant/component-packages.nix

···
     "spotify" = ps: with ps; [ aiohttp-cors spotipy ];
     "sql" = ps: with ps; [ sqlalchemy ];
     "squeezebox" = ps: with ps; [ pysqueezebox ];
-    "srp_energy" = ps: with ps; [ ]; # missing inputs: srpenergy
+    "srp_energy" = ps: with ps; [ srpenergy ];
     "ssdp" = ps: with ps; [ aiohttp-cors async-upnp-client defusedxml ifaddr netdisco zeroconf ];
-    "starline" = ps: with ps; [ ]; # missing inputs: starline
+    "starline" = ps: with ps; [ starline ];
     "starlingbank" = ps: with ps; [ ]; # missing inputs: starlingbank
     "startca" = ps: with ps; [ xmltodict ];
     "statistics" = ps: with ps; [ sqlalchemy ];

pkgs/servers/home-assistant/default.nix

···
     "spotify"
     "sql"
     "squeezebox"
+    "srp_energy"
     "ssdp"
+    "starline"
     "startca"
     "statistics"
     "statsd"

pkgs/tools/misc/fluent-bit/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fluent-bit";
-  version = "1.7.6";
+  version = "1.7.9";
 
   src = fetchFromGitHub {
     owner = "fluent";
     repo = "fluent-bit";
     rev = "v${version}";
-    sha256 = "sha256-/Mpdi414LNzavh4nUY2pnflyshzwTYv1XK1HmnAHJaQ=";
+    sha256 = "sha256-rL2IJYTMs0Yzo/oqrcI56krmVnxxxRWCebSjjbjiP/k=";
   };
 
   nativeBuildInputs = [ cmake flex bison ];

pkgs/tools/misc/goreleaser/default.nix

···
 
 buildGoModule rec {
   pname = "goreleaser";
-  version = "0.168.0";
+  version = "0.172.0";
 
   src = fetchFromGitHub {
     owner = "goreleaser";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-+WDKpkjUlwR39nVB99saSB03NScPzPiyR8xvRBfASTQ=";
+    sha256 = "sha256-QHtxrdmtmvnyMmtpvbEw5VjGz2XN1iqHu+5dHS9yiNo=";
   };
 
-  vendorSha256 = "sha256-W/G5AMfYyA9adVFOT/IXI+Bds/6osBOrQ6CtgeHZ8R8=";
+  vendorSha256 = "sha256-Zd48I7e5zCbSXz5RVckMXQMpqvf6gAoajx5yLk2ODmU=";
 
   buildFlagsArray = [
     "-ldflags="

pkgs/tools/networking/tinc/pre.nix

···
 
 stdenv.mkDerivation rec {
   pname = "tinc";
-  version = "1.1pre17";
+  version = "1.1pre18";
 
   src = fetchgit {
-    rev = "refs/tags/release-${version}";
+    rev = "release-${version}";
     url = "git://tinc-vpn.org/tinc";
-    sha256 = "12abmx9qglchgn94a1qwgzldf2kaz77p8705ylpggzyncxv6bw2q";
+    sha256 = "0a7d1xg34p54sv66lckn8rz2bpg7bl01najm2rxiwbsm956y7afm";
   };
 
   outputs = [ "out" "man" "info" ];
-
-  patches = [
-    (fetchpatch {
-      name = "tinc-openssl-1.0.2r.patch";
-      url = "http://git.tinc-vpn.org/git/browse?p=tinc;a=patch;h=2b0aeec02d64bb4724da9ff1dbc19b7d35d7c904";
-      sha256 = "0kidzlmgl0cin4g54ygcxa0jbq9vwlk3dyq5f65nkjd8yvayfzi8";
-    })
-  ];
 
   nativeBuildInputs = [ autoreconfHook texinfo ];
   buildInputs = [ ncurses readline zlib lzo openssl ];

pkgs/top-level/all-packages.nix

···
 
   shmig = callPackage ../development/tools/database/shmig { };
 
+  # smlnjBootstrap should be redundant, now that smlnj works on Darwin natively
   smlnjBootstrap = callPackage ../development/compilers/smlnj/bootstrap.nix { };
-  smlnj = callPackage ../development/compilers/smlnj { };
+  smlnj = callPackage ../development/compilers/smlnj {
+    inherit (darwin) Libsystem;
+  };
 
   smlpkg = callPackage ../tools/package-management/smlpkg { };
 
···
 
   iprover = callPackage ../applications/science/logic/iprover { };
 
-  jonprl = callPackage ../applications/science/logic/jonprl {
-    smlnj = if stdenv.isDarwin
-      then smlnjBootstrap
-      else smlnj;
-  };
+  jonprl = callPackage ../applications/science/logic/jonprl { };
 
   key = callPackage ../applications/science/logic/key { };
 
···
 
   tptp = callPackage ../applications/science/logic/tptp {};
 
-  celf = callPackage ../applications/science/logic/celf {
-    smlnj = if stdenv.isDarwin
-      then smlnjBootstrap
-      else smlnj;
-  };
+  celf = callPackage ../applications/science/logic/celf { };
 
   fast-downward = callPackage ../applications/science/logic/fast-downward { };
 
-  twelf = callPackage ../applications/science/logic/twelf {
-    smlnj = if stdenv.isDarwin
-      then smlnjBootstrap
-      else smlnj;
-  };
+  twelf = callPackage ../applications/science/logic/twelf { };
 
   verifast = callPackage ../applications/science/logic/verifast {};
 

pkgs/top-level/python-packages.nix

···
 
   srp = callPackage ../development/python-modules/srp { };
 
+  srpenergy = callPackage ../development/python-modules/srpenergy { };
+
   srptools = callPackage ../development/python-modules/srptools { };
 
   srsly = callPackage ../development/python-modules/srsly { };
···
   };
 
   starkbank-ecdsa = callPackage ../development/python-modules/starkbank-ecdsa { };
+
+  starline = callPackage ../development/python-modules/starline { };
 
   staticjinja = callPackage ../development/python-modules/staticjinja { };