Merge staging-next into staging

lib/systems/platforms.nix

···
       arch = "armv5te";
     };
 
-    kernelMajor = "2.6";
     kernelBaseConfig = "multi_v5_defconfig";
     kernelArch = "arm";
     kernelAutoModules = false;
···
 
   sheevaplug = {
     name = "sheevaplug";
-    kernelMajor = "2.6";
     kernelBaseConfig = "multi_v5_defconfig";
     kernelArch = "arm";
     kernelAutoModules = false;
···
 
   raspberrypi = {
     name = "raspberrypi";
-    kernelMajor = "2.6";
     kernelBaseConfig = "bcm2835_defconfig";
     kernelDTB = true;
     kernelArch = "arm";
···
 
   utilite = {
     name = "utilite";
-    kernelMajor = "2.6";
     kernelBaseConfig = "multi_v7_defconfig";
     kernelArch = "arm";
     kernelAutoModules = false;
···
 
   armv7l-hf-multiplatform = {
     name = "armv7l-hf-multiplatform";
-    kernelMajor = "2.6"; # Using "2.6" enables 2.6 kernel syscalls in glibc.
     kernelBaseConfig = "multi_v7_defconfig";
     kernelArch = "arm";
     kernelDTB = true;
···
 
   aarch64-multiplatform = {
     name = "aarch64-multiplatform";
-    kernelMajor = "2.6"; # Using "2.6" enables 2.6 kernel syscalls in glibc.
     kernelBaseConfig = "defconfig";
     kernelArch = "arm64";
     kernelDTB = true;
···
 
   ben_nanonote = {
     name = "ben_nanonote";
-    kernelMajor = "2.6";
     kernelArch = "mips";
     gcc = {
       arch = "mips32";
···
 
   fuloong2f_n32 = {
     name = "fuloong2f_n32";
-    kernelMajor = "2.6";
     kernelBaseConfig = "lemote2f_defconfig";
     kernelArch = "mips";
     kernelAutoModules = false;

maintainers/maintainer-list.nix

···
     githubId = 46303707;
     name = "Christian Lütke-Stetzkamp";
   };
-  kampka = {
-    email = "[e-mail]";
-    github = "kampka";
-    githubId = 422412;
-    name = "Christian Kampka";
-    keys = [{
-      longkeyid = "ed25519/0x1CBE9645DD68E915";
-      fingerprint = "F7FA 0BD0 8775 337C F6AB  4A14 1CBE 9645 DD68 E915";
-    }];
-  };
   ckauhaus = {
     email = "[e-mail]";
     github = "ckauhaus";
···
     github = "kyleondy";
     githubId = 1640900;
     name = "Kyle Ondy";
+    keys = [{
+      longkeyid = "rsa4096/0xDB0E3C33491F91C9";
+      fingerprint = "3C79 9D26 057B 64E6 D907  B0AC DB0E 3C33 491F 91C9";
+    }];
   };
   kylesferrazza = {
     name = "Kyle Sferrazza";
···
     github = "thiagokokada";
     githubId = 844343;
     name = "Thiago K. Okada";
+  };
+  thibautmarty = {
+    email = "[e-mail]";
+    github = "ThibautMarty";
+    githubId = 3268082;
+    name = "Thibaut Marty";
   };
   thmzlt = {
     email = "[e-mail]";

nixos/doc/manual/release-notes/rl-2003.xml

···
    </listitem>
    <listitem>
     <para>
+     Grub is updated to 2.04, adding support for booting from F2FS filesystems and
+     Btrfs volumes using zstd compression. Note that some users have been unable
+to boot after upgrading to 2.04 - for more information, please see <link
+xlink:href="https://github.com/NixOS/nixpkgs/issues/61718#issuecomment-617618503">this
+     discussion</link>.
+    </para>
+   </listitem>
+   <listitem>
+    <para>
      Postgresql for NixOS service now defaults to v11.
     </para>
    </listitem>

nixos/modules/services/web-apps/trilium.nix

···
 
   config = lib.mkIf cfg.enable (lib.mkMerge [
   {
-    meta.maintainers = with lib.maintainers; [ kampka ];
+    meta.maintainers = with lib.maintainers; [ ];
 
     users.groups.trilium = {};
     users.users.trilium = {

nixos/tests/all-tests.nix

···
   haproxy = handleTest ./haproxy.nix {};
   hardened = handleTest ./hardened.nix {};
   hedgedoc = handleTest ./hedgedoc.nix {};
+  herbstluftwm = handleTest ./herbstluftwm.nix {};
   installed-tests = pkgs.recurseIntoAttrs (handleTest ./installed-tests {});
   oci-containers = handleTestOn ["x86_64-linux"] ./oci-containers.nix {};
   # 9pnet_virtio used to mount /nix partition doesn't support

nixos/tests/containers-tmpfs.nix

···
 import ./make-test-python.nix ({ pkgs, ...} : {
   name = "containers-tmpfs";
   meta = with pkgs.lib.maintainers; {
-    maintainers = [ kampka ];
+    maintainers = [ ];
   };
 
   machine =

nixos/tests/herbstluftwm.nix

···
+import ./make-test-python.nix ({ lib, ...} : {
+  name = "herbstluftwm";
+
+  meta = {
+    maintainers = with lib.maintainers; [ thibautmarty ];
+    timeout = 30;
+  };
+
+  machine = { pkgs, lib, ... }: {
+    imports = [ ./common/x11.nix ./common/user-account.nix ];
+    test-support.displayManager.auto.user = "alice";
+    services.xserver.displayManager.defaultSession = lib.mkForce "none+herbstluftwm";
+    services.xserver.windowManager.herbstluftwm.enable = true;
+    environment.systemPackages = [ pkgs.dzen2 ]; # needed for upstream provided panel
+  };
+
+  testScript = ''
+    with subtest("ensure x starts"):
+        machine.wait_for_x()
+        machine.wait_for_file("/home/alice/.Xauthority")
+        machine.succeed("xauth merge ~alice/.Xauthority")
+
+    with subtest("ensure client is available"):
+        machine.succeed("herbstclient --version")
+
+    with subtest("ensure keybindings are set"):
+        machine.wait_until_succeeds("herbstclient list_keybinds | grep xterm")
+
+    with subtest("ensure panel starts"):
+        machine.wait_for_window("dzen title")
+
+    with subtest("ensure we can open a new terminal"):
+        machine.send_key("alt-ret")
+        machine.wait_for_window(r"alice.*?machine")
+        machine.sleep(2)
+        machine.screenshot("terminal")
+  '';
+})

nixos/tests/zsh-history.nix

···
 import ./make-test-python.nix ({ pkgs, ...} : {
   name = "zsh-history";
   meta = with pkgs.lib.maintainers; {
-    maintainers = [ kampka ];
+    maintainers = [ ];
   };
 
   nodes.default = { ... }: {

pkgs/applications/audio/faust/faustlive.nix

···
 
 stdenv.mkDerivation rec {
   pname = "faustlive";
-  version = "2.5.4";
+  version = "unstable-dev-2020-08-03";
   src = fetchFromGitHub {
     owner = "grame-cncm";
     repo = "faustlive";
-    rev = version;
-    sha256 = "0npn8fvq8iafyamq4wrj1k1bmk4xd0my2sp3gi5jdjfx6hc1sm3n";
+    rev = "c16565dc1b616ac0aad7c303c1997fa9e57177ab";
+    sha256 = "1ys661lp1xwz21vy12kwkg248jvjq1z9w433knkh0ldyy2igvmd5";
     fetchSubmodules = true;
   };
 

pkgs/applications/audio/ft2-clone/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ft2-clone";
-  version = "1.42";
+  version = "1.43";
 
   src = fetchFromGitHub {
     owner = "8bitbubsy";
     repo = "ft2-clone";
     rev = "v${version}";
-    sha256 = "0w3c1rgm8qlqi50gavrcjz40xb0nkis4i9mvpwmvzmdv9nipxry9";
+    sha256 = "sha256-OIQk7ngg1wsB6DFcxhrviPGlhzdaAWBi9C2roSNg1eI=";
   };
 
   # Adapt the linux-only CMakeLists to darwin (more reliable than make-macos.sh)

pkgs/applications/blockchains/bitcoin.nix

···
 
   postInstall = optional withGui ''
     install -Dm644 ${desktop} $out/share/applications/bitcoin-qt.desktop
-    install -Dm644 share/pixmaps/bitcoin128.png $out/share/pixmaps/bitcoin128.png
+    substituteInPlace $out/share/applications/bitcoin-qt.desktop --replace "Icon=bitcoin128" "Icon=bitcoin"
+    install -Dm644 share/pixmaps/bitcoin256.png $out/share/pixmaps/bitcoin.png
   '';
 
   configureFlags = [

pkgs/applications/editors/kakoune/plugins/kak-auto-pairs.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 stdenv.mkDerivation {
   name = "kak-auto-pairs";
   version = "2020-07-14";

pkgs/applications/editors/kakoune/plugins/kak-powerline.nix

···
 { stdenv, git, fetchFromGitHub }:
 stdenv.mkDerivation {
   name = "kak-powerline";
-  version = "2019-07-23";
+  version = "2020-08-22";
   src = fetchFromGitHub {
-    owner = "andreyorst";
+    owner = "jdugan6240";
     repo = "powerline.kak";
-    rev = "82b01eb6c97c7380b7da253db1fd484a5de13ea4";
-    sha256 = "1480wp2jc7c84z1wqmpf09lzny6kbnbhiiym2ffaddxrd4ns9i6z";
+    rev = "d641b2cd8024f872bcda23f9256e7aff36da02ae";
+    sha256 = "65948f5ef3ab2f46f6d186ad752665c251d887631d439949decc2654a67958a4";
   };
 
   configurePhase = ''
···
 
   meta = with lib;
   { description = "Kakoune modeline, but with passion";
-    homepage = "https://github.com/andreyorst/powerline.kak";
+    homepage = "https://github.com/jdugan6240/powerline.kak";
     license = licenses.mit;
     maintainers = with maintainers; [ nrdxp ];
     platform = platforms.all;

pkgs/applications/editors/kakoune/plugins/kak-prelude.nix

···
 { stdenv, fetchFromGitHub }:
 stdenv.mkDerivation {
   name = "kak-prelude";
-  version = "2020-03-15";
+  version = "2020-06-09";
 
   src = fetchFromGitHub {
     owner = "alexherbo2";
     repo = "prelude.kak";
-    rev = "05b2642b1e014bd46423f9d738cc38a624947b63";
-    sha256 = "180p8hq8z7mznzd9w9ma5as3ijs7zbzcj96prcpswqg263a0b329";
+    rev = "f1e0f4d5cb62a36924e3f8ba6824d6aed8c19d23";
+    sha256 = "1pncr8azqvl2z9yvzhc68p1s9fld8cvak8yz88zgrp5ypx2cxl8c";
   };
 
   installPhase = ''

pkgs/applications/graphics/fondo/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fondo";
-  version = "1.5.0";
+  version = "1.5.1";
 
   src = fetchFromGitHub {
     owner = "calo001";
     repo = pname;
     rev = version;
-    sha256 = "1zmrpk0b5z6m956j923njn6dpqdm2p8653a325hgjjjq0sgwbhj2";
+    sha256 = "sha256-eGHgZm9Q6JnY6OQNAyrFvRsuyuFnruMJNckOCCiO4Ug=";
   };
 
   nativeBuildInputs = [

pkgs/applications/graphics/hdr-plus/default.nix

···
+{ stdenv, fetchFromGitHub, fetchpatch
+, cmake, halide
+, libpng, libjpeg, libtiff, libraw
+}:
+
+stdenv.mkDerivation rec {
+  pname = "hdr-plus-unstable";
+  version = "2020-10-29";
+
+  src = fetchFromGitHub {
+    owner = "timothybrooks";
+    repo = "hdr-plus";
+    rev = "132bd73ccd4eaef9830124605c93f06a98607cfa";
+    sha256 = "1n49ggrppf336p7n510kapzh376791bysxj3f33m3bdzksq360ps";
+  };
+
+  patches = [
+    # PR #70, fixes incompatibility with Halide 10.0.0
+    (fetchpatch {
+      url = "https://github.com/timothybrooks/hdr-plus/pull/70/commits/077e1a476279539c72e615210762dca27984c57b.patch";
+      sha256 = "1sg2l1bqs2smpfpy4flwg86fzhcc4yf7zx998v1bfhim43yyrx59";
+    })
+  ];
+
+  nativeBuildInputs = [ cmake ];
+
+  buildInputs = [ halide libpng libjpeg libtiff libraw ];
+
+  installPhase = ''
+    for bin in hdrplus stack_frames; do
+      install -Dm755 $bin $out/bin/$bin
+    done
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Burst photography pipeline based on Google's HDR+";
+    homepage = "https://www.timothybrooks.com/tech/hdr-plus/";
+    license = licenses.mit;
+    maintainers = with maintainers; [ OPNA2608 ];
+    platforms = platforms.all;
+  };
+}

pkgs/applications/graphics/megapixels/default.nix

···
+{ stdenv
+, lib
+, fetchgit
+, meson
+, ninja
+, pkg-config
+, wrapGAppsHook
+, gtk3
+, gnome3
+, tiffSupport ? true
+, libraw
+, jpgSupport ? true
+, imagemagick
+, exiftool
+}:
+
+assert jpgSupport -> tiffSupport;
+
+let
+  inherit (lib) makeBinPath optional optionals optionalString;
+  runtimePath = makeBinPath (
+    optional tiffSupport libraw
+    ++ optionals jpgSupport [ imagemagick exiftool ]
+  );
+in
+stdenv.mkDerivation rec {
+  pname = "megapixels";
+  version = "0.14.0";
+
+  src = fetchgit {
+    url = "https://git.sr.ht/~martijnbraam/megapixels";
+    rev = version;
+    sha256 = "136rv9sx0kgfkpqn5s90j7j4qhb8h04p14g5qhqshb89kmmsmxiw";
+  };
+
+  nativeBuildInputs = [ meson ninja pkg-config wrapGAppsHook ];
+
+  buildInputs = [ gtk3 gnome3.adwaita-icon-theme ]
+  ++ optional tiffSupport libraw
+  ++ optional jpgSupport imagemagick;
+
+  preFixup = optionalString (tiffSupport || jpgSupport) ''
+    gappsWrapperArgs+=(
+      --prefix PATH : ${runtimePath}
+    )
+  '';
+
+  meta = with lib; {
+    description = "GTK3 camera application using raw v4l2 and media-requests";
+    homepage = "https://sr.ht/~martijnbraam/Megapixels";
+    license = licenses.gpl3Only;
+    maintainers = with maintainers; [ OPNA2608 ];
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/graphics/xmountains/default.nix

···
+{ lib, stdenv, fetchFromGitHub, xlibsWrapper, xorg }:
+
+stdenv.mkDerivation rec {
+  pname = "xmountains";
+  version = "2.10";
+
+  src = fetchFromGitHub {
+    owner = "spbooth";
+    repo = pname;
+    rev = "aa3bcbfed228adf3fff0fe4295589f13fc194f0b";
+    sha256 = "0dx4n2y736lv04sj41cp1dw8n5zkw5gyd946a6zsiv0k796s9ra9";
+  };
+
+  buildInputs = [ xlibsWrapper xorg.xbitmaps ];
+  nativeBuildInputs = with xorg; [ imake gccmakedep ];
+
+  installPhase = "install -Dm755 xmountains -t $out/bin";
+
+  meta = with lib; {
+    description = "X11 based fractal landscape generator";
+    homepage = "https://spbooth.github.io/xmountains";
+    license = licenses.hpndSellVariant;
+    maintainers = with maintainers; [ djanatyn ];
+  };
+}

pkgs/applications/misc/ipmicfg/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ipmicfg";
-  version = "1.30.0";
-  buildVersion = "190710";
+  version = "1.32.0";
+  buildVersion = "200910";
 
   src = fetchzip {
     url = "https://www.supermicro.com/wftp/utility/IPMICFG/IPMICFG_${version}_build.${buildVersion}.zip";
-    sha256 = "0srkzivxa4qlf3x9zdkri7xfq7kjj4fsmn978vzmzsvbxkqswd5a";
+    sha256 = "1mncinwgx5d8jkvnvhccqlj2xp0xa5xjsab4r5mblmcnvm609rr3";
   };
 
   installPhase = ''

pkgs/applications/misc/keepassx/community.nix

···
 
 stdenv.mkDerivation rec {
   pname = "keepassxc";
-  version = "2.6.2";
+  version = "2.6.3";
 
   src = fetchFromGitHub {
     owner = "keepassxreboot";
     repo = "keepassxc";
     rev = version;
-    sha256 = "032dzywvwpclhsl3n1pq2m9gyxqpg0gkci6axbvbs7bn82wznc4h";
+    sha256 = "1jd2mvafyn095crfs2hnfprqiy8yqsvfybwbjq8n0agapnz4bl5h";
   };
 
   NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isClang [
···
     "-D__BIG_ENDIAN__=${if stdenv.isBigEndian then "1" else "0"}"
   ];
 
-  postPatch = lib.optionalString stdenv.isDarwin ''
-    substituteInPlace CMakeLists.txt \
-      --replace "/usr/local/bin" "../bin" \
-      --replace "/usr/local/share/man" "../share/man"
-  '';
   NIX_LDFLAGS = lib.optionalString stdenv.isDarwin "-rpath ${libargon2}/lib";
 
   patches = [
···
 
   doCheck = true;
   checkPhase = ''
+    runHook preCheck
+
     export LC_ALL="en_US.UTF-8"
     export QT_QPA_PLATFORM=offscreen
     export QT_PLUGIN_PATH="${qtbase.bin}/${qtbase.qtPluginPrefix}"
     # testcli and testgui are flaky - skip them both
     make test ARGS+="-E 'testcli|testgui' --output-on-failure"
+
+    runHook postCheck
   '';
 
-  nativeBuildInputs = [ cmake wrapQtAppsHook qttools ];
+  nativeBuildInputs = [ cmake wrapQtAppsHook qttools pkg-config ];
 
   buildInputs = [
     asciidoctor
···
     libgpgerror
     libsodium
     libyubikey
-    pkg-config
     qrencode
     qtbase
     qtsvg
···
     description = "Password manager to store your passwords safely and auto-type them into your everyday websites and applications";
     longDescription = "A community fork of KeePassX, which is itself a port of KeePass Password Safe. The goal is to extend and improve KeePassX with new features and bugfixes to provide a feature-rich, fully cross-platform and modern open-source password manager. Accessible via native cross-platform GUI, CLI, and browser integration with the KeePassXC Browser Extension (https://github.com/keepassxreboot/keepassxc-browser).";
     homepage = "https://keepassxc.org/";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     maintainers = with maintainers; [ jonafato turion ];
     platforms = platforms.linux ++ platforms.darwin;
   };

pkgs/applications/misc/rescuetime/default.nix

···
-{ stdenv, lib, fetchurl, dpkg, patchelf, qt5, libXtst, libXext, libX11, mkDerivation, makeWrapper, libXScrnSaver, writeScript }:
+{ stdenv, lib, fetchurl, dpkg, patchelf, qt5, libXtst, libXext, libX11, mkDerivation, makeWrapper, libXScrnSaver, writeScript, common-updater-scripts, curl, pup }:
 
 let
   version = "2.16.4.2";
···
       url = "https://www.rescuetime.com/installers/rescuetime_${version}_amd64.deb";
       sha256 = "03bmnkxhip1wilnfqs8akmy1hppahxrmnm8gasnmw5s922vn06cv";
     };
-in mkDerivation {
+in mkDerivation rec {
   # https://www.rescuetime.com/updates/linux_release_notes.html
   inherit version;
   pname = "rescuetime";
···
       $out/bin/rescuetime
   '';
 
-  passthru.updateScript = writeScript "rescuetime-updater" ''
-    #!/usr/bin/env nix-shell
-    #!nix-shell -i bash -p curl pup common-updater-scripts
+  passthru.updateScript = writeScript "${pname}-updater" ''
+    #!${stdenv.shell}
     set -eu -o pipefail
+    PATH=${stdenv.lib.makeBinPath [curl pup common-updater-scripts]}:$PATH
     latestVersion="$(curl -sS https://www.rescuetime.com/release-notes/linux | pup '.release:first-of-type h2 strong text{}' | tr -d '\n')"
-    update-source-version rescuetime "$latestVersion"
+
+    for platform in ${stdenv.lib.concatStringsSep " " meta.platforms}; do
+      # The script will not perform an update when the version attribute is up to date from previous platform run
+      # We need to clear it before each run
+      update-source-version ${pname} 0 $(yes 0 | head -64 | tr -d "\n") --system=$platform
+      update-source-version ${pname} "$latestVersion" --system=$platform
+    done
   '';
 
   meta = with lib; {

pkgs/applications/networking/cluster/atlantis/default.nix

···
 
 buildGoModule rec {
   pname = "atlantis";
-  version = "0.15.1";
+  version = "0.16.0";
 
   src = fetchFromGitHub {
     owner = "runatlantis";
     repo = "atlantis";
     rev = "v${version}";
-    sha256 = "0xxg48f28ac7x6kap6w1hgsimdc604ivkck4dx7p5p7xd3s7gld5";
+    sha256 = "sha256-1sak6CaqFhiBIoaa7kERXLHsgn24oMgBlOJaQDuF61E=";
   };
 
   vendorSha256 = null;

pkgs/applications/networking/cluster/fluxcd/default.nix

···
 
 buildGoModule rec {
   pname = "fluxcd";
-  version = "0.6.0";
+  version = "0.6.1";
 
   src = fetchFromGitHub {
     owner = "fluxcd";
     repo = "flux2";
     rev = "v${version}";
-    sha256 = "16jq6ygm7and4fixh8f7jjv45vgjmyy8wghwnkhwb0140j6lj3ym";
+    sha256 = "sha256-A5sEv8d6T0tvhD5UzZ2h2cymtXSO2h68pnD8MGg+Dfo=";
   };
 
-  vendorSha256 = "1909czaa0q03xh1qvg3f2qzwfwlqyc0akg2c98wd7qrnk1yzzdxy";
+  vendorSha256 = "sha256-eh5oUOLgZLIODL58WI1trXerHDWrIiclkrv/w0lvzL4=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/networking/cluster/fluxctl/default.nix

···
 
 buildGoModule rec {
   pname = "fluxctl";
-  version = "1.21.0";
+  version = "1.21.1";
 
   src = fetchFromGitHub {
     owner = "weaveworks";
     repo = "flux";
     rev = version;
-    sha256 = "007i6kb80142v19w2dm3667sskcvdp1ilg3q3f9gjgr9c5nrg1m2";
+    sha256 = "sha256-/go8V1EjY/iL3csoNpPyeWORvWCf0WnnaSOgiZ8UFQ8=";
   };
 
-  vendorSha256 = "01v4x2mk5jglnigq0iic52f84vzx56zh46i7v2wlq8ninj8y1k0x";
+  vendorSha256 = "sha256-GEU0Q2Elhiel20xvup+i1DSXCjQdA9s7cWykcbKR5KA=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/networking/cluster/kops/default.nix

···
           homepage = "https://github.com/kubernetes/kops";
           changelog = "https://github.com/kubernetes/kops/tree/master/docs/releases";
           license = licenses.asl20;
-          maintainers = with maintainers; [ offline zimbatm kampka ];
+          maintainers = with maintainers; [ offline zimbatm ];
           platforms = platforms.unix;
         };
       } // attrs';

pkgs/applications/networking/cluster/spacegun/default.nix

···
 
   meta = with lib; {
     description = "Version controlled multi-cluster deployment manager for kubernetes";
-    maintainers = with maintainers; [ kampka ];
+    maintainers = with maintainers; [ ];
     license = licenses.mit;
   };
 }

pkgs/applications/networking/znc/modules.nix

···
 
   palaver = zncDerivation rec {
     name = "znc-palaver-${version}";
-    version = "2018-09-18";
+    version = "2020-07-18";
     module_name = "palaver";
 
     src = fetchFromGitHub {
       owner = "cocodelabs";
       repo = "znc-palaver";
-      rev = "c70e8112686f917d39197d582db36c3ea37a4cb6";
-      sha256 = "1gjr8yqgpkpcc18rf0zfgil3rcd1ihqk0q9f8rwbfvs5381h3c58";
+      rev = "825cb6814d64006ca0f85fec23fa0a8a3a2d14ca";
+      sha256 = "zXWPIxhO5Z2L6f+Hf3vIpEh6V4kjUONWAaKexKLECc8=";
     };
 
     meta = with lib; {
       description = "Palaver ZNC module";
       homepage = "https://github.com/cocodelabs/znc-palaver";
       license = licenses.mit;
-      maintainers = with maintainers; [ kiwi ];
+      maintainers = with maintainers; [ kiwi szlend ];
     };
   };
 

pkgs/applications/office/trilium/default.nix

···
     homepage = "https://github.com/zadam/trilium";
     license = licenses.agpl3;
     platforms = [ "x86_64-linux" ];
-    maintainers = with maintainers; [ emmanuelrosa dtzWill kampka ];
+    maintainers = with maintainers; [ emmanuelrosa dtzWill ];
   };
 
   version = "0.43.3";

pkgs/applications/version-management/git-and-tools/git-ignore/default.nix

···
 
 buildRustPackage rec {
   pname = "git-ignore";
-  version = "1.0.0";
+  version = "1.1.1";
 
   src = fetchFromGitHub {
     owner = "sondr3";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0krz50pw9bkyzl78bvppk6skbpjp8ga7bd34jya4ha1xfmd8p89c";
+    sha256 = "sha256-bKIBPqGKiS3ey8vH2F4EoleV1H2PTOp+71d/YW3jkT0=";
   };
 
-  cargoSha256 = "0vcg2pl0s329fr8p23pwdx2jy7qahbr7n337ib61f69aaxi1xmq0";
+  cargoSha256 = "sha256-D1CIITuZSAsKYsK8U0q8HwPsYCyrfkTXZThxufEEkWU=";
 
   nativeBuildInputs = [ pkgconfig installShellFiles ];
   buildInputs = [ openssl ]

pkgs/applications/version-management/git-and-tools/git-workspace/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "git-workspace";
-  version = "0.7.0";
+  version = "0.8.0";
 
   src = fetchFromGitHub {
     owner = "orf";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1ckfk221ag6yhbqxfz432wpgbhddgzgdsaxhl1ymw90pwpnz717y";
+    sha256 = "sha256-//EyGhuE8rMRL03TtECIi0X51/p/GvTqvr2FRQEIqFA=";
   };
 
-  cargoSha256 = "0zkns037vgy96ybmn80px515ivz6yhj5br5mwbvxgl73va92wd9v";
+  cargoSha256 = "sha256-lvxEYjVMJoAFFRG5iVfGwxUeJObIxfEaWokk69l++nI=";
 
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ openssl ] ++ lib.optional stdenv.isDarwin Security;

pkgs/applications/version-management/git-and-tools/gitflow/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gitflow";
-  version = "1.12.2";
+  version = "1.12.3";
 
   src = fetchFromGitHub {
     owner = "petervanderdoes";
     repo = pname;
     rev = version;
-    sha256 = "0smwlc1wa4ndvspc9x6f4jwnzr58achysrhhip402j98d7di8hw5";
+    sha256 = "sha256-kHirHG/bfsU6tKyQ0khNSTyChhzHfzib+HyA3LOtBI8=";
   };
 
   buildInputs = [ pkgs.makeWrapper ];

pkgs/applications/version-management/git-and-tools/glab/default.nix

···
 
 buildGoModule rec {
   pname = "glab";
-  version = "1.11.1";
+  version = "1.13.1";
 
   src = fetchFromGitHub {
     owner = "profclems";
     repo = pname;
     rev = "v${version}";
-    sha256 = "mmrTuldU2WDe9t2nC3DYfqwb28uh6qjAaaveR221mjw=";
+    sha256 = "sha256-NSc/h6cENuXIBwC4ixvZDlERV7b/X0GB4OGzxGEk4YY=";
   };
 
-  vendorSha256 = "B4RKcKUTdGkonsKhL7NIKzVpZq6XD6cMMWed4wr/Moc=";
+  vendorSha256 = "sha256-N9swoVltKzdYez1WSoXMLZCvfYSFhVXgPjUfR0+5aAo=";
   runVend = true;
 
   # Tests are trying to access /homeless-shelter

pkgs/applications/window-managers/herbstluftwm/default.nix

···
-{ lib, stdenv, fetchurl, cmake, pkgconfig, glib, libX11, libXext, libXinerama, libXrandr
-, withDoc ? stdenv.buildPlatform == stdenv.targetPlatform, asciidoc ? null }:
+{ lib, stdenv, fetchurl, cmake, pkgconfig, python3, libX11, libXext, libXinerama, libXrandr, asciidoc
+, xdotool, xorgserver, xsetroot, xterm, runtimeShell
+, nixosTests }:
 
 # Doc generation is disabled by default when cross compiling because asciidoc
-# does not cross compile for now
+# dependency is broken when cross compiling for now
 
-assert withDoc -> asciidoc != null;
+let
+  cross = stdenv.buildPlatform != stdenv.targetPlatform;
 
-stdenv.mkDerivation rec {
+in stdenv.mkDerivation rec {
   pname = "herbstluftwm";
-  version = "0.8.3";
+  version = "0.9.1";
 
   src = fetchurl {
     url = "https://herbstluftwm.org/tarballs/herbstluftwm-${version}.tar.gz";
-    sha256 = "1qmb4pjf2f6g0dvcg11cw9njwmxblhqzd70ai8qnlgqw1iz3nkm1";
+    sha256 = "0r4qaklv97qcq8p0pnz4f2zqg69vfai6c2qi1ydi2kz24xqjf5hy";
   };
 
   outputs = [
     "out"
-  ] ++ lib.optionals withDoc [
-    "doc"
+    "doc" # share/doc exists with examples even without generated html documentation
+  ] ++ lib.optionals (!cross) [
     "man"
   ];
 
   cmakeFlags = [
     "-DCMAKE_INSTALL_SYSCONF_PREFIX=${placeholder "out"}/etc"
-  ] ++ lib.optional (!withDoc) "-DWITH_DOCUMENTATION=OFF";
+  ] ++ lib.optional cross "-DWITH_DOCUMENTATION=OFF";
 
   nativeBuildInputs = [
     cmake
     pkgconfig
-  ] ++ lib.optional withDoc asciidoc;
+    python3
+  ] ++ lib.optional (!cross) asciidoc;
 
   buildInputs = [
     libX11
···
     libXrandr
   ];
 
-  meta = {
+  patches = [
+    ./test-path-environment.patch
+  ];
+
+  postPatch = ''
+    patchShebangs doc/gendoc.py
+
+    # fix /etc/xdg/herbstluftwm paths in documentation and scripts
+    grep -rlZ /etc/xdg/herbstluftwm share/ doc/ scripts/ | while IFS="" read -r -d "" path; do
+      substituteInPlace "$path" --replace /etc/xdg/herbstluftwm $out/etc/xdg/herbstluftwm
+    done
+
+    # fix shebang in generated scripts
+    substituteInPlace tests/conftest.py --replace "/usr/bin/env bash" ${runtimeShell}
+    substituteInPlace tests/test_herbstluftwm.py --replace "/usr/bin/env bash" ${runtimeShell}
+  '';
+
+  doCheck = true;
+
+  checkInputs = [
+    (python3.withPackages (ps: with ps; [ ewmh pytest xlib ]))
+    xdotool
+    xorgserver
+    xsetroot
+    xterm
+    python3.pkgs.pytestCheckHook
+  ];
+
+  # make the package's module avalaible
+  preCheck = ''
+    export PYTHONPATH="$PYTHONPATH:../python"
+  '';
+
+  pytestFlagsArray = [ "../tests" ];
+
+  passthru = {
+    tests.herbstluftwm = nixosTests.herbstluftwm;
+  };
+
+  meta = with lib; {
     description = "A manual tiling window manager for X";
     homepage = "https://herbstluftwm.org/";
-    license = lib.licenses.bsd2;
-    platforms = lib.platforms.linux;
+    license = licenses.bsd2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ thibautmarty ];
   };
 }

pkgs/applications/window-managers/herbstluftwm/test-path-environment.patch

···
+--- a/tests/conftest.py
++++ b/tests/conftest.py
+@@ -43,6 +43,7 @@
+         self.next_client_id = 0
+         self.env = {
+             'DISPLAY': display,
++            'PATH': os.environ['PATH']
+         }
+         self.env = extend_env_with_whitelist(self.env)
+         self.hlwm_process = hlwm_process

pkgs/desktops/lxde/core/lxsession/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoconf
+, automake
+, docbook_xml_dtd_412
+, docbook_xsl
+, intltool
+, libxml2
+, libxslt
+, pkg-config
+, wrapGAppsHook
+, gtk2-x11
+, libX11
+, polkit
+, vala
+}:
+
+stdenv.mkDerivation rec {
+  pname = "lxsession";
+  version = "0.5.5";
+
+  src = fetchFromGitHub {
+    owner = "lxde";
+    repo = "lxsession";
+    rev = version;
+    sha256 = "17sqsx57ymrimm5jfmcyrp7b0nzi41bcvpxsqckmwbhl19g6c17d";
+  };
+
+  patches = [ ./xmlcatalog_patch.patch ];
+
+  nativeBuildInputs = [
+    autoconf
+    automake
+    docbook_xml_dtd_412
+    docbook_xsl
+    intltool
+    libxml2
+    libxslt
+    pkg-config
+    wrapGAppsHook
+  ];
+
+  buildInputs = [
+    gtk2-x11
+    libX11
+    polkit
+    vala
+  ];
+
+  configureFlags = [
+    "--enable-man"
+    "--disable-buildin-clipboard"
+    "--disable-buildin-polkit"
+    "--with-xml-catalog=${docbook_xml_dtd_412}/xml/dtd/docbook/catalog.xml"
+  ];
+
+  preConfigure = "./autogen.sh";
+
+  meta = with lib; {
+    description = "Classic LXDE session manager";
+    license = licenses.gpl2Plus;
+    homepage = "https://wiki.lxde.org/en/LXSession";
+    maintainers = [ maintainers.shamilton ];
+    platforms = platforms.linux;
+  };
+}

pkgs/desktops/lxde/core/lxsession/xmlcatalog_patch.patch

···
+diff --color -ur a/configure.ac b/configure.ac
+--- a/configure.ac	2021-01-18 12:39:19.556844678 +0100
++++ b/configure.ac	2021-01-18 17:26:47.989410501 +0100
+@@ -167,18 +167,7 @@
+ AM_GLIB_GNU_GETTEXT
+ AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE", [Gettext package.])
+ 
+-if test x"$enable_man" = x"yes"; then
+-	AC_PATH_PROG([XSLTPROC], [xsltproc])
+-	if test -z "$XSLTPROC"; then
+-		enable_man=no
+-	fi
+-
+-	dnl check for DocBook DTD and stylesheets in the local catalog.
+-	JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
+-		[DocBook XML DTD V4.1.2], [], enable_man=no)
+-	JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
+-		[DocBook XSL Stylesheets >= 1.70.1], [], enable_man=no)
+-fi
++AC_PATH_PROG([XSLTPROC], [xsltproc])
+ 
+ AM_CONDITIONAL(ENABLE_REGENERATE_MAN, test "x$enable_man" != "xno")
+ 

pkgs/development/compilers/acme/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "acme";
-  version = "120";
+  version = "unstable-2020-12-27";
 
   src = fetchsvn {
     url = "svn://svn.code.sf.net/p/acme-crossass/code-0/trunk";
-    rev = version;
-    sha256 = "0w17b8f8bis22m6l5bg8qg8nniy20f8yg2xmzjipblmc39vpv6s2";
+    rev = "314";
+    sha256 = "08zg26rh19nlif7id91nv0syx5n243ssxhfw0nk2r2bhjm5jrjz1";
   };
 
   sourceRoot = "code-0-r${src.rev}/src";

pkgs/development/compilers/llvm/11/llvm.nix

···
     ln -s $lib/lib/libLLVM.dylib $lib/lib/libLLVM-${release_version}.dylib
   '';
 
-  doCheck = stdenv.isLinux && (!stdenv.isx86_32);
+  doCheck = stdenv.isLinux && (!stdenv.isx86_32) && (!stdenv.hostPlatform.isMusl);
 
   checkTarget = "check-all";
 

pkgs/development/interpreters/bats/default.nix

···
-{ stdenv, fetchzip, coreutils, gnugrep }:
+{ stdenv, lib, fetchzip, bash, makeWrapper, coreutils, gnugrep, doCheck ? true }:
 
 stdenv.mkDerivation rec {
   pname = "bats";
-  version = "1.2.0";
+  version = "1.2.1";
 
   src = fetchzip {
     url = "https://github.com/bats-core/bats-core/archive/v${version}.tar.gz";
-    sha256 = "0f59zh4d4pa1a7ybs5zl6h0csbqqv11lbnq0jl1dgwm1s6p49bsq";
+    hash = "sha256-grB/rJaDU0fuw4Hm3/9nI2px8KZnSWqRjTJPd7Mmb7s=";
   };
+
+  nativeBuildInputs = [ makeWrapper ];
 
   patchPhase = ''
-    patchShebangs ./install.sh
+    patchShebangs .
+  '';
 
-    substituteInPlace ./libexec/bats-core/bats \
-        --replace 'type -p greadlink readlink' 'type -p ${coreutils}/bin/readlink'
-    substituteInPlace ./libexec/bats-core/bats-format-tap-stream \
-        --replace grep ${gnugrep}/bin/grep
+  installPhase = ''
+    ./install.sh $out
+    wrapProgram $out/bin/bats --suffix PATH : "${lib.makeBinPath [ bash coreutils gnugrep ]}"
   '';
 
-  installPhase = "./install.sh $out";
+  inherit doCheck;
+  checkPhase = ''
+    # test generates file with absolute shebang dynamically
+    substituteInPlace test/install.bats --replace \
+      "/usr/bin/env bash" "${bash}/bin/bash"
+    bin/bats test
+  '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/bats-core/bats-core";
     description = "Bash Automated Testing System";
-    maintainers = [ maintainers.lnl7 ];
+    maintainers = with maintainers; [ abathur ];
     license = licenses.mit;
     platforms = platforms.unix;
   };

pkgs/development/interpreters/guile/default.nix

···
   # "libgcc_s.so.1 must be installed for pthread_cancel to work".
 
   # don't have "libgcc_s.so.1" on darwin
-  LDFLAGS = stdenv.lib.optionalString (!stdenv.isDarwin) "-lgcc_s";
+  LDFLAGS = stdenv.lib.optionalString
+    (!stdenv.isDarwin && !stdenv.hostPlatform.isStatic) "-lgcc_s";
 
   configureFlags = [ "--with-libreadline-prefix=${readline.dev}" ]
     ++ stdenv.lib.optionals stdenv.isSunOS [

pkgs/development/interpreters/wasmer/default.nix

···
 
   nativeBuildInputs = [ cmake pkg-config ];
 
+  # Since wasmer 0.17 no backends are enabled by default. Backends are now detected
+  # using the [makefile](https://github.com/wasmerio/wasmer/blob/master/Makefile).
+  # Enabling cranelift as this used to be the old default. At least one backend is
+  # needed for the run subcommand to work.
+  cargoBuildFlags = [ "--features 'backend-cranelift'" ];
+
   LIBCLANG_PATH = "${llvmPackages.libclang}/lib";
 
   meta = with lib; {

pkgs/development/libraries/bashup-events/3.2.nix

···
+{ callPackage, fetchFromGitHub }:
+
+callPackage ./generic.nix {
+  variant = "3.2";
+  version = "2019-07-27";
+  branch = "master";
+  src = fetchFromGitHub {
+    owner = "bashup";
+    repo = "events";
+    rev = "83744c21bf720afb8325343674c62ab46a8f3d94";
+    hash = "sha256-0VDjd+1T1JBmSDGovWOOecUZmNztlwG32UcstfdigbI=";
+  };
+  fake = {
+    # Note: __ev.encode is actually defined, but it happens in a
+    # quoted arg to eval, which resholve currently doesn't (and may
+    # never) parse into. See abathur/resholve/issues/2.
+    function = [ "__ev.encode" ];
+  };
+  keep = {
+    # allow vars in eval
+    eval = [ "e" "f" "q" "r" ];
+    # allow vars executed as commands
+    "$f" = true;
+    "$n" = true;
+  };
+}

pkgs/development/libraries/bashup-events/4.4.nix

···
+{ callPackage, fetchFromGitHub }:
+
+callPackage ./generic.nix {
+  variant = "4.4";
+  version = "2020-04-04";
+  branch = "bash44";
+  src = fetchFromGitHub {
+    owner = "bashup";
+    repo = "events";
+    rev = "e97654f5602fc4e31083b27afa18dcc89b3e8296";
+    hash = "sha256-51OSIod3mEg3MKs4rrMgRcOimDGC+3UIr4Bl/cTRyGM=";
+  };
+  keep = {
+    # allow vars in eval
+    eval = [ "e" "bashup_ev" "n" ];
+    # allow vars executed as commands
+    "$f" = true;
+    "$n" = true;
+  };
+}

pkgs/development/libraries/bashup-events/default.nix

···
+{ callPackage }:
+
+{
+  bashup-events32 = callPackage ./3.2.nix { };
+  bashup-events44 = callPackage ./4.4.nix { };
+}

pkgs/development/libraries/bashup-events/generic.nix

···
+{
+  # general
+  lib
+, callPackage
+, runCommand
+, resholvePackage
+, bash
+, shellcheck
+, doCheck ? true
+, doInstallCheck ? true
+  # variant-specific
+, variant
+, version
+, branch
+, src
+, fake ? false
+, keep
+}:
+let
+  # extracting this so that it's trivial to test in other shells
+  installCheck = shell:
+    ''
+      echo "testing bashup.events in ${shell}"
+      ${shell} <<'EOF'
+      source $out/bin/bashup.events
+      neat(){
+        echo $0: Hi from event \'test event\'. I can have both $1 and $2 arguments.
+        exit 0
+      }
+      event on "test event" @2 neat curried
+      echo event registered
+      event emit "test event" runtime
+      exit 1 # fail if emitting event didn't exit clean
+      EOF
+    '';
+
+in
+resholvePackage rec {
+  # bashup.events doesn't version yet but it has two variants with
+  # differing features/performance characteristics:
+  # - branch master: a variant for bash 3.2+
+  # - branch bash44: a variant for bash 4.4+
+  pname = "bashup-events${variant}-unstable";
+  # should be YYYY-MM-DD
+  inherit version;
+  inherit src;
+
+  installPhase = ''
+    install -Dt $out/bin bashup.events
+  '';
+
+  inherit doCheck;
+  checkInputs = [ shellcheck bash ];
+
+  # check based on https://github.com/bashup/events/blob/master/.dkrc
+  checkPhase = ''
+    SHELLCHECK_OPTS='-e SC2016,SC2145' ${shellcheck}/bin/shellcheck ./bashup.events
+    ${bash}/bin/bash -n ./bashup.events
+    ${bash}/bin/bash ./bashup.events
+  '';
+
+  solutions = {
+    events = {
+      inputs = [ ];
+      interpreter = "none";
+      scripts = [ "bin/bashup.events" ];
+      inherit keep;
+    } // lib.optionalAttrs (lib.isAttrs fake) { inherit fake; };
+  };
+
+  inherit doInstallCheck;
+  installCheckInputs = [ bash ];
+  installCheckPhase = installCheck "${bash}/bin/bash";
+
+  meta = with lib; {
+    inherit branch;
+    description = "An event listener/callback API for creating extensible bash programs";
+    homepage = "https://github.com/bashup/events";
+    license = licenses.cc0;
+    maintainers = with maintainers; [ abathur ];
+    platforms = platforms.all;
+  };
+}

pkgs/development/libraries/fcft/default.nix

···
 { stdenv, lib, fetchgit, pkg-config, meson, ninja, scdoc
-,freetype, fontconfig, harfbuzz, pixman, tllist, check }:
+, freetype, fontconfig, pixman, tllist, check
+, withHarfBuzz ? true
+, harfbuzz
+}:
 
 stdenv.mkDerivation rec {
   pname = "fcft";
-  version = "2.3.1";
+  version = "2.3.2";
 
   src = fetchgit {
     url = "https://codeberg.org/dnkl/fcft.git";
     rev = version;
-    sha256 = "sha256-FD3KfaQbSEA1XdmS6YxH+c5fSsra9Ro/KKslb7Brv7U=";
+    sha256 = "0k2i57rakm4g86f7hbhkby8af0vv7v63a70lk3m58mkycpy5q2rm";
   };
 
   nativeBuildInputs = [ pkg-config meson ninja scdoc ];
-  buildInputs = [ freetype fontconfig pixman tllist harfbuzz ];
+  buildInputs = [ freetype fontconfig pixman tllist ]
+    ++ lib.optional withHarfBuzz harfbuzz;
   checkInputs = [ check ];
 
-  mesonFlags = [ "--buildtype=release" ];
+  mesonFlags = [
+    "--buildtype=release"
+    "-Dtext-shaping=${if withHarfBuzz then "enabled" else "disabled"}"
+  ];
 
   doCheck = true;
 

pkgs/development/libraries/libinfinity/default.nix

···
 
   self = stdenv.mkDerivation rec {
     pname = "libinfinity";
-    version = "0.7.1";
+    version = "0.7.2";
     src = fetchurl {
-      url = "http://releases.0x539.de/libinfinity/${pname}-${version}.tar.gz";
-      sha256 = "1jw2fhrcbpyz99bij07iyhy9ffyqdn87vl8cb1qz897y3f2f0vk2";
+      url = "https://github.com/gobby/${pname}/releases/download/${version}/${pname}-${version}.tar.gz";
+      sha256 = "17i3g61hxz9pzl3ryd1yr15142r25m06jfzjrpdy7ic1b8vjjw3f";
     };
 
     outputs = [ "bin" "out" "dev" "man" "devdoc" ];
···
     };
 
     meta = {
-      homepage = "http://gobby.0x539.de/";
+      homepage = "https://gobby.github.io/";
       description = "An implementation of the Infinote protocol written in GObject-based C";
       license = stdenv.lib.licenses.lgpl2Plus;
       maintainers = [ stdenv.lib.maintainers.phreedom ];

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

···
   outputs = [ "bin" "out" "dev" ];
 
   src = fetchFromGitHub {
-    owner = "Paul-Browne";
+    owner = "Mattey40";
     repo = "poly2tri-c";
     rev = "p2tc-${version}";
     sha256 = "158vm3wqfxs22b74kqc4prlvjny38qqm3kz5wrgasmx0qciwh0g8";

pkgs/development/misc/resholve/README.md

···
 
 > Fair warning: resholve does *not* aspire to resolving all valid Shell
 > scripts. It depends on the OSH/Oil parser, which aims to support most (but
-> not all) Bash, and aims to be a ~90% sort of solution.
+> not all) Bash. resholve aims to be a ~90% sort of solution.
 
-Let's start with a simple example from one of my own projects:
+## API Concepts
+
+The main difference between `resholvePackage` and other builder functions
+is the `solutions` attrset, which describes which scripts to resolve and how.
+Each "solution" (k=v pair) in this attrset describes one resholve invocation.
+
+> NOTE: For most shell packages, one invocation will probably be enough:
+> - Packages with a single script will only need one solution.
+> - Packages with multiple scripts can still use one solution if the scripts
+>   don't require conflicting directives.
+> - Packages with scripts that require conflicting directives can use multiple
+>   solutions to resolve the scripts separately, but produce a single package.
+
+## Basic Example
+
+Here's a simple example from one of my own projects, with annotations:
+<!--
+TODO: ideally this will use a nixpkgs example; but we don't have any IN yet
+and the first package PR (bashup-events) is too complex for this context.
+-->
 
 ```nix
 { stdenv, lib, resholvePackage, fetchFromGitHub, bashup-events44, bashInteractive_5, doCheck ? true, shellcheck }:
···
   };
 
   solutions = {
+    # Give each solution a short name. This is what you'd use to
+    # override its settings, and it shows in (some) error messages.
     profile = {
-      # the only *required* arguments
+      # the only *required* arguments are the 3 below
+
+      # Specify 1 or more $out-relative script paths. Unlike many
+      # builders, resholvePackage modifies the output files during
+      # fixup (to correctly resolve in-package sourcing).
       scripts = [ "bin/shellswain.bash" ];
+
+      # "none" for no shebang, "${bash}/bin/bash" for bash, etc.
       interpreter = "none";
+
+      # packages resholve should resolve executables from
       inputs = [ bashup-events44 ];
     };
   };
···
 }
 ```
 
-I'll focus on the `solutions` attribute, since this is the only part
-that differs from other derivations.
-
-Each "solution" (k=v pair)
-describes one resholve invocation. For most shell packages, one
-invocation will probably be enough. resholve will make you be very
-explicit about your script's dependencies, and it may also need your
-help sorting out some references or problems that it can't safely
-handle on its own.
+## Options
 
-If you have more than one script, and your scripts need conflicting
-directives, you can specify more than one solution to resolve the
-scripts separately, but still produce a single package.
+`resholvePackage` maps Nix types/idioms into the flags and environment variables
+that the `resholve` CLI expects. Here's an overview:
 
-Let's take a closer look:
+| Option        | Type    | Containing                                            |
+| ------------- | ------- | ----------------------------------------------------- |
+| scripts       | list    | $out-relative string paths to resolve                 |
+| inputs        | list    | packages to resolve executables from                  |
+| interpreter   | string  | 'none' or abspath for shebang                         |
+| prologue      | file    | text to insert before the first code-line             |
+| epilogue      | file    | text to isnert after the last code-line               |
+| flags         | list    | strings to pass as flags                              |
+| fake          | attrset | [directives](#controlling-resolution-with-directives) |
+| fix           | attrset | [directives](#controlling-resolution-with-directives) |
+| keep          | attrset | [directives](#controlling-resolution-with-directives) |
 
-```nix
-  solutions = {
-    # each solution has a short name; this is what you'd use to
-    # override the settings of this solution, and it may also show up
-    # in (some) error messages.
-    profile = {
-      # specify one or more $out-relative script paths (unlike many
-      # builders, resholve will modify the output files during fixup
-      # to correctly resolve scripts that source within the package)
-      scripts = [ "bin/shellswain.bash" ];
-      # "none" for no shebang, "${bash}/bin/bash" for bash, etc.
-      interpreter = "none";
-      # packages resholve should resolve executables from
-      inputs = [ bashup-events44 ];
-    };
-  };
-```
+## Controlling resolution with directives
 
-resholve has a (growing) number of options for handling more complex
-scripts. I won't cover these in excruciating detail here. You can find
-more information about these in `man resholve` via `nixpkgs.resholve`.
+In order to resolve a script, resholve will make you disambiguate how it should
+handle any potential problems it encounters with directives. There are currently
+3 types:
+1. `fake` directives tell resholve to pretend it knows about an identifier
+   such as a function, builtin, external command, etc. if there's a good reason
+   it doesn't already know about it. Common examples:
+   - builtins for a non-bash shell
+   - loadable builtins
+   - platform-specific external commands in cross-platform conditionals
+2. `fix` directives give resholve permission to fix something that it can't
+   safely fix automatically. Common examples:
+   - resolving commands in aliases (this is appropriate for standalone scripts
+     that use aliases non-interactively--but it would prevent profile/rc
+     scripts from using the latest current-system symlinks.)
+   - resolve commands in a variable definition
+   - resolve an absolute command path from inputs as if it were a bare reference
+3. `keep` directives tell resholve not to raise an error (i.e., ignore)
+   something it would usually object to. Common examples:
+   - variables used as/within the first word of a command
+   - pre-existing absolute or user-relative (~) command paths
+   - dynamic (variable) arguments to commands known to accept/run other commands
 
-Instead, we'll look at the general form of the solutions attrset:
+> NOTE: resholve has a (growing) number of directives detailed in `man resholve`
+> via `nixpkgs.resholve`.
 
-```nix
-solutions = {
-  shortname = {
-    # required
-    # $out-relative paths to try resolving
-    scripts = [ "bin/shunit2" ];
-    # packages to resolve executables from
-    inputs = [ coreutils gnused gnugrep findutils ];
-    # path for shebang, or 'none' to omit shebang
-    interpreter = "${bash}/bin/bash";
+Each of these 3 types is represented by its own attrset, where you can think
+of the key as a scope. The value should be:
+- `true` for any directives that the resholve CLI accepts as a single word
+- a list of strings for all other options
+<!--
+TODO: these should be fully-documented here, but I'm already maintaining
+more copies of their specification/behavior than I like, and continuing to
+add more at this early date will only ensure that I spend more time updating
+docs and less time filling in feature gaps.
 
-    # optional
-    fake = { fake directives };
-    fix = { fix directives };
-    keep = { keep directives };
-    # file to inject before first code-line of script
-    prologue = file;
-    # file to inject after last code-line of script
-    epilogue = file;
-    # extra command-line flags passed to resholve; generally this API
-    # should align with what resholve supports, but flags may help if
-    # you need to override the version of resholve.
-    flags = [ ];
-  };
-};
-```
+Full documentation may be greatly accellerated if someone can help me sort out
+single-sourcing. See: https://github.com/abathur/resholve/issues/19
+-->
 
-The main way you'll adjust how resholve handles your scripts are the
-fake, fix, and keep directives. The manpage covers their purpose and
-how to format them on the command-line, so I'll focus on how you'll
-need to translate them into Nix types.
+This will hopefully make more sense when you see it. Here are CLI examples
+from the manpage, and the Nix equivalents:
 
 ```nix
 # --fake 'f:setUp;tearDown builtin:setopt source:/etc/bashrc'
 fake = {
-    function = [ "setUp" "tearDown" ];
-    builtin = [ "setopt" ];
-    source = [ "/etc/bashrc" ];
+  # fake accepts the initial of valid identifier types as a CLI convienience.
+  # Use full names in the Nix API.
+  function = [ "setUp" "tearDown" ];
+  builtin = [ "setopt" ];
+  source = [ "/etc/bashrc" ];
 };
 
 # --fix 'aliases xargs:ls $GIT:gix'
 fix = {
-    # all single-word directives use `true` as value
-    aliases = true;
-    xargs = [ "ls" ];
-    "$GIT" = [ "gix" ];
+  # all single-word directives use `true` as value
+  aliases = true;
+  xargs = [ "ls" ];
+  "$GIT" = [ "gix" ];
 };
 
 # --keep 'which:git;ls .:$HOME $LS:exa /etc/bashrc ~/.bashrc'
 keep = {
-    which = [ "git" "ls" ];
-    "." = [ "$HOME" ];
-    "$LS" = [ "exa" ];
-    "/etc/bashrc" = true;
-    "~/.bashrc" = true;
+  which = [ "git" "ls" ];
+  "." = [ "$HOME" ];
+  "$LS" = [ "exa" ];
+  "/etc/bashrc" = true;
+  "~/.bashrc" = true;
 };
 ```

pkgs/development/python-modules/alerta-server/default.nix

···
 
 buildPythonPackage rec {
   pname = "alerta-server";
-  version = "8.1.0";
+  version = "8.2.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "32a97eee95aea5527f6efa844c18b727fe4a6d61356ea3c0769a29a163ddcb7e";
+    sha256 = "ee06d0f828b679402847989de9013a1271db282af377f5dce776347623dde345";
   };
 
   propagatedBuildInputs = [

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

···
 , isPy3k
 , pytest
 , pytest-asyncio
+, pytest-cov
 , pytestCheckHook
 }:
 
 buildPythonPackage rec {
   pname = "aresponses";
-  version = "2.1.0";
+  version = "2.1.2";
 
   disabled = !isPy3k;
 
···
     owner = "CircleUp";
     repo = pname;
     rev = version;
-    sha256 = "0dc1y4s6kpmr0ar63kkyghvisgbmb8qq5wglmjclrpzd5180mjcl";
+    sha256 = "007wrk4wdy97a81imgzxd6sm5dly9v7abmxh9fyfi0vp1p7s75bw";
   };
 
   propagatedBuildInputs = [
···
 
   checkInputs = [
     aiohttp
+    pytest-asyncio
+    pytest-cov
     pytestCheckHook
-    pytest-asyncio
   ];
 
   # Disable tests which requires network access
···
     "test_foo"
     "test_passthrough"
   ];
+
+  __darwinAllowLocalNetworking = true;
 
   pythonImportsCheck = [ "aresponses" ];
 

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

···
 
 buildPythonPackage rec {
   pname = "cx_Oracle";
-  version = "8.0.1";
+  version = "8.1.0";
 
   buildInputs = [ odpic ];
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f10ada7f821a325c6befdd6fef1cac44ebc830736d0b75dda7b8ac9f851087b2";
+    sha256 = "e1698c5522ee1355e552b30bfa0a58e6e772475b882c5d69d158bd7e6aed45de";
   };
 
   preConfigure = ''

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

···
 
 buildPythonPackage rec {
   pname = "mongoengine";
-  version = "0.21.0";
+  version = "0.22.0";
   disabled = isPy27;
 
   src = fetchFromGitHub {
     owner = "MongoEngine";
     repo = pname;
     rev = "v${version}";
-    sha256 = "02amfdirdw3nc0kgiyax7yndk5b65g83kbjvwwxbgnlcrb9vjzcd";
+    sha256 = "14n9rl8w3i1fq96f3jzsg7gy331d7fmrapva6m38ih53rnf38bdf";
   };
 
   propagatedBuildInputs = [

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

···
     description = "Access a multitude of neuroimaging data formats";
     license = licenses.mit;
     maintainers = with maintainers; [ ashgillman ];
-    platforms = platforms.x86_64;  # https://github.com/nipy/nibabel/issues/861
   };
 }

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

···
 
   doCheck = false;
   propagatedBuildInputs = [
-    pytz requests tzlocal i3ipc pydbus pygobject3 pyserial setuptools dbus-python
+    pytz requests tzlocal i3ipc pydbus pygobject3 pyserial setuptools dbus-python file
   ];
-  buildInputs = [ file ];
   prePatch = ''
     sed -i -e "s|'file|'${file}/bin/file|" py3status/parse_config.py
     sed -i -e "s|\[\"acpi\"|\[\"${acpi}/bin/acpi\"|" py3status/modules/battery_level.py

pkgs/development/python-modules/sqlite-utils/default.nix

···
 
 buildPythonPackage rec {
   pname = "sqlite-utils";
-  version = "3.2";
+  version = "3.3";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "83d60e0f0de5e4a367e2ad414dc008c0602e2af35325b09e41c7b2c69808dcc1";
+    sha256 = "1linla3za1gb3w0n0k6h3q8in62qhipizff259p14gzmyr95rjjv";
   };
 
   propagatedBuildInputs = [
···
     pytestrunner
     black
     hypothesis
-  ];
-
-  # disabled until upstream updates tests
-  disabledTests = lib.optionals (lib.versionAtLeast sqlite.version "3.34.0") [
-    "test_optimize"
   ];
 
   meta = with lib; {

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

···
+{ lib
+, aiohttp
+, async-timeout
+, buildPythonPackage
+, fetchPypi
+}:
+
+buildPythonPackage rec {
+  pname = "waqiasync";
+  version = "1.0.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1yxls7ywfg954c3vxgnp98qa1b8dsq9b2fld11fb9sx1k4mjc29d";
+  };
+
+  propagatedBuildInputs = [
+    aiohttp
+    async-timeout
+  ];
+
+  # Project has no tests
+  doCheck = false;
+  pythonImportsCheck = [ "waqiasync" ];
+
+  meta = with lib; {
+    description = "Python library for http://aqicn.org";
+    homepage = "https://github.com/andrey-git/waqi-async";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/development/r-modules/default.nix

···
     mwaved = [ pkgs.fftw.dev ];
     ncdf4 = [ pkgs.netcdf ];
     nloptr = [ pkgs.nlopt pkgs.pkgconfig ];
+    n1qn1 = [ pkgs.gfortran ];
     odbc = [ pkgs.unixODBC ];
     pander = [ pkgs.pandoc pkgs.which ];
     pbdMPI = [ pkgs.openmpi ];
···
     systemfonts = [ pkgs.pkgconfig ];
     tesseract = [ pkgs.pkgconfig ];
     Cairo = [ pkgs.pkgconfig ];
+    CLVTools = [ pkgs.gsl ];
+    JMcmprsk = [ pkgs.gsl ];
+    mashr = [ pkgs.gsl ];
+    hadron = [ pkgs.gsl ];
+    AMOUNTAIN = [ pkgs.gsl ];
     Rsymphony = [ pkgs.pkgconfig pkgs.doxygen pkgs.graphviz pkgs.subversion ];
     tcltk2 = [ pkgs.tcl pkgs.tk ];
     tikzDevice = [ pkgs.which pkgs.texlive.combined.scheme-medium ];
···
     openssl = old.openssl.overrideDerivation (attrs: {
       preConfigure = ''
         patchShebangs configure
-        '';
+      '';
       PKGCONFIG_CFLAGS = "-I${pkgs.openssl.dev}/include";
       PKGCONFIG_LIBS = "-Wl,-rpath,${pkgs.openssl.out}/lib -L${pkgs.openssl.out}/lib -lssl -lcrypto";
     });
···
     });
 
     magick = old.magick.overrideDerivation (attrs: {
+      preConfigure = ''
+        patchShebangs configure
+        '';
+    });
+
+    libgeos = old.libgeos.overrideDerivation (attrs: {
       preConfigure = ''
         patchShebangs configure
         '';

pkgs/development/r-modules/patches/qtbase.patch

···
-diff -ru -x '*~' qtbase_orig/src/Makefile qtbase/src/Makefile
---- qtbase_orig/src/Makefile	2012-03-03 03:57:47.000000000 +0900
-+++ qtbase/src/Makefile	2014-11-01 23:06:51.383876323 +0900
-@@ -10,6 +10,9 @@
- 	      -DR_INCLUDES=${R_INCLUDE_DIR} \
- 	      -DCMAKE_INSTALL_PREFIX=../src; \
- 	make install
-+# I could not control RPATH via CMake. HELP WANTED!
-+	patchelf --set-rpath ${CMAKE_LIBRARY_PATH} qtbase.so
-+	find ../inst/local/ -executable -type f -print0 | xargs -0 patchelf --set-rpath ${CMAKE_LIBRARY_PATH} 
- 
- clean:
- 	rm -rf ../kdebindings-build

pkgs/development/tools/continuous-integration/fly/default.nix

···
 
 buildGoModule rec {
   pname = "fly";
-  version = "6.7.2";
+  version = "6.7.3";
 
   src = fetchFromGitHub {
     owner = "concourse";
     repo = "concourse";
     rev = "v${version}";
-    sha256 = "0c5alf2a0088i25mglla9dl4m3wr5y8pnl5cczgn06sz8qp9a0s0";
+    sha256 = "sha256-XaoM/1YuHBl8ndPz3EByW1X0CzTuvJ5ju11mStbJnEU=";
   };
 
-  vendorSha256 = "1fxbxkg7disndlmb065abnfn7sn79qclkcbizmrq49f064w1ijr4";
+  vendorSha256 = "sha256-xeptlcJLj+R1BdC8Rdi3hsJVxdrmvfeTMsrhMNGrXi8=";
 
   doCheck = false;
 

pkgs/development/tools/git-quick-stats/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "git-quick-stats";
-  version = "2.1.4";
+  version = "2.1.5";
 
   src = fetchFromGitHub {
     repo = "git-quick-stats";
     owner = "arzzen";
     rev = version;
-    sha256 = "0fg0fijghcz7hvbc9y8dfksz0qmsz700kc2mfb03y90kja99v68y";
+    sha256 = "sha256-d5B+SSUXtOD4x+dChQsUCkiHuHcW3lOrL4QhQekY7cA=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/tools/swiftformat/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "swiftformat";
-  version = "0.44.9";
+  version = "0.47.10";
 
   src = fetchFromGitHub {
     owner = "nicklockwood";
     repo = "SwiftFormat";
     rev = version;
-    sha256 = "0zajvbaf3r02k53lv5zdxf13apc6chnjmj69zkyac48lpnpbcxq6";
+    sha256 = "1gqxpymbhpmap0i2blg9akarlql4mkzv45l4i212gsxcs991b939";
   };
 
   preConfigure = "LD=$CC";

pkgs/development/web/flyctl/default.nix

···
 
 buildGoModule rec {
   pname = "flyctl";
-  version = "0.0.154";
+  version = "0.0.161";
 
   src = fetchFromGitHub {
     owner = "superfly";
     repo = "flyctl";
     rev = "v${version}";
-    sha256 = "0hf33jm0ph4a79jg9irz0ynvdyah942cm5hb6j04hmg24x1037jm";
+    sha256 = "sha256-mM+jo1zKfA8u0IxtruQp4va0f7PldJQJV1/ypF1K0fI=";
   };
 
   preBuild = ''
···
 
   subPackages = [ "." ];
 
-  vendorSha256 = "0fmbwk0j2aayvi3cx8cfp4b3h89v88qm4kslbmhlj8mny9rd7lys";
+  vendorSha256 = "sha256-8rzXltsAXF9qIX1BrBwwi+145nQcXjrEBdIXgSgVYRw=";
 
   doCheck = false;
 

pkgs/games/gnujump/default.nix

···
-{ lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer }:
+{ lib, stdenv, makeDesktopItem, copyDesktopItems, fetchurl, SDL, SDL_image, SDL_mixer }:
 
 stdenv.mkDerivation rec {
   pname = "gnujump";
···
     url = "mirror://gnu/gnujump/${pname}-${version}.tar.gz";
     sha256 = "05syy9mzbyqcfnm0hrswlmhwlwx54f0l6zhcaq8c1c0f8dgzxhqk";
   };
+
+  nativeBuildInputs = [ copyDesktopItems ];
   buildInputs = [ SDL SDL_image SDL_mixer ];
 
   NIX_LDFLAGS = "-lm";
+
+  desktopItems = [ (makeDesktopItem {
+    name = "gnujump";
+    exec = "gnujump";
+    icon = "gnujump";
+    desktopName = "GNUjump";
+    comment     = "Jump up the tower to survive";
+    categories  = "Game;ArcadeGame;";
+  }) ];
+
+  postInstall = ''
+    install -Dm644 ${./gnujump.xpm} $out/share/pixmaps/gnujump.xpm
+  '';
 
   meta = with lib; {
     homepage = "https://jump.gnu.sinusoid.es/index.php?title=Main_Page";

pkgs/games/gnujump/gnujump.xpm

···
+/* XPM */
+static char *gnujump[] = {
+/* columns rows colors chars-per-pixel */
+"32 32 26 1 ",
+"  c black",
+". c #D10000",
+"X c #E80000",
+"o c #E90000",
+"O c #F90000",
+"+ c red",
+"@ c #00C500",
+"# c #00DC00",
+"$ c #00DD00",
+"% c #00EF00",
+"& c #00FA00",
+"* c #00FB00",
+"= c green",
+"- c #FFC882",
+"; c #FFC982",
+": c #FFD298",
+"> c #FFD299",
+", c #FFD399",
+"< c #FFDAAB",
+"1 c #FFDBAB",
+"2 c #FFDBAC",
+"3 c #FFE1BA",
+"4 c #FFE5C3",
+"5 c #FFE5C4",
+"6 c #FFE7C7",
+"7 c None",
+/* pixels */
+"77777777777777777777777777777777",
+"77777777777777777777777777777777",
+"7777777777777     77777777777777",
+"77777777777         777777777777",
+"7777777777           77777777777",
+"777777777             7777777777",
+"777777777       ;;;-- 7777777777",
+"77777777      ::>>,>1: 777777777",
+"77777777     :<1<1:>2: 777777777",
+"77777777    :1331:  :: 7777 7777",
+"77777777   :<3431:  :, 777 o 777",
+"777  777  ->236531>:2: 77 oo 777",
+"77 .o  77 -,145443<1, 77 oOo 777",
+"77 .ooo 7 -:13333312: 7 oOo 7777",
+"777 oOOo   :,11<<<::   oOOo 7777",
+"7777 XOOooo  :::>:  XooO+Oo 7777",
+"77777 oOOOOoo     ooOOO+Oo 77777",
+"777777 oOO+OOoooooOO++OOo 777777",
+"7777777 XoOOOOOOOOOOOOoo 7777777",
+"77777777  oooooooooooo  77777777",
+"7777777777            7777777777",
+"777777777 @@@@@@@@@@@@   7777777",
+"77777777 #######$$##$#### 777777",
+"7777777 #%%%%%%%%%%%%%%%%# 77777",
+"7777777 #%*&*&*%%%%%%*&*%# 77777",
+"777777 #%*=**%%#####$%%&*%# 7777",
+"777777 #%&*%%##      ##%&%# 7777",
+"77777 #%*%%##  777777  #%%# 7777",
+"77777 #%%#$   777777777 #%%# 777",
+"7777 @%##   777777777777 #%# 777",
+"7777 ##  7777777777777777 $# 777",
+"77777  7777777777777777777  7777"
+};

pkgs/games/quake3/content/hires.nix

···
+{ stdenv, lib, fetchzip }:
+
+stdenv.mkDerivation {
+  pname = "quake3hires";
+  version = "2020-01-20"; # Unknown version, used the date of web.archive.org capture.
+
+  src = fetchzip {
+    url = "https://web.archive.org/web/20200120024216/http://ioquake3.org/files/xcsv_hires.zip";
+    sha256 = "09vhrray8mh1ic2qgcwv0zlmsnz789y32dkkvrz1vdki4yqkf717";
+    stripRoot = false;
+  };
+
+  buildCommand = ''
+    mkdir -p $out/baseq3
+    install -Dm444 $src/xcsv_bq3hi-res.pk3 $out/baseq3/xcsv_bq3hi-res.pk3
+  '';
+
+  preferLocalBuild = true;
+
+  meta = with lib; {
+    description = "Quake 3 high-resolution textures";
+    license = licenses.cc0;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ rvolosatovs ];
+  };
+}

pkgs/games/xbill/default.nix

···
-{ stdenv, lib, fetchurl, libX11, libXpm, libXt, motif, ... }:
+{ stdenv, lib, makeDesktopItem, copyDesktopItems, fetchurl, libX11, libXpm, libXt, motif, ... }:
 
 stdenv.mkDerivation rec {
   pname = "xbill";
   version = "2.1";
 
+  nativeBuildInputs = [ copyDesktopItems ];
   buildInputs = [ libX11 libXpm libXt motif ];
 
   NIX_CFLAGS_LINK = "-lXpm";
···
     url = "http://www.xbill.org/download/${pname}-${version}.tar.gz";
     sha256 = "13b08lli2gvppmvyhy0xs8cbjbkvrn4b87302mx0pxrdrvqzzz8f";
   };
+
+  desktopItems = [ (makeDesktopItem {
+    name = "xbill";
+    exec = "xbill";
+    icon = "xbill";
+    desktopName = "XBill";
+    comment     = "Get rid of those Wingdows viruses!";
+    categories  = "Game;ArcadeGame;";
+  }) ];
+
+  postInstall = ''
+    install -Dm644 pixmaps/icon.xpm $out/share/pixmaps/xbill.xpm
+  '';
 
   meta = with stdenv; {
     description = "Protect a computer network from getting infected";

pkgs/misc/emulators/citra/default.nix

···
 
 mkDerivation {
   pname = "citra";
-  version = "2020-03-21";
+  version = "2020-12-07";
 
   # Submodules
   src = fetchgit {
     url = "https://github.com/citra-emu/citra";
-    rev = "8722b970c52f2c0d8e82561477edb62a53ae9dbb";
-    sha256 = "0c1zn1f84h4f6n6p0aqz905yvv5qpdmkj2z58yla6bfgbzabfyrj";
+    rev = "3f13e1cc2419fac837952c44d7be9db78b054a2f";
+    sha256 = "1bbg8cwrgncmcavqpj3yp4dbfkip1i491krp6dcpgvsd5yfr7f0v";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/misc/tmux-plugins/default.nix

···
 
   tmux-fzf = mkDerivation {
     pluginName = "tmux-fzf";
-    version = "unstable-2020-11-23";
+    rtpFilePath = "main.tmux";
+    version = "unstable-2020-12-07";
     src = fetchFromGitHub {
       owner = "sainnhe";
       repo = "tmux-fzf";
-      rev = "312685b2a7747b61f1f4a96bd807819f1450479d";
+      rev = "5efeb91086040a3becf5372fb38258acd0579954";
       sha256 = "1z0zmsf8asxs9wbwvkiyd81h93wb2ikl8nxxc26sdpi6l333q5s9";
     };
     postInstall = ''

pkgs/misc/vim-plugins/generated.nix

···
     meta.homepage = "https://github.com/junegunn/fzf.vim/";
   };
 
+  galaxyline-nvim = buildVimPluginFrom2Nix {
+    pname = "galaxyline-nvim";
+    version = "2020-12-14";
+    src = fetchFromGitHub {
+      owner = "glepnir";
+      repo = "galaxyline.nvim";
+      rev = "528bb65b00f9ef5081cb524638b3337c4e5f26b5";
+      sha256 = "069ksz4nfhlr5zlkpawh1yak4yk3vc2cd9mgy5f0r6in3wh0iypc";
+    };
+    meta.homepage = "https://github.com/glepnir/galaxyline.nvim/";
+  };
+
   gen_tags-vim = buildVimPluginFrom2Nix {
     pname = "gen_tags-vim";
     version = "2020-10-12";

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

···
 GEverding/vim-hocon
 gfanto/fzf-lsp.nvim@main
 gibiansky/vim-textobj-haskell
+glepnir/galaxyline.nvim
 glts/vim-textobj-comment
 godlygeek/csapprox
 godlygeek/tabular

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

···
     sha256 = "0apxgmkhsk3vxn9q3libxn3dgrdljrxyy4mli2gk49m7hi3na7xp";
   };
 
-  makeFlags =
-    [ "LIBDIR=$(out)/lib" "BINDIR=$(out)/sbin" "MANDIR=$(out)/share/man"
-      "ETCDIR=$(out)/etc" "INITDIR=$(TMPDIR)" "SYSCONFIGDIR=$(out)/etc/sysconfig"
-      "LOCALSTATEDIR=/var"
-    ];
+  makeFlags = [
+    "LIBDIR=$(out)/lib" "BINDIR=$(out)/sbin" "MANDIR=$(out)/share/man"
+    "ETCDIR=$(out)/etc" "INITDIR=$(TMPDIR)" "SYSCONFIGDIR=$(out)/etc/sysconfig"
+    "LOCALSTATEDIR=/var"
+  ];
 
   NIX_CFLAGS_COMPILE = "-Wno-error";
 
   preInstall = "mkdir -p $out/etc/sysconfig";
+
+  postInstall = ''
+    ln -s $out/sbin/ebtables-legacy          $out/sbin/ebtables
+    ln -s $out/sbin/ebtables-legacy-restore  $out/sbin/ebtables-restore
+    ln -s $out/sbin/ebtables-legacy-save     $out/sbin/ebtables-save
+  '';
 
   meta = with lib; {
     description = "A filtering tool for Linux-based bridging firewalls";

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

···
 
 stdenv.mkDerivation rec {
   pname = "fwts";
-  version = "20.09.00";
+  version = "20.11.00";
 
   src = fetchzip {
     url = "http://fwts.ubuntu.com/release/${pname}-V${version}.tar.gz";
-    sha256 = "1vzzlb7xdrk8rhi27jdw9baskild4dmk7g5d0hhfh6z3fx4lfhgk";
+    sha256 = "0s8iz6c9qhyndcsjscs3qail2mzfywpbiys1x232igm5kl089vvr";
     stripRoot = false;
   };
 

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

···
     "vultr" = ps: with ps; [ vultr ];
     "w800rf32" = ps: with ps; [ ]; # missing inputs: pyW800rf32
     "wake_on_lan" = ps: with ps; [ wakeonlan ];
-    "waqi" = ps: with ps; [ ]; # missing inputs: waqiasync
+    "waqi" = ps: with ps; [ waqiasync ];
     "water_heater" = ps: with ps; [ ];
     "waterfurnace" = ps: with ps; [ waterfurnace ];
     "watson_iot" = ps: with ps; [ ]; # missing inputs: ibmiotf

pkgs/servers/matrix-synapse/matrix-appservice-slack/default.nix

···
 
   meta = with lib; {
     description = "A Matrix <--> Slack bridge";
-    maintainers = with maintainers; [ kampka ];
+    maintainers = with maintainers; [ ];
     license = licenses.asl20;
   };
 }

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

···
     license = licenses.mit;
     homepage = "https://github.com/b4b4r07/history";
     platforms = platforms.unix;
-    maintainers = with maintainers; [ kampka ];
+    maintainers = with maintainers; [ ];
   };
 
   passthru.tests = {

pkgs/tools/graphics/gifski/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "gifski";
-  version = "1.2.4";
+  version = "1.2.6";
 
   src = fetchFromGitHub {
     owner = "ImageOptim";
     repo = "gifski";
     rev = version;
-    sha256 = "0mr4ni75klmzfjivfv5xmcdw03y1gjvkz1d297gwh46zq1q7blf3";
+    sha256 = "sha256-pnaNBjMKWfnCHG4MTLS2tJ2lrKxH6tcnvbOFZSDtPJY=";
   };
 
-  cargoSha256 = "0wm139lik6w2hwg72j8hcphp0z89bbabfxjmfyqrih6akyzb0l01";
+  cargoSha256 = "sha256-M5LEoEaWKT6nfQsnuqfyRBtDILewAxzMs7d6DvhkvFg=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/tools/misc/gammy/default.nix

···
 
 let
   pname = "gammy";
-  version = "0.9.59";
+  version = "0.9.62";
 in
 
 stdenv.mkDerivation {
···
     owner = "Fushko";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1iz41larqr6ss5kar1pds6zgcrch6ch34cr0ngd71gcaxal0rb72";
+    sha256 = "sha256-fyr+khLgaX5xbKCW3pqt6fFvZBHGEVs1BsMireZDxP0=";
   };
 
   nativeBuildInputs = [ qmake wrapQtAppsHook ];

pkgs/tools/networking/cassowary/default.nix

···
 
 buildGoModule rec {
   pname = "cassowary";
-  version = "0.11.0";
+  version = "0.12.0";
 
   src = fetchFromGitHub {
     owner = "rogerwelin";
     repo = pname;
     rev = "v${version}";
-    sha256 = "161wzcdq7kpny6fzxsqk2ivnah0xwmh2knv37jn0x18lclga1k9s";
+    sha256 = "sha256-HRshuMnRPMzatOYYI//yEtjC46kORGXaAWJJjLHW2+k=";
   };
 
-  vendorSha256 = "1qgilmkai9isbbg4pzqic6i8v5z8cay0ilw1gb69z4a6f2q4zhkp";
+  vendorSha256 = "sha256-d8JPsHBGkZ/MeoHTCLxi6JeNomER/0veWjqmqGal8eE=";
 
   doCheck = false;
 

pkgs/tools/networking/gandi-cli/default.nix

···
     description = "Command-line interface to the public Gandi.net API";
     homepage = "https://cli.gandi.net/";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ kampka ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/tools/networking/mosh/default.nix

···
 
   patches = [
     ./ssh_path.patch
+    ./mosh-client_path.patch
     ./utempter_path.patch
     # Fix w/c++17, ::bind vs std::bind
     (fetchpatch {
···
   postPatch = ''
     substituteInPlace scripts/mosh.pl \
         --subst-var-by ssh "${openssh}/bin/ssh"
+    substituteInPlace scripts/mosh.pl \
+        --subst-var-by mosh-client "$out/bin/mosh-client"
   '';
 
   configureFlags = [ "--enable-completion" ] ++ lib.optional withUtempter "--with-utempter";

pkgs/tools/networking/mosh/mosh-client_path.patch

···
+diff --git a/scripts/mosh.pl b/scripts/mosh.pl
+index 56e96d7..2a2177e 100755
+--- a/scripts/mosh.pl
++++ b/scripts/mosh.pl
+@@ -61,7 +61,7 @@ my $have_ipv6 = eval {
+ 
+ $|=1;
+ 
+-my $client = 'mosh-client';
++my $client = '@mosh-client@';
+ my $server = 'mosh-server';
+ 
+ my $predict = undef;
+@@ -91,7 +91,7 @@ my @cmdline = @ARGV;
+ my $usage =
+ qq{Usage: $0 [options] [--] [user@]host [command...]
+         --client=PATH        mosh client on local machine
+-                                (default: "mosh-client")
++                                (default: "@mosh-client@")
+         --server=COMMAND     mosh server on remote machine
+                                 (default: "mosh-server")
+ 

pkgs/tools/networking/ssh-ident/default.nix

···
-{ stdenv, lib, fetchFromGitHub, python3, makeWrapper, openssh }:
+{ stdenvNoCC, lib, fetchFromGitHub, python3, openssh}:
 
-stdenv.mkDerivation {
+stdenvNoCC.mkDerivation {
   pname = "ssh-ident";
   version = "2016-04-21";
   src = fetchFromGitHub  {
···
     sha256 = "1jf19lz1gwn7cyp57j8d4zs5bq13iw3kw31m8nvr8h6sib2pf815";
   };
 
-  buildInputs = [ python3 makeWrapper ];
+  postPatch = ''
+    substituteInPlace ssh-ident \
+      --replace 'ssh-agent >' '${openssh}/bin/ssh-agent >'
+  '';
+  buildInputs = [ python3 ];
+
   installPhase = ''
     mkdir -p $out/bin
     install -m 755 ssh-ident $out/bin/ssh-ident
-    wrapProgram $out/bin/ssh-ident \
-      --prefix PATH : ${lib.makeBinPath [ openssh  ]}
   '';
 
-  meta = {
+  meta = with lib; {
     homepage = "https://github.com/ccontavalli/ssh-ident";
     description = "Start and use ssh-agent and load identities as necessary";
-    license = lib.licenses.bsd2;
-    maintainers = with lib.maintainers; [ telotortium ];
-    platforms = with lib.platforms; unix;
+    license = licenses.bsd2;
+    maintainers = with maintainers; [ telotortium ];
+    platforms = with platforms; unix;
   };
 }

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "emplace";
-  version = "0.3.9";
+  version = "0.4.1";
 
   src = fetchFromGitHub {
     owner = "tversteeg";
     repo = pname;
     rev = "v${version}";
-    sha256 = "173nj6fx2l15shy7s4dngnfqsa10m7qwhi2ia2rr421l7b24ixqq";
+    sha256 = "sha256-iPfE2z98j93zqK2uZ8R+Fy2qNOCH9oCxHgeedvs/onY=";
   };
 
-  cargoSha256 = "0bjw3fvc430b1jxla25clr75c94p2ms7d94j72d8mirxsiklgsp9";
+  cargoSha256 = "sha256-62DHIIwloB+pPAZnOEfLJzAWrRJSxPp4IghBh6lRuc8=";
 
   meta = with lib; {
     description = "Mirror installed software on multiple machines";

pkgs/tools/security/bitwarden_rs/vault.nix

···
 
 stdenv.mkDerivation rec {
   pname = "bitwarden_rs-vault";
-  version = "2.16.1";
+  version = "2.17.1";
 
   src = fetchurl {
     url = "https://github.com/dani-garcia/bw_web_builds/releases/download/v${version}/bw_web_v${version}.tar.gz";
-    sha256 = "1c4fcf8jzgd6636wv903r5msc9z5l56l2i4k93kvb2zvg7qj014w";
+    sha256 = "1kd21higniszk1na5ag7q4g0l7h6ddl91gpbjbwym28hsbjvxla7";
   };
 
   buildCommand = ''

pkgs/tools/security/bypass403/default.nix

···
+{ buildGoModule
+, fetchFromGitHub
+, lib
+}:
+
+buildGoModule rec {
+  pname = "bypass403";
+  version = "1.4.0";
+
+  src = fetchFromGitHub {
+    owner = "drsigned";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1x3a4lnxjxbv80kaydy57809n9r7vzci9ki4f98smf3w04s86rcl";
+  };
+
+  vendorSha256 = "1bp6bf99rxlyg91pn1y228q18lawpykmvkl22cydmclms0q0n238";
+
+  meta = with lib; {
+    description = "Tool to bypass 403 Forbidden responses";
+    homepage = "https://github.com/drsigned/bypass403";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/tools/security/corsmisc/default.nix

···
+{ buildGoModule
+, fetchFromGitHub
+, lib
+}:
+
+buildGoModule rec {
+  pname = "corsmisc";
+  version = "1.3.0";
+
+  src = fetchFromGitHub {
+    owner = "drsigned";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "18a70v093jl85vnih80i50wvac8hsg3f2gmcws9jyhj2brndq2qj";
+  };
+
+  vendorSha256 = "1bp6bf99rxlyg91pn1y228q18lawpykmvkl22cydmclms0q0n238";
+
+  meta = with lib; {
+    description = "Tool to discover CORS misconfigurations vulnerabilities";
+    homepage = "https://github.com/drsigned/corsmisc";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/tools/security/gospider/default.nix

···
 
 buildGoModule rec {
   pname = "gospider";
-  version = "1.1.4";
+  version = "1.1.5";
 
   src = fetchFromGitHub {
     owner = "jaeles-project";
     repo = pname;
     rev = version;
-    sha256 = "03gl8y2047iwa6bhmayyds3li21wy3sw1x4hpp9zgqgi95039q86";
+    sha256 = "sha256-yfW94sQzT1u6O0s1sqpeANlukC5y8fNvHNL2c77+dxU=";
   };
 
-  vendorSha256 = "0dc4ddi26i38c5rvy9zbal27a7qvn17h64w1yhbig4iyb79b18ym";
+  vendorSha256 = "sha256-1aOw0lk+khcX9IETA0+wGx91BFXrJ79zYWhEI2JrhDU=";
 
   # tests require internet access and API keys
   doCheck = false;

pkgs/top-level/all-packages.nix

···
 
   coolreader = libsForQt5.callPackage ../applications/misc/coolreader {};
 
+  corsmisc = callPackage ../tools/security/corsmisc { };
+
   cozy = callPackage ../applications/audio/cozy-audiobooks { };
 
   cpuid = callPackage ../os-specific/linux/cpuid { };
···
     # Choices: [ tmux screen ];
     textual-window-manager = tmux;
   };
+
+  bypass403 = callPackage ../tools/security/bypass403 { };
 
   bsh = fetchurl {
     url = "http://www.beanshell.org/bsh-2.0b5.jar";
···
 
   lxrandr = callPackage ../desktops/lxde/core/lxrandr { };
 
+  lxsession = callPackage ../desktops/lxde/core/lxsession { };
+
   kona = callPackage ../development/interpreters/kona {};
 
   lolcode = callPackage ../development/interpreters/lolcode { };
···
   backward-cpp = callPackage ../development/libraries/backward-cpp { };
 
   bamf = callPackage ../development/libraries/bamf { };
+
+  inherit (callPackages ../development/libraries/bashup-events { }) bashup-events32 bashup-events44;
 
   bcg729 = callPackage ../development/libraries/bcg729 { };
 
···
 
   hdhomerun-config-gui = callPackage ../applications/video/hdhomerun-config-gui { };
 
+  hdr-plus = callPackage ../applications/graphics/hdr-plus {
+    stdenv = clangStdenv;
+  };
+
   heimer = libsForQt5.callPackage ../applications/misc/heimer { };
 
   hello = callPackage ../applications/misc/hello { };
···
   mediainfo-gui = callPackage ../applications/misc/mediainfo-gui { };
 
   mediathekview = callPackage ../applications/video/mediathekview { };
+
+  megapixels = callPackage ../applications/graphics/megapixels { };
 
   meteo = callPackage ../applications/networking/weather/meteo { };
 
···
     desktopSupport = "xfce4";
   };
 
+  xmountains = callPackage ../applications/graphics/xmountains { };
+
   xmpp-client = callPackage ../applications/networking/instant-messengers/xmpp-client { };
 
   libxpdf = callPackage ../applications/misc/xpdf/libxpdf.nix { };
···
   quake3demodata = callPackage ../games/quake3/content/demo.nix { };
 
   quake3pointrelease = callPackage ../games/quake3/content/pointrelease.nix { };
+
+  quake3hires = callPackage ../games/quake3/content/hires.nix { };
 
   quakespasm = callPackage ../games/quakespasm { };
   vkquake = callPackage ../games/quakespasm/vulkan.nix { };

pkgs/top-level/python-packages.nix

···
 
   warrant = callPackage ../development/python-modules/warrant { };
 
+  waqiasync = callPackage ../development/python-modules/waqiasync { };
+
   wasabi = callPackage ../development/python-modules/wasabi { };
 
   wasm = callPackage ../development/python-modules/wasm { };