Merge branch 'master' into staging-next

nixos/lib/make-system-tarball.nix

···
-{ stdenv, perl, pixz, pathsFromGraph
+{ stdenv, closureInfo, pixz
 
 , # The file name of the resulting tarball
   fileName ? "nixos-system-${stdenv.hostPlatform.system}"
···
 , extraInputs ? [ pixz ]
 }:
 
+let
+  symlinks = map (x: x.symlink) storeContents;
+  objects = map (x: x.object) storeContents;
+in
+
 stdenv.mkDerivation {
   name = "tarball";
   builder = ./make-system-tarball.sh;
-  buildInputs = [ perl ] ++ extraInputs;
+  buildInputs = extraInputs;
 
-  inherit fileName pathsFromGraph extraArgs extraCommands compressCommand;
+  inherit fileName extraArgs extraCommands compressCommand;
 
   # !!! should use XML.
   sources = map (x: x.source) contents;
   targets = map (x: x.target) contents;
 
   # !!! should use XML.
-  objects = map (x: x.object) storeContents;
-  symlinks = map (x: x.symlink) storeContents;
+  inherit symlinks objects;
 
-  # For obtaining the closure of `storeContents'.
-  exportReferencesGraph =
-    map (x: [("closure-" + baseNameOf x.object) x.object]) storeContents;
+  closureInfo = closureInfo {
+    rootPaths = objects;
+  };
 
   extension = compressionExtension;
 }

nixos/lib/make-system-tarball.sh

···
 sources_=($sources)
 targets_=($targets)
 
-echo $objects
 objects=($objects)
 symlinks=($symlinks)
 
···
     res="$1"
     if test "${res:0:1}" = /; then res=${res:1}; fi
 }
-
-touch pathlist
 
 # Add the individual files.
 for ((i = 0; i < ${#targets_[@]}; i++)); do
···
 
 
 # Add the closures of the top-level store objects.
+chmod +w .
 mkdir -p nix/store
-storePaths=$(perl $pathsFromGraph closure-*)
-for i in $storePaths; do
+for i in $(< $closureInfo/store-paths); do
     cp -a "$i" "${i:1}"
 done
 
···
 # TODO tar ruxo
 # Also include a manifest of the closures in a format suitable for
 # nix-store --load-db.
-printRegistration=1 perl $pathsFromGraph closure-* > nix-path-registration
+cp $closureInfo/registration nix-path-registration
 
 # Add symlinks to the top-level store objects.
 for ((n = 0; n < ${#objects[*]}; n++)); do

nixos/modules/hardware/raid/hpsa.nix

···
     version = "2.40-13.0";
 
     src = pkgs.fetchurl {
-      url = "http://downloads.linux.hpe.com/SDR/downloads/MCP/Ubuntu/pool/non-free/${name}_amd64.deb";
+      url = "https://downloads.linux.hpe.com/SDR/downloads/MCP/Ubuntu/pool/non-free/${name}_amd64.deb";
       sha256 = "11w7fwk93lmfw0yya4jpjwdmgjimqxx6412sqa166g1pz4jil4sw";
     };
 
···
 
     meta = with lib; {
       description = "HP Smart Array CLI";
-      homepage = http://downloads.linux.hpe.com/SDR/downloads/MCP/Ubuntu/pool/non-free/;
+      homepage = https://downloads.linux.hpe.com/SDR/downloads/MCP/Ubuntu/pool/non-free/;
       license = licenses.unfreeRedistributable;
       platforms = [ "x86_64-linux" ];
       maintainers = with maintainers; [ volth ];

nixos/modules/misc/ids.nix

···
       dnsmasq = 141;
       uhub = 142;
       yandexdisk = 143;
-      #collectd = 144; #unused
+      mxisd = 144; # was once collectd
       consul = 145;
       mailpile = 146;
       redmine = 147;
···
       #dnsmasq = 141; # unused
       uhub = 142;
       #yandexdisk = 143; # unused
-      #collectd = 144; # unused
+      mxisd = 144; # was once collectd
       #consul = 145; # unused
       mailpile = 146;
       redmine = 147;

nixos/modules/module-list.nix

···
   ./services/networking/miredo.nix
   ./services/networking/mstpd.nix
   ./services/networking/murmur.nix
+  ./services/networking/mxisd.nix
   ./services/networking/namecoind.nix
   ./services/networking/nat.nix
   ./services/networking/ndppd.nix

nixos/modules/profiles/docker-container.nix

···
 
   # Create the tarball
   system.build.tarball = pkgs.callPackage ../../lib/make-system-tarball.nix {
-    contents = [];
+    contents = [
+      {
+        source = "${config.system.build.toplevel}/.";
+        target = "./";
+      }
+    ];
     extraArgs = "--owner=0";
 
     # Add init script to image
-    storeContents = [
-      { object = config.system.build.toplevel + "/init";
-        symlink = "/init";
-      }
-    ] ++ (pkgs2storeContents [ pkgs.stdenv ]);
+    storeContents = pkgs2storeContents [
+      config.system.build.toplevel
+      pkgs.stdenv
+    ];
 
     # Some container managers like lxc need these
     extraCommands = "mkdir -p proc sys dev";

nixos/modules/profiles/hardened.nix

···
 
   boot.kernelPackages = mkDefault pkgs.linuxPackages_hardened;
 
+  nix.allowedUsers = mkDefault [ "@users" ];
+
   security.hideProcessInformation = mkDefault true;
 
   security.lockKernelModules = mkDefault true;

nixos/modules/services/mail/rspamd.nix

···
       else "${config.socket}${maybeOption "mode"}${maybeOption "owner"}${maybeOption "group"}";
   };
 
-  workerOpts = { name, ... }: {
+  traceWarning = w: x: builtins.trace "warning: ${w}" x;
+
+  workerOpts = { name, options, ... }: {
     options = {
       enable = mkOption {
         type = types.nullOr types.bool;
···
       };
       type = mkOption {
         type = types.nullOr (types.enum [
-          "normal" "controller" "fuzzy_storage" "rspamd_proxy" "lua"
+          "normal" "controller" "fuzzy_storage" "rspamd_proxy" "lua" "proxy"
         ]);
-        description = "The type of this worker";
+        description = ''
+          The type of this worker. The type <literal>proxy</literal> is
+          deprecated and only kept for backwards compatibility and should be
+          replaced with <literal>rspamd_proxy</literal>.
+        '';
+        apply = let
+            from = "services.rspamd.workers.\”${name}\".type";
+            files = options.type.files;
+            warning = "The option `${from}` defined in ${showFiles files} has enum value `proxy` which has been renamed to `rspamd_proxy`";
+          in x: if x == "proxy" then traceWarning warning "rspamd_proxy" else x;
       };
       bindSockets = mkOption {
         type = types.listOf (types.either types.str (types.submodule bindSocketOpts));

nixos/modules/services/monitoring/apcupsd.nix

···
       serviceConfig = {
         Type = "oneshot";
         ExecStart = "${pkgs.apcupsd}/bin/apcupsd --killpower -f ${configFile}";
-        TimeoutSec = 0;
+        TimeoutSec = "infinity";
         StandardOutput = "tty";
         RemainAfterExit = "yes";
       };

nixos/modules/services/monitoring/osquery.nix

···
         mkdir -p "$(dirname ${escapeShellArg cfg.databasePath})"
       '';
       serviceConfig = {
-        TimeoutStartSec = 0;
+        TimeoutStartSec = "infinity";
         ExecStart = "${pkgs.osquery}/bin/osqueryd --logger_path ${escapeShellArg cfg.loggerPath} --pidfile ${escapeShellArg cfg.pidfile} --database_path ${escapeShellArg cfg.databasePath}";
         KillMode = "process";
         KillSignal = "SIGTERM";

nixos/modules/services/monitoring/systemhealth.nix

···
   systemhealth = with pkgs; stdenv.mkDerivation {
     name = "systemhealth-1.0";
     src = fetchurl {
-      url = "http://www.brianlane.com/static/downloads/systemhealth/systemhealth-1.0.tar.bz2";
+      url = "https://www.brianlane.com/downloads/systemhealth/systemhealth-1.0.tar.bz2";
       sha256 = "1q69lz7hmpbdpbz36zb06nzfkj651413n9icx0njmyr3xzq1j9qy";
     };
     buildInputs = [ python ];

nixos/modules/services/networking/consul.nix

···
           PermissionsStartOnly = true;
           User = if cfg.dropPrivileges then "consul" else null;
           Restart = "on-failure";
-          TimeoutStartSec = "0";
+          TimeoutStartSec = "infinity";
         } // (optionalAttrs (cfg.leaveOnStop) {
           ExecStop = "${cfg.package.bin}/bin/consul leave";
         });

nixos/modules/services/networking/flashpolicyd.nix

···
 
     src = pkgs.fetchurl {
       name = "flashpolicyd_v0.6.zip";
-      url = "http://www.adobe.com/content/dotcom/en/devnet/flashplayer/articles/socket_policy_files/_jcr_content/articlePrerequistes/multiplefiles/node_1277808777771/file.res/flashpolicyd_v0.6%5B1%5D.zip";
+      url = "https://download.adobe.com/pub/adobe/devnet/flashplayer/articles/socket_policy_files/flashpolicyd_v0.6.zip";
       sha256 = "16zk237233npwfq1m4ksy4g5lzy1z9fp95w7pz0cdlpmv0fv9sm3";
     };
 
···
   ###### interface
 
   options = {
-  
+
     services.flashpolicyd = {
-    
+
       enable = mkOption {
         default = false;
         description =
···
             connections to your server.
           '';
       };
-      
+
       policy = mkOption {
         default =
           ''
             <?xml version="1.0"?>
             <!DOCTYPE cross-domain-policy SYSTEM "/xml/dtds/cross-domain-policy.dtd">
-            <cross-domain-policy> 
+            <cross-domain-policy>
               <site-control permitted-cross-domain-policies="master-only"/>
               <allow-access-from domain="*" to-ports="*" />
             </cross-domain-policy>

nixos/modules/services/networking/mxisd.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.mxisd;
+
+  server = optionalAttrs (cfg.server.name != null) { inherit (cfg.server) name; }
+        // optionalAttrs (cfg.server.port != null) { inherit (cfg.server) port; };
+
+  baseConfig = {
+    matrix.domain = cfg.matrix.domain;
+    key.path = "${cfg.dataDir}/signing.key";
+    storage = {
+      provider.sqlite.database = "${cfg.dataDir}/mxisd.db";
+    };
+  } // optionalAttrs (server != {}) { inherit server; };
+
+  # merges baseConfig and extraConfig into a single file
+  fullConfig = recursiveUpdate baseConfig cfg.extraConfig;
+
+  configFile = pkgs.writeText "mxisd-config.yaml" (builtins.toJSON fullConfig);
+
+in {
+  options = {
+    services.mxisd = {
+      enable = mkEnableOption "mxisd matrix federated identity server";
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.mxisd;
+        defaultText = "pkgs.mxisd";
+        description = "The mxisd package to use";
+      };
+
+      dataDir = mkOption {
+        type = types.str;
+        default = "/var/lib/mxisd";
+        description = "Where data mxisd uses resides";
+      };
+
+      extraConfig = mkOption {
+        type = types.attrs;
+        default = {};
+        description = "Extra options merged into the mxisd configuration";
+      };
+
+      matrix = {
+
+        domain = mkOption {
+          type = types.str;
+          description = ''
+            the domain of the matrix homeserver
+          '';
+        };
+
+      };
+
+      server = {
+
+        name = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''
+            Public hostname of mxisd, if different from the Matrix domain.
+          '';
+        };
+
+        port = mkOption {
+          type = types.nullOr types.int;
+          default = null;
+          description = ''
+            HTTP port to listen on (unencrypted)
+          '';
+        };
+
+      };
+
+    };
+  };
+
+  config = mkIf cfg.enable {
+    users.users = [
+      {
+        name = "mxisd";
+        group = "mxisd";
+        home = cfg.dataDir;
+        createHome = true;
+        shell = "${pkgs.bash}/bin/bash";
+        uid = config.ids.uids.mxisd;
+      }
+    ];
+
+    users.groups = [
+      {
+        name = "mxisd";
+        gid = config.ids.gids.mxisd;
+      }
+    ];
+
+    systemd.services.mxisd = {
+      description = "a federated identity server for the matrix ecosystem";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+
+      # mxisd / spring.boot needs the configuration to be named "application.yaml"
+      preStart = ''
+        config=${cfg.dataDir}/application.yaml
+        cp ${configFile} $config
+        chmod 444 $config
+      '';
+
+      serviceConfig = {
+        Type = "simple";
+        User = "mxisd";
+        Group = "mxisd";
+        ExecStart = "${cfg.package}/bin/mxisd --spring.config.location=${cfg.dataDir}/ --spring.profiles.active=systemd --java.security.egd=file:/dev/./urandom";
+        WorkingDirectory = cfg.dataDir;
+        PermissionsStartOnly = true;
+        SuccessExitStatus = 143;
+        Restart = "on-failure";
+      };
+    };
+  };
+}

nixos/modules/services/security/tor.nix

···
   # Hidden services
   + concatStrings (flip mapAttrsToList cfg.hiddenServices (n: v: ''
     HiddenServiceDir ${torDirectory}/onion/${v.name}
+    ${optionalString (v.version != null) "HiddenServiceVersion ${toString v.version}"}
     ${flip concatMapStrings v.map (p: ''
       HiddenServicePort ${toString p.port} ${p.destination}
     '')}
···
                    };
                  };
                }));
+             };
+
+             version = mkOption {
+               default = null;
+               description = "Rendezvous service descriptor version to publish for the hidden service. Currently, versions 2 and 3 are supported. (Default: 2)";
+               type = types.nullOr (types.enum [ 2 3 ]);
              };
           };
 

nixos/modules/services/system/cloud-init.nix

···
           { Type = "oneshot";
             ExecStart = "${pkgs.cloud-init}/bin/cloud-init init --local";
             RemainAfterExit = "yes";
-            TimeoutSec = "0";
+            TimeoutSec = "infinity";
             StandardOutput = "journal+console";
           };
       };
···
           { Type = "oneshot";
             ExecStart = "${pkgs.cloud-init}/bin/cloud-init init";
             RemainAfterExit = "yes";
-            TimeoutSec = "0";
+            TimeoutSec = "infinity";
             StandardOutput = "journal+console";
           };
       };
···
           { Type = "oneshot";
             ExecStart = "${pkgs.cloud-init}/bin/cloud-init modules --mode=config";
             RemainAfterExit = "yes";
-            TimeoutSec = "0";
+            TimeoutSec = "infinity";
             StandardOutput = "journal+console";
           };
       };
···
           { Type = "oneshot";
             ExecStart = "${pkgs.cloud-init}/bin/cloud-init modules --mode=final";
             RemainAfterExit = "yes";
-            TimeoutSec = "0";
+            TimeoutSec = "infinity";
             StandardOutput = "journal+console";
           };
       };

nixos/modules/services/web-servers/apache-httpd/mediawiki.nix

···
     name= "mediawiki-1.29.1";
 
     src = pkgs.fetchurl {
-      url = "http://download.wikimedia.org/mediawiki/1.29/${name}.tar.gz";
+      url = "https://releases.wikimedia.org/mediawiki/1.29/${name}.tar.gz";
       sha256 = "03mpazbxvb011s2nmlw5p6dc43yjgl5yrsilmj1imyykm57bwb3m";
     };
 
···
       description = ''
         Any additional text to be appended to MediaWiki's
         configuration file.  This is a PHP script.  For configuration
-        settings, see <link xlink:href='http://www.mediawiki.org/wiki/Manual:Configuration_settings'/>.
+        settings, see <link xlink:href='https://www.mediawiki.org/wiki/Manual:Configuration_settings'/>.
       '';
     };
 

nixos/modules/virtualisation/docker-image.nix

···
   # Socket activated ssh presents problem in Docker.
   services.openssh.startWhenNeeded = false;
 }
+
+# Example usage:
+#
+## default.nix
+# let
+#   nixos = import <nixpkgs/nixos> {
+#     configuration = ./configuration.nix;
+#     system = "x86_64-linux";
+#   };
+# in
+# nixos.config.system.build.tarball
+#
+## configuration.nix
+# { pkgs, config, lib, ... }:
+# {
+#   imports = [
+#     <nixpkgs/nixos/modules/virtualisation/docker-image.nix>
+#     <nixpkgs/nixos/modules/installer/cd-dvd/channel.nix>
+#   ];
+#
+#   documentation.doc.enable = false;
+#
+#   environment.systemPackages = with pkgs; [
+#     bashInteractive
+#     cacert
+#     nix
+#   ];
+# }
+#
+## Run
+# Build the tarball:
+# $ nix-build default.nix
+# Load into docker:
+# $ docker import result/tarball/nixos-system-*.tar.xz nixos-docker
+# Boots into systemd
+# $ docker run --privileged -it nixos-docker /init
+# Log into the container
+# $ docker exec -it <container-name> /run/current-system/sw/bin/bash

nixos/modules/virtualisation/google-compute-image.nix

···
       ExecStop = "${gce}/bin/google_metadata_script_runner --debug --script-type shutdown";
       Type = "oneshot";
       RemainAfterExit = true;
-      TimeoutStopSec = 0;
+      TimeoutStopSec = "infinity";
     };
   };
 

nixos/tests/hardened.nix

···
     { users.users.alice = { isNormalUser = true; extraGroups = [ "proc" ]; };
       users.users.sybil = { isNormalUser = true; group = "wheel"; };
       imports = [ ../modules/profiles/hardened.nix ];
+      nix.useSandbox = false;
       virtualisation.emptyDiskImages = [ 4096 ];
       boot.initrd.postDeviceCommands = ''
         ${pkgs.dosfstools}/bin/mkfs.vfat -n EFISYS /dev/vdb
···
         $machine->execute("mkdir -p /efi");
         $machine->succeed("mount /dev/disk/by-label/EFISYS /efi");
         $machine->succeed("mountpoint -q /efi"); # now mounted
+      };
+
+      # Test Nix dæmon usage
+      subtest "nix-daemon", sub {
+        $machine->fail("su -l nobody -s /bin/sh -c 'nix ping-store'");
+        $machine->succeed("su -l alice -c 'nix ping-store'") =~ "OK";
       };
     '';
 })

nixos/tests/mxisd.nix

···
+import ./make-test.nix ({ pkgs, ... } : {
+
+  name = "mxisd";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ mguentner ];
+  };
+
+  nodes = {
+    server_mxisd = args : {
+      services.mxisd.enable = true;
+      services.mxisd.matrix.domain = "example.org";
+    };
+  };
+
+  testScript = ''
+    startAll;
+    $server_mxisd->waitForUnit("mxisd.service");
+    $server_mxisd->waitForOpenPort(8090);
+    $server_mxisd->succeed("curl -Ssf \"http://127.0.0.1:8090/_matrix/identity/api/v1\"")
+  '';
+})

nixos/tests/rspamd.nix

···
       services.rspamd = {
         enable = true;
         postfix.enable = true;
+        workers.rspamd_proxy.type = "proxy";
       };
     };
     testScript = ''

pkgs/applications/audio/a2jmidid/default.nix

···
   version = "8";
 
   src = fetchurl {
-    url = "http://repo.or.cz/a2jmidid.git/snapshot/7383d268c4bfe85df9f10df6351677659211d1ca.tar.gz";
+    url = "https://repo.or.cz/a2jmidid.git/snapshot/7383d268c4bfe85df9f10df6351677659211d1ca.tar.gz";
     sha256 = "06dgf5655znbvrd7fhrv8msv6zw8vk0hjqglcqkh90960mnnmwz7";
   };
 
-  nativeBuildInputs = [ pkgconfig wafHook ];
-  buildInputs = [ makeWrapper alsaLib dbus libjack2 python dbus-python ];
+  nativeBuildInputs = [ pkgconfig makeWrapper wafHook ];
+  buildInputs = [ alsaLib dbus libjack2 python dbus-python ];
 
   postInstall = ''
     wrapProgram $out/bin/a2j_control --set PYTHONPATH $PYTHONPATH

pkgs/applications/audio/cadence/default.nix

···
 { stdenv
-, fetchurl
+, fetchzip
 , pkgconfig
 , qtbase
 , makeWrapper
···
   version = "0.9.0";
   pname = "cadence";
 
-  src = fetchurl {
+  src = fetchzip {
     url = "https://github.com/falkTX/Cadence/archive/v${version}.tar.gz";
-    sha256 = "07z1mnb0bmldb3i31bgw816pnvlvr9gawr51rpx3mhixg5wpiqzb";
+    sha256 = "08vcggypkdfr70v49innahs5s11hi222dhhnm5wcqzdgksphqzwx";
   };
 
-  buildInputs = [
-    makeWrapper
-    pkgconfig
-    qtbase
-  ];
-
-  apps = [
-    "cadence"
-    "cadence-jacksettings"
-    "cadence-pulse2loopback"
-    "claudia"
-    "cadence-aloop-daemon"
-    "cadence-logs"
-    "cadence-render"
-    "catarina"
-    "claudia-launcher"
-    "cadence-pulse2jack"
-    "cadence-session-start"
-    "catia"
-  ];
+  nativeBuildInputs = [ makeWrapper pkgconfig ];
+  buildInputs = [ qtbase ];
 
   makeFlags = ''
     PREFIX=""
···
   propagatedBuildInputs = with python3Packages; [ pyqt5 ];
 
   postInstall = ''
-    # replace with our own wrappers.
-    for app in $apps; do
-      rm $out/bin/$app
-      makeWrapper ${python3Packages.python.interpreter} $out/bin/$app \
-        --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
-        --add-flags "-O $out/share/cadence/src/$app.py"
-    done
+    # replace with our own wrappers. They need to be changed manually since it wouldn't work otherwise
+    rm $out/bin/cadence
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/cadence \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/cadence.py"
+    rm $out/bin/claudia
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/claudia \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/claudia.py"
+    rm $out/bin/catarina
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/catarina \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/catarina.py"
+    rm $out/bin/catia
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/catia \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/catia.py"
+    rm $out/bin/cadence-jacksettings
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/cadence-jacksettings \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/jacksettings.py"
+    rm $out/bin/cadence-aloop-daemon
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/cadence-aloop-daemon \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/cadence_aloop_daemon.py"
+    rm $out/bin/cadence-logs
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/cadence-logs \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/logs.py"
+    rm $out/bin/cadence-render
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/cadence-render \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/render.py"
+    rm $out/bin/claudia-launcher
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/claudia-launcher \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/claudia_launcher.py"
+    rm $out/bin/cadence-session-start
+    makeWrapper ${python3Packages.python.interpreter} $out/bin/cadence-session-start \
+      --set PYTHONPATH "$PYTHONPATH:$out/share/cadence" \
+      --add-flags "-O $out/share/cadence/src/cadence_session_start.py"
   '';
 
   meta = {
     homepage = https://github.com/falkTX/Cadence/;
     description = "Collection of tools useful for audio production";
-    license = stdenv.lib.licenses.mit;
+    license = stdenv.lib.licenses.gpl2Plus;
     maintainers = with stdenv.lib.maintainers; [ genesis ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = [ "x86_64-linux" ];
   };
 }

pkgs/applications/audio/renoise/default.nix

···
-{ stdenv, fetchurl, libX11, libXext, libXcursor, libXrandr, libjack2, alsaLib, releasePath ? null }:
+{ stdenv, fetchurl, libX11, libXext, libXcursor, libXrandr, libjack2, alsaLib,
+  mpg123, makeWrapper, releasePath ? null }:
 
 with stdenv.lib;
 
···
         releasePath
     else throw "Platform is not supported by Renoise";
 
+  nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ libX11 libXext libXcursor libXrandr alsaLib libjack2 ];
 
   installPhase = ''
···
     ln -s $out/renoise $out/bin/renoise
 
     patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath $out/lib $out/renoise
+    wrapProgram "$out/renoise" --prefix LD_LIBRARY_PATH : "${mpg123}/lib"
   '';
 
   meta = {
     description = "Modern tracker-based DAW";
-    homepage = http://www.renoise.com/;
+    homepage = https://www.renoise.com/;
     license = licenses.unfree;
     maintainers = [];
     platforms = [ "i686-linux" "x86_64-linux" ];

pkgs/applications/audio/seq24/default.nix

···
   version = "0.9.3";
 
   src = fetchurl {
-    url = "http://launchpad.net/seq24/trunk/${version}/+download/${name}.tar.gz";
+    url = "https://launchpad.net/seq24/trunk/${version}/+download/${name}.tar.gz";
     sha256 = "1qpyb7355s21sgy6gibkybxpzx4ikha57a8w644lca6qy9mhcwi3";
   };
 

pkgs/applications/audio/synthv1/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "synthv1-${version}";
-  version = "0.9.2";
+  version = "0.9.3";
 
   src = fetchurl {
     url = "mirror://sourceforge/synthv1/${name}.tar.gz";
-    sha256 = "1r60l286n8y4a4rrlnbc3h7xk4s2pvqykvskls89prxg0lkpz7kl";
+    sha256 = "0f58k5n2k667q8wsigg7bzl3lfgaf6jdj98r2a5nvyb18v1wpy2c";
   };
 
   buildInputs = [ qt5.qtbase qt5.qttools libjack2 alsaLib liblo lv2 ];
···
 
   meta = with stdenv.lib; {
     description = "An old-school 4-oscillator subtractive polyphonic synthesizer with stereo fx";
-    homepage = http://synthv1.sourceforge.net/;
+    homepage = https://synthv1.sourceforge.io/;
     license = licenses.gpl2Plus;
     platforms = platforms.linux;
     maintainers = [ maintainers.goibhniu ];

pkgs/applications/audio/transcribe/default.nix

···
-{ stdenv, fetchzip, lib, makeWrapper, alsaLib, atk, cairo, gdk_pixbuf
-, glib, gst-ffmpeg, gst-plugins-bad, gst-plugins-base
-, gst-plugins-good, gst-plugins-ugly, gstreamer, gtk2, libSM, libX11
-, libpng12, pango, zlib }:
+{ stdenv, fetchzip, wrapGAppsHook, alsaLib, atk, cairo, gdk_pixbuf
+, glib, gst_all_1,  gtk3, libSM, libX11, libpng12, pango, zlib }:
 
 stdenv.mkDerivation rec {
   name = "transcribe-${version}";
-  version = "8.40";
+  version = "8.72";
 
   src = if stdenv.hostPlatform.system == "i686-linux" then
     fetchzip {
-      url = "https://www.seventhstring.com/xscribe/downlinux32_old/xscsetup.tar.gz";
-      sha256 = "1ngidmj9zz8bmv754s5xfsjv7v6xr03vck4kigzq4bpc9b1fdhjq";
+      url = "https://www.seventhstring.com/xscribe/downlinux32/xscsetup.tar.gz";
+      sha256 = "1h5l7ry9c9awpxfnd29b0wm973ifrhj17xl5d2fdsclw2swsickb";
     }
   else if stdenv.hostPlatform.system == "x86_64-linux" then
     fetchzip {
-      url = "https://www.seventhstring.com/xscribe/downlinux64_old/xsc64setup.tar.gz";
-      sha256 = "0svzi8svj6zn06gj0hr8mpnhq4416dvb4g5al0gpb1g3paywdaf9";
+      url = "https://www.seventhstring.com/xscribe/downlinux64/xsc64setup.tar.gz";
+      sha256 = "1rpd3ppnx5i5yrnfbjrx7h7dk48kwl99i9lnpa75ap7nxvbiznm0";
     }
   else throw "Platform not supported";
 
-  nativeBuildInputs = [ makeWrapper ];
+  nativeBuildInputs = [ wrapGAppsHook ];
 
-  buildInputs = [ gst-plugins-base gst-plugins-good
-    gst-plugins-bad gst-plugins-ugly gst-ffmpeg ];
+  buildInputs = with gst_all_1; [ gst-plugins-base gst-plugins-good
+    gst-plugins-bad gst-plugins-ugly ];
 
   dontPatchELF = true;
 
-  libPath = lib.makeLibraryPath [
-    stdenv.cc.cc glib gtk2 atk pango cairo gdk_pixbuf alsaLib
+  libPath = with gst_all_1; stdenv.lib.makeLibraryPath [
+    stdenv.cc.cc glib gtk3 atk pango cairo gdk_pixbuf alsaLib
     libX11 libSM libpng12 gstreamer gst-plugins-base zlib
   ];
 
···
     patchelf \
       --set-interpreter $(cat ${stdenv.cc}/nix-support/dynamic-linker) \
       $out/libexec/transcribe
+  '';
 
-    wrapProgram $out/libexec/transcribe \
-      --prefix GST_PLUGIN_SYSTEM_PATH : "$GST_PLUGIN_SYSTEM_PATH" \
+  preFixup = ''
+    gappsWrapperArgs+=(
+      --prefix GST_PLUGIN_SYSTEM_PATH : "$GST_PLUGIN_SYSTEM_PATH_1_0"
       --prefix LD_LIBRARY_PATH : "${libPath}"
+    )
+  '';
 
+  postFixup = ''
     ln -s $out/libexec/transcribe $out/bin/
-    '';
+  '';
 
   meta = with stdenv.lib; {
     description = "Software to help transcribe recorded music";

pkgs/applications/editors/monodevelop/default.nix

···
   };
 
   nunit2510 = fetchurl {
-    url = "http://launchpad.net/nunitv2/2.5/2.5.10/+download/NUnit-2.5.10.11092.zip";
+    url = "https://launchpad.net/nunitv2/2.5/2.5.10/+download/NUnit-2.5.10.11092.zip";
     sha256 = "0k5h5bz1p2v3d0w0hpkpbpvdkcszgp8sr9ik498r1bs72w5qlwnc";
   };
 

pkgs/applications/graphics/deskew/default.nix

···
+{ stdenv, fetchFromBitbucket, libtiff, fpc }:
+
+stdenv.mkDerivation rec {
+
+  name = "deskew-${version}";
+  version = "1.25";
+
+  src = fetchFromBitbucket {
+    owner = "galfar";
+    repo = "app-deskew";
+    rev = "v${version}";
+    sha256 = "0zjjj66qhgqkmfxl3q7p78dv4xl4ci918pgl4d5259pqdj1bfgc8";
+  };
+
+  nativeBuildInputs = [ fpc ];
+  buildInputs = [ libtiff ];
+
+  buildPhase = ''
+    rm -r Bin # Remove pre-compiled binary
+    mkdir Bin
+    chmod +x compile.sh
+    ./compile.sh
+  '';
+
+  installPhase = ''
+    install -Dt $out/bin Bin/*
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A command line tool for deskewing scanned text documents";
+    homepage = https://bitbucket.org/galfar/app-deskew/overview;
+    license = licenses.mit;
+    maintainers = with maintainers; [ryantm];
+    platforms = platforms.all;
+  };
+
+}

pkgs/applications/misc/llpp/default.nix

···
   '';
 
   meta = with stdenv.lib; {
-    homepage = http://repo.or.cz/w/llpp.git;
+    homepage = https://repo.or.cz/w/llpp.git;
     description = "A MuPDF based PDF pager written in OCaml";
     platforms = platforms.linux;
     maintainers = with maintainers; [ pSub ];

pkgs/applications/misc/mako/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mako-${version}";
-  version = "1.1";
+  version = "1.2";
 
   src = fetchFromGitHub {
     owner = "emersion";
     repo = "mako";
     rev = "v${version}";
-    sha256 = "18krsyp9g6f689024dn1mq8dyj4yg8c3kcy5s88q1gm8py6c4493";
+    sha256 = "112b7s5bkvwlgsm2kng2vh8mn6wr3a6c7n1arl9adxlghdym449h";
   };
 
   nativeBuildInputs = [ meson ninja pkgconfig scdoc ];

pkgs/applications/misc/nnn/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "nnn-${version}";
-  version = "2.0";
+  version = "2.1";
 
   src = fetchFromGitHub {
     owner = "jarun";
     repo = "nnn";
     rev = "v${version}";
-    sha256 = "16c6fimr1ayb2x3mvli70x2va3nz106jdfyqn53bhss7zjqvszxl";
+    sha256 = "1vkrhsdwgacln335rjywdf7nj7fg1x55szmm8xrvwda8y2qjqhc4";
   };
 
   configFile = optionalString (conf!=null) (builtins.toFile "nnn.h" conf);

pkgs/applications/misc/pinfo/default.nix

···
 
   src = fetchurl {
     # homepage needed you to login to download the tarball
-    url = "http://src.fedoraproject.org/repo/pkgs/pinfo/pinfo-0.6.10.tar.bz2"
+    url = "https://src.fedoraproject.org/repo/pkgs/pinfo/pinfo-0.6.10.tar.bz2"
       + "/fe3d3da50371b1773dfe29bf870dbc5b/pinfo-0.6.10.tar.bz2";
     sha256 = "0p8wyrpz9npjcbx6c973jspm4c3xz4zxx939nngbq49xqah8088j";
   };

pkgs/applications/misc/sakura/default.nix

···
   version = "3.6.0";
 
   src = fetchurl {
-    url = "http://launchpad.net/sakura/trunk/${version}/+download/${name}.tar.bz2";
+    url = "https://launchpad.net/sakura/trunk/${version}/+download/${name}.tar.bz2";
     sha256 = "1q463qm41ym7jb3kbzjz7b6x549vmgkb70arpkhsf86yxly1y5m1";
   };
 

pkgs/applications/misc/tilda/default.nix

···
-{ stdenv, fetchurl, pkgconfig
+{ stdenv, fetchzip, pkgconfig
 , autoreconfHook, gettext, expat
-, confuse, vte, gtk
+, libconfuse, vte, gtk
 , makeWrapper }:
 
 stdenv.mkDerivation rec {
···
   name = "tilda-${version}";
   version = "1.4.1";
 
-  src = fetchurl {
+  src = fetchzip {
     url = "https://github.com/lanoxx/tilda/archive/${name}.tar.gz";
-    sha256 = "0w2hry2bqcqrkik4l100b1a9jlsih6sq8zwhfpl8zzfq20i00lfs";
+    sha256 = "154rsldqjv2m1bddisb930qicb0y35kx7bxq392n2hn68jr2pxkj";
   };
 
-  nativeBuildInputs = [ autoreconfHook pkgconfig ];
-  buildInputs = [ gettext confuse vte gtk makeWrapper ];
+  nativeBuildInputs = [ autoreconfHook makeWrapper pkgconfig ];
+  buildInputs = [ gettext libconfuse vte gtk ];
 
   LD_LIBRARY_PATH = "${expat.out}/lib"; # ugly hack for xgettext to work during build
 

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

···
 
 buildGoPackage rec {
   name = "terragrunt-${version}";
-  version = "0.17.2";
+  version = "0.17.3";
 
   goPackagePath = "github.com/gruntwork-io/terragrunt";
 
···
     owner  = "gruntwork-io";
     repo   = "terragrunt";
     rev    = "v${version}";
-    sha256 = "069l9ynyl96rfs9zw6w6n1yzjjin27731nj1ajr9jsyc8rhd84wv";
+    sha256 = "1b0fwql9nr00qpvcbsbdymxf1wrgr590gkms7yz3yirb4xfl3gl3";
   };
 
   goDeps = ./deps.nix;

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

···
     license = stdenv.lib.licenses.asl20;
     maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
-    homepage = http://re-alpine.sf.net/;
-    downloadPage = "http://sourceforge.net/projects/re-alpine/files/";
+    homepage = https://sourceforge.net/projects/re-alpine/;
+    downloadPage = "https://sourceforge.net/projects/re-alpine/files/";
   };
 }

pkgs/applications/networking/seafile-client/default.nix

···
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  version = "6.2.5";
+  version = "6.2.7";
   name = "seafile-client-${version}";
 
   src = fetchFromGitHub {
     owner = "haiwen";
     repo = "seafile-client";
     rev = "v${version}";
-    sha256 = "1g09gsaqr4swgwnjxz994xgjsv7mlfaypp6r37bbsiy89a7ppzfl";
+    sha256 = "16ikl6vkp9v16608bq2sfg48idn2p7ik3q8n6j866zxkmgdvkpsg";
   };
 
   nativeBuildInputs = [ pkgconfig cmake makeWrapper ];

pkgs/applications/office/kmymoney/default.nix

···
       "$out/share/kmymoney/weboob/kmymoneyweboob.py"
   '';
 
-  doInstallCheck = stdenv.hostPlatform == stdenv.buildPlatform;
-  installCheckPhase = let
-    pluginPath = "${qtbase.bin}/${qtbase.qtPluginPrefix}";
-  in lib.optionalString doInstallCheck ''
-    QT_PLUGIN_PATH=${lib.escapeShellArg pluginPath} CTEST_OUTPUT_ON_FAILURE=1 \
-      ${xvfb_run}/bin/xvfb-run -s '-screen 0 1024x768x24' make test \
+  doInstallCheck = true;
+  installCheckInputs = [ xvfb_run ];
+  installCheckPhase = ''
+    QT_PLUGIN_PATH=${lib.escapeShellArg "${qtbase.bin}/${qtbase.qtPluginPrefix}"} \
+      xvfb-run -s '-screen 0 1024x768x24' make test \
       ARGS="-E '(reports-chart-test)'" # Test fails, so exclude it for now.
   '';
 

pkgs/applications/science/chemistry/gwyddion/default.nix

···
 stdenv.mkDerivation {
   name = "gwyddion-${version}";
   src = fetchurl {
-    url = "http://sourceforge.net/projects/gwyddion/files/gwyddion/${version}/gwyddion-${version}.tar.xz";
+    url = "mirror://sourceforge/gwyddion/files/gwyddion/${version}/gwyddion-${version}.tar.xz";
     sha256 = "119iw58ac2wn4cas6js8m7r1n4gmmkga6b1y711xzcyjp9hshgwx";
   };
   nativeBuildInputs = [ pkgconfig ];

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

···
   inherit name;
 
   src = fetchurl {
-    url    = "http://sourceforge.net/projects/fricas/files/fricas/${version}/${name}-full.tar.bz2";
+    url    = "mirror://sourceforge/fricas/files/fricas/${version}/${name}-full.tar.bz2";
     sha256 = "156k9az1623y5808j845c56z2nvvdrm48dzg1v0ivpplyl7vp57x";
   };
 

pkgs/applications/science/math/sage/README.md

···
 
 Sage is a pretty complex package that depends on many other complex packages and patches some of those. As a result, the sage nix package is also quite complex.
 
-Don't feel discouraged to fix, simplify or improve things though. Here's a quick overview over the functions of the individual files:
-
-- `sage-src.nix`  
-  Downloads the source code and applies patches. This makes sure that all the other files work with the same sage source. If you want to apply a patch to sage or update sage to a new version, this is the place to do it.
-
-- `env-locations.nix`  
-  Creates a bash file that sets a bunch of environment variables telling sage where to find various packages and files. The definitions of those environment variables can be found in the sage source in the `src/env.py` file. This bash file needs to be sourced before sage is started (done in `sage-env.nix` and `sagedoc.nix`).
-
-- `sage-env.nix`  
-  Sets all environment variables sage needs to run. This includes the package locations defined in `env-locations.nix` as well as the location of sage itself and its various subdirectories.
-
-- `sagelib.nix`  
-  Defines the main sage package (without setting the necessary environments or running any tests).
-
-- `sage-with-env.nix`  
-  Wraps sage in the necessary environment.
-
-- `sage.nix`  
-  Runs sages doctests.
-
-- `sage-wrapper.nix`  
-  Optionally tells sage where do find the docs.
-
-- `sagedoc.nix`  
-  Builds and tests the sage html documentation. Can be used for offline documentation viewing as well as the sage `browse_sage_doc` and `search_doc` functions.
-
-- `sagenb.nix`  
-  The (semi deprecated) sage notebook.
-
-- `default.nix`  
-  Introduces necessary overrides, defines new packages and ties everything together (returning the `sage` package).
-
-- `flask-oldsessions.nix`, `flask-openid.nix`, `python-openid.nix`
-  These are python packages that were rejected from the main nixpkgs tree because they appear unmaintained. They are needed for the (semi-deprecated) sage notebook. Since that notebook is still needed to run the sage doctests, these packages are included but not exposed to the rest of nixpkgs.
-
-- `pybrial.nix`  
-  pybrial is a dependency of sage. However, pybrial itself also has sage as a dependency. Because of that circular dependency, pybrial is hidden from the rest of nixpkgs (just as the flask packages and python-openid.
-
-- `openblas-pc.nix`  
-  This creates a `.pc` file to be read by `pkg-config` that allows openblas to take on different roles, like `cblas` or `lapack`.
+Don't feel discouraged to fix, simplify or improve things though. The individual files have comments explaining their purpose. The most importent ones are `default.nix` linking everything together, `sage-src.nix` adding patches and `sagelib.nix` building the actual sage package.
 
 ## The sage build is broken
 

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

···
-{ nixpkgs
+{ pkgs
 , withDoc ? false
 }:
 
+# Here sage and its dependencies are put together. Some dependencies may be pinned
+# as a last resort. Patching sage for compatibility with newer dependency versions
+# is always preferred, see `sage-src.nix` for that.
+
 let
-  inherit (nixpkgs) fetchpatch fetchurl symlinkJoin callPackage nodePackages;
+  inherit (pkgs) fetchurl symlinkJoin callPackage nodePackages;
 
   # https://trac.sagemath.org/ticket/15980 for tracking of python3 support
-  python = nixpkgs.python2.override {
+  python = pkgs.python2.override {
     packageOverrides = self: super: {
       # python packages that appear unmaintained and were not accepted into the nixpkgs
       # tree because of that. These packages are only dependencies of the more-or-less
       # deprecated sagenb. However sagenb is still a default dependency and the doctests
       # depend on it.
       # See https://github.com/NixOS/nixpkgs/pull/38787 for a discussion.
+      # The dependency on the sage notebook (and therefore these packages) will be
+      # removed in the future:
+      # https://trac.sagemath.org/ticket/25837
       flask-oldsessions = self.callPackage ./flask-oldsessions.nix {};
       flask-openid = self.callPackage ./flask-openid.nix {};
       python-openid = self.callPackage ./python-openid.nix {};
+      sagenb = self.callPackage ./sagenb.nix {
+        mathjax = nodePackages.mathjax;
+      };
 
+      # Package with a cyclic dependency with sage
       pybrial = self.callPackage ./pybrial.nix {};
 
+      # `sagelib`, i.e. all of sage except some wrappers and runtime dependencies
       sagelib = self.callPackage ./sagelib.nix {
         inherit flint ecl arb;
-        inherit sage-src openblas-blas-pc openblas-cblas-pc openblas-lapack-pc pynac singular;
-        linbox = nixpkgs.linbox.override { withSage = true; };
+        inherit sage-src pynac singular;
+        linbox = pkgs.linbox.override { withSage = true; };
       };
+    };
+  };
 
-      sagenb = self.callPackage ./sagenb.nix {
-        mathjax = nodePackages.mathjax;
-      };
+  jupyter-kernel-definition = {
+    displayName = "SageMath ${sage-src.version}";
+    argv = [
+      "${sage-with-env}/bin/sage" # FIXME which sage
+      "--python"
+      "-m"
+      "sage.repl.ipython_kernel"
+      "-f"
+      "{connection_file}"
+    ];
+    language = "sagemath";
+    # just one 16x16 logo is available
+    logo32 = "${sage-src}/doc/common/themes/sage/static/sageicon.png";
+    logo64 = "${sage-src}/doc/common/themes/sage/static/sageicon.png";
+  };
 
-      sagedoc = self.callPackage ./sagedoc.nix {
-        inherit sage-src;
-      };
+  # A bash script setting various environment variables to tell sage where
+  # the files its looking fore are located. Also see `sage-env`.
+  env-locations = callPackage ./env-locations.nix {
+    inherit pari_data ecl;
+    inherit singular;
+    cysignals = python.pkgs.cysignals;
+    three = nodePackages.three;
+    mathjax = nodePackages.mathjax;
+  };
 
-      env-locations = self.callPackage ./env-locations.nix {
-        inherit pari_data ecl;
-        inherit singular;
-        three = nodePackages.three;
-        mathjax = nodePackages.mathjax;
-      };
+  # The shell file that gets sourced on every sage start. Will also source
+  # the env-locations file.
+  sage-env = callPackage ./sage-env.nix {
+    sagelib = python.pkgs.sagelib;
+    inherit env-locations;
+    inherit python rWrapper ecl singular palp flint pynac pythonEnv;
+    pkg-config = pkgs.pkgconfig; # not to confuse with pythonPackages.pkgconfig
+  };
 
-      sage-env = self.callPackage ./sage-env.nix {
-        inherit sage-src python rWrapper openblas-cblas-pc ecl singular palp flint pynac pythonEnv;
-        pkg-config = nixpkgs.pkgconfig; # not to confuse with pythonPackages.pkgconfig
-      };
-
-      sage-with-env = self.callPackage ./sage-with-env.nix {
-        inherit pythonEnv;
-        inherit sage-src openblas-blas-pc openblas-cblas-pc openblas-lapack-pc pynac singular;
-        pkg-config = nixpkgs.pkgconfig; # not to confuse with pythonPackages.pkgconfig
-        three = nodePackages.three;
-      };
-
-      sage = self.callPackage ./sage.nix { };
+  # The documentation for sage, building it takes a lot of ram.
+  sagedoc = callPackage ./sagedoc.nix {
+    inherit sage-with-env;
+    inherit python;
+  };
 
-      sage-wrapper = self.callPackage ./sage-wrapper.nix {
-        inherit sage-src withDoc;
-      };
-    };
+  # sagelib with added wrappers and a dependency on sage-tests to make sure thet tests were run.
+  sage-with-env = callPackage ./sage-with-env.nix {
+    inherit pythonEnv;
+    inherit sage-env;
+    inherit pynac singular;
+    pkg-config = pkgs.pkgconfig; # not to confuse with pythonPackages.pkgconfig
+    three = nodePackages.three;
   };
 
-  openblas-blas-pc = callPackage ./openblas-pc.nix { name = "blas"; };
-  openblas-cblas-pc = callPackage ./openblas-pc.nix { name = "cblas"; };
-  openblas-lapack-pc = callPackage ./openblas-pc.nix { name = "lapack"; };
+  # Doesn't actually build anything, just runs sages testsuite. This is a
+  # separate derivation to make it possible to re-run the tests without
+  # rebuilding sagelib (which takes ~30 minutes).
+  # Running the tests should take something in the order of 1h.
+  sage-tests = callPackage ./sage-tests.nix {
+    inherit sage-with-env;
+  };
 
   sage-src = callPackage ./sage-src.nix {};
 
···
     sympy
     fpylll
     matplotlib
+    tkinter # optional, as a matplotlib backend (use with `%matplotlib tk`)
     scipy
     ipywidgets
     rpy2
···
   } // { extraLibs = pythonRuntimeDeps; }; # make the libs accessible
 
   # needs to be rWrapper, standard "R" doesn't include default packages
-  rWrapper = nixpkgs.rWrapper.override {
+  rWrapper = pkgs.rWrapper.override {
     # https://trac.sagemath.org/ticket/25674
-    R = nixpkgs.R.overrideAttrs (attrs: rec {
+    R = pkgs.R.overrideAttrs (attrs: rec {
       name = "R-3.4.4";
       src = fetchurl {
         url = "http://cran.r-project.org/src/base/R-3/${name}.tar.gz";
···
     });
   };
 
-  arb = nixpkgs.arb.override { inherit flint; };
+  arb = pkgs.arb.override { inherit flint; };
 
-  singular = nixpkgs.singular.override { inherit flint; };
+  singular = pkgs.singular.override { inherit flint; };
 
   # *not* to confuse with the python package "pynac"
-  pynac = nixpkgs.pynac.override { inherit singular flint; };
+  pynac = pkgs.pynac.override { inherit singular flint; };
 
   # With openblas (64 bit), the tests fail the same way as when sage is build with
   # openblas instead of openblasCompat. Apparently other packages somehow use flints
   # blas when it is available. Alternative would be to override flint to use
   # openblasCompat.
-  flint = nixpkgs.flint.override { withBlas = false; };
+  flint = pkgs.flint.override { withBlas = false; };
 
   # Multiple palp dimensions need to be available and sage expects them all to be
   # in the same folder.
   palp = symlinkJoin {
-    name = "palp-${nixpkgs.palp.version}";
+    name = "palp-${pkgs.palp.version}";
     paths = [
-      (nixpkgs.palp.override { dimensions = 4; doSymlink = false; })
-      (nixpkgs.palp.override { dimensions = 5; doSymlink = false; })
-      (nixpkgs.palp.override { dimensions = 6; doSymlink = true; })
-      (nixpkgs.palp.override { dimensions = 11; doSymlink = false; })
+      (pkgs.palp.override { dimensions = 4; doSymlink = false; })
+      (pkgs.palp.override { dimensions = 5; doSymlink = false; })
+      (pkgs.palp.override { dimensions = 6; doSymlink = true; })
+      (pkgs.palp.override { dimensions = 11; doSymlink = false; })
     ];
   };
 
   # Sage expects those in the same directory.
   pari_data = symlinkJoin {
     name = "pari_data";
-    paths = with nixpkgs; [
+    paths = with pkgs; [
       pari-galdata
       pari-seadata-small
     ];
   };
 
   # https://trac.sagemath.org/ticket/22191
-  ecl = nixpkgs.ecl_16_1_2;
+  ecl = pkgs.ecl_16_1_2;
 in
-  python.pkgs.sage-wrapper // {
-    doc = python.pkgs.sagedoc;
-    lib = python.pkgs.sagelib;
-  }
+# A wrapper around sage that makes sure sage finds its docs (if they were build).
+callPackage ./sage.nix {
+  inherit sage-tests sage-with-env sagedoc jupyter-kernel-definition;
+  inherit withDoc;
+}

pkgs/applications/science/math/sage/env-locations.nix

···
 , cysignals
 }:
 
+# A bash script setting various environment variables to tell sage where
+# the files its looking fore are located. Also see `sage-env`.
 writeTextFile rec {
   name = "sage-env-locations";
   destination = "/${name}";

pkgs/applications/science/math/sage/openblas-pc.nix

···
-{ openblasCompat
-, writeTextFile
-, name
-}:
-
-writeTextFile {
-  name = "openblas-${name}-pc-${openblasCompat.version}";
-  destination = "/lib/pkgconfig/${name}.pc";
-  text = ''
-    Name: ${name}
-    Version: ${openblasCompat.version}
-
-    Description: ${name} for SageMath, provided by the OpenBLAS package.
-    Cflags: -I${openblasCompat}/include
-    Libs: -L${openblasCompat}/lib -lopenblas
-  '';
-}

pkgs/applications/science/math/sage/patches/eclib-20180710.patch

···
-diff --git a/src/sage/interfaces/mwrank.py b/src/sage/interfaces/mwrank.py
-index 4417b59276..ae57ca2991 100644
---- a/src/sage/interfaces/mwrank.py
-+++ b/src/sage/interfaces/mwrank.py
-@@ -54,8 +54,9 @@ def Mwrank(options="", server=None, server_tmpdir=None):
-         sage: M = Mwrank('-v 0 -l')
-         sage: print(M('0 0 1 -1 0'))
-         Curve [0,0,1,-1,0] :    Rank = 1
--        Generator 1 is [0:-1:1]; height 0.0511114082399688
--        Regulator = 0.0511114082399688
-+        Generator 1 is [0:-1:1]; height 0.051111408239969
-+        Regulator = 0.051111408239969
-+
-     """
-     global instances
-     try:

pkgs/applications/science/math/sage/patches/eclib-regulator-precision.patch

···
-diff --git a/src/sage/libs/eclib/interface.py b/src/sage/libs/eclib/interface.py
-index f77000c478..9d17d412ae 100644
---- a/src/sage/libs/eclib/interface.py
-+++ b/src/sage/libs/eclib/interface.py
-@@ -1014,7 +1014,7 @@ class mwrank_MordellWeil(SageObject):
-             WARNING: saturation at primes p > 2 will not be done;
-             ...
-             Gained index 2
--            New regulator =  93.857300720636393209
-+            New regulator =  93.85730...
-             (False, 2, '[ ]')
-             sage: EQ.points()
-             [[-2, 3, 1], [2707496766203306, 864581029138191, 2969715140223272], [-13422227300, -49322830557, 12167000000]]
-@@ -1025,7 +1025,7 @@ class mwrank_MordellWeil(SageObject):
-             WARNING: saturation at primes p > 3 will not be done;
-             ...
-             Gained index 3
--            New regulator =  10.4285889689595992455
-+            New regulator =  10.42858...
-             (False, 3, '[ ]')
-             sage: EQ.points()
-             [[-2, 3, 1], [-14, 25, 8], [-13422227300, -49322830557, 12167000000]]
-@@ -1036,7 +1036,7 @@ class mwrank_MordellWeil(SageObject):
-             WARNING: saturation at primes p > 5 will not be done;
-             ...
-             Gained index 5
--            New regulator =  0.417143558758383969818
-+            New regulator =  0.41714...
-             (False, 5, '[ ]')
-             sage: EQ.points()
-             [[-2, 3, 1], [-14, 25, 8], [1, -1, 1]]
-@@ -1221,7 +1221,7 @@ class mwrank_MordellWeil(SageObject):
-             WARNING: saturation at primes p > 2 will not be done;
-             ...
-             Gained index 2
--            New regulator =  93.857300720636393209
-+            New regulator =  93.85730...
-             (False, 2, '[ ]')
-             sage: EQ
-             Subgroup of Mordell-Weil group: [[-2:3:1], [2707496766203306:864581029138191:2969715140223272], [-13422227300:-49322830557:12167000000]]
-@@ -1235,7 +1235,7 @@ class mwrank_MordellWeil(SageObject):
-             WARNING: saturation at primes p > 3 will not be done;
-             ...
-             Gained index 3
--            New regulator =  10.4285889689595992455
-+            New regulator =  10.42858...
-             (False, 3, '[ ]')
-             sage: EQ
-             Subgroup of Mordell-Weil group: [[-2:3:1], [-14:25:8], [-13422227300:-49322830557:12167000000]]
-@@ -1249,7 +1249,7 @@ class mwrank_MordellWeil(SageObject):
-             WARNING: saturation at primes p > 5 will not be done;
-             ...
-             Gained index 5
--            New regulator =  0.417143558758383969818
-+            New regulator =  0.41714...
-             (False, 5, '[ ]')
-             sage: EQ
-             Subgroup of Mordell-Weil group: [[-2:3:1], [-14:25:8], [1:-1:1]]
-diff --git a/src/sage/libs/eclib/mwrank.pyx b/src/sage/libs/eclib/mwrank.pyx
-index a4f89e1ca5..f8a22d2f55 100644
---- a/src/sage/libs/eclib/mwrank.pyx
-+++ b/src/sage/libs/eclib/mwrank.pyx
-@@ -1234,9 +1234,9 @@ cdef class _two_descent:
-             sage: D2.saturate()
-             Searching for points (bound = 8)...done:
-               found points which generate a subgroup of rank 3
--              and regulator 0.417143558758383969817119544618093396749810106098479
-+              and regulator 0.41714...
-             Processing points found during 2-descent...done:
--              now regulator = 0.417143558758383969817119544618093396749810106098479
-+              now regulator = 0.41714...
-             No saturation being done
-             sage: D2.getbasis()
-             '[[1:-1:1], [-2:3:1], [-14:25:8]]'
-@@ -1281,9 +1281,9 @@ cdef class _two_descent:
-             sage: D2.saturate()
-             Searching for points (bound = 8)...done:
-               found points which generate a subgroup of rank 3
--              and regulator 0.417143558758383969817119544618093396749810106098479
-+              and regulator 0.41714...
-             Processing points found during 2-descent...done:
--              now regulator = 0.417143558758383969817119544618093396749810106098479
-+              now regulator = 0.41714...
-             No saturation being done
-             sage: D2.getbasis()
-             '[[1:-1:1], [-2:3:1], [-14:25:8]]'
-@@ -1329,9 +1329,9 @@ cdef class _two_descent:
-             sage: D2.saturate()
-             Searching for points (bound = 8)...done:
-               found points which generate a subgroup of rank 3
--              and regulator 0.417143558758383969817119544618093396749810106098479
-+              and regulator 0.41714...
-             Processing points found during 2-descent...done:
--              now regulator = 0.417143558758383969817119544618093396749810106098479
-+              now regulator = 0.41714...
-             No saturation being done
-             sage: D2.getbasis()
-             '[[1:-1:1], [-2:3:1], [-14:25:8]]'

pkgs/applications/science/math/sage/patches/known-padics-bug.patch

···
-diff --git a/build/pkgs/openblas/package-version.txt b/build/pkgs/openblas/package-version.txt
-index 3bc45c25d4..7c7c224887 100644
---- a/src/sage/schemes/elliptic_curves/padics.py
-+++ b/src/sage/schemes/elliptic_curves/padics.py
-@@ -292,8 +292,8 @@ def padic_regulator(self, p, prec=20, height=None, check_hypotheses=True):
- 
-         sage: max_prec = 30    # make sure we get past p^2    # long time
-         sage: full = E.padic_regulator(5, max_prec)           # long time
--        sage: for prec in range(1, max_prec):                 # long time
--        ....:     assert E.padic_regulator(5, prec) == full   # long time
-+        sage: for prec in range(1, max_prec):                 # known bug (#25969) # long time
-+        ....:     assert E.padic_regulator(5, prec) == full   # known bug (#25969) # long time
- 
-     A case where the generator belongs to the formal group already
-     (:trac:`3632`)::

pkgs/applications/science/math/sage/patches/matplotlib-normed-deprecated.patch

···
-diff --git a/src/sage/all.py b/src/sage/all.py
-index 14cec431f1..25a35a0522 100644
---- a/src/sage/all.py
-+++ b/src/sage/all.py
-@@ -310,6 +310,7 @@ warnings.filters.remove(('ignore', None, DeprecationWarning, None, 0))
- # Ignore all deprecations from IPython etc.
- warnings.filterwarnings('ignore',
-     module='.*(IPython|ipykernel|jupyter_client|jupyter_core|nbformat|notebook|ipywidgets|storemagic)')
-+warnings.filterwarnings('ignore', "The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.") # matplotlib normed deprecation
- # However, be sure to keep OUR deprecation warnings
- warnings.filterwarnings('default',
-     '[\s\S]*See http://trac.sagemath.org/[0-9]* for details.')

pkgs/applications/science/math/sage/sage-env.nix

···
 , lib
 , writeTextFile
 , python
-, sage-src
 , sagelib
 , env-locations
 , gfortran
···
 , lcalc
 , rubiks
 , flintqs
-, openblas-cblas-pc
+, openblasCompat
 , flint
 , gmp
 , mpfr
···
 , gsl
 , ntl
 }:
+
+# This generates a `sage-env` shell file that will be sourced by sage on startup.
+# It sets up various environment variables, telling sage where to find its
+# dependencies.
 
 let
   runtimepath = (lib.makeBinPath ([
···
   destination = "/${name}";
   text = ''
     export PKG_CONFIG_PATH='${lib.concatStringsSep ":" (map (pkg: "${pkg}/lib/pkgconfig") [
-        # This is only needed in the src/sage/misc/cython.py test and I'm not sure if there's really a use-case
-        # for it outside of the tests. However since singular and openblas are runtime dependencies anyways
-        # and openblas-cblas-pc is tiny, it doesn't really hurt to include.
+        # This is only needed in the src/sage/misc/cython.py test and I'm not
+        # sure if there's really a usecase for it outside of the tests. However
+        # since singular and openblas are runtime dependencies anyways, it doesn't
+        # really hurt to include.
         singular
-        openblas-cblas-pc
+        openblasCompat
       ])
     }'
-    export SAGE_ROOT='${sage-src}'
+    export SAGE_ROOT='${sagelib.src}'
     export SAGE_LOCAL='@sage-local@'
     export SAGE_SHARE='${sagelib}/share'
     orig_path="$PATH"
     export PATH='${runtimepath}'
 
     # set dependent vars, like JUPYTER_CONFIG_DIR
-    source "${sage-src}/src/bin/sage-env"
+    source "${sagelib.src}/src/bin/sage-env"
     export PATH="${runtimepath}:$orig_path" # sage-env messes with PATH
 
     export SAGE_LOGS="$TMPDIR/sage-logs"
     export SAGE_DOC="''${SAGE_DOC_OVERRIDE:-doc-placeholder}"
-    export SAGE_DOC_SRC="''${SAGE_DOC_SRC_OVERRIDE:-${sage-src}/src/doc}"
+    export SAGE_DOC_SRC="''${SAGE_DOC_SRC_OVERRIDE:-${sagelib.src}/src/doc}"
 
     # set locations of dependencies
     . ${env-locations}/sage-env-locations
···
 
     export SAGE_LIB='${sagelib}/${python.sitePackages}'
 
-    export SAGE_EXTCODE='${sage-src}/src/ext'
+    export SAGE_EXTCODE='${sagelib.src}/src/ext'
 
-    # for find_library
+  # for find_library
     export DYLD_LIBRARY_PATH="${lib.makeLibraryPath [stdenv.cc.libc singular]}:$DYLD_LIBRARY_PATH"
   '';
+} // {
+  lib = sagelib; # equivalent of `passthru`, which `writeTextFile` doesn't support
 }

pkgs/applications/science/math/sage/sage-src.nix

···
 , fetchFromGitHub
 , fetchpatch
 }:
+
+# This file is responsible for fetching the sage source and adding necessary patches.
+# It does not actually build anything, it just copies the patched sources to $out.
+# This is done because multiple derivations rely on these sources and they should
+# all get the same sources with the same patches applied.
+
 stdenv.mkDerivation rec {
   version = "8.4";
   name = "sage-src-${version}";
···
     sha256 = "0gips1hagiz9m7s21bg5as8hrrm2x5k47h1bsq0pc46iplfwmv2d";
   };
 
+  # Patches needed because of particularities of nix or the way this is packaged.
+  # The goal is to upstream all of them and get rid of this list.
   nixPatches = [
     # https://trac.sagemath.org/ticket/25358
     (fetchpatch {
···
     # Revert the commit that made the sphinx build fork even in the single thread
     # case. For some yet unknown reason, that breaks the docbuild on nix and archlinux.
     # See https://groups.google.com/forum/#!msg/sage-packaging/VU4h8IWGFLA/mrmCMocYBwAJ.
+    # https://trac.sagemath.org/ticket/26608
     ./patches/revert-sphinx-always-fork.patch
 
     # Make sure py2/py3 tests are only run when their expected context (all "sage"
···
     ./patches/Only-test-py2-py3-optional-tests-when-all-of-sage-is.patch
   ];
 
+  # Patches needed because of package updates. We could just pin the versions of
+  # dependencies, but that would lead to rebuilds, confusion and the burdons of
+  # maintaining multiple versions of dependencies. Instead we try to make sage
+  # compatible with never dependency versions when possible. All these changes
+  # should come from or be proposed to upstream. This list will probably never
+  # be empty since dependencies update all the time.
   packageUpgradePatches = let
-    # fetch a diff between base and rev on sage's git server
-    # used to fetch trac tickets by setting the base to the release and the
-    # revision to the last commit that should be included
+    # Fetch a diff between `base` and `rev` on sage's git server.
+    # Used to fetch trac tickets by setting the `base` to the last release and the
+    # `rev` to the last commit of the ticket.
     fetchSageDiff = { base, rev, ...}@args: (
       fetchpatch ({
         url = "https://git.sagemath.org/sage.git/patch?id2=${base}&id=${rev}";
···
   in [
     # New glpk version has new warnings, filter those out until upstream sage has found a solution
     # https://trac.sagemath.org/ticket/24824
-    ./patches/pari-stackwarn.patch # not actually necessary since tha pari upgrade, but necessary for the glpk patch to apply
+    ./patches/pari-stackwarn.patch # not actually necessary since the pari upgrade, but necessary for the glpk patch to apply
     (fetchpatch {
       url = "https://salsa.debian.org/science-team/sagemath/raw/58bbba93a807ca2933ca317501d093a1bb4b84db/debian/patches/dt-version-glpk-4.65-ignore-warnings.patch";
       sha256 = "0b9293v73wb4x13wv5zwyjgclc01zn16msccfzzi6znswklgvddp";
···
     # https://trac.sagemath.org/ticket/25260
     ./patches/numpy-1.15.1.patch
 
-    # ntl upgrade
-    # https://trac.sagemath.org/ticket/25532#comment:29
+    # needed for ntl update
+    # https://trac.sagemath.org/ticket/25532
     (fetchpatch {
       name = "lcalc-c++11.patch";
       url = "https://git.archlinux.org/svntogit/community.git/plain/trunk/sagemath-lcalc-c++11.patch?h=packages/sagemath&id=0e31ae526ab7c6b5c0bfacb3f8b1c4fd490035aa";
···
     })
   ];
 
-  patches = nixPatches ++ packageUpgradePatches ++ [
-    ./patches/known-padics-bug.patch
-  ];
+  patches = nixPatches ++ packageUpgradePatches;
 
   postPatch = ''
     # make sure shebangs etc are fixed, but sage-python23 still works

pkgs/applications/science/math/sage/sage-tests.nix

···
+{ stdenv
+, lib
+, sage-with-env
+, makeWrapper
+, files ? null # "null" means run all tests
+, longTests ? true # run tests marked as "long time"
+}:
+
+# for a quick test of some source files:
+# nix-build -E 'with (import ./. {}); sage.tests.override { files = [ "src/sage/misc/cython.py" ];}'
+
+let
+  src = sage-with-env.env.lib.src;
+  runAllTests = files == null;
+  testArgs = if runAllTests then "--all" else testFileList;
+  patienceSpecifier = if longTests then "--long" else "";
+  relpathToArg = relpath: lib.escapeShellArg "${src}/${relpath}"; # paths need to be absolute
+  testFileList = lib.concatStringsSep " " (map relpathToArg files);
+in
+stdenv.mkDerivation rec {
+  version = src.version;
+  name = "sage-tests-${version}";
+  inherit src;
+
+  buildInputs = [
+    makeWrapper
+    sage-with-env
+  ];
+
+  unpackPhase = "#do nothing";
+  configurePhase = "#do nothing";
+  buildPhase = "#do nothing";
+
+  installPhase = ''
+    # This output is not actually needed for anything, the package just
+    # exists to decouple the sage build from its t ests.
+
+    mkdir -p "$out/bin"
+    # Like a symlink, but make sure that $0 points to the original.
+    makeWrapper "${sage-with-env}/bin/sage" "$out/bin/sage"
+  '';
+
+  doInstallCheck = true;
+  installCheckPhase = ''
+    export HOME="$TMPDIR/sage-home"
+    mkdir -p "$HOME"
+
+    # "--long" tests are in the order of 1h, without "--long" its 1/2h
+    "sage" -t --nthreads "$NIX_BUILD_CORES" --optional=sage ${patienceSpecifier} ${testArgs}
+  '';
+}

pkgs/applications/science/math/sage/sage-with-env.nix

···
 , lib
 , makeWrapper
 , sage-env
-, sage-src
 , openblasCompat
-, openblas-blas-pc
-, openblas-cblas-pc
-, openblas-lapack-pc
 , pkg-config
 , three
 , singular
···
 , pythonEnv
 }:
 
+# Wrapper that combined `sagelib` with `sage-env` to produce an actually
+# executable sage. No tests are run yet and no documentation is built.
+
 let
   buildInputs = [
     pythonEnv # for patchShebangs
     makeWrapper
     pkg-config
     openblasCompat # lots of segfaults with regular (64 bit) openblas
-    openblas-blas-pc
-    openblas-cblas-pc
-    openblas-lapack-pc
     singular
     three
     pynac
···
   input_names = map (dep: pkg_to_spkg_name dep patch_names) transitiveDeps;
 in
 stdenv.mkDerivation rec {
-  version = sage-src.version;
+  version = src.version;
   name = "sage-with-env-${version}";
+  src = sage-env.lib.src;
 
   inherit buildInputs;
-
-  src = sage-src;
 
   configurePhase = "#do nothing";
 
···
 
   installPhase = ''
     mkdir -p "$out/var/lib/sage"
-    cp -r installed $out/var/lib/sage
+    cp -r installed "$out/var/lib/sage"
 
     mkdir -p "$out/etc"
     # sage tests will try to create this file if it doesn't exist
     touch "$out/etc/sage-started.txt"
 
     mkdir -p "$out/build"
+
+    # the scripts in src/bin will find the actual sage source files using environment variables set in `sage-env`
     cp -r src/bin "$out/bin"
     cp -r build/bin "$out/build/bin"
+
     cp -f '${sage-env}/sage-env' "$out/bin/sage-env"
     substituteInPlace "$out/bin/sage-env" \
       --subst-var-by sage-local "$out"
   '';
+
+  passthru = {
+    env = sage-env;
+  };
 }

pkgs/applications/science/math/sage/sage-wrapper.nix

···
-{ stdenv
-, makeWrapper
-, sage
-, sage-src
-, sagedoc
-, withDoc
-}:
-
-stdenv.mkDerivation rec {
-  version = sage.version;
-  name = "sage-${version}";
-
-  buildInputs = [
-    makeWrapper
-  ];
-
-  unpackPhase = "#do nothing";
-  configurePhase = "#do nothing";
-  buildPhase = "#do nothing";
-
-  installPhase = ''
-    mkdir -p "$out/bin"
-    makeWrapper "${sage}/bin/sage" "$out/bin/sage" \
-      --set SAGE_DOC_SRC_OVERRIDE "${sage-src}/src/doc" ${
-      stdenv.lib.optionalString withDoc "--set SAGE_DOC_OVERRIDE ${sagedoc}/share/doc/sage"
-    }
-  '';
-
-  doInstallCheck = withDoc;
-  installCheckPhase = ''
-    export HOME="$TMPDIR/sage-home"
-    mkdir -p "$HOME"
-    "$out/bin/sage" -c 'browse_sage_doc._open("reference", testing=True)'
-  '';
-
-  meta = with stdenv.lib; {
-    description = "Open Source Mathematics Software, free alternative to Magma, Maple, Mathematica, and Matlab";
-    license = licenses.gpl2;
-    maintainers = with maintainers; [ timokau ];
-  };
-}

pkgs/applications/science/math/sage/sage.nix

···
 { stdenv
+, makeWrapper
+, sage-tests
 , sage-with-env
-, makeWrapper
+, jupyter-kernel-definition
+, jupyter-kernel
+, sagedoc
+, withDoc
 }:
 
+# A wrapper that makes sure sage finds its docs (if they were build) and the
+# jupyter kernel spec.
+
+let 
+  # generate kernel spec + default kernels
+  kernel-specs = jupyter-kernel.create {
+    definitions = jupyter-kernel.default // {
+      sagemath = jupyter-kernel-definition;
+    };
+  };
+in
 stdenv.mkDerivation rec {
-  version = sage-with-env.version;
-  name = "sage-tests-${version}";
+  version = src.version;
+  name = "sage-${version}";
+  src = sage-with-env.env.lib.src;
 
   buildInputs = [
     makeWrapper
+
+    # This is a hack to make sure sage-tests is evaluated. It doesn't acutally
+    # produce anything of value, it just decouples the tests from the build.
+    sage-tests
   ];
 
   unpackPhase = "#do nothing";
···
 
   installPhase = ''
     mkdir -p "$out/bin"
-    # Like a symlink, but make sure that $0 points to the original.
-    makeWrapper "${sage-with-env}/bin/sage" "$out/bin/sage"
+    makeWrapper "${sage-with-env}/bin/sage" "$out/bin/sage" \
+      --set SAGE_DOC_SRC_OVERRIDE "${src}/src/doc" ${
+        stdenv.lib.optionalString withDoc "--set SAGE_DOC_OVERRIDE ${sagedoc}/share/doc/sage"
+      } \
+      --prefix JUPYTER_PATH : "${kernel-specs}"
   '';
 
-  doInstallCheck = true;
+  doInstallCheck = withDoc;
   installCheckPhase = ''
     export HOME="$TMPDIR/sage-home"
     mkdir -p "$HOME"
-
-    # "--long" tests are in the order of 1h, without "--long" its 1/2h
-    "$out/bin/sage" -t --nthreads "$NIX_BUILD_CORES" --optional=sage --long --all
+    "$out/bin/sage" -c 'browse_sage_doc._open("reference", testing=True)'
   '';
+
+  passthru = {
+    tests = sage-tests;
+    doc = sagedoc;
+    lib = sage-with-env.env.lib;
+    kernelspec = jupyter-kernel-definition;
+  };
+
+  meta = with stdenv.lib; {
+    description = "Open Source Mathematics Software, free alternative to Magma, Maple, Mathematica, and Matlab";
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ timokau ];
+  };
 }

pkgs/applications/science/math/sage/sagedoc.nix

···
 { stdenv
-, sage-src
 , sage-with-env
-, sagelib
-, python2
-, psutil
-, future
-, sphinx
-, sagenb
+, python
 , maxima-ecl
-, networkx
-, scipy
-, sympy
-, matplotlib
-, pillow
-, ipykernel
-, jupyter_client
 , tachyon
 , jmol
-, ipywidgets
-, typing
 , cddlib
-, pybrial
 }:
 
 stdenv.mkDerivation rec {
-  version = sage-src.version;
+  version = src.version;
   name = "sagedoc-${version}";
+  src = sage-with-env.env.lib.src;
 
 
   # Building the documentation has many dependencies, because all documented
   # modules are imported and because matplotlib is used to produce plots.
   buildInputs = [
-    sagelib
-    python2
+    sage-with-env.env.lib
+    python
+    maxima-ecl
+    tachyon
+    jmol
+    cddlib
+  ] ++ (with python.pkgs; [
     psutil
     future
     sphinx
     sagenb
-    maxima-ecl
-    networkx
     scipy
     sympy
     matplotlib
     pillow
+    networkx
     ipykernel
+    ipywidgets
     jupyter_client
-    tachyon
-    jmol
-    ipywidgets
     typing
-    cddlib
     pybrial
-  ];
+  ]);
 
   unpackPhase = ''
     export SAGE_DOC_OVERRIDE="$PWD/share/doc/sage"
     export SAGE_DOC_SRC_OVERRIDE="$PWD/docsrc"
 
-    cp -r "${sage-src}/src/doc" "$SAGE_DOC_SRC_OVERRIDE"
+    cp -r "${src}/src/doc" "$SAGE_DOC_SRC_OVERRIDE"
     chmod -R 755 "$SAGE_DOC_SRC_OVERRIDE"
   '';
 

pkgs/applications/science/math/sage/sagelib.nix

···
 , buildPythonPackage
 , arb
 , openblasCompat
-, openblas-blas-pc
-, openblas-cblas-pc
-, openblas-lapack-pc
 , brial
 , cliquer
 , cypari2
···
 , libbraiding
 }:
 
+# This is the core sage python package. Everything else is just wrappers gluing
+# stuff together. It is not very useful on its own though, since it will not
+# find many of its dependencies without `sage-env`, will not be tested without
+# `sage-tests` and will not have html docs without `sagedoc`.
+
 buildPythonPackage rec {
   format = "other";
-  version = sage-src.version;
-  pname = "sagelib";
-
+  version = src.version;
+  name = "sagelib-${version}";
   src = sage-src;
 
   nativeBuildInputs = [
     iml
     perl
-    openblas-blas-pc
-    openblas-cblas-pc
-    openblas-lapack-pc
     jupyter_core
   ];
 

pkgs/applications/science/math/sage/sagenb.nix

···
-# Has a cyclic dependency with sage (not expressed here) and is not useful outside of sage
 { stdenv
 , fetchpatch
 , python
···
 , flask-autoindex
 , flask-babel
 }:
+
+# Has a cyclic dependency with sage (not expressed here) and is not useful outside of sage.
+# Deprecated, hopefully soon to be removed. See
+# https://trac.sagemath.org/ticket/25837
 
 buildPythonPackage rec {
   pname = "sagenb";

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

···
     license = stdenv.lib.licenses.gpl2;
     maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
-    downloadPage = "http://sourceforge.net/projects/golly/files/golly";
+    downloadPage = "https://sourceforge.net/projects/golly/files/golly";
   };
 }

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

···
     license = stdenv.lib.licenses.gpl2;
     maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
-    downloadPage = "http://sourceforge.net/projects/golly/files/golly";
+    downloadPage = "https://sourceforge.net/projects/golly/files/golly";
   };
 }

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

···
-url http://sourceforge.net/projects/golly/files/golly/
+url https://sourceforge.net/projects/golly/files/golly/
 version_link '[-][0-9.]+/$'
 SF_version_tarball 'src'
 SF_redirect

pkgs/applications/version-management/bazaar/tools.nix

···
   version = "2.6.0";
 
   src = fetchurl {
-    url = "http://launchpad.net/bzrtools/stable/${version}/+download/bzrtools-${version}.tar.gz";
+    url = "https://launchpad.net/bzrtools/stable/${version}/+download/bzrtools-${version}.tar.gz";
     sha256 = "0n3zzc6jf5866kfhmrnya1vdr2ja137a45qrzsz8vz6sc6xgn5wb";
   };
 

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

···
 
   meta = {
     description = "Import svn, mercurial into git";
-    homepage = http://repo.or.cz/w/fast-export.git;
+    homepage = https://repo.or.cz/w/fast-export.git;
     license = licenses.gpl2;
     maintainers = [ maintainers.koral ];
     platforms = stdenv.lib.platforms.unix;

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

···
   patchFlags = ["-p0"];
   patches = [
     (fetchurl {
-      url = "http://src.fedoraproject.org/cgit/rpms/monotone-viz.git/plain/monotone-viz-1.0.2-dot.patch";
+      url = "https://src.fedoraproject.org/cgit/rpms/monotone-viz.git/plain/monotone-viz-1.0.2-dot.patch";
       sha256 = "0risfy8iqmkr209hmnvpv57ywbd3rvchzzd0jy2lfyqrrrm6zknw";
     })
     (fetchurl {
-      url = "http://src.fedoraproject.org/cgit/rpms/monotone-viz.git/plain/monotone-viz-1.0.2-new-stdio.patch";
+      url = "https://src.fedoraproject.org/cgit/rpms/monotone-viz.git/plain/monotone-viz-1.0.2-new-stdio.patch";
       sha256 = "16bj0ppzqd45an154dr7sifjra7lv4m9anxfw3c56y763jq7fafa";
     })
     (fetchurl {
-      url = "http://src.fedoraproject.org/cgit/rpms/monotone-viz.git/plain/monotone-viz-1.0.2-typefix.patch";
+      url = "https://src.fedoraproject.org/cgit/rpms/monotone-viz.git/plain/monotone-viz-1.0.2-typefix.patch";
       sha256 = "1gfp82rc7pawb5x4hh2wf7xh1l1l54ib75930xgd1y437la4703r";
     })
   ];

pkgs/applications/video/openshot-qt/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   name = "openshot-qt-${version}";
-  version = "2.4.2";
+  version = "2.4.3";
 
   src = fetchFromGitHub {
     owner = "OpenShot";
     repo = "openshot-qt";
     rev = "v${version}";
-    sha256 = "0m4fq9vj8gc5ngk8qf6ikj85qgzxhfk7nnz7n7362dzlfymaz18q";
+    sha256 = "1qdw1mli4y9qhrnllnkaf6ydgw5vfvdb90chs4i679k0x0jyb9a2";
   };
 
   nativeBuildInputs = [ doxygen wrapGAppsHook ];

pkgs/applications/video/pyca/default.nix

···
+{ stdenv, buildPythonApplication, fetchFromGitHub, pycurl, dateutil, configobj, sqlalchemy, sdnotify, flask }:
+
+buildPythonApplication rec {
+  pname = "pyca";
+  version = "2.1";
+
+  src = fetchFromGitHub {
+    owner = "opencast";
+    repo = "pyCA";
+    rev = "v${version}";
+    sha256 = "0cvkmdlcax9da9iw4ls73vw0pxvm8wvchab5gwdy9w9ibqdpcmwh";
+  };
+
+  propagatedBuildInputs = [
+    pycurl
+    dateutil
+    configobj
+    sqlalchemy
+    sdnotify
+    flask
+  ];
+
+  meta = with stdenv.lib; {
+    description = "A fully functional Opencast capture agent written in Python";
+    homepage = https://github.com/opencast/pyCA;
+    license = licenses.lgpl3;
+    maintainers = with maintainers; [ pmiddend ];
+  };
+}
+

pkgs/applications/virtualization/driver/win-spice/default.nix

···
 
 let
   src_usbdk_x86 = fetchurl {
-    url = "http://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.4_x86.msi";
+    url = "https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.4_x86.msi";
     sha256 = "17hv8034wk1xqnanm5jxs4741nl7asps1fdz6lhnrpp6gvj6yg9y";
   };
 
   src_usbdk_amd64 = fetchurl {
-    url = "http://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.4_x64.msi";
+    url = "https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.4_x64.msi";
     sha256 = "0alcqsivp33pm8sy0lmkvq7m5yh6mmcmxdl39zjxjra67kw8r2sd";
   };
 
   src_qxlwddm = fetchurl {
-    url = "http://people.redhat.com/~vrozenfe/qxlwddm/qxlwddm-0.11.zip";
+    url = "https://people.redhat.com/~vrozenfe/qxlwddm/qxlwddm-0.11.zip";
     sha256 = "082zdpbh9i3bq2ds8g33rcbcw390jsm7cqf46rrlx02x8r03dm98";
   };
 
   src_vdagent_x86 = fetchurl {
-    url = "http://www.spice-space.org/download/windows/vdagent/vdagent-win-0.7.3/vdagent_0_7_3_x86.zip";
+    url = "https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.7.3/vdagent_0_7_3_x86.zip";
     sha256 = "0d928g49rf4dl79jmvnqh6g864hp1flw1f0384sfp82himm3bxjs";
   };
 
   src_vdagent_amd64 = fetchurl {
-    url = "http://www.spice-space.org/download/windows/vdagent/vdagent-win-0.7.3/vdagent_0_7_3_x64.zip";
+    url = "https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.7.3/vdagent_0_7_3_x64.zip";
     sha256 = "0djmvm66jcmcyhhbjppccbai45nqpva7vyvry6w8nyc0fwi1vm9l";
   };
 in
···
       (copy "amd64" "w8.1") + (copy "x86" "w8.1");
 
   meta = with stdenv.lib; {
-    description = ''Windows SPICE Drivers'';
-    homepage = http://www.spice-space.org;
+    description = "Windows SPICE Drivers";
+    homepage = https://www.spice-space.org/;
+    license = [ licenses.asl20 ]; # See https://github.com/vrozenfe/qxl-dod
     maintainers = [ maintainers.tstrobel ];
     platforms = platforms.linux;
   };

pkgs/applications/virtualization/spice-vdagent/default.nix

···
          to the client resolution
        * Multiple displays
     '';
-    homepage = http://www.spice-space.org/home.html;
+    homepage = https://www.spice-space.org/;
     license = stdenv.lib.licenses.gpl3;
     maintainers = [ stdenv.lib.maintainers.aboseley ];
     platforms = stdenv.lib.platforms.linux;

pkgs/applications/window-managers/dwm/dwm-status.nix

···
 
 rustPlatform.buildRustPackage rec {
   name = "dwm-status-${version}";
-  version = "1.2.0";
+  version = "1.4.0";
 
   src = fetchFromGitHub {
     owner = "Gerschtli";
     repo = "dwm-status";
     rev = version;
-    sha256 = "0bv1jkqkf509akg3dvdy8b2q1kh8i75vw4n6a9rjvslx9s9nh6ca";
+    sha256 = "1v9ksv8hdxhpm7vs71p9s1y3gnahczza0w4wyrk2fsc6x2kwlh6x";
   };
 
   nativeBuildInputs = [ makeWrapper pkgconfig ];

pkgs/applications/window-managers/i3/status.nix

···
-{ fetchurl, stdenv, confuse, yajl, alsaLib, libpulseaudio, libnl, pkgconfig
+{ fetchurl, stdenv, libconfuse, yajl, alsaLib, libpulseaudio, libnl, pkgconfig
   }:
 
 stdenv.mkDerivation rec {
···
   };
 
   nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ confuse yajl alsaLib libpulseaudio libnl ];
+  buildInputs = [ libconfuse yajl alsaLib libpulseaudio libnl ];
 
   makeFlags = [ "all" "PREFIX=$(out)" ];
 

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

···
 
   passthru = {
     updateInfo = {
-      downloadPage = "http://sourceforge.net/projects/stalonetray/files/";
+      downloadPage = "https://sourceforge.net/projects/stalonetray/files/";
     };
   };
 }

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

···
       maintainers = with maintainers; [ mathnerd314 ];
     };
   };
-  noto-fonts-emoji = let version = "2018-04-24-pistol-update"; in stdenv.mkDerivation {
+  noto-fonts-emoji = let version = "2018-08-10-unicode11"; in stdenv.mkDerivation {
     name = "noto-fonts-emoji-${version}";
 
     src = fetchFromGitHub {
       owner = "googlei18n";
       repo = "noto-emoji";
       rev = "v${version}";
-      sha256 = "1f9k182j0619xvwk60gw2hng3lcd483sva2fabjdhznk8yf9f7jg";
+      sha256 = "1y54zsvwf5pqhcd9cl2zz5l52qyswn6kycvrq03zm5kqqsngbw3p";
     };
 
     buildInputs = [ cairo ];
···
       inherit version;
       description = "Color and Black-and-White emoji fonts";
       homepage = https://github.com/googlei18n/noto-emoji;
-      license = licenses.asl20;
+      license = with licenses; [ ofl asl20 ];
       platforms = platforms.all;
       maintainers = with maintainers; [ mathnerd314 ];
     };

pkgs/data/fonts/sarasa-gothic/default.nix

···
 { stdenv, fetchurl, p7zip }:
 
-stdenv.mkDerivation rec {
+let
   version = "0.6.0";
+  sha256 = "08g3kzplp3v8kvni1vzl73fgh03xgfl8pwqyj7vwjihjdr1xfjyz";
+in fetchurl rec {
+  inherit sha256;
+
   name = "sarasa-gothic-${version}";
 
-  package = fetchurl {
-    url = "https://github.com/be5invis/Sarasa-Gothic/releases/download/v${version}/sarasa-gothic-ttf-${version}.7z";
-    sha256 = "00kyx03lpgycxaw0cyx96hhrx8gwkcmy3qs35q7r09y60vg5i0nv";
-  };
+  url = "https://github.com/be5invis/Sarasa-Gothic/releases/download/v${version}/sarasa-gothic-ttc-${version}.7z";
 
-  nativeBuildInputs = [ p7zip ];
+  recursiveHash = true;
+  downloadToTemp = true;
 
-  unpackPhase = ''
-    7z x $package
-  '';
-
-  installPhase = ''
-    mkdir -p $out/share/fonts/truetype
-    cp *.ttf $out/share/fonts/truetype
+  postFetch = ''
+    ${p7zip}/bin/7z x $downloadedFile
+    mkdir -p $out/share/fonts
+    install -m644 *.ttc $out/share/fonts/
   '';
 
   meta = with stdenv.lib; {
···
     license = licenses.ofl;
     maintainers = [ maintainers.ChengCat ];
     platforms = platforms.all;
-    # large package, mainly i/o bound
-    hydraPlatforms = [];
   };
 }

pkgs/data/fonts/twemoji-color-font/default.nix

···
     owner = "eosrei";
     repo = "twemoji-color-font";
     rev = "v${meta.version}";
-    sha256 = "0z8r7z2r0r2wng4a7hvqvkcpd43l0d57yl402r7ci5bnmb02yvsa";
+    sha256 = "07yawvbdkk15d7ac9dj7drs1rqln9sba1fd6jx885ms7ww2sfm7r";
   };
 
   nativeBuildInputs = [ inkscape imagemagick potrace svgo scfbuild ];
···
   '';
 
   meta = with stdenv.lib; {
-    version = "1.4";
+    version = "11.2.0";
     description = "Color emoji SVGinOT font using Twitter Unicode 10 emoji with diversity and country flags";
     longDescription = ''
       A color and B&W emoji SVGinOT font built from the Twitter Emoji for

pkgs/data/misc/hackage/default.nix

···
 { fetchurl }:
 
 fetchurl {
-  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/3487551670de487866a34bd466b33b5146087882.tar.gz";
-  sha256 = "10kag8qmlsnj3qwq0zxb6apd2z7jg17srvhsax5lgbwvlymbnckb";
+  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/95366a34cd5c9b47444ac819562fff2f23d7d753.tar.gz";
+  sha256 = "184qrgb7jl1s79v4z1jz9ywihilf60jh93xhwf0n75vnxb4ibnfd";
 }

pkgs/data/misc/mailcap/default.nix

···
+{ lib, fetchzip }:
+
+let
+  version = "2.1.48";
+
+in fetchzip {
+  name = "mailcap-${version}";
+
+  url = "https://releases.pagure.org/mailcap/mailcap-${version}.tar.xz";
+  sha256 = "0m1rls4z85aby9fggwx2x70b4y6l0jjyiqdv30p8g91nv8hrq9fw";
+
+  postFetch = ''
+    tar -xavf $downloadedFile --strip-components=1
+    substituteInPlace mailcap --replace "/usr/bin/" ""
+    gzip mailcap.4
+
+    install -D -m0644 -t $out/etc mailcap mime.types
+    install -D -m0644 -t $out/share/man/man4 mailcap.4.gz
+  '';
+
+  meta = with lib; {
+    description = "Helper application and MIME type associations for file types";
+    homepage = "https://pagure.io/mailcap";
+    license = licenses.mit;
+    maintainers = with maintainers; [ c0bw3b ];
+    platforms = platforms.all;
+  };
+}

pkgs/development/compilers/ghc/8.4.4.nix

···
 
 # build-tools
 , bootPkgs
-, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4
+, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx
 
 , libiconv ? null, ncurses
 
···
   strictDeps = true;
 
   nativeBuildInputs = [
-    perl autoconf automake m4 python3
+    perl autoconf automake m4 python3 sphinx
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
   ];
 

pkgs/development/compilers/ghc/8.6.1.nix

···
 
 # build-tools
 , bootPkgs
-, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4
+, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx
 
 , libiconv ? null, ncurses
 
···
   strictDeps = true;
 
   nativeBuildInputs = [
-    perl autoconf automake m4 python3
+    perl autoconf automake m4 python3 sphinx
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
   ];
 

pkgs/development/compilers/ghc/8.6.2.nix

···
 
 # build-tools
 , bootPkgs
-, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4
+, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx
 
 , libiconv ? null, ncurses
 
···
   strictDeps = true;
 
   nativeBuildInputs = [
-    perl autoconf automake m4 python3
+    perl autoconf automake m4 python3 sphinx
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
   ];
 

pkgs/development/compilers/ghc/head.nix

···
 
 # build-tools
 , bootPkgs
-, autoconf, automake, coreutils, fetchgit, perl, python3, m4
+, autoconf, automake, coreutils, fetchgit, perl, python3, m4, sphinx
 
 , libiconv ? null, ncurses
 

pkgs/development/haskell-modules/configuration-common.nix

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "0dnrihpdshrldais74jm5wjfw650i4va8znc1k2zq8gl9p4i8p39";
+      sha256 = "0f0pp0d5q4122cjh4j7iasnjh234fmkvlwgb3f49087cg8rr2czh";
     };
   }).override {
     dbus = if pkgs.stdenv.isLinux then self.dbus else null;

pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix

···
 
   # LTS-12.x versions do not compile.
   base-orphans = self.base-orphans_0_8;
-  brick = self.brick_0_41_3;
+  brick = self.brick_0_41_4;
   cassava-megaparsec = doJailbreak super.cassava-megaparsec;
   config-ini = doJailbreak super.config-ini;   # https://github.com/aisamanra/config-ini/issues/18
   contravariant = self.contravariant_1_5;

pkgs/development/haskell-modules/configuration-ghc-head.nix

···
   xhtml = null;
 
   # jailbreak-cabal can use the native Cabal library.
-  jailbreak-cabal = pkgs.haskell.packages.ghc802.jailbreak-cabal;
+  jailbreak-cabal = super.jailbreak-cabal.override { Cabal = null; };
 
   # haddock: No input file(s).
   nats = dontHaddock super.nats;

pkgs/development/haskell-modules/hackage-packages.nix

···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "DAV_1_3_3" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , data-default, exceptions, haskeline, http-client, http-client-tls
+     , http-types, lens, mtl, network, network-uri, optparse-applicative
+     , transformers, transformers-base, transformers-compat, utf8-string
+     , xml-conduit, xml-hamlet
+     }:
+     mkDerivation {
+       pname = "DAV";
+       version = "1.3.3";
+       sha256 = "149rdrbjx59a2rbx2r6fzhmyl3f35a2gbh4sarbpffv0pmirrx14";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers data-default exceptions
+         http-client http-client-tls http-types lens mtl transformers
+         transformers-base transformers-compat utf8-string xml-conduit
+         xml-hamlet
+       ];
+       executableHaskellDepends = [
+         base bytestring case-insensitive containers data-default exceptions
+         haskeline http-client http-client-tls http-types lens mtl network
+         network-uri optparse-applicative transformers transformers-base
+         transformers-compat utf8-string xml-conduit xml-hamlet
+       ];
+       description = "RFC 4918 WebDAV support";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "DBFunctor" = callPackage
     ({ mkDerivation, base, bytestring, cassava, cereal, containers
      , deepseq, either, MissingH, text, transformers
···
     ({ mkDerivation, base, bytestring, containers, parseargs }:
      mkDerivation {
        pname = "WAVE";
-       version = "0.1.3";
-       sha256 = "1cgla9y1lwcsdad5qdspymd7s6skdw961fgzh02kvi7gjbrrcyi7";
+       version = "0.1.4";
+       sha256 = "1zr2sw3m0pwbn5qfxhgf8195f4pjj3azc2w849l0cdi3znvmlxih";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
···
      }:
      mkDerivation {
        pname = "adblock2privoxy";
-       version = "1.4.2";
-       sha256 = "17ikb90zwz3vvs9yg3z83pzs442vy5nx0h44i64akn10aykw8hic";
+       version = "2.0.0";
+       sha256 = "0wd6zavym2afw7ba2h6i5snwp5gyq64q81gwwlw7y0kslv3xkaw9";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "aeson_1_4_1_0" = callPackage
+  "aeson_1_4_2_0" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat, base-orphans
-     , base16-bytestring, bytestring, containers, deepseq, directory
-     , dlist, filepath, generic-deriving, ghc-prim, hashable
+     , base16-bytestring, bytestring, containers, contravariant, deepseq
+     , directory, dlist, filepath, generic-deriving, ghc-prim, hashable
      , hashable-time, integer-logarithms, primitive, QuickCheck
      , quickcheck-instances, scientific, tagged, tasty, tasty-hunit
      , tasty-quickcheck, template-haskell, text, th-abstraction, time
···
      }:
      mkDerivation {
        pname = "aeson";
-       version = "1.4.1.0";
-       sha256 = "1mf29mxdqkpgbvqx1acbbv75wpzhwpnnf4iapmm5v3zg2k7g3hyi";
-       revision = "1";
-       editedCabalFile = "12zvcm121dc0fpyzm1wr0b9k5lwyca298vgvf192sp2dykxkj9m7";
+       version = "1.4.2.0";
+       sha256 = "1l4b675nxddim3v30kd7zr3vmrs7i1m81rh8h9bfbm9k9a0p3kkm";
        libraryHaskellDepends = [
-         attoparsec base base-compat bytestring containers deepseq dlist
-         ghc-prim hashable primitive scientific tagged template-haskell text
-         th-abstraction time time-locale-compat unordered-containers
-         uuid-types vector
+         attoparsec base base-compat bytestring containers contravariant
+         deepseq dlist ghc-prim hashable primitive scientific tagged
+         template-haskell text th-abstraction time time-locale-compat
+         unordered-containers uuid-types vector
        ];
        testHaskellDepends = [
          attoparsec base base-compat base-orphans base16-bytestring
···
        pname = "aeson-diff";
        version = "1.1.0.5";
        sha256 = "1kzvqzbl6pp5g49dp4qqc7cbisnkpqz0i18b6nmdb7f1nrhdvnb1";
+       revision = "1";
+       editedCabalFile = "0a29nph4a1ny365nhsxlm73mk6zgaam4sfx6knzqjy8dxp1gkj48";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "api-tools" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, alex, array, attoparsec, base
-     , base16-bytestring, base64-bytestring, binary, bytestring, Cabal
+     , base16-bytestring, base64-bytestring, bytestring, Cabal
      , case-insensitive, cborg, containers, deepseq, happy, lens
      , QuickCheck, regex-compat-tdfa, safe, safecopy, scientific
      , serialise, tasty, tasty-hunit, tasty-quickcheck, template-haskell
···
      }:
      mkDerivation {
        pname = "api-tools";
-       version = "0.8.0.1";
-       sha256 = "19a2g5rym3cydbdb9b6x0rm7xdw2m5ckqdzb02yblx9pv045nfzx";
+       version = "0.8.0.2";
+       sha256 = "0q10vqaf4y3zwa2nrwllxi8ac8ch6jjr4r3s5g6gy51bp04ggzv9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty array attoparsec base base16-bytestring
-         base64-bytestring binary bytestring Cabal case-insensitive cborg
+         base64-bytestring bytestring Cabal case-insensitive cborg
          containers deepseq lens QuickCheck regex-compat-tdfa safe safecopy
          scientific serialise template-haskell text time
          unordered-containers vector
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
-         aeson aeson-pretty array attoparsec base base64-bytestring
-         bytestring case-insensitive cborg containers deepseq lens
-         QuickCheck regex-compat-tdfa safe safecopy serialise
-         template-haskell text time unordered-containers vector
+         aeson aeson-pretty base bytestring deepseq QuickCheck serialise
        ];
        testHaskellDepends = [
-         aeson aeson-pretty array attoparsec base base64-bytestring
-         bytestring Cabal case-insensitive cborg containers lens QuickCheck
-         regex-compat-tdfa safe safecopy serialise tasty tasty-hunit
+         aeson aeson-pretty base base64-bytestring bytestring Cabal cborg
+         containers QuickCheck safecopy serialise tasty tasty-hunit
          tasty-quickcheck template-haskell text time unordered-containers
-         vector
        ];
        description = "DSL for generating API boilerplate and docs";
        license = stdenv.lib.licenses.bsd3;
···
 
   "ats-pkg" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, binary, bytestring, bzlib
-     , Cabal, cli-setup, composition-prelude, containers, dependency
-     , dhall, directory, file-embed, filemanip, filepath, http-client
-     , http-client-tls, lzma, microlens, mtl, optparse-applicative
-     , parallel-io, process, shake, shake-ats, shake-c, shake-ext, tar
-     , temporary, text, unix, zip-archive, zlib
+     , Cabal, cli-setup, composition-prelude, containers, cpphs
+     , dependency, dhall, directory, file-embed, filemanip, filepath
+     , http-client, http-client-tls, lzma, microlens, mtl
+     , optparse-applicative, parallel-io, process, shake, shake-ats
+     , shake-c, shake-ext, tar, temporary, text, unix, zip-archive, zlib
      }:
      mkDerivation {
        pname = "ats-pkg";
-       version = "3.2.4.0";
-       sha256 = "0pj7zyf38rbi48lh8jhcm54wrflkdyh1583d9h4iy9nj5apa85ip";
+       version = "3.2.4.2";
+       sha256 = "168mgwx0m2kriz494r9isd27rflfh4np7pjm1hxzwc8pnyd3mdx9";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          microlens mtl parallel-io process shake shake-ats shake-c shake-ext
          tar text unix zip-archive zlib
        ];
+       libraryToolDepends = [ cpphs ];
        executableHaskellDepends = [
          base bytestring cli-setup dependency directory microlens
          optparse-applicative parallel-io shake shake-ats temporary text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "brick_0_41_3" = callPackage
+  "brick_0_41_4" = callPackage
     ({ mkDerivation, base, config-ini, containers, contravariant
      , data-clist, deepseq, dlist, microlens, microlens-mtl
      , microlens-th, QuickCheck, stm, template-haskell, text
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "0.41.3";
-       sha256 = "19hfcfsalffk0ayi0wjyha08j5wz8pkbw14z5dl26isxdfx1mbb2";
+       version = "0.41.4";
+       sha256 = "1mmdzirpqfwg03dng09i91nkzvv7765flj7xaw79grwwx6xchpnq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "co-log-sys" = callPackage
-    ({ mkDerivation, aeson, base-noprelude, co-log-core, fmt
-     , loot-prelude, microlens, monad-control, mtl, network, universum
-     , unix
+    ({ mkDerivation, aeson, base, co-log-core, fmt, microlens
+     , monad-control, mtl, network, universum, unix
      }:
      mkDerivation {
        pname = "co-log-sys";
-       version = "0.1.0.0";
-       sha256 = "02lh14jhl5qyjlacbp62a6193fqc6p3nk30pksnw5zz8dsyj5iz2";
+       version = "0.1.1.0";
+       sha256 = "12qpbil3zzh7hy28fms4hc1pfmkf9bxqncimwz3mqys7gc3qzi3x";
        libraryHaskellDepends = [
-         aeson base-noprelude co-log-core fmt loot-prelude microlens
-         monad-control mtl network universum unix
+         aeson base co-log-core fmt microlens monad-control mtl network
+         universum unix
        ];
        testHaskellDepends = [
-         aeson base-noprelude co-log-core fmt loot-prelude microlens
-         monad-control mtl network universum unix
+         aeson base co-log-core fmt microlens monad-control mtl network
+         universum unix
        ];
        description = "Syslog implementation on top of 'co-log-core'";
        license = stdenv.lib.licenses.mpl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {loot-prelude = null;};
+     }) {};
 
   "coalpit" = callPackage
     ({ mkDerivation, base, generic-random, megaparsec, network-uri
···
     ({ mkDerivation, base, constraints, template-haskell }:
      mkDerivation {
        pname = "constraints-extras";
-       version = "0.2.0.0";
-       sha256 = "0id5xaij014vabzkbnl54h8km667vk1mz8dk27kdzfa5vg6pj8j8";
+       version = "0.2.1.0";
+       sha256 = "17rz4j5xgh4qn8ngd4b2814zdp1c59mcksg9jxbln6nvzvw7q0ng";
        libraryHaskellDepends = [ base constraints template-haskell ];
        description = "Utility package for constraints";
        license = stdenv.lib.licenses.bsd3;
···
        testHaskellDepends = [ base HUnit QuickCheck ];
        description = "An Enigma machine simulator with display";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "crypto-enigma_0_1_1_1" = callPackage
+    ({ mkDerivation, ansi-terminal, base, containers, HUnit
+     , optparse-applicative, QuickCheck, split, text
+     }:
+     mkDerivation {
+       pname = "crypto-enigma";
+       version = "0.1.1.1";
+       sha256 = "0cfkzmgszvlwi4cylzxi2fpniw9a4ral4c6nyrdzjjdij55prafj";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers split text ];
+       executableHaskellDepends = [
+         ansi-terminal base containers optparse-applicative split text
+       ];
+       testHaskellDepends = [ base HUnit QuickCheck ];
+       description = "An Enigma machine simulator with display";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "crypto-multihash" = callPackage
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "dbus_1_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, conduit, containers
+     , criterion, deepseq, directory, exceptions, extra, filepath, lens
+     , network, parsec, process, QuickCheck, random, resourcet, split
+     , tasty, tasty-hunit, tasty-quickcheck, template-haskell, text
+     , th-lift, transformers, unix, vector, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "dbus";
+       version = "1.1.0";
+       sha256 = "0r0q69ml5nl45lgiwv3g2zggz8cychysxmplbyks8n50qa7h414j";
+       libraryHaskellDepends = [
+         base bytestring cereal conduit containers deepseq exceptions
+         filepath lens network parsec random split template-haskell text
+         th-lift transformers unix vector xml-conduit xml-types
+       ];
+       testHaskellDepends = [
+         base bytestring cereal containers directory extra filepath network
+         parsec process QuickCheck random resourcet tasty tasty-hunit
+         tasty-quickcheck text transformers unix vector
+       ];
+       benchmarkHaskellDepends = [ base criterion ];
+       doCheck = false;
+       description = "A client library for the D-Bus IPC system";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "dbus-client" = callPackage
     ({ mkDerivation, base, containers, dbus-core, monads-tf, text
      , transformers
···
      }:
      mkDerivation {
        pname = "deferred-folds";
-       version = "0.9.9";
-       sha256 = "1hsfz93h6d4bzrllgmqr22ankl5pas3vlwg2yhbbcfpf35pdk9vd";
+       version = "0.9.9.1";
+       sha256 = "0dq914blk3w8yw29aw7pm4f3chkjh1v0jwvc1kr1j3v46jjxq17n";
        libraryHaskellDepends = [
          base bytestring containers foldl hashable primitive transformers
          unordered-containers vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall_1_18_0" = callPackage
+  "dhall_1_19_0" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, case-insensitive
      , cborg, containers, contravariant, criterion, cryptonite, deepseq
      , Diff, directory, doctest, exceptions, filepath, haskeline
···
      , prettyprinter, prettyprinter-ansi-terminal, QuickCheck
      , quickcheck-instances, repline, scientific, serialise, tasty
      , tasty-hunit, tasty-quickcheck, template-haskell, text
-     , transformers, unordered-containers, vector
+     , transformers, unordered-containers, uri-encode, vector
      }:
      mkDerivation {
        pname = "dhall";
-       version = "1.18.0";
-       sha256 = "155bmfk4ivjvffyj0zbd21hwg47blswgydhnys2s0zvm9zzyqa5m";
+       version = "1.19.0";
+       sha256 = "1sz24w3vl0jffdv392kxdp01z823cbssk8w687v7gg27sdliq4gz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          haskeline http-client http-client-tls lens-family-core megaparsec
          memory mtl optparse-applicative parsers prettyprinter
          prettyprinter-ansi-terminal repline scientific serialise
-         template-haskell text transformers unordered-containers vector
+         template-haskell text transformers unordered-containers uri-encode
+         vector
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-bash_1_0_16" = callPackage
+  "dhall-bash_1_0_17" = callPackage
     ({ mkDerivation, base, bytestring, containers, dhall
      , neat-interpolation, optparse-generic, shell-escape, text
      }:
      mkDerivation {
        pname = "dhall-bash";
-       version = "1.0.16";
-       sha256 = "0zaz38df08fyfil11906agmz7vfz9wapxszzizyvvp9zid5gx58g";
+       version = "1.0.17";
+       sha256 = "0z3wp25rj9czsmycs5h2sy76mnh9d8lxabngn2wbf1r6wbp6bpfv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-json_1_2_4" = callPackage
+  "dhall-json_1_2_5" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, dhall
      , optparse-applicative, tasty, tasty-hunit, text
      , unordered-containers, vector, yaml
      }:
      mkDerivation {
        pname = "dhall-json";
-       version = "1.2.4";
-       sha256 = "1rv3vf5g3cwiy0ps1yn9jnhk56rbw7fci54xj9fj4iwc2rxb9575";
+       version = "1.2.5";
+       sha256 = "0zdxv43kj8dp2w9hy4px9xf785ybs9jy5pzhzybiagq428k4kcbf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Template text using Dhall";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "dhall-text_1_0_14" = callPackage
+    ({ mkDerivation, base, dhall, optparse-applicative, text }:
+     mkDerivation {
+       pname = "dhall-text";
+       version = "1.0.14";
+       sha256 = "1485p4fazh3qcbb9khj1pk4f2gh6p6927sabh6miswczdn78z6sy";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base dhall optparse-applicative text
+       ];
+       description = "Template text using Dhall";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "dhall-to-cabal" = callPackage
···
      }:
      mkDerivation {
        pname = "egison-tutorial";
-       version = "3.7.12";
-       sha256 = "16dpqwp96ngc15igzxhkn7waxynnxy87lx5j1flp5dj2v71fx17m";
+       version = "3.7.14";
+       sha256 = "1ar5yg00arqd09wva0q1y4d8lfpd0vjw9sgk47jsyqs7ydm59hnb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "escaped" = callPackage
+    ({ mkDerivation, base, doctest, hspec, QuickCheck
+     , quickcheck-instances, quickcheck-properties, text, unix
+     }:
+     mkDerivation {
+       pname = "escaped";
+       version = "1.0.0.0";
+       sha256 = "1fpnaj0ycjhb73skv5dxrycwyyvy0rripvcag88hsjyh1ybxx91v";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base QuickCheck quickcheck-instances text unix
+       ];
+       executableHaskellDepends = [ base text ];
+       testHaskellDepends = [
+         base doctest hspec QuickCheck quickcheck-properties
+       ];
+       description = "Produce Text with terminal escape sequences";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "escoger" = callPackage
     ({ mkDerivation, base, bytestring, criterion, HUnit, mtl
      , test-framework, test-framework-hunit, unix, vector
···
      }:
      mkDerivation {
        pname = "expiring-containers";
-       version = "0.2";
-       sha256 = "1bqcxq42x4s8kj7wpa9iqgaxww6m7vqzkd2dakry1ssy9dv8wp28";
+       version = "0.2.1";
+       sha256 = "0v8vk0lmvl4a1dm7vvwi9wx1pqyrphxbiwj11fxpr2k1ybycjw54";
        libraryHaskellDepends = [
          base containers hashable int-multimap time timestamp
          unordered-containers
···
      }:
      mkDerivation {
        pname = "fast-arithmetic";
-       version = "0.6.4.1";
-       sha256 = "0rnbqj495lj2c5xmk35iwhlx6h4m14b35hqz73adspm4ryym00b3";
-       revision = "2";
-       editedCabalFile = "0hla00m1v9sk480yif3kgi2zzqq7snfz6san3yznigpxqzq5rczm";
+       version = "0.6.4.2";
+       sha256 = "1jfdwhbw6g435p7waspg19viykqlqqqc7n8m75j34a8vwqyh5zpa";
        libraryHaskellDepends = [ base hgmp ];
        testHaskellDepends = [ arithmoi base combinat hspec QuickCheck ];
        benchmarkHaskellDepends = [ arithmoi base combinat criterion ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "filecache_0_4_1" = callPackage
+    ({ mkDerivation, base, containers, directory, exceptions, filepath
+     , fsnotify, hspec, mtl, stm, strict-base-types, temporary, time
+     }:
+     mkDerivation {
+       pname = "filecache";
+       version = "0.4.1";
+       sha256 = "17fbjdy2cicrd956317jj7fir0bd621c4zb5sb4991ph7jsah0n5";
+       libraryHaskellDepends = [
+         base containers directory exceptions filepath fsnotify mtl stm
+         strict-base-types time
+       ];
+       testHaskellDepends = [
+         base containers directory filepath hspec stm temporary
+       ];
+       description = "A cache system associating values to files";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "filediff" = callPackage
     ({ mkDerivation, base, bytestring, data-default
      , data-memocombinators, directory, either, hashmap, mtl, rainbow
···
      }) {};
 
   "fix-imports" = callPackage
-    ({ mkDerivation, base, containers, cpphs, directory, filepath
-     , haskell-src-exts, process, split, text, uniplate
+    ({ mkDerivation, base, containers, cpphs, deepseq, directory
+     , filepath, haskell-src-exts, mtl, pretty, process, split
+     , test-karya, text, time, uniplate
      }:
      mkDerivation {
        pname = "fix-imports";
-       version = "1.1.0";
-       sha256 = "1w2j7l6515khp0zl3cf6pyxsv55c65qqfcxi94vikd8fk88sswd9";
+       version = "2.1.0";
+       sha256 = "1qi877cpfkp7lzdjwq2q6gqqkbvby63z6r22f3ydkx5362ins6kh";
        isLibrary = false;
        isExecutable = true;
-       enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base containers cpphs directory filepath haskell-src-exts process
-         split text uniplate
+         base containers cpphs deepseq directory filepath haskell-src-exts
+         pretty process split text time uniplate
+       ];
+       testHaskellDepends = [
+         base containers cpphs deepseq directory filepath haskell-src-exts
+         mtl pretty process split test-karya text time uniplate
        ];
        description = "Program to manage the imports of a haskell module";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fuzzyset_0_1_0_7" = callPackage
+    ({ mkDerivation, base, base-unicode-symbols, data-default, hspec
+     , ieee754, lens, text, text-metrics, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "fuzzyset";
+       version = "0.1.0.7";
+       sha256 = "1smkvbz22dfx1d99dcb0p1j4bnkw1jd553ca6zkqhk0yqvhm2w4q";
+       libraryHaskellDepends = [
+         base base-unicode-symbols data-default lens text text-metrics
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         base base-unicode-symbols hspec ieee754 lens text
+         unordered-containers
+       ];
+       description = "Fuzzy set for approximate string matching";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "fuzzytime" = callPackage
     ({ mkDerivation, base, cmdargs, directory, old-time, process }:
      mkDerivation {
···
      , byteable, bytestring, Cabal, case-insensitive, concurrent-output
      , conduit, connection, containers, crypto-api, cryptonite, curl
      , data-default, DAV, dbus, directory, disk-free-space, dlist
-     , edit-distance, esqueleto, exceptions, fdo-notify, feed, filepath
-     , free, git, gnupg, hinotify, hslogger, http-client
-     , http-client-tls, http-conduit, http-types, IfElse, lsof, magic
-     , memory, microlens, monad-control, monad-logger, mountpoints, mtl
-     , network, network-info, network-multicast, network-uri, old-locale
-     , openssh, optparse-applicative, perl, persistent
-     , persistent-sqlite, persistent-template, process, QuickCheck
-     , random, regex-tdfa, resourcet, rsync, SafeSemaphore, sandi
-     , securemem, socks, split, stm, stm-chans, tagsoup, tasty
-     , tasty-hunit, tasty-quickcheck, tasty-rerun, text, time, torrent
-     , transformers, unix, unix-compat, unordered-containers
-     , utf8-string, uuid, vector, wget, which
+     , edit-distance, exceptions, fdo-notify, feed, filepath, free, git
+     , gnupg, hinotify, hslogger, http-client, http-client-tls
+     , http-conduit, http-types, IfElse, lsof, magic, memory, microlens
+     , monad-control, monad-logger, mountpoints, mtl, network
+     , network-info, network-multicast, network-uri, old-locale, openssh
+     , optparse-applicative, perl, persistent, persistent-sqlite
+     , persistent-template, process, QuickCheck, random, regex-tdfa
+     , resourcet, rsync, SafeSemaphore, sandi, securemem, socks, split
+     , stm, stm-chans, tagsoup, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-rerun, text, time, torrent, transformers, unix, unix-compat
+     , unordered-containers, utf8-string, uuid, vector, wget, which
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "7.20181105";
-       sha256 = "0jh49bfgsccrvhdgyp1xp5rj0vp9iz8kkmh1x5cmrsjajs8qdpw3";
+       version = "7.20181121";
+       sha256 = "07fbnz3rr9dq76zx6cpxdxppkgb7wwhbrm9y89jdcpn8giaz0i6h";
        configureFlags = [
          "-fassistant" "-fcryptonite" "-fdbus" "-fdesktopnotify" "-fdns"
          "-ffeed" "-finotify" "-fpairing" "-fproduction" "-fquvi" "-f-s3"
···
          aeson async attoparsec base bloomfilter byteable bytestring
          case-insensitive concurrent-output conduit connection containers
          crypto-api cryptonite data-default DAV dbus directory
-         disk-free-space dlist edit-distance esqueleto exceptions fdo-notify
-         feed filepath free hinotify hslogger http-client http-client-tls
+         disk-free-space dlist edit-distance exceptions fdo-notify feed
+         filepath free hinotify hslogger http-client http-client-tls
          http-conduit http-types IfElse magic memory microlens monad-control
          monad-logger mountpoints mtl network network-info network-multicast
          network-uri old-locale optparse-applicative persistent
···
      }:
      mkDerivation {
        pname = "githash";
-       version = "0.1.2.0";
-       sha256 = "0pwh0s4gfddy0ixx92ww00v9qam2cx047ivqcm373fw5h2h1vrq8";
+       version = "0.1.3.0";
+       sha256 = "0rnp5ljrb05kd127fy2s5jlxjvjfs50dar92pahb36w2qw2clnp7";
        libraryHaskellDepends = [
          base bytestring directory filepath process template-haskell
        ];
···
        ];
        description = "Haskell binding for Gremlin graph query language";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "greskell_0_2_2_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, doctest, doctest-discover
+     , exceptions, greskell-core, hint, hspec, semigroups, text
+     , transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "greskell";
+       version = "0.2.2.0";
+       sha256 = "1ka4iqfyr03dj2kw22h1gik70cfhhvn870w9q9fd42n2k794snbz";
+       libraryHaskellDepends = [
+         aeson base exceptions greskell-core semigroups text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring doctest doctest-discover greskell-core hint
+         hspec text unordered-containers
+       ];
+       description = "Haskell binding for Gremlin graph query language";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "greskell-core" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hedis_0_10_6" = callPackage
+  "hedis_0_10_8" = callPackage
     ({ mkDerivation, async, base, bytestring, bytestring-lexing
      , deepseq, doctest, errors, HTTP, HUnit, mtl, network, network-uri
-     , resource-pool, scanner, slave-thread, stm, test-framework
-     , test-framework-hunit, text, time, tls, unordered-containers
-     , vector
+     , resource-pool, scanner, stm, test-framework, test-framework-hunit
+     , text, time, tls, unordered-containers, vector
      }:
      mkDerivation {
        pname = "hedis";
-       version = "0.10.6";
-       sha256 = "0s5snr3qbr2yd1ij6ifsrjaabx24ppmckz7ygdsr6c2fd99hijai";
+       version = "0.10.8";
+       sha256 = "058lm0gfgqack5627ys1iwlwkqgcniqfnvjlabvhkq4643lgv6a1";
        libraryHaskellDepends = [
          async base bytestring bytestring-lexing deepseq errors HTTP mtl
          network network-uri resource-pool scanner stm text time tls
          unordered-containers vector
        ];
        testHaskellDepends = [
-         async base bytestring doctest HUnit mtl slave-thread stm
-         test-framework test-framework-hunit text time
+         async base bytestring doctest HUnit mtl stm test-framework
+         test-framework-hunit text time
        ];
        benchmarkHaskellDepends = [ base mtl time ];
        description = "Client library for the Redis datastore: supports full command set, pipelining";
···
      }:
      mkDerivation {
        pname = "hoauth2";
-       version = "1.8.2";
-       sha256 = "0bh6ngq9850bxl2m1qpvnanif5nz09k697rw3sk6djqkcw3lv305";
+       version = "1.8.3";
+       sha256 = "1mx0ifkcji8d30f4ar50jraj1sz91n6v803yfb4zaj9wppw2iz57";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hookup";
        version = "0.2.2";
        sha256 = "1q9w8j4g8j9ijfvwpng4i3k2b8pkf4ln27bcdaalnp9yyidmxlqf";
-       revision = "2";
-       editedCabalFile = "12x7h7yg0x9gqv9yj2snp3k221yzyphm1l7aixkz1szxp1pndfgy";
+       revision = "3";
+       editedCabalFile = "0fmnfnlcc5jg0na2723ibh26sch190s62d52g14gffh9fsl9icgy";
        libraryHaskellDepends = [
          attoparsec base bytestring HsOpenSSL HsOpenSSL-x509-system network
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) postgresql;};
 
-  "hpqtypes_1_6_0_0" = callPackage
+  "hpqtypes_1_6_1_0" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers
      , data-default-class, directory, exceptions, filepath, HUnit
      , lifted-base, monad-control, mtl, postgresql, QuickCheck, random
···
      }:
      mkDerivation {
        pname = "hpqtypes";
-       version = "1.6.0.0";
-       sha256 = "1aydpbkp5if7416dvswiygn7vfhgg7nza9p011gld18pr9mpsf5i";
-       revision = "4";
-       editedCabalFile = "0ap170l390j0iwxlrrqarnxqp2bbpfv0xjkxnwdri0ksw7p7h7i2";
+       version = "1.6.1.0";
+       sha256 = "02vh9l86dnayccvfq3cqmk6gbbwyqglnpg3mhr3v72vraxymm7jn";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          aeson async base bytestring containers data-default-class
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hprotoc_2_4_12" = callPackage
+    ({ mkDerivation, alex, array, base, binary, bytestring, containers
+     , directory, filepath, haskell-src-exts, mtl, parsec
+     , protocol-buffers, protocol-buffers-descriptor, utf8-string
+     }:
+     mkDerivation {
+       pname = "hprotoc";
+       version = "2.4.12";
+       sha256 = "0xj000ikh3y8dg5sbrl7ycb471qgra4khmk4kq079biasjvhf58a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base binary bytestring containers directory filepath
+         haskell-src-exts mtl parsec protocol-buffers
+         protocol-buffers-descriptor utf8-string
+       ];
+       libraryToolDepends = [ alex ];
+       executableHaskellDepends = [
+         array base binary bytestring containers directory filepath
+         haskell-src-exts mtl parsec protocol-buffers
+         protocol-buffers-descriptor utf8-string
+       ];
+       executableToolDepends = [ alex ];
+       description = "Parse Google Protocol Buffer specifications";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hprotoc-fork" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , directory, filepath, haskell-src-exts, mtl, parsec
···
     ({ mkDerivation, base, HUnit, lens }:
      mkDerivation {
        pname = "hsPID";
-       version = "0.1";
-       sha256 = "16ks8pvpd0rcw11zinzlldv21i6mbcbrnnq3j9z3vmcjpd25wzim";
+       version = "0.1.1";
+       sha256 = "0wdafvzgnmgm365x9qwdcwzxcdmm71fllwqqcifx8dy88254qgik";
        libraryHaskellDepends = [ base lens ];
        testHaskellDepends = [ base HUnit lens ];
        description = "PID control loop";
···
     ({ mkDerivation, base, hspec, hspec-core, HUnit, leancheck }:
      mkDerivation {
        pname = "hspec-leancheck";
-       version = "0.0.2";
-       sha256 = "1780xhwmbvkhca3l6rckbnr92f7i3icarwprdcfnrrdpk4yq9ml8";
+       version = "0.0.3";
+       sha256 = "0lnqk4dkzqlzrq2hb72yv8xbbnps4bmjqz1qy9q47r8nrac8xpiq";
        libraryHaskellDepends = [ base hspec hspec-core HUnit leancheck ];
        testHaskellDepends = [ base hspec leancheck ];
        description = "LeanCheck support for the Hspec test framework";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hsyslog-udp_0_2_4" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hsyslog, network, text
+     , time, unix
+     }:
+     mkDerivation {
+       pname = "hsyslog-udp";
+       version = "0.2.4";
+       sha256 = "1xahxchr1il9naf8kdwdbh1sy5vv4afqkcxfy4993nsk5j7zs586";
+       libraryHaskellDepends = [
+         base bytestring hsyslog network text time unix
+       ];
+       testHaskellDepends = [ base hspec time ];
+       description = "Log to syslog over a network via UDP";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hszephyr" = callPackage
     ({ mkDerivation, base, bytestring, com_err, mtl, time, zephyr }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "http-conduit_2_3_3" = callPackage
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring
+     , case-insensitive, conduit, conduit-extra, connection, cookie
+     , data-default-class, hspec, http-client, http-client-tls
+     , http-types, HUnit, mtl, network, resourcet, streaming-commons
+     , temporary, text, time, transformers, unliftio, unliftio-core
+     , utf8-string, wai, wai-conduit, warp, warp-tls
+     }:
+     mkDerivation {
+       pname = "http-conduit";
+       version = "2.3.3";
+       sha256 = "1kqj9pzgw970y488yqm3xj90sfbm6gxyhzgn23mwq4i7nv5z1vc5";
+       libraryHaskellDepends = [
+         aeson base bytestring conduit conduit-extra http-client
+         http-client-tls http-types mtl resourcet transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base blaze-builder bytestring case-insensitive conduit
+         conduit-extra connection cookie data-default-class hspec
+         http-client http-types HUnit network resourcet streaming-commons
+         temporary text time transformers unliftio utf8-string wai
+         wai-conduit warp warp-tls
+       ];
+       doCheck = false;
+       description = "HTTP client package with conduit interface and HTTPS support";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "http-conduit-browser" = callPackage
     ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
      , case-insensitive, conduit, containers, cookie, data-default
···
      }:
      mkDerivation {
        pname = "hw-dsv";
-       version = "0.3.0";
-       sha256 = "0cpnzf8f4mk28jpxx66q8mv0gm3rassjp48r17hwzkalvw3ng3ni";
+       version = "0.3.1";
+       sha256 = "1fdc0hrcv1ypnkbfjazw0x4yzlsnrbfzddk0xvsqadhd3rl62slk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hw-prim_0_6_2_20" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, directory, exceptions
+     , hedgehog, hspec, hw-hspec-hedgehog, mmap, QuickCheck, semigroups
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "hw-prim";
+       version = "0.6.2.20";
+       sha256 = "05azmns8nvdpfhd0fi71slsgn8irghyx25rynipc44ff407c1maa";
+       libraryHaskellDepends = [
+         base bytestring mmap semigroups transformers vector
+       ];
+       testHaskellDepends = [
+         base bytestring directory exceptions hedgehog hspec
+         hw-hspec-hedgehog mmap QuickCheck semigroups transformers vector
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion mmap semigroups transformers vector
+       ];
+       description = "Primitive functions and data types";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hw-prim-bits" = callPackage
     ({ mkDerivation, base, criterion, hedgehog, hspec, hw-hedgehog
      , hw-hspec-hedgehog, QuickCheck, vector
···
        pname = "irc-core";
        version = "2.5.0";
        sha256 = "124zfp6s8hj7z3m873145bnr0z8xlkbr1qgj2hvasd2qs2zrb8y8";
+       revision = "1";
+       editedCabalFile = "06n7shnd8ij4wlzm5xhxdqv26b3am8mgbqfcvsqppk6hgmmyvggq";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring bytestring hashable primitive
          text time vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "json-feed_1_0_5" = callPackage
+       pname = "nanovg";
+       pname = "nanovg";
+     }:
+     mkDerivation {
+       pname = "nanovg";
+       version = "1.0.5";
+       sha256 = "17y8hnqp4ahg7cx6fwfd4y65pz16py1avhfkn4fcfjs06xv465qs";
+       libraryHaskellDepends = [
+       pname = "nanovg";
+       ];
+       testHaskellDepends = [
+       pname = "nanovg";
+         text time
+       ];
+       pname = "nanovg";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
        pname = "nanovg";
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
        pname = "nanovg";
···
        pname = "nanovg";
      mkDerivation {
        pname = "nanovg";
-       version = "0.1.1.0";
-       pname = "nanovg";
+       version = "0.2.0";
+       sha256 = "07bvdys7xlxds1q6hlqn299709k1fha81hap7jfn8snyjv3fdfal";
        pname = "nanovg";
        pname = "nanovg";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "lackey_1_0_7" = callPackage
+       pname = "nanovg";
+     mkDerivation {
+       pname = "nanovg";
+       version = "1.0.7";
+       sha256 = "0n90m4dsqfp4x4bckwxasg2cmjrzxp2szrlqf43pmp2dsc8g0646";
+       pname = "nanovg";
+       pname = "nanovg";
+       pname = "nanovg";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
        pname = "nanovg";
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "libssh2";
-       version = "0.2.0.6";
-       sha256 = "17v006ixkn9wblhnq1nyx1xi7sc9lshyh1ma2y82483w18n849s1";
+       version = "0.2.0.7";
+       sha256 = "05h0awwhqlswjjybw6y1p8byyvfggnx63n0cbqvknrkq338qfnyw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring network syb time unix ];
···
     ({ mkDerivation, base, containers, doctest, hedgehog }:
      mkDerivation {
        pname = "loc";
-       version = "0.1.3.3";
-       sha256 = "0vnnw8ix38r441czsgmcwn7iavvmy6v5c12qflhz0ah055ahl8xa";
+       version = "0.1.3.4";
+       sha256 = "1xdqnqr4wy3xw9vyfkf6c8xsq74nryhb8z31grcwpn6ppdgzyqy2";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers doctest hedgehog ];
        description = "Types representing line and column positions and ranges in text files";
···
     ({ mkDerivation, base, containers, hedgehog, loc }:
      mkDerivation {
        pname = "loc-test";
-       version = "0.1.3.3";
-       sha256 = "148nc6qy4afrw707kvq7k1052pfj717apsmr2b98x8w5xcc7f567";
+       version = "0.1.3.4";
+       sha256 = "1lzmyxm34zvkdz3piwmnhd7m0ijjnlwqbpi5lgbqvbrikbw579qp";
        libraryHaskellDepends = [ base containers hedgehog loc ];
        description = "Test-related utilities related to the /loc/ package";
        license = stdenv.lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "merkle-tree";
-       version = "0.1.0";
-       sha256 = "0k9ifkl8ywp0svn83rlczrq2s1aamwri2vx25cs42f64bgxr7ics";
-       revision = "1";
-       editedCabalFile = "1ibsr79qmzykn2i7p8zvzp8v79lsr54gc3zdqmfgk2cjx1x8k6dz";
+       version = "0.1.1";
+       sha256 = "1am2bfyzdhr2skvjwrvgkk7ihnili0z0lyigpy5lndrhc93n4ni1";
        libraryHaskellDepends = [
          base bytestring cereal cryptonite memory protolude random
        ];
···
          base bytestring cereal cryptonite memory protolude QuickCheck
          random tasty tasty-quickcheck
        ];
-       description = "An implementation of a Merkle Tree and merkle tree proofs";
+       description = "An implementation of a Merkle tree and merkle tree proofs of inclusion";
        license = stdenv.lib.licenses.asl20;
      }) {};
 
···
      }) {};
 
   "monopati" = callPackage
-    ({ mkDerivation, base, directory, free, hedgehog, split
+    ({ mkDerivation, base, directory, free, hedgehog, peano, split
      , transformers
      }:
      mkDerivation {
        pname = "monopati";
-       version = "0.1.3";
-       sha256 = "1g7n1m6df2c9rl99fii7x4a7z3xwv2mcvxd96gg1maji9709chqb";
-       libraryHaskellDepends = [ base directory free split ];
+       version = "0.1.4";
+       sha256 = "159r99x00vylxb50hyrb8xd67ag4x1mmrfddj5bq31bxiwb6j47s";
+       libraryHaskellDepends = [ base directory free peano split ];
        testHaskellDepends = [
-         base directory free hedgehog split transformers
+         base directory free hedgehog peano split transformers
        ];
        description = "Well-typed paths";
        license = stdenv.lib.licenses.bsd3;
···
 
   "multilinear" = callPackage
     ({ mkDerivation, base, containers, criterion, deepseq
-     , generic-random, mwc-random, primitive, QuickCheck
-     , quickcheck-instances, statistics, vector, weigh
+     , generic-random, parallel, QuickCheck, quickcheck-instances
+     , vector, weigh
      }:
      mkDerivation {
        pname = "multilinear";
-       version = "0.3.2.0";
-       sha256 = "0wjl4lzigbb7js99dd3i5kl081qqmrvk1w3kkjw7brasj8sqp01h";
+       version = "0.4.0.0";
+       sha256 = "1xiv3a9q2wfkgqy6xmz7qg0wdzgakbf4y5y5vxi85cz13lm2iny2";
        libraryHaskellDepends = [
-         base containers deepseq mwc-random primitive statistics vector
+         base containers deepseq parallel vector
        ];
        testHaskellDepends = [
          base containers deepseq generic-random QuickCheck
···
      }:
      mkDerivation {
        pname = "multilinear-io";
-       version = "0.3.0.0";
-       sha256 = "0228jy5qhydxliww13mxs7j287pcg43cnmgqrw0yb3ckghz0nf8w";
+       version = "0.4.0.0";
+       sha256 = "1zmhakpfmrcr0ikw4idd5k0iq5l7mm3idy329kwn5a2zcap7cmri";
+       revision = "1";
+       editedCabalFile = "1q7jzirjvc97xscx55pk01q1gqd0lb4g4ax2my45k8741mxclh3d";
        libraryHaskellDepends = [
          aeson base bytestring cassava cereal cereal-vector conduit either
          multilinear transformers vector zlib
···
        benchmarkHaskellDepends = [
          base criterion deepseq directory either multilinear transformers
        ];
-       description = "Input/output capability for multilinear package";
+       description = "Conduit-based input/output capability for multilinear package";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
     ({ mkDerivation, base, containers, megaparsec, Nmis }:
      mkDerivation {
        pname = "nmis-parser";
-       version = "0.1.0.1";
-       sha256 = "0fgh0x2b468j3pxx5nqkvq1wavgap9q7hdnypmdqn5v5jp45l36z";
+       version = "0.1.0.2";
+       sha256 = "0ad30rdpsd80ysqsaa72m3nnwzslr666ssnwlxyhvmbn3aqqvfbb";
        libraryHaskellDepends = [ base containers megaparsec ];
        testHaskellDepends = [ base Nmis ];
        description = "NMIS file parser";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "openapi-petstore" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , case-insensitive, containers, deepseq, exceptions, hspec
+     , http-api-data, http-client, http-client-tls, http-media
+     , http-types, iso8601-time, katip, microlens, mtl, network
+     , QuickCheck, random, safe-exceptions, semigroups, text, time
+     , transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "openapi-petstore";
+       version = "0.0.3.0";
+       sha256 = "1zm76djxnr2hrws3rhby144m2hqgwfk57cm3my2r26py76lf8c5i";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive containers
+         deepseq exceptions http-api-data http-client http-client-tls
+         http-media http-types iso8601-time katip microlens mtl network
+         random safe-exceptions text time transformers unordered-containers
+         vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec iso8601-time mtl QuickCheck
+         semigroups text time transformers unordered-containers vector
+       ];
+       description = "Auto-generated openapi-petstore API Client";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "opench-meteo" = callPackage
     ({ mkDerivation, aeson, base, data-default, text, time }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "pandoc-crossref";
-       version = "0.3.3.0";
-       sha256 = "0gnchg8z07g95wrsj9ywd308gy3h6ihrg7p50rw1dsszrdbfldiw";
+       version = "0.3.4.0";
+       sha256 = "15vfqpfkw4wnsg98804l5ylqbc926s2j5z4ik5zhval4d3kiamgz";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, base, doctest, hedgehog }:
      mkDerivation {
        pname = "partial-semigroup";
-       version = "0.4.0.1";
-       sha256 = "0jfdybqxqrkxwbvscgy6q6vp32jp5h9xbyfykxbvsc64h02kn6gs";
+       version = "0.5.0.0";
+       sha256 = "03wfizykalpnv2i2qmj2vm27ajs1s8kmzy7ynsh8b2l43nafixqm";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest hedgehog ];
        description = "A partial binary associative operator";
···
     ({ mkDerivation, base, hedgehog, partial-semigroup }:
      mkDerivation {
        pname = "partial-semigroup-hedgehog";
-       version = "0.4.0.1";
-       sha256 = "1nvfy1cwp7qv77bm0ax3ll7jmqciasq9gsyyrghsx18y1q2d8qzp";
+       version = "0.5.0.0";
+       sha256 = "17j27i0b971abz2j51a9nr599bqnwb65d2p1445a5s62hcz2jdzl";
        libraryHaskellDepends = [ base hedgehog partial-semigroup ];
        description = "Property testing for partial semigroups using Hedgehog";
        license = stdenv.lib.licenses.asl20;
···
     ({ mkDerivation, base, bytestring, path, safe-exceptions, text }:
      mkDerivation {
        pname = "path-text-utf8";
-       version = "0.0.1.1";
-       sha256 = "0c572nkkanz9n862q87q5jfpmg17v6flhl4201i67r7fp5icihwr";
+       version = "0.0.1.2";
+       sha256 = "1z8wyjsr7mgl120ayfl520i6p6s961380b1xy63zl7qp4cnnbhpn";
        libraryHaskellDepends = [
          base bytestring path safe-exceptions text
        ];
···
        pname = "pattern-trie";
        version = "0.1.0";
        sha256 = "1ldy1b81sryngf4rlfsw3f2qw0cirjnbvddvw98wrl2m50wzdmlg";
+       revision = "1";
+       editedCabalFile = "1v9f28gpns5v646hdzn7xfimq2v0sx3rws56r7lfh1qgcfdavy9f";
        libraryHaskellDepends = [
          base bytestring containers deepseq hashable text
          unordered-containers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "pinboard_0_9_12_11" = callPackage
+  "pinboard_0_10_0_2" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hspec
      , http-client, http-client-tls, http-types, monad-logger, mtl
-     , network, profunctors, QuickCheck, random, safe-exceptions
-     , semigroups, text, time, transformers, unordered-containers
+     , network, profunctors, QuickCheck, random, semigroups, text, time
+     , transformers, unliftio, unliftio-core, unordered-containers
      , vector
      }:
      mkDerivation {
        pname = "pinboard";
-       version = "0.9.12.11";
-       sha256 = "12vj9lg7l2nb92j9mydsa8hcy0ql71qnphfhgdm30xrsps79vwd0";
+       version = "0.10.0.2";
+       sha256 = "0yi9xnvy153mrb6ypjx7pnbjapdsh65bxqfp6y0s7s6f8vwzpqff";
+       revision = "1";
+       editedCabalFile = "08khbrpsk9yhd795l2zjfhsp8f0wxxwwycrkhsfkqw295zcbaqbh";
        libraryHaskellDepends = [
          aeson base bytestring containers http-client http-client-tls
-         http-types monad-logger mtl network profunctors random
-         safe-exceptions text time transformers unordered-containers vector
+         http-types monad-logger mtl network profunctors random text time
+         transformers unliftio unliftio-core unordered-containers vector
        ];
        testHaskellDepends = [
-         aeson base bytestring containers hspec mtl QuickCheck
-         safe-exceptions semigroups text time transformers
-         unordered-containers
+         aeson base bytestring containers hspec mtl QuickCheck semigroups
+         text time transformers unliftio unliftio-core unordered-containers
        ];
        description = "Access to the Pinboard API";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "postgresql-binary_0_12_1_2" = callPackage
+    ({ mkDerivation, aeson, base, base-prelude, binary-parser
+     , bytestring, bytestring-strict-builder, containers, conversion
+     , conversion-bytestring, conversion-text, criterion, json-ast
+     , loch-th, network-ip, placeholders, postgresql-libpq, QuickCheck
+     , quickcheck-instances, rerebase, scientific, tasty, tasty-hunit
+     , tasty-quickcheck, text, time, transformers, unordered-containers
+     , uuid, vector
+     }:
+     mkDerivation {
+       pname = "postgresql-binary";
+       version = "0.12.1.2";
+       sha256 = "10h5299fxqmfz0kxyvivfy396q35gzg60spnjagyha33kx5m3bc3";
+       libraryHaskellDepends = [
+         aeson base base-prelude binary-parser bytestring
+         bytestring-strict-builder containers loch-th network-ip
+         placeholders scientific text time transformers unordered-containers
+         uuid vector
+       ];
+       testHaskellDepends = [
+         aeson conversion conversion-bytestring conversion-text json-ast
+         loch-th network-ip placeholders postgresql-libpq QuickCheck
+         quickcheck-instances rerebase tasty tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "Encoders and decoders for the PostgreSQL's binary format";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "postgresql-common" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, postgresql-simple }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "proto-lens-arbitrary_0_1_2_4" = callPackage
+  "proto-lens-arbitrary_0_1_2_5" = callPackage
     ({ mkDerivation, base, bytestring, containers, lens-family
      , proto-lens, QuickCheck, text
      }:
      mkDerivation {
        pname = "proto-lens-arbitrary";
-       version = "0.1.2.4";
-       sha256 = "0d17vkcv21qphs44ig5fdcvisxn20980m0lx693w52ikzsax5k4s";
+       version = "0.1.2.5";
+       sha256 = "13cd9r9r2g913p3d3m7ljgv97wsdlr0v6js1r7k2w6npclgj13hd";
        libraryHaskellDepends = [
          base bytestring containers lens-family proto-lens QuickCheck text
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "protocol-buffers_2_4_12" = callPackage
+    ({ mkDerivation, aeson, array, base, base16-bytestring, binary
+     , bytestring, containers, directory, filepath, mtl, parsec, syb
+     , text, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "protocol-buffers";
+       version = "2.4.12";
+       sha256 = "0z1vkqdhj41bqnjhks4d82jby6l9j91k8ycna76bhv9p2w0gvp4g";
+       libraryHaskellDepends = [
+         aeson array base base16-bytestring binary bytestring containers
+         directory filepath mtl parsec syb text utf8-string vector
+       ];
+       description = "Parse Google Protocol Buffer specifications";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "protocol-buffers-descriptor" = callPackage
     ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
      mkDerivation {
···
        ];
        description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "protocol-buffers-descriptor_2_4_12" = callPackage
+    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
+     mkDerivation {
+       pname = "protocol-buffers-descriptor";
+       version = "2.4.12";
+       sha256 = "0h4c1pgl51h7xrsm76mz6wd1l41ps93y3nvdl0p7mks9w7wlpccn";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring containers protocol-buffers
+       ];
+       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "protocol-buffers-descriptor-fork" = callPackage
···
   "purescript" = callPackage
     ({ mkDerivation, aeson, aeson-better-errors, ansi-terminal
      , ansi-wl-pprint, base, base-compat, blaze-html, bower-json, boxes
-     , bytestring, cheapskate, clock, containers, data-ordlist, deepseq
-     , directory, dlist, edit-distance, file-embed, filepath, fsnotify
-     , gitrev, Glob, haskeline, hspec, hspec-discover, http-types, HUnit
-     , language-javascript, lens, lifted-base, monad-control
-     , monad-logger, mtl, network, optparse-applicative, parallel
-     , parsec, pattern-arrows, process, protolude, regex-tdfa, safe
-     , scientific, semigroups, sourcemap, spdx, split, stm, stringsearch
-     , syb, tasty, tasty-hspec, text, time, transformers
-     , transformers-base, transformers-compat, unordered-containers
-     , utf8-string, vector, wai, wai-websockets, warp, websockets
+     , bytestring, Cabal, cheapskate, clock, containers, data-ordlist
+     , deepseq, directory, dlist, edit-distance, file-embed, filepath
+     , fsnotify, gitrev, Glob, haskeline, hspec, hspec-discover
+     , http-types, HUnit, language-javascript, lifted-base
+     , microlens-platform, monad-control, monad-logger, mtl, network
+     , optparse-applicative, parallel, parsec, pattern-arrows, process
+     , protolude, regex-tdfa, safe, scientific, semigroups, sourcemap
+     , split, stm, stringsearch, syb, tasty, tasty-hspec, text, time
+     , transformers, transformers-base, transformers-compat
+     , unordered-containers, utf8-string, vector, wai, wai-websockets
+     , warp, websockets
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.12.0";
-       sha256 = "0lkrlry4rr1l1c5ncy7wlbv1ll6n0dkw7j1gjpxn3706gan921rb";
+       version = "0.12.1";
+       sha256 = "0m1460p8kllcbbk2ppp9hcf1jbzfnlim0nnkapj4wpm8jklngaw1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-better-errors ansi-terminal base base-compat blaze-html
-         bower-json boxes bytestring cheapskate clock containers
+         bower-json boxes bytestring Cabal cheapskate clock containers
          data-ordlist deepseq directory dlist edit-distance file-embed
-         filepath fsnotify Glob haskeline language-javascript lens
-         lifted-base monad-control monad-logger mtl parallel parsec
+         filepath fsnotify Glob haskeline language-javascript lifted-base
+         microlens-platform monad-control monad-logger mtl parallel parsec
          pattern-arrows process protolude regex-tdfa safe scientific
-         semigroups sourcemap spdx split stm stringsearch syb text time
+         semigroups sourcemap split stm stringsearch syb text time
          transformers transformers-base transformers-compat
          unordered-containers utf8-string vector
        ];
        executableHaskellDepends = [
          aeson aeson-better-errors ansi-terminal ansi-wl-pprint base
-         base-compat blaze-html bower-json boxes bytestring cheapskate clock
-         containers data-ordlist deepseq directory dlist edit-distance
+         base-compat blaze-html bower-json boxes bytestring Cabal cheapskate
+         clock containers data-ordlist deepseq directory dlist edit-distance
          file-embed filepath fsnotify gitrev Glob haskeline http-types
-         language-javascript lens lifted-base monad-control monad-logger mtl
-         network optparse-applicative parallel parsec pattern-arrows process
-         protolude regex-tdfa safe scientific semigroups sourcemap spdx
-         split stm stringsearch syb text time transformers transformers-base
-         transformers-compat unordered-containers utf8-string vector wai
-         wai-websockets warp websockets
+         language-javascript lifted-base microlens-platform monad-control
+         monad-logger mtl network optparse-applicative parallel parsec
+         pattern-arrows process protolude regex-tdfa safe scientific
+         semigroups sourcemap split stm stringsearch syb text time
+         transformers transformers-base transformers-compat
+         unordered-containers utf8-string vector wai wai-websockets warp
+         websockets
        ];
        testHaskellDepends = [
          aeson aeson-better-errors ansi-terminal base base-compat blaze-html
-         bower-json boxes bytestring cheapskate clock containers
+         bower-json boxes bytestring Cabal cheapskate clock containers
          data-ordlist deepseq directory dlist edit-distance file-embed
          filepath fsnotify Glob haskeline hspec hspec-discover HUnit
-         language-javascript lens lifted-base monad-control monad-logger mtl
-         parallel parsec pattern-arrows process protolude regex-tdfa safe
-         scientific semigroups sourcemap spdx split stm stringsearch syb
-         tasty tasty-hspec text time transformers transformers-base
-         transformers-compat unordered-containers utf8-string vector
+         language-javascript lifted-base microlens-platform monad-control
+         monad-logger mtl parallel parsec pattern-arrows process protolude
+         regex-tdfa safe scientific semigroups sourcemap split stm
+         stringsearch syb tasty tasty-hspec text time transformers
+         transformers-base transformers-compat unordered-containers
+         utf8-string vector
        ];
        testToolDepends = [ hspec-discover ];
        doCheck = false;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "qnap-decrypt_0_3_3" = callPackage
+    ({ mkDerivation, base, binary, bytestring, cipher-aes128, conduit
+     , conduit-extra, crypto-api, directory, filepath, hspec, HUnit
+     , optparse-applicative, streaming-commons, tagged, temporary
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "qnap-decrypt";
+       version = "0.3.3";
+       sha256 = "0gwnpyzyrfw6i8a5arm8q6psjhwa8kl8n94wcglsnl59k1iadfb6";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base binary bytestring cipher-aes128 conduit conduit-extra
+         crypto-api directory streaming-commons tagged utf8-string
+       ];
+       executableHaskellDepends = [
+         base binary bytestring cipher-aes128 conduit conduit-extra
+         crypto-api directory filepath optparse-applicative
+         streaming-commons tagged utf8-string
+       ];
+       testHaskellDepends = [
+         base binary bytestring cipher-aes128 conduit conduit-extra
+         crypto-api directory filepath hspec HUnit streaming-commons tagged
+         temporary utf8-string
+       ];
+       description = "Decrypt files encrypted by QNAP's Hybrid Backup Sync";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "qq-literals" = callPackage
     ({ mkDerivation, base, network-uri, template-haskell }:
      mkDerivation {
···
     ({ mkDerivation, base, criterion, deepseq, hspec }:
      mkDerivation {
        pname = "ralist";
-       version = "0.2.1.0";
-       sha256 = "19fnjza5gk02vdl4yvg453h44x41y19c81ldd7h60h82mkhsvc43";
+       version = "0.2.1.1";
+       sha256 = "0fy8c36ygdn609nq6wasc685y3z7g188nkhym7bpb7rigi1si7xj";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        benchmarkHaskellDepends = [ base criterion deepseq ];
···
        ];
        description = "Notify Honeybadger about exceptions";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "ratel_1_0_7" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, filepath, hspec, http-client, http-client-tls
+     , http-types, text, uuid
+     }:
+     mkDerivation {
+       pname = "ratel";
+       version = "1.0.7";
+       sha256 = "1kp6f45wn3a7wnsvj08a3b0kp5wwprw4rjrrqqd22yr9mpwx2z7w";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers http-client
+         http-client-tls http-types text uuid
+       ];
+       testHaskellDepends = [
+         aeson base bytestring case-insensitive containers filepath hspec
+         http-client http-client-tls http-types text uuid
+       ];
+       description = "Notify Honeybadger about exceptions";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ratel-wai" = callPackage
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.1.1.0";
-       sha256 = "0in2kb12848g4ggph2m2h2csc3j0jg9572vi25pdlvr5xrlvxm0m";
+       version = "0.1.1.2";
+       sha256 = "0shcp8capsxs8avaslfj6f0zmqxishmiymy848igfsfdi7m4apl4";
        libraryHaskellDepends = [
          base exceptions protolude resourcet text transformers-base
        ];
···
        pname = "servant-streaming";
        version = "0.3.0.0";
        sha256 = "0k2sgh7qhp54050k6xlz4zi5jf29xnar2iv02f4rg1k5fxjlh3cq";
-       revision = "1";
-       editedCabalFile = "1a9lg7cxbkj658hc76r5yk104q0hm3q9mkjzk17dwkwlnvdfq6m2";
+       revision = "2";
+       editedCabalFile = "0v435r9kzhn9jcws3kibxgr46ii6kbdniqk56qmx6hzfmkwvgwgk";
        libraryHaskellDepends = [ base http-types servant ];
        testHaskellDepends = [ base hspec http-types QuickCheck servant ];
        description = "Servant combinators for the 'streaming' package";
···
        pname = "shh";
        version = "0.1.0.0";
        sha256 = "0ixvfwrz1bsj1c2ln7fhvf6wawf75nzqfb784xgral33hmflm518";
+       revision = "1";
+       editedCabalFile = "10h2hz3fda9zg6zpkmmjjfxjghs7g0cj3r85vifp0za9ap41ph3k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "simple-get-opt";
-       version = "0.1.0.0";
-       sha256 = "1hia6kjx3nnv6i5wrkmvj6vz52pw12fwsz48gkz7049ygpa5jnl5";
+       version = "0.2.0";
+       sha256 = "1xx751j2vszqr8x9nf4f56aj5b6v0j8qdf90pd1xdasrfc67af9c";
        libraryHaskellDepends = [ base ];
        description = "A simple library for processing command-line options";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, containers, regex-compat }:
      mkDerivation {
        pname = "stp";
-       version = "0.1.0.0";
-       sha256 = "1anajnwakr3j2yixjjq2clk36b5043hpr0kfqm6qahj62hcdq9wm";
+       version = "0.1.0.1";
+       sha256 = "1vg2w6iawqydg2n4k6m6pzfxr7sr10cx33aabyx6b9wp1i8xa5kl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stratosphere_0_27_0" = callPackage
+  "stratosphere_0_28_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , hashable, hspec, hspec-discover, lens, template-haskell, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "stratosphere";
-       version = "0.27.0";
-       sha256 = "0n3bfsdv9fgk47zlfc4myh36y0qy4va0yq3ngnsi9zx4vi7pjk0y";
+       version = "0.28.0";
+       sha256 = "1rb138h9w34qvdjc3zddz4gm169ddiv690cwq0mpbfwv28v6j1fg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "structured-cli";
-       version = "2.4.0.1";
-       sha256 = "1978icz9iiq213l240r3m5dmizdl3493xrqlzdz16b0vpfkxmq0k";
+       version = "2.5.0.1";
+       sha256 = "0a28m0i0fygs1i0lxq27vs2l749saqwph1rjdvv10xvxa16kx552";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "swagger2_2_3_0_1" = callPackage
+  "swagger2_2_3_1" = callPackage
     ({ mkDerivation, aeson, base, base-compat-batteries, bytestring
-     , Cabal, cabal-doctest, containers, doctest, generics-sop, Glob
-     , hashable, hspec, hspec-discover, http-media, HUnit
+     , Cabal, cabal-doctest, containers, cookie, doctest, generics-sop
+     , Glob, hashable, hspec, hspec-discover, http-media, HUnit
      , insert-ordered-containers, lens, mtl, network, QuickCheck
      , quickcheck-instances, scientific, template-haskell, text, time
      , transformers, transformers-compat, unordered-containers
···
      }:
      mkDerivation {
        pname = "swagger2";
-       version = "2.3.0.1";
-       sha256 = "1l8piv2phl8kq3rgna8wld80b569vazqk2ll1rgs5iakm42lxr1f";
-       revision = "2";
-       editedCabalFile = "0dfxf47mzzb5rmln2smsk0qx53kj1lc3a087r52g2rzz6971zivb";
+       version = "2.3.1";
+       sha256 = "0717i4bv97sywbdf94bszh2g858wznvl8q7ngv0zirnlvx8a27y6";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
-         aeson base base-compat-batteries bytestring containers generics-sop
-         hashable http-media insert-ordered-containers lens mtl network
-         scientific template-haskell text time transformers
-         transformers-compat unordered-containers uuid-types vector
+         aeson base base-compat-batteries bytestring containers cookie
+         generics-sop hashable http-media insert-ordered-containers lens mtl
+         network QuickCheck scientific template-haskell text time
+         transformers transformers-compat unordered-containers uuid-types
+         vector
        ];
        testHaskellDepends = [
          aeson base base-compat-batteries bytestring containers doctest Glob
···
      }:
      mkDerivation {
        pname = "table-layout";
-       version = "0.8.0.2";
-       sha256 = "0dxdk1yjbk0f648q59dfkgx9asc24f733ww3cs98p799n7jnfl1v";
+       version = "0.8.0.3";
+       sha256 = "03q3icqgxiwbyl9bhqzhdwsdirr9r40k20k1j8z1barg2309r2aa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      , gi-glib, gi-gtk, gi-pango, gi-vte, gtk3, haskell-gi-base
      , hedgehog, lens, mono-traversable, pretty-simple, QuickCheck
      , singletons, tasty, tasty-hedgehog, tasty-hspec, template-haskell
-     , xml-conduit, xml-html-qq
+     , vte_291, xml-conduit, xml-html-qq
      }:
      mkDerivation {
        pname = "termonad";
-       version = "1.0.0.0";
-       sha256 = "1jnn7fbvxq2cxgj92qa2swznvpnqkiqklky9lj6a71j9zp7xray8";
+       version = "1.0.1.0";
+       sha256 = "1mmj7zamq83yb8wg2p127pa969pf06cwdcrvy2h6nb72m098fqcx";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          mono-traversable pretty-simple QuickCheck singletons xml-conduit
          xml-html-qq
        ];
-       libraryPkgconfigDepends = [ gtk3 ];
+       libraryPkgconfigDepends = [ gtk3 vte_291 ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
          base doctest genvalidity-containers genvalidity-hspec hedgehog lens
···
        ];
        description = "Terminal emulator configurable in Haskell";
        license = stdenv.lib.licenses.bsd3;
-     }) {gtk3 = pkgs.gnome3.gtk;};
+     }) {gtk3 = pkgs.gnome3.gtk; vte_291 = pkgs.gnome3.vte;};
 
   "termplot" = callPackage
     ({ mkDerivation, base, brick, data-default, optparse-applicative
···
      }) {};
 
   "toodles" = callPackage
-    ({ mkDerivation, aeson, base, blaze-html, cmdargs, directory
-     , megaparsec, MissingH, regex-posix, servant, servant-blaze
-     , servant-server, strict, text, wai, warp, yaml
+    ({ mkDerivation, aeson, base, blaze-html, cmdargs, directory, hspec
+     , hspec-expectations, megaparsec, MissingH, regex-posix, servant
+     , servant-blaze, servant-server, strict, text, wai, warp, yaml
      }:
      mkDerivation {
        pname = "toodles";
-       version = "0.1.4";
-       sha256 = "02s0hna69iwr0834c11xyi3pj1rai1syqrdrdsv882kbad3w499h";
-       isLibrary = false;
+       version = "1.0.0";
+       sha256 = "1ycmf0id5vp0ax4rmvcma4yhdis9p51qkvd43afz84hf0r26gzr6";
+       isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base blaze-html cmdargs directory hspec hspec-expectations
+         megaparsec MissingH regex-posix servant servant-blaze
+         servant-server strict text wai warp yaml
+       ];
        executableHaskellDepends = [
-         aeson base blaze-html cmdargs directory megaparsec MissingH
-         regex-posix servant servant-blaze servant-server strict text wai
-         warp yaml
+         aeson base blaze-html cmdargs directory hspec hspec-expectations
+         megaparsec MissingH regex-posix servant servant-blaze
+         servant-server strict text wai warp yaml
+       ];
+       testHaskellDepends = [
+         aeson base blaze-html cmdargs directory hspec hspec-expectations
+         megaparsec MissingH regex-posix servant servant-blaze
+         servant-server strict text wai warp yaml
        ];
        description = "Manage the TODO entries in your code";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, containers, semiring-num }:
      mkDerivation {
        pname = "total-map";
-       version = "0.0.8";
-       sha256 = "0qzlpcczj5nh786070qp5ln1l8j5qbzdx7dmx08lmc69gf6dwf4i";
+       version = "0.1.0";
+       sha256 = "0fqgazhs3ppv4ywdxjrhrdzp5z1szgkq4l0lqpbzqwrhi7axgl69";
        libraryHaskellDepends = [ base containers semiring-num ];
        description = "Finitely represented /total/ maps";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "wai-route" = callPackage
-    ({ mkDerivation, base, bytestring, http-types, mtl, QuickCheck
-     , tasty, tasty-quickcheck, unordered-containers, wai
+    ({ mkDerivation, base, bytestring, containers, deepseq, doctest
+     , http-api-data, http-types, mtl, pattern-trie, QuickCheck, tasty
+     , tasty-quickcheck, text, unordered-containers, wai
      }:
      mkDerivation {
        pname = "wai-route";
-       version = "0.4.0";
-       sha256 = "1rdrb7v17svz6y502bg49pj1wik7zy7r2l8bldfkssqh9kbrjiyp";
+       version = "1.0.0";
+       sha256 = "1hm947mzp3lynsjlhbl9nawa3p35cca15xj32cv5dyyllf0lac8w";
        libraryHaskellDepends = [
-         base bytestring http-types unordered-containers wai
+         base bytestring containers deepseq http-api-data http-types
+         pattern-trie text unordered-containers wai
        ];
        testHaskellDepends = [
-         base bytestring http-types mtl QuickCheck tasty tasty-quickcheck
-         wai
+         base bytestring containers deepseq doctest http-types mtl
+         pattern-trie QuickCheck tasty tasty-quickcheck text
+         unordered-containers wai
        ];
-       description = "Minimalistic, efficient routing for WAI";
+       description = "WAI middleware for path-based request routing with captures";
        license = stdenv.lib.licenses.mpl20;
      }) {};
 
···
     ({ mkDerivation, base, containers, dbus, X11 }:
      mkDerivation {
        pname = "xmonad-spotify";
-       version = "0.1.0.1";
-       sha256 = "11j2kd3l8yh3fn7smcggmi8jv66x80df52vwa7kmxchbsxf5qrpi";
+       version = "0.1.1.0";
+       sha256 = "1pihi0959wys3sd4r8r1rmh5vx84174wmjpanbyihzjhykvf7n2j";
        libraryHaskellDepends = [ base containers dbus X11 ];
        description = "Bind media keys to work with Spotify";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "xmonad-volume";
        version = "0.1.0.1";
        sha256 = "0lv1009d8w2xyx98c6g65z4mxp31jz79lqayvdw26a02kq63cild";
-       revision = "1";
-       editedCabalFile = "0wj87ijsfdzibx0k6m1pq2m47gkaddbdy282hcqiishfibkqrig5";
+       revision = "2";
+       editedCabalFile = "1lyaapci7phy59h2f4y7gk4i16i4bl7jnp835i41d5sr2m7mcr4p";
        libraryHaskellDepends = [
          alsa-mixer base composition-prelude containers X11
        ];
···
      }:
      mkDerivation {
        pname = "yesod-auth-oauth2";
-       version = "0.5.2.0";
-       sha256 = "0pf1bplly18rjhagzkqacbpi5wq78kisg0vz217yml5z0xwy1rkj";
+       version = "0.6.0.0";
+       sha256 = "12n2af0by708d5g2080y6w1xf8h692v1nxzgmwqfmsqf0c51ad05";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yesod-markdown";
-       version = "0.12.4";
-       sha256 = "14fpjdx5bn9qflarj4za5ncqd7q3dlpa71y76x7z9inz1k1jx684";
+       version = "0.12.5";
+       sha256 = "12h3z7k83qfx2nyqciqg9z3mpbl14z5rpfl8q2768m5rp8gg9j84";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring directory pandoc persistent
          shakespeare text xss-sanitize yesod-core yesod-form

pkgs/development/libraries/SDL/default.nix

···
     # Ticket: https://bugs.freedesktop.org/show_bug.cgi?id=27222
     (fetchpatch {
       name = "SDL_SetGamma.patch";
-      url = "http://src.fedoraproject.org/cgit/rpms/SDL.git/plain/SDL-1.2.15-x11-Bypass-SetGammaRamp-when-changing-gamma.patch?id=04a3a7b1bd88c2d5502292fad27e0e02d084698d";
+      url = "https://src.fedoraproject.org/cgit/rpms/SDL.git/plain/SDL-1.2.15-x11-Bypass-SetGammaRamp-when-changing-gamma.patch?id=04a3a7b1bd88c2d5502292fad27e0e02d084698d";
       sha256 = "0x52s4328kilyq43i7psqkqg7chsfwh0aawr50j566nzd7j51dlv";
     })
     # Fix a build failure on OS X Mavericks

pkgs/development/libraries/confuse/default.nix

···
-{stdenv, fetchurl}:
-
-stdenv.mkDerivation rec {
-  name = "confuse-${version}";
-  version = "3.2.1";
-  src = fetchurl {
-    url = "https://github.com/martinh/libconfuse/releases/download/v${version}/${name}.tar.xz";
-    sha256 = "0pnjmlj9i0alp407qd7c0vq83sz7gpsjrbdgpcn4xvzjp9r35ii3";
-  };
-
-  meta = {
-    homepage = http://www.nongnu.org/confuse/;
-    description = "Configuration file parser library";
-    license = stdenv.lib.licenses.isc;
-    platforms = stdenv.lib.platforms.unix;
-  };
-}

pkgs/development/libraries/cyrus-sasl/default.nix

···
     ./missing-size_t.patch # https://bugzilla.redhat.com/show_bug.cgi?id=906519
     (fetchpatch {
       name = "CVE-2013-4122.patch";
-      url = "http://sourceforge.net/projects/miscellaneouspa/files/glibc217/cyrus-sasl-2.1.26-glibc217-crypt.diff";
+      url = "mirror://sourceforge/miscellaneouspa/files/glibc217/cyrus-sasl-2.1.26-glibc217-crypt.diff";
       sha256 = "05l7dh1w9d5fvzg0pjwzqh0fy4ah8y5cv6v67s4ssbq8xwd4pkf2";
     })
   ] ++ lib.optional stdenv.isFreeBSD (

pkgs/development/libraries/dssi/default.nix

···
     ];
     platforms = platforms.linux;
     license = licenses.lgpl21;
-    downloadPage = "http://sourceforge.net/projects/dssi/files/dssi/";
+    downloadPage = "https://sourceforge.net/projects/dssi/files/dssi/";
   };
 }

pkgs/development/libraries/kyotocabinet/default.nix

···
 
   patches = [(fetchurl {
     name = "gcc6.patch";
-    url = "http://src.fedoraproject.org/rpms/kyotocabinet/raw/master/f/kyotocabinet-1.2.76-gcc6.patch";
+    url = "https://src.fedoraproject.org/rpms/kyotocabinet/raw/master/f/kyotocabinet-1.2.76-gcc6.patch";
     sha256 = "1h5k38mkiq7lz8nd2gbn7yvimcz49g3z7phn1cr560bzjih8rz23";
   })];
 

pkgs/development/libraries/libftdi/1.x.nix

···
-{ stdenv, fetchurl, cmake, pkgconfig, libusb1, confuse
+{ stdenv, fetchurl, cmake, pkgconfig, libusb1, libconfuse
 , cppSupport ? true, boost ? null
 , pythonSupport ? true, python ? null, swig ? null
 , docSupport ? true, doxygen ? null
···
     sha256 = "0x0vncf6i92slgrn0h7ghkskqbglbs534220qa84d0qg114zndpc";
   };
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = with stdenv.lib; [ cmake confuse ]
+  nativeBuildInputs = [ cmake pkgconfig ];
+  buildInputs = with stdenv.lib; [ libconfuse ]
     ++ optionals cppSupport [ boost ]
     ++ optionals pythonSupport [ python swig ]
     ++ optionals docSupport [ doxygen ];

pkgs/development/libraries/libipfix/default.nix

···
   name = "libipfix-${version}";
   version = "110209";
   src = fetchurl {
-    url = "http://sourceforge.net/projects/libipfix/files/libipfix/libipfix_110209.tgz";
+    url = "mirror://sourceforge/libipfix/files/libipfix/libipfix_110209.tgz";
     sha256 = "0h7v0sxjjdc41hl5vq2x0yhyn04bczl11bqm97825mivrvfymhn6";
   };
   meta = with stdenv.lib; {

pkgs/development/libraries/libmatheval/default.nix

···
   # Patches coming from debian package
   # https://packages.debian.org/source/sid/libs/libmatheval
   patches = [ (fetchpatch {
-                url = "http://anonscm.debian.org/cgit/debian-science/packages/libmatheval.git/plain/debian/patches/002-skip-docs.patch";
+                url = "https://salsa.debian.org/science-team/libmatheval/raw/debian/1.1.11+dfsg-3/debian/patches/002-skip-docs.patch";
                 sha256 = "1nnkk9aw4jj6nql46zhwq6vx74zrmr1xq5ix0xyvpawhabhgjg62";
               } )
               (fetchpatch {
-                url = "http://anonscm.debian.org/cgit/debian-science/packages/libmatheval.git/plain/debian/patches/003-guile2.0.patch";
+                url = "https://salsa.debian.org/science-team/libmatheval/raw/debian/1.1.11+dfsg-3/debian/patches/003-guile2.0.patch";
                 sha256 = "1xgfw4finfvr20kjbpr4yl2djxmyr4lmvfa11pxirfvhrdi602qj";
                } )
               (fetchpatch {
-                url = "http://anonscm.debian.org/cgit/debian-science/packages/libmatheval.git/plain/debian/patches/disable_coth_test.patch";
+                url = "https://salsa.debian.org/science-team/libmatheval/raw/debian/1.1.11+dfsg-3/debian/patches/disable_coth_test.patch";
                 sha256 = "0bai8jrd5azfz5afmjixlvifk34liq58qb7p9kb45k6kc1fqqxzm";
                } )
             ];
-  
+
   meta = {
     description = "A library to parse and evaluate symbolic expressions input as text";
     longDescription = ''
-      GNU libmatheval is a library (callable from C and Fortran) to parse and evaluate symbolic 
-      expressions input as text. It supports expressions in any number of variables of arbitrary 
-      names, decimal and symbolic constants, basic unary and binary operators, and elementary 
-      mathematical functions. In addition to parsing and evaluation, libmatheval can also compute 
+      GNU libmatheval is a library (callable from C and Fortran) to parse and evaluate symbolic
+      expressions input as text. It supports expressions in any number of variables of arbitrary
+      names, decimal and symbolic constants, basic unary and binary operators, and elementary
+      mathematical functions. In addition to parsing and evaluation, libmatheval can also compute
       symbolic derivatives and output expressions to strings.
     '';
     homepage = https://www.gnu.org/software/libmatheval/;

pkgs/development/libraries/libp11/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "libp11-${version}";
-  version = "0.4.7";
+  version = "0.4.9";
 
   src = fetchFromGitHub {
     owner = "OpenSC";
     repo = "libp11";
     rev = name;
-    sha256 = "0n1i0pxj6l0vdq8gpdwfp5p9qd7wkymg0lpy6a17ix8hpqsljlhr";
+    sha256 = "1f0ir1mnr4wxxnql8ld2aa6288fn04fai5pr0sics7kbdm1g0cki";
   };
 
   makeFlags = [ "DESTDIR=$(out)" "PREFIX=" ];

pkgs/development/libraries/libtar/default.nix

···
   patches = let
     fp =  name: sha256:
       fetchpatch {
-        url = "http://sources.debian.net/data/main/libt/libtar/1.2.20-4/debian/patches/${name}.patch";
+        url = "https://sources.debian.net/data/main/libt/libtar/1.2.20-4/debian/patches/${name}.patch";
         inherit sha256;
       };
     in [
···
 
   meta = with stdenv.lib; {
     description = "C library for manipulating POSIX tar files";
-    homepage = http://repo.or.cz/libtar;
+    homepage = https://repo.or.cz/libtar;
     license = licenses.bsd3;
     platforms = with platforms; linux ++ darwin;
     maintainers = [ maintainers.bjornfor ];

pkgs/development/libraries/ntrack/default.nix

···
   name = "ntrack-${version}";
 
   src = fetchurl {
-    url = "http://launchpad.net/ntrack/main/${version}/+download/${name}.tar.gz";
+    url = "https://launchpad.net/ntrack/main/${version}/+download/${name}.tar.gz";
     sha256 = "037ig5y0mp327m0hh4pnfr3vmsk3wrxgfjy3645q4ws9vdhx807w";
   };
 

pkgs/development/libraries/spice-gtk/default.nix

···
       Python bindings are available too.
     '';
 
-    homepage = http://www.spice-space.org/;
+    homepage = https://www.spice-space.org/;
     license = licenses.lgpl21;
     maintainers = [ maintainers.xeji ];
     platforms = platforms.linux;

pkgs/development/libraries/spice-protocol/default.nix

···
 
   meta = with stdenv.lib; {
     description = "Protocol headers for the SPICE protocol";
-    homepage = http://www.spice-space.org;
+    homepage = https://www.spice-space.org/;
     license = licenses.bsd3;
     maintainers = with maintainers; [ bluescreen303 ];
     platforms = platforms.linux;

pkgs/development/libraries/spice/default.nix

···
       VD-Interfaces. The VD-Interfaces (VDI) enable both ends of the solution to be easily
       utilized by a third-party component.
     '';
-    homepage = http://www.spice-space.org/;
+    homepage = https://www.spice-space.org/;
     license = licenses.lgpl21;
 
     maintainers = [ maintainers.bluescreen303 ];

pkgs/development/libraries/taglib/1.9.nix

···
   name = "taglib-1.9.1";
 
   src = fetchurl {
-    url = http://taglib.github.io/releases/taglib-1.9.1.tar.gz;
+    url = https://taglib.github.io/releases/taglib-1.9.1.tar.gz;
     sha256 = "06n7gnbcqa3r6c9gv00y0y1r48dyyazm6yj403i7ma0r2k6p3lvj";
   };
 
···
   buildInputs = [ zlib ];
 
   meta = {
-    homepage = http://developer.kde.org/~wheeler/taglib.html;
+    homepage = https://taglib.org/;
     repositories.git = git://github.com/taglib/taglib.git;
     description = "A library for reading and editing the meta-data of several popular audio formats";
     inherit (cmake.meta) platforms;

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

···
   version = "2.39";
 
   src = fetchurl {
-    url = "http://launchpad.net/python-distutils-extra/trunk/${version}/+download/python-${pname}-${version}.tar.gz";
+    url = "https://launchpad.net/python-distutils-extra/trunk/${version}/+download/python-${pname}-${version}.tar.gz";
     sha256 = "1bv3h2p9ffbzyddhi5sccsfwrm3i6yxzn0m06fdxkj2zsvs28gvj";
   };
 

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

···
 { buildPythonPackage
 , fetchPypi
+, isPy37
 , lib
 , six
 , attrs
···
   checkPhase = ''
     pytest .
   '';
+  # Tests fails on python3.7 https://github.com/python-effect/effect/issues/78
+  doCheck = !isPy37;
   meta = with lib; {
     description = "Pure effects for Python";
     homepage = https://github.com/python-effect/effect;

pkgs/development/python-modules/hg-git/default.nix

···
 , fetchPypi
 , dulwich
 , isPy3k
+, fetchpatch
 }:
 
 buildPythonPackage rec {
   pname = "hg-git";
-  version = "0.8.11";
+  version = "0.8.12";
   disabled = isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "08kw1sj3sq1q1571hwkc51w20ks9ysmlg93pcnmd6gr66bz02dyn";
+    sha256 = "13hbm0ki6s88r6p65ibvrbxnskinzdz0m9gsshb8s571p91ymfjn";
   };
 
   propagatedBuildInputs = [ dulwich ];
+
+  # Needs patch to work with Mercurial 4.8
+  # https://bitbucket.org/durin42/hg-git/issues/264/unexpected-keyword-argument-createopts-hg
+  patches =
+    fetchpatch {
+      url = "https://bitbucket.org/rsalmaso/hg-git/commits/a778506fd4be0bf1afa75755f6ee9260fa234a0f/raw";
+      sha256 = "12r4qzbc5xcqwv0kvf8g4wjji7n45421zkbf6i75vyi4nl6n4j15";
+    };
 
   meta = with stdenv.lib; {
     description = "Push and pull from a Git server using Mercurial";

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

···
 
   patches = stdenv.lib.singleton (fetchurl {
     name = "libnotify07.patch";
-    url = "http://src.fedoraproject.org/cgit/notify-python.git/plain/"
+    url = "https://src.fedoraproject.org/cgit/notify-python.git/plain/"
         + "libnotify07.patch?id2=289573d50ae4838a1658d573d2c9f4c75e86db0c";
     sha256 = "1lqdli13mfb59xxbq4rbq1f0znh6xr17ljjhwmzqb79jl3dig12z";
   });

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

···
-{ stdenv, buildPythonPackage, fetchPypi, pythonOlder, pytest, setuptools, structlog, pytest-asyncio, pytest_xdist, flaky, tornado }:
+{ stdenv, buildPythonPackage, fetchPypi, pythonOlder, pytest, setuptools, structlog, pytest-asyncio, pytest_xdist, flaky, tornado, pycurl }:
 
 buildPythonPackage rec {
   pname = "nvchecker";
-  version = "1.1";
+  version = "1.2.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1nk9ff26s5r6v5v7w4l9110qi5kmhllvwk5kh20zyyhdvxv72m3i";
+    sha256 = "19qc2wwkdr701mx94r75ayq5h2jz3q620hcqaj2ng9qdgxm90940";
   };
 
-  # tornado is not present in the tarball setup.py but is required by the executable
-  propagatedBuildInputs = [ setuptools structlog tornado ];
+  propagatedBuildInputs = [ setuptools structlog tornado pycurl ];
   checkInputs = [ pytest pytest-asyncio pytest_xdist flaky ];
 
   # Disable tests for now, because our version of pytest seems to be too new

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

···
     "test_clipboard"
   ]);
 
+  doCheck = !stdenv.isAarch64; # upstream doesn't test this architecture
+
   checkPhase = ''
     runHook preCheck
   ''

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

···
 
 buildPythonPackage rec {
   pname = "plotly";
-  version = "3.3.0";
+  version = "3.4.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1bsjk4crf9p08lmgmiibmk8w8kmlrfadyly5l12zz1d330acijl1";
+    sha256 = "1pq5k1b4gwdbdsb0alzgmr54zjvzf0csw5lq8s61zh5jnhfgn23y";
   };
 
   propagatedBuildInputs = [

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

···
 buildPythonPackage rec {
   pname = "py4j";
 
-  version = "0.10.7";
+  version = "0.10.8.1";
 
   src = fetchPypi {
     inherit pname version;
     extension= "zip";
-    sha256 = "721189616b3a7d28212dfb2e7c6a1dd5147b03105f1fc37ff2432acd0e863fa5";
+    sha256 = "0x52rjn2s44mbpk9p497p3yba9xnpl6hcaiacklppwqcd8avnac3";
   };
 
   # No tests in archive

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

···
   md5_path = "f6d33a8362dee358517d0a9e2ebdd044";
 
   src = pkgs.fetchurl rec {
-    url = "http://src.fedoraproject.org/repo/pkgs/python-pyblock/"
+    url = "https://src.fedoraproject.org/repo/pkgs/python-pyblock/"
         + "${name}.tar.bz2/${md5_path}/${name}.tar.bz2";
     sha256 = "f6cef88969300a6564498557eeea1d8da58acceae238077852ff261a2cb1d815";
   };

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

···
   format = "other";
 
   src = fetchurl {
-    url = "http://launchpad.net/pyexiv2/0.3.x/0.3.2/+download/${pname}-${version}.tar.bz2";
+    url = "https://launchpad.net/pyexiv2/0.3.x/0.3.2/+download/${pname}-${version}.tar.bz2";
     sha256 = "09r1ga6kj5cnmrldpkqzvdhh7xi7aad9g4fbcr1gawgsd9y13g0a";
   };
 

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

···
   md5_path = "d249f60aa89b1b4facd63f776925116d";
 
   src = fetchurl rec {
-    url = "http://src.fedoraproject.org/repo/pkgs/pykickstart/"
+    url = "https://src.fedoraproject.org/repo/pkgs/pykickstart/"
     + "${pname}-${version}.tar.gz/${md5_path}/${pname}-${version}.tar.gz";
     sha256 = "e0d0f98ac4c5607e6a48d5c1fba2d50cc804de1081043f9da68cbfc69cad957a";
   };

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

···
 { lib
 , buildPythonPackage
-, fetchPypi
+, fetchFromGitHub
 , python
 , nose2
+, cython
 , proj ? null
 }:
 
 buildPythonPackage (rec {
   pname = "pyproj";
-  version = "1.9.5.1";
+  version = "unstable-2018-11-13";
 
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "53fa54c8fa8a1dfcd6af4bf09ce1aae5d4d949da63b90570ac5ec849efaf3ea8";
+  src = fetchFromGitHub {
+    owner = "jswhit";
+    repo = pname;
+    rev = "78540f5ff40da92160f80860416c91ee74b7643c";
+    sha256 = "1vq5smxmpdjxialxxglsfh48wx8kaq9sc5mqqxn4fgv1r5n1m3n9";
   };
 
-  buildInputs = [ nose2 ];
+  buildInputs = [ cython ];
+
+  checkInputs = [ nose2 ];
 
   checkPhase = ''
     runHook preCheck

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+}:
+
+buildPythonPackage rec {
+  pname = "sdnotify";
+  version = "0.3.2";
+
+  src = fetchPypi {
+    sha256 = "1wdrdg2j16pmqhk0ify20s5pngijh7zc6hyxhh8w8v5k8v3pz5vk";
+    inherit pname version;
+  };
+
+  meta = with stdenv.lib; {
+    description = "A pure Python implementation of systemd's service notification protocol";
+    homepage = https://github.com/bb4242/sdnotify;
+    license = licenses.mit;
+    maintainers = with maintainers; [ pmiddend ];
+  };
+}

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

···
+{ lib, buildPythonPackage, fetchPypi, fetchpatch, mock
+, future, six, setuptools_scm }:
+
+buildPythonPackage rec {
+  pname = "sievelib";
+  version = "1.1.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1sl1fnwr5jdacrrnq2rvzh4vv1dyxd3x31vnqga36gj8h546h7mz";
+  };
+
+  patches = [
+    (fetchpatch {
+      url = "https://github.com/tonioo/sievelib/commit/1deef0e2bf039a0e817ea6f19aaf1947dc9fafbc.patch";
+      sha256 = "0vaj73mcij9dism8vfaai82irh8j1b2n8gf9jl1a19d2l26jrflk";
+    })
+  ];
+
+  buildInputs = [ setuptools_scm ];
+  propagatedBuildInputs = [ future six ];
+  checkInputs = [ mock ];
+
+  meta = {
+    description = "Client-side Sieve and Managesieve library written in Python";
+    homepage    = https://github.com/tonioo/sievelib;
+    license     = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ leenaars ];
+    longDescription = ''
+      A library written in Python that implements RFC 5228 (Sieve: An Email
+      Filtering Language) and RFC 5804 (ManageSieve: A Protocol for
+      Remotely Managing Sieve Scripts), as well as the following extensions:
+
+       * Copying Without Side Effects (RFC 3894)
+       * Body (RFC 5173)
+       * Date and Index (RFC 5260)
+       * Vacation (RFC 5230)
+       * Imap4flags (RFC 5232)
+    '';
+  };
+}

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

···
+{ lib , buildPythonPackage , fetchPypi }:
+
+buildPythonPackage rec {
+  pname = "simplekml";
+  version = "1.3.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "30c121368ce1d73405721730bf766721e580cae6fbb7424884c734c89ec62ad7";
+  };
+
+  doCheck = false; # no tests are defined in 1.3.1
+
+  meta = with lib; {
+    description = "Generate KML with as little effort as possible";
+    homepage =  https://readthedocs.org/projects/simplekml/;
+    license = licenses.lgpl3Plus;
+    maintainers = with maintainers; [ rvolosatovs ];
+  };
+}

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

···
+{ lib, stdenv, buildPythonPackage, fetchPypi }:
+
+buildPythonPackage rec {
+  pname = "yattag";
+  version = "1.10.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0r3pwfygvpkgc0hzxc6z8dl56g6brlh52r0x8kcjhywr1biahqb2";
+  };
+
+  meta = with lib; {
+    description = "Generate HTML or XML in a pythonic way. Pure python alternative to web template engines. Can fill HTML forms with default values and error messages.";
+    license = [ licenses.lgpl21 ];
+    homepage = http://www.yattag.org/;
+  };
+}

pkgs/development/r-modules/wrapper-rstudio.nix

···
-{ stdenv, R, rstudio, makeWrapper, recommendedPackages, packages }:
+{ stdenv, R, rstudio, makeWrapper, recommendedPackages, packages, qtbase }:
 
+let
+  qtVersion = with stdenv.lib.versions; "${major qtbase.version}.${minor qtbase.version}";
+in
 stdenv.mkDerivation rec {
 
   name = rstudio.name + "-wrapper";
···
     echo -n $R_LIBS_SITE | sed -e 's/:/", "/g' >> $out/${fixLibsR}
     echo -n "\"))" >> $out/${fixLibsR}
     echo >> $out/${fixLibsR}
-    makeWrapper ${rstudio}/bin/rstudio $out/bin/rstudio --set R_PROFILE_USER $out/${fixLibsR}
+    makeWrapper ${rstudio}/bin/rstudio $out/bin/rstudio --set R_PROFILE_USER $out/${fixLibsR} \
+      --prefix QT_PLUGIN_PATH : ${qtbase}/lib/qt-${qtVersion}/plugins    
   '';
   
   meta = {

pkgs/development/ruby-modules/bundled-common/default.nix

···
       gemAttrs = composeGemAttrs ruby gems name attrs;
     in
     if gemAttrs.type == "path" then
-      pathDerivation gemAttrs
+      pathDerivation (gemAttrs.source // gemAttrs)
     else
       buildRubyGem gemAttrs
   );

pkgs/development/tools/fusee-launcher/default.nix

···
+{ stdenv
+, lib
+, python3Packages
+, python3
+, fetchFromGitHub
+, pkgsCross
+, makeWrapper
+} :
+
+stdenv.mkDerivation rec {
+  name = "fusee-launcher-${version}";
+  version = "unstable-2018-07-14";
+
+  src = fetchFromGitHub {
+    owner = "Cease-and-DeSwitch";
+    repo = "fusee-launcher";
+    rev = "265e8f3e1987751ec41db6f1946d132b296aba43";
+    sha256 = "1pqkgw5bk0xcz9x7pc1f0r0b9nsc8jnnvcs1315d8ml8mx23fshm";
+  };
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share
+    cp fusee-launcher.py $out/bin/fusee-launcher
+    cp intermezzo.bin $out/share/intermezzo.bin
+
+    # Wrap with path to intermezzo.bin relocator binary in /share
+    wrapProgram $out/bin/fusee-launcher \
+      --add-flags "--relocator $out/share/intermezzo.bin" \
+      --prefix PYTHONPATH : "$PYTHONPATH:$(toPythonPath $out)"
+  '';
+
+  nativeBuildInputs = [ pkgsCross.arm-embedded.buildPackages.gcc makeWrapper python3Packages.wrapPython ];
+  buildInputs = [ python3 python3Packages.pyusb ];
+  pythonPath = with python3Packages; [ pyusb ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/Cease-and-DeSwitch/fusee-launcher;
+    description = "Work-in-progress launcher for one of the Tegra X1 bootROM exploits";
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ pneumaticat ];
+  };
+
+}

pkgs/development/tools/heroku/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "heroku-${version}";
-  version = "7.16.0";
+  version = "7.18.2";
 
   src = fetchurl {
     url = "https://cli-assets.heroku.com/heroku-v${version}/heroku-v${version}.tar.xz";
-    sha256 = "434573b4773ce7ccbb21b43b19529475d941fa7dd219b01b75968b42e6b62abe";
+    sha256 = "1dplh3bfin1g0wwbkg76z3xsja4zqj350vrzl8jfw7982saxqywh";
   };
 
-  buildInputs = [ makeWrapper ];
+  nativeBuildInputs = [ makeWrapper ];
 
   dontBuild = true;
 

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

···
   };
 
   meta = {
-    homepage = http://people.redhat.com/jakub/prelink/;
+    homepage = https://people.redhat.com/jakub/prelink/;
     license = "GPL";
     description = "ELF prelinking utility to speed up dynamic linking";
     platforms = stdenv.lib.platforms.linux;

pkgs/development/tools/ocaml/omake/0.9.8.6-rc1.nix

···
   name = "${pname}-${version}";
 
   src = fetchurl {
-    url = "http://src.fedoraproject.org/repo/pkgs/ocaml-omake/${pname}-${version}.tar.gz/fe39a476ef4e33b7ba2ca77a6bcaded2/${pname}-${version}.tar.gz";
+    url = "https://src.fedoraproject.org/repo/pkgs/ocaml-omake/${pname}-${version}.tar.gz/fe39a476ef4e33b7ba2ca77a6bcaded2/${pname}-${version}.tar.gz";
     sha256 = "1sas02pbj56m7wi5vf3vqrrpr4ynxymw2a8ybvfj2dkjf7q9ii13";
   };
   patchFlags = "-p0";

pkgs/development/tools/pew/default.nix

···
 
     propagatedBuildInputs = [ virtualenv virtualenv-clone setuptools ];
 
+    LC_ALL = "en_US.UTF-8";
+
     postFixup = ''
       set -euo pipefail
       PEW_SITE="$out/lib/${python.libPrefix}/site-packages"
···
     '';
 
     meta = with stdenv.lib; {
+      homepage = https://github.com/berdario/pew;
       description = "Tools to manage multiple virtualenvs written in pure python";
       license = licenses.mit;
       platforms = platforms.all;

pkgs/development/tools/phantomjs2/default.nix

···
 
   patches = [
     (fetchpatch {
-      url = "https://anonscm.debian.org/cgit/collab-maint/phantomjs.git/plain/debian/patches/build-hardening.patch?id=42c9154d8c87c9fe434908259b0eddde4d892ca3";
+      url = https://salsa.debian.org/debian/phantomjs/raw/0b20f0dd/debian/patches/build-hardening.patch;
       sha256 = "1qs1r76w90qgpw742i7lf0y3b7m9zh5wxcbrhrak6mq1kqaphqb5";
     })
     (fetchpatch {
-      url = "https://anonscm.debian.org/cgit/collab-maint/phantomjs.git/plain/debian/patches/build-qt-components.patch?id=9b5c1ce95a7044ebffc634f773edf7d4eb9b6cd3";
+      url = https://salsa.debian.org/debian/phantomjs/raw/0b20f0dd/debian/patches/build-qt-components.patch;
       sha256 = "1fw2q59aqcks3abvwkqg9903yif6aivdsznc0h6frhhjvpp19vsb";
     })
     (fetchpatch {
-      url = "https://anonscm.debian.org/cgit/collab-maint/phantomjs.git/plain/debian/patches/build-qt55-evaluateJavaScript.patch?id=9b5c1ce95a7044ebffc634f773edf7d4eb9b6cd3";
+      url = https://salsa.debian.org/debian/phantomjs/raw/0b20f0dd/debian/patches/build-qt55-evaluateJavaScript.patch;
       sha256 = "1avig9cfny8kv3s4mf3mdzvf3xlzgyh351yzwc4bkpnjvzv4fmq6";
     })
     (fetchpatch {
-      url = "https://anonscm.debian.org/cgit/collab-maint/phantomjs.git/plain/debian/patches/build-qt55-no-websecurity.patch?id=9b5c1ce95a7044ebffc634f773edf7d4eb9b6cd3";
+      url = https://salsa.debian.org/debian/phantomjs/raw/0b20f0dd/debian/patches/build-qt55-no-websecurity.patch;
       sha256 = "1nykqpxa7lcf9iarz5lywgg3v3b1h19iwvjdg4kgq0ai6idhcab8";
     })
     (fetchpatch {
-      url = "https://anonscm.debian.org/cgit/collab-maint/phantomjs.git/plain/debian/patches/build-qt55-print.patch?id=9b5c1ce95a7044ebffc634f773edf7d4eb9b6cd3";
+      url = https://salsa.debian.org/debian/phantomjs/raw/0b20f0dd/debian/patches/build-qt55-print.patch;
       sha256 = "1fydmdjxnplglpbd3ypaih5l237jkxjirpdhzz92mcpy29yla6jw";
     })
     (fetchpatch {
-      url = "https://anonscm.debian.org/cgit/collab-maint/phantomjs.git/plain/debian/patches/unlock-qt.patch";
+      url = https://salsa.debian.org/debian/phantomjs/raw/0b20f0dd/debian/patches/unlock-qt.patch;
       sha256 = "13bwz4iw17d6hq5pwkbpcckqyw7fhc6648lvs26m39pp31zwyp03";
     })
     ./system-qtbase.patch

pkgs/games/blobby/default.nix

···
   name = "blobby-volley-${version}";
 
   src = fetchurl {
-    url = "http://softlayer-ams.dl.sourceforge.net/project/blobby/Blobby%20Volley%202%20%28Linux%29/1.0/blobby2-linux-1.0.tar.gz";
+    url = "mirror://sourceforge/blobby/Blobby%20Volley%202%20%28Linux%29/1.0/blobby2-linux-1.0.tar.gz";
     sha256 = "1qpmbdlyhfbrdsq4vkb6cb3b8mh27fpizb71q4a21ala56g08yms";
   };
 
···
     platforms = with stdenv.lib.platforms; linux;
     maintainers = with stdenv.lib.maintainers; [raskin];
     homepage = http://blobby.sourceforge.net/;
-    downloadPage = "http://sourceforge.net/projects/blobby/files/Blobby%20Volley%202%20%28Linux%29/";
+    downloadPage = "https://sourceforge.net/projects/blobby/files/Blobby%20Volley%202%20%28Linux%29/";
     inherit version;
   };
 }

pkgs/games/blobby/default.upstream

···
-url http://sourceforge.net/projects/blobby/files/Blobby%20Volley%202%20%28Linux%29/
+url https://sourceforge.net/projects/blobby/files/Blobby%20Volley%202%20%28Linux%29/
 SF_version_dir
 version_link '[.]tar[.][^.]+/download$'
 SF_redirect

pkgs/games/crack-attack/default.nix

···
-{ stdenv, fetchurl, pkgconfig, gtk2, freeglut, SDL, libGLU_combined, libXi, libXmu}:
+{ stdenv, fetchurl, pkgconfig, gtk2, freeglut, SDL, SDL_mixer, libGLU_combined, libXi, libXmu }:
 
 stdenv.mkDerivation {
   name = "crack-attack-1.1.14";
···
     url = mirror://savannah/crack-attack/crack-attack-1.1.14.tar.gz;
     sha256 = "1sakj9a2q05brpd7lkqxi8q30bccycdzd96ns00s6jbxrzjlijkm";
   };
+
+  patches = [
+    ./crack-attack-1.1.14-gcc43.patch
+    ./crack-attack-1.1.14-glut.patch
+  ];
+
+  configureFlags = [ "--enable-sound=yes" ];
 
   nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ gtk2 freeglut SDL libGLU_combined libXi libXmu ];
+  buildInputs = [ gtk2 freeglut SDL SDL_mixer libGLU_combined libXi libXmu ];
 
   hardeningDisable = [ "format" ];
+  enableParallelBuilding = true;
 
   meta = {
     description = "A fast-paced puzzle game inspired by the classic Super NES title Tetris Attack!";
···
     platforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.piotr ];
   };
-
-  patches = [
-    ./crack-attack-1.1.14-gcc43.patch
-    ./crack-attack-1.1.14-glut.patch
-  ];
 }

pkgs/games/steam/runtime-wrapped.nix

···
     libva1
     libvdpau
     vulkan-loader
-    gcc.cc
+    gcc.cc.lib
     nss
     nspr
     xorg.libxcb

pkgs/games/tennix/fix_FTBFS.patch

···
 From: Thomas Perl <[e-mail]>
 Description: Fix FTBFS 
-Origin: upstream, http://repo.or.cz/w/tennix.git/commitdiff/6144cb7626dfdc0820a0036af83a531e8e68bae6
-Bug-Debian:  http://bugs.debian.org/664907
+Origin: upstream, https://repo.or.cz/w/tennix.git/commitdiff/6144cb7626dfdc0820a0036af83a531e8e68bae6
+Bug-Debian:  https://bugs.debian.org/664907
 
 --- tennix-1.1.orig/archivetool.cc
 +++ tennix-1.1/archivetool.cc

pkgs/games/widelands/default.nix

···
   ];
 
   src = fetchurl {
-    url = "http://launchpad.net/widelands/build${version}/build${version}/+download/widelands-build${version}-src-gcc7.tar.bz2";
+    url = "https://launchpad.net/widelands/build${version}/build${version}/+download/widelands-build${version}-src-gcc7.tar.bz2";
     sha256 = "0n2lb1c2dix32j90nir96zfqivn63izr1pmabjnhns3wbb7vhwzg";
   };
 

pkgs/misc/seafile-shared/default.nix

···
 {stdenv, fetchFromGitHub, which, autoreconfHook, pkgconfig, curl, vala, python, intltool, fuse, ccnet}:
 
 stdenv.mkDerivation rec {
-  version = "6.2.5";
+  version = "6.2.7";
   name = "seafile-shared-${version}";
 
   src = fetchFromGitHub {
     owner = "haiwen";
     repo = "seafile";
     rev = "v${version}";
-    sha256 = "1s8cqh5wfll81d060f4zknxhmwwqckci6dadmslbvbvx55lgyspa";
+    sha256 = "0f8h7x6q830q4pw6f6bbykiyj3lkdlgvjzg2sdaqm4bhj2c4k1n0";
   };
 
   nativeBuildInputs = [ pkgconfig which autoreconfHook vala intltool ];

pkgs/misc/themes/nordic/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "nordic-${version}";
-  version = "1.2.1";
+  version = "1.3.0";
 
   srcs = [
     (fetchurl {
       url = "https://github.com/EliverLara/Nordic/releases/download/v${version}/Nordic.tar.xz";
-      sha256 = "1k8fzvjb92wcqha378af5hk6r75xanff9iwlx51jmi67ny8z28pn";
+      sha256 = "04axs2yldppcx159nwj70g4cyw0hbbzk5250677i9ny8b0w3gr9x";
     })
     (fetchurl {
       url = "https://github.com/EliverLara/Nordic/releases/download/v${version}/Nordic-standard-buttons.tar.xz";
-      sha256 = "12w01z88rqkds1wm2kskql1x5c6prpgpc9cxxnl0b11knsfhi6jn";
+      sha256 = "0xnj1am1q26xppp8y07iik648hhgn3gmzqvkdhg3il4qnkndjvld";
     })
   ];
 

pkgs/misc/vim-plugins/default.nix

···
   overrides = callPackage ./overrides.nix {
     inherit (darwin.apple_sdk.frameworks) Cocoa CoreFoundation CoreServices;
     inherit buildVimPluginFrom2Nix;
+    inherit llvmPackages;
   };
 
   overriden = generated // (overrides generated);

pkgs/misc/vim-plugins/overrides.nix

···
     preFixup = ''
       substituteInPlace "$out"/share/vim-plugins/clang_complete/plugin/clang_complete.vim \
         --replace "let g:clang_library_path = '' + "''" + ''" "let g:clang_library_path='${llvmPackages.clang.cc.lib}/lib/libclang.so'"
+
+      substituteInPlace "$out"/share/vim-plugins/clang_complete/plugin/libclang.py \
+        --replace "/usr/lib/clang" "${llvmPackages.clang.cc}/lib/clang"
     '';
   });
 
   clighter8 = clighter8.overrideAttrs(old: {
     preFixup = ''
-      sed "/^let g:clighter8_libclang_path/s|')$|${llvmPackages.clang.cc}/lib/libclang.so')|" \
+      sed "/^let g:clighter8_libclang_path/s|')$|${llvmPackages.clang.cc.lib}/lib/libclang.so')|" \
         -i "$out"/share/vim-plugins/clighter8/plugin/clighter8.vim
     '';
   });

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

···
   '';
   meta = {
     description = "Audit Library";
-    homepage = http://people.redhat.com/sgrubb/audit/;
+    homepage = https://people.redhat.com/sgrubb/audit/;
     license = stdenv.lib.licenses.gpl2;
     platforms = stdenv.lib.platforms.linux;
     maintainers = with stdenv.lib.maintainers; [ fuuzetsu ];

pkgs/os-specific/linux/bridge-utils/default.nix

···
   '';
 
   meta = {
-    description = "http://sourceforge.net/projects/bridge/";
-    homepage = http://www.linux-foundation.org/en/Net:Bridge/;
-    license = "GPL";
+    description = "https://sourceforge.net/projects/bridge/";
+    homepage = https://wiki.linuxfoundation.org/networking/bridge;
+    license = stdenv.lib.licenses.gpl2Plus;
     platforms = stdenv.lib.platforms.linux;
   };
 }

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

···
   version = "0.13";
 
   src = fetchurl {
-    url = "http://launchpad.net/fatrace/trunk/${version}/+download/${name}.tar.bz2";
+    url = "https://launchpad.net/fatrace/trunk/${version}/+download/${name}.tar.bz2";
     sha256 = "0hrh45bpzncw0jkxw3x2smh748r65k2yxvfai466043bi5q0d2vx";
   };
 

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

···
     maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
     homepage = https://l3net.wordpress.com/projects/firejail/;
-    downloadPage = "http://sourceforge.net/projects/firejail/files/firejail/";
+    downloadPage = "https://sourceforge.net/projects/firejail/files/firejail/";
   };
 }

pkgs/os-specific/linux/firejail/default.upstream

···
-url http://sourceforge.net/projects/firejail/files/firejail/
+url https://sourceforge.net/projects/firejail/files/firejail/
 version_link '[-][0-9.]+[.]tar[.][a-z0-9]+/download$'
 SF_redirect

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

···
 
   src = fetchurl {
     #url = http://gogo6.com/downloads/gogoc-1_2-RELEASE.tar.gz;
-    url = http://src.fedoraproject.org/repo/pkgs/gogoc/gogoc-1_2-RELEASE.tar.gz/41177ed683cf511cc206c7782c37baa9/gogoc-1_2-RELEASE.tar.gz;
+    url = https://src.fedoraproject.org/repo/pkgs/gogoc/gogoc-1_2-RELEASE.tar.gz/41177ed683cf511cc206c7782c37baa9/gogoc-1_2-RELEASE.tar.gz;
     sha256 = "a0ef45c0bd1fc9964dc8ac059b7d78c12674bf67ef641740554e166fa99a2f49";
   };
   patches = [./gcc46-include-fix.patch ./config-paths.patch ];

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

···
   buildInputs = [ perl ];
   meta = with stdenv.lib; {
     description = "Direct access to I/O ports from the command line";
-    homepage = http://people.redhat.com/rjones/ioport/;
+    homepage = https://people.redhat.com/rjones/ioport/;
     license = licenses.gpl2Plus;
     platforms = [ "x86_64-linux" "i686-linux" ];
     maintainers = [ maintainers.cleverca22 ];

pkgs/os-specific/linux/kernel/linux-rpi.nix

···
     efiBootStub = false;
   } // (args.features or {});
 
-  extraMeta.hydraPlatforms = [];
+  extraMeta.hydraPlatforms = with stdenv.lib.platforms; [ aarch64 ];
 })) (oldAttrs: {
   postConfigure = ''
     # The v7 defconfig has this set to '-v7' which screws up our modDirVersion.

pkgs/os-specific/linux/kernel/linux-testing.nix

···
 { stdenv, buildPackages, fetchurl, perl, buildLinux, libelf, utillinux, ... } @ args:
 
 buildLinux (args // rec {
-  version = "4.20-rc3";
-  modDirVersion = "4.20.0-rc3";
+  version = "4.20-rc4";
+  modDirVersion = "4.20.0-rc4";
   extraMeta.branch = "4.20";
 
   src = fetchurl {
     url = "https://git.kernel.org/torvalds/t/linux-${version}.tar.gz";
-    sha256 = "0iin34alr5ax15pvilhdn5pifqav4gkxalb7vqb8zvxnhsm6kk58";
+    sha256 = "0kni1l1gk9mva7ym091mrkn9f2bdbh80i7589ahk6j5blpj9m3ns";
   };
 
   # Should the testing kernels ever be built on Hydra?

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

···
   ];
 
   meta = with stdenv.lib; {
-    homepage = http://people.redhat.com/dhowells/keyutils/;
+    homepage = https://people.redhat.com/dhowells/keyutils/;
     description = "Tools used to control the Linux kernel key management system";
     license = licenses.gpl2Plus;
     platforms = platforms.linux;

pkgs/os-specific/linux/libcap-ng/default.nix

···
 
   meta = let inherit (stdenv.lib) platforms licenses maintainers; in {
     description = "Library for working with POSIX capabilities";
-    homepage = http://people.redhat.com/sgrubb/libcap-ng/;
+    homepage = https://people.redhat.com/sgrubb/libcap-ng/;
     platforms = platforms.linux;
     license = licenses.lgpl21;
     maintainers = with maintainers; [ wkennington ];

pkgs/os-specific/linux/nvidia-x11/default.nix

···
   beta = stable;
 
   legacy_340 = generic {
-    version = "340.104";
-    sha256_32bit = "1l8w95qpxmkw33c4lsf5ar9w2fkhky4x23rlpqvp1j66wbw1b473";
-    sha256_64bit = "18k65gx6jg956zxyfz31xdp914sq3msn665a759bdbryksbk3wds";
-    settingsSha256 = "1vvpqimvld2iyfjgb9wvs7ca0b0f68jzfdpr0icbyxk4vhsq7sxk";
-    persistencedSha256 = "0zqws2vsrxbxhv6z0nn2galnghcsilcn3s0f70bpm6jqj9wzy7x8";
+    version = "340.107";
+    sha256_32bit = "0mh83affz6bim26ws7kkwwcfj2s6vkdy4d45hifsbshr82qd52wd";
+    sha256_64bit = "0pv9yv3x0kg9hfkmc50xb54ahxkbnyy2vyy4hj2h0s6m9sb5kqz3";
+    settingsSha256 = "1rgaa24acdyqa1rqrx56293vxpskr792njqqpigqmps04llsx703";
+    persistencedSha256 = "0nwv6kh4gxgy80x1zs6gcg5hy3amg25xhsfa2v4mwqa36sblxz6l";
     useGLVND = false;
 
     patches = maybePatch_drm_legacy ++ [ ./vm_operations_struct-fault.patch ];

pkgs/os-specific/linux/open-iscsi/default.nix

···
-{ stdenv, fetchFromGitHub, automake, autoconf, libtool, gettext, utillinux, openisns, openssl, kmod }:
+{ stdenv, fetchFromGitHub, automake, autoconf, libtool, gettext
+, utillinux, openisns, openssl, kmod, perl, systemd, pkgconf
+}:
+
 stdenv.mkDerivation rec {
   name = "open-iscsi-${version}";
-  version = "2.0-873-${stdenv.lib.substring 0 7 src.rev}";
+  version = "2.0.877";
+
+  nativeBuildInputs = [ autoconf automake gettext libtool perl pkgconf ];
+  buildInputs = [ kmod openisns.lib openssl systemd utillinux ];
 
-  buildInputs = [ automake autoconf libtool gettext utillinux openisns.lib openssl kmod ];
-  
   src = fetchFromGitHub {
     owner = "open-iscsi";
     repo = "open-iscsi";
-    rev = "4c1f2d90ef1c73e33d9f1e4ae9c206ffe015a8f9";
-    sha256 = "0h030zk4zih3l8z5662b3kcifdxlakbwwkz1afb7yf0cicds7va8";
+    rev = version;
+    sha256 = "0v3dsrl34pdx0yl5jsanrpgg3vw466rl8k81hkshgq3a5mq5qhf6";
   };
-  
+
   DESTDIR = "$(out)";
-  
-  NIX_LDFLAGS = "-lkmod";
+
+  NIX_LDFLAGS = "-lkmod -lsystemd";
   NIX_CFLAGS_COMPILE = "-DUSE_KMOD";
 
   preConfigure = ''
     sed -i 's|/usr|/|' Makefile
   '';
-  
+
   postInstall = ''
     cp usr/iscsistart $out/sbin/
     $out/sbin/iscsistart -v
···
 
   meta = with stdenv.lib; {
     description = "A high performance, transport independent, multi-platform implementation of RFC3720";
-    license = licenses.gpl2Plus;
-    homepage = http://www.open-iscsi.com;
+    license = licenses.gpl2;
+    homepage = https://www.open-iscsi.com;
     platforms = platforms.linux;
-    maintainers = with maintainers; [ cleverca22 ];
+    maintainers = with maintainers; [ cleverca22 zaninime ];
   };
 }

pkgs/os-specific/linux/pommed-light/default.nix

···
-{
-  stdenv
-, fetchurl
+{ stdenv
+, fetchFromGitHub
 , pciutils
-, confuse
+, libconfuse
 , alsaLib
 , audiofile
 , pkgconfig
···
   version = "1.51lw";
   name = "${pkgname}-${version}";
 
-  src = fetchurl {
-    url = "https://github.com/bytbox/${pkgname}/archive/v${version}.tar.gz";
-
-    sha256 = "11wi17bh2br1hp8gmq40b1hm5drm6h969505f7432zam3cm8mc8q";
+  src = fetchFromGitHub {
+    owner = "bytbox";
+    repo = pkgname;
+    rev = "v${version}";
+    sha256 = "18fvdwwhcl6s4bpf2f2i389s71c8k4g0yb81am9rdddqmzaw27iy";
   };
 
   postPatch = ''
···
     substituteInPlace pommed/cd_eject.c --replace /usr/bin/eject ${eject}/bin/eject
   '';
 
+  nativeBuildInputs = [ pkgconfig ];
   buildInputs = [
     pciutils
-    confuse
+    libconfuse
     alsaLib
     audiofile
-    pkgconfig
     zlib
     eject
   ];

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

···
-{ 
-  stdenv
-, fetchurl
-, pciutils
-, confuse
-, dbus, dbus-glib
-, alsaLib
-, audiofile
-, pkgconfig
-, gtk2
-, gettext
-, libXpm
-}:
-
-let
-
-  build_flags_patch = fetchurl {
-    url = http://patch-tracker.debian.org/patch/series/dl/pommed/1.39~dfsg-2/build_flags.patch;
-    sha256 = "109n5v0m91fqf8vqnpqg1zw8mk8fi9pkzqsfrmlavalg4xz49x9j";
-  }; 
-
-in
-
-stdenv.mkDerivation rec {
-  name = "pommed-1.39";
-
-  src = fetchurl {
-    url = "http://alioth.debian.org/frs/download.php/3583/${name}.tar.gz";
-    sha256 = "18lxywmikanjr5pk1jdqda88dxd2579fpyd332xn4njjhlgwy5fp";
-  };
-
-  patches = [ build_flags_patch ./find-eject-in-path.patch ];
-
-  buildInputs = [
-    pciutils
-    confuse
-    dbus
-    alsaLib
-    audiofile
-    dbus-glib
-    pkgconfig
-    gtk2
-    gettext
-    libXpm
-  ];
-
-  installPhase = ''
-    mkdir -pv $out/bin $out/etc/init.d $out/etc/dbus-1/system.d \
-      $out/share/pommed $out/share/gpomme $out/share/applications \
-      $out/share/icons/hicolor/scalable/apps $out/share/pixmaps
-
-    install -v -m755 pommed/pommed wmpomme/wmpomme gpomme/gpomme $out/bin
-    install -v -m644 pommed/data/* $out/share/pommed
-    install -v -m644 pommed.conf.mactel $out/etc/pommed.conf
-    install -v -m644 pommed.init $out/etc/init.d
-    install -v -m644 dbus-policy.conf $out/etc/dbus-1/system.d/pommed.conf
-
-    cp -av gpomme/themes $out/share/gpomme
-    for lang in de es fr it ja; do
-      mkdir -pv $out/share/locale/"$lang"/LC_MESSAGES
-      install -v -m644 gpomme/po/"$lang".mo $out/share/locale/"$lang"/LC_MESSAGES/gpomme.mo
-    done
-    install -v -m644 gpomme/gpomme*.desktop $out/share/applications
-    for size in 128 16 192 22 24 32 36 48 64 72 96; do
-      mkdir -pv $out/share/icons/hicolor/"$size"x"$size"/apps
-      install -v -m644 icons/gpomme_"$size"x"$size".png \
-        $out/share/icons/hicolor/"$size"x"$size"/apps
-    done
-    install -v -m644 icons/gpomme.svg  $out/share/icons/hicolor/scalable/apps
-
-    install -v -m644 icons/gpomme_192x192.xpm $out/share/pixmaps/wmpomme.xpm
-  '';
-
-  meta = {
-    description = "A tool to handle hotkeys on Apple laptop keyboards";
-    homepage = http://www.technologeek.org/projects/pommed/index.html;
-    license = stdenv.lib.licenses.gpl2;
-    broken = true; # hash changed, and it's quite suspicious
-  };
-}

pkgs/os-specific/linux/pommed/find-eject-in-path.patch

···
-diff -Naur pommed-1.39-orig/pommed/cd_eject.c pommed-1.39/pommed/cd_eject.c
---- pommed-1.39-orig/pommed/cd_eject.c	2011-06-02 05:24:05.000000000 -0400
-+++ pommed-1.39/pommed/cd_eject.c	2012-03-20 14:25:33.397712520 -0400
-@@ -100,7 +100,7 @@
-       for (fd = 3; fd < max_fd; fd++)
- 	close(fd);
- 
--      execve("/usr/bin/eject", eject_argv, eject_envp);
-+      execvpe("eject", eject_argv, eject_envp);
- 
-       logmsg(LOG_ERR, "Could not execute eject: %s", strerror(errno));
-       exit(1);

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

···
 
   patches = [(fetchpatch {
     name = "reproducibility.patch";
-    url = "http://anonscm.debian.org/cgit/collab-maint/tiptop.git/plain/debian/"
-      + "patches/0001-fix-reproducibility-of-build-process.patch?id=c777d0d5803";
+    url = "https://salsa.debian.org/debian/tiptop/raw/debian/2.3.1-1/debian/patches/0001-fix-reproducibility-of-build-process.patch";
     sha256 = "116l7n3nl9lj691i7j8x0d0za1i6zpqgghw5d70qfpb17c04cblp";
   })];
 

pkgs/os-specific/linux/udisks-glue/default.nix

···
-{ stdenv, fetchurl, pkgconfig, automake, autoconf, udisks1, dbus-glib, glib, confuse }:
+{ stdenv, fetchurl, pkgconfig, automake, autoconf, udisks1, dbus-glib, glib, libconfuse }:
 
 stdenv.mkDerivation {
   name = "udisks-glue-1.3.5";
···
   };
 
   nativeBuildInputs = [ pkgconfig automake autoconf ];
-  buildInputs = [ udisks1 dbus-glib glib confuse ];
+  buildInputs = [ udisks1 dbus-glib glib libconfuse ];
 
   preConfigure = "sh autogen.sh";
 
···
     description = "A tool to associate udisks events to user-defined actions";
     platforms = stdenv.lib.platforms.linux;
     maintainers = with stdenv.lib.maintainers; [pSub];
-    license = stdenv.lib.licenses.free;
+    license = stdenv.lib.licenses.bsd2;
   };
 }

pkgs/servers/home-assistant/appdaemon.nix

···
           inherit version;
           sha256 = "8adda6583ba438a4c70693374e10b60168663ffa6564c5c75d3c7a9055290964";
         };
+        # TODO: remove after pinning aiohttp to a newer version
+        propagatedBuildInputs = oldAttrs.propagatedBuildInputs ++ [ self.idna-ssl ];
       });
 
       yarl = super.yarl.overridePythonAttrs (oldAttrs: rec {

pkgs/servers/mxisd/0001-gradle.patch

···
+--- a/build.gradle	2018-11-16 15:15:29.021469758 +0100
++++ b/build.gradle	2018-11-16 15:16:50.982289782 +0100
+@@ -64,7 +64,7 @@
+ 
+ buildscript {
+     repositories {
+-        mavenCentral()
++    REPLACE
+     }
+ 
+     dependencies {
+@@ -73,9 +73,7 @@
+ }
+ 
+ repositories {
+-    mavenCentral()
+-    maven { url "https://kamax.io/maven/releases/" }
+-    maven { url "https://kamax.io/maven/snapshots/" }
++REPLACE
+ }
+ 
+ dependencies {

pkgs/servers/mxisd/default.nix

···
+{ stdenv, fetchFromGitHub, jdk, jre, git, gradle_2_5, perl, makeWrapper, writeText }:
+
+let
+  name = "mxisd-${version}";
+  version = "1.2.0";
+  rev = "8c4ddd2e6526c1d2b284ba88cce3c2b926d99c62";
+
+  src = fetchFromGitHub {
+    inherit rev;
+    owner = "kamax-matrix";
+    repo = "mxisd";
+    sha256 = "083plqg0rxsqwzyskin78wkmylhb7cqz37lpsa1zy56sxpdw1a3l";
+  };
+
+
+  deps = stdenv.mkDerivation {
+    name = "${name}-deps";
+    inherit src;
+    nativeBuildInputs = [ gradle_2_5 perl git ];
+
+    buildPhase = ''
+      export MXISD_BUILD_VERSION=${rev}
+      export GRADLE_USER_HOME=$(mktemp -d);
+      gradle --no-daemon build -x test
+    '';
+
+     # perl code mavenizes pathes (com.squareup.okio/okio/1.13.0/a9283170b7305c8d92d25aff02a6ab7e45d06cbe/okio-1.13.0.jar -> com/squareup/okio/okio/1.13.0/okio-1.13.0.jar)
+    installPhase = ''
+      find $GRADLE_USER_HOME/caches/modules-2 -type f -regex '.*\.\(jar\|pom\)' \
+        | perl -pe 's#(.*/([^/]+)/([^/]+)/([^/]+)/[0-9a-f]{30,40}/([^/\s]+))$# ($x = $2) =~ tr|\.|/|; "install -Dm444 $1 \$out/$x/$3/$4/$5" #e' \
+        | sh
+    '';
+
+    dontStrip = true;
+
+    outputHashAlgo = "sha256";
+    outputHashMode = "recursive";
+    outputHash = "0shshn05nzv23shry1xpcgvqg59gx929n0qngpfjhbq0kp7px68m";
+  };
+
+in
+stdenv.mkDerivation {
+  inherit name src version;
+  nativeBuildInputs = [ gradle_2_5 perl makeWrapper ];
+  buildInputs = [ jre ];
+
+  patches = [ ./0001-gradle.patch ];
+
+  buildPhase = ''
+    export MXISD_BUILD_VERSION=${rev}
+    export GRADLE_USER_HOME=$(mktemp -d)
+
+    sed -ie "s#REPLACE#mavenLocal(); maven { url '${deps}' }#g" build.gradle
+    gradle --offline --no-daemon build -x test
+  '';
+
+  installPhase = ''
+    install -D build/libs/source.jar $out/lib/mxisd.jar
+    makeWrapper ${jre}/bin/java $out/bin/mxisd --add-flags "-jar $out/lib/mxisd.jar"
+  '';
+
+  meta = with stdenv.lib; {
+    description = "a federated matrix identity server";
+    homepage = https://github.com/kamax-matrix/mxisd;
+    license = licenses.agpl3;
+    maintainers = with maintainers; [ mguentner ];
+    platforms = platforms.all;
+  };
+
+}

pkgs/shells/zsh/grml-zsh-config/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "grml-zsh-config-${version}";
-  version = "0.15.0";
+  version = "0.15.1";
 
   src = fetchFromGitHub {
     owner = "grml";
     repo = "grml-etc-core";
     rev = "v${version}";
-    sha256 = "0a39m7rlf30r0ja56mmhidqbalck8f5gkmgngcvkxy3n486xxmkm";
+    sha256 = "13mm1vjmb600l4g0ssr56xrlx6lwpv1brrpmf2v2pp2d5ki0d47x";
   };
 
   buildInputs = [ zsh coreutils txt2tags procps ]

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

···
 { stdenv, fetchFromGitHub }:
 
 let
-  version = "0.4.0";
+  version = "0.4.1";
 in
 
 stdenv.mkDerivation rec {
···
     owner = "spwhitt";
     repo = "nix-zsh-completions";
     rev = "${version}";
-    sha256 = "0m8b9xgbz2nvk1q7m0gqy83gbqa49n062gymhk9x93zhbdh8vwky";
+    sha256 = "1p2y1sg6jghixv2j3fwxnkyl3idj44gcm71bbn25mnqfhm0z25hr";
   };
 
   installPhase = ''

pkgs/stdenv/generic/make-derivation.nix

···
           inherit doCheck doInstallCheck;
 
           inherit outputs;
-        } // lib.optionalAttrs strictDeps {
-          # Make sure "build" dependencies don’t leak into outputs. We
-          # want to disallow references to depsBuildBuild,
-          # nativeBuildInputs, and depsBuildTarget. But depsHostHost,
-          # buildInputs, and depsTargetTarget is okay, so we subtract
-          # those from disallowedReferences in case a dependency is
-          # listed in multiple dependency lists. We also include
-          # propagated dependencies here as well.
-          disallowedReferences = (attrs.disallowedReferences or [])
-          ++ (lib.subtractLists
-               (lib.concatLists ((lib.elemAt propagatedDependencies 0) ++
-                                 (lib.elemAt propagatedDependencies 1) ++
-                                 (lib.elemAt dependencies 1) ++
-                                 (lib.elemAt propagatedDependencies 2) ++
-                                 (lib.elemAt dependencies 2) ) )
-               (lib.concatLists ((lib.elemAt dependencies 0)) ) );
         } // lib.optionalAttrs (stdenv.hostPlatform != stdenv.buildPlatform) {
           cmakeFlags =
             (/**/ if lib.isString cmakeFlags then [cmakeFlags]

pkgs/tools/X11/ckbcomp/default.nix

···
-{ stdenv, fetchgit, perl, xkeyboard_config }:
+{ stdenv, fetchFromGitLab, perl, xkeyboard_config }:
 
 stdenv.mkDerivation rec {
   name = "ckbcomp-${version}";
-  version = "1.133";
+  version = "1.187";
 
-  src = fetchgit {
-    url = "git://anonscm.debian.org/d-i/console-setup.git";
-    rev = "refs/tags/${version}";
-    sha256 = "1whli40ik5izyfs0m8d08gq8zcsdjscnxbsvxyxvdnkrvzw4izdz";
+  src = fetchFromGitLab {
+    domain = "salsa.debian.org";
+    owner = "installer-team";
+    repo = "console-setup";
+    rev = version;
+    sha256 = "1dcsgdai5lm1r0bhlcfwh01s9k11iwgnd0111gpgbv568rs5isqh";
   };
 
   buildInputs = [ perl ];
···
   dontBuild = true;
 
   installPhase = ''
-    mkdir -p "$out"/bin
-    cp Keyboard/ckbcomp "$out"/bin/
-    mkdir -p "$out"/share/man/man1
-    cp man/ckbcomp.1 "$out"/share/man/man1
+    install -Dm0555 -t $out/bin Keyboard/ckbcomp
+    install -Dm0444 -t $out/share/man/man1 man/ckbcomp.1
   '';
 
   meta = with stdenv.lib; {
     description = "Compiles a XKB keyboard description to a keymap suitable for loadkeys";
-    homepage = http://anonscm.debian.org/cgit/d-i/console-setup.git;
+    homepage = https://salsa.debian.org/installer-team/console-setup;
     license = licenses.gpl2Plus;
     maintainers = with stdenv.lib.maintainers; [ dezgeg ];
     platforms = platforms.unix;

pkgs/tools/X11/dispad/default.nix

···
-{ stdenv, fetchFromGitHub, libX11, libXi, confuse }:
+{ stdenv, fetchFromGitHub, libX11, libXi, libconfuse }:
 
 stdenv.mkDerivation rec {
   name = "dispad-${version}";
···
     sha256 = "0y0n9mf1hs3s706gkpmg1lh74m6vvkqc9rdbzgc6s2k7vdl2zp1y";
   };
 
-  buildInputs = [ libX11 libXi confuse ];
+  buildInputs = [ libX11 libXi libconfuse ];
 
   meta = with stdenv.lib; {
     description = "A small daemon for disabling trackpads while typing";

pkgs/tools/X11/keynav/default.nix

···
 { stdenv, fetchFromGitHub, pkgconfig, libX11, xextproto, libXtst, libXi, libXext
-, libXinerama, glib, cairo, xdotool }:
+, libXinerama, libXrandr, glib, cairo, xdotool }:
 
-let release = "20150730"; in
+let release = "20180821"; in
 stdenv.mkDerivation rec {
   name = "keynav-0.${release}.0";
 
   src = fetchFromGitHub {
     owner = "jordansissel";
     repo = "keynav";
-    rev = "4ae486db6697877e84b66583a0502afc7301ba16";
-    sha256 = "0v1m8w877fcrk918p6b6q3753dsz8i1f4mb9bi064cp11kh85nq5";
+    rev = "78f9e076a5618aba43b030fbb9344c415c30c1e5";
+    sha256 = "0hmc14fj612z5h7gjgk95zyqab3p35c4a99snnblzxfg0p3x2f1d";
   };
 
   nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ libX11 xextproto libXtst libXi libXext libXinerama
+  buildInputs = [ libX11 xextproto libXtst libXi libXext libXinerama libXrandr
                   glib cairo xdotool ];
 
   patchPhase = ''

pkgs/tools/admin/lxd/default.nix

···
 , makeWrapper, acl, rsync, gnutar, xz, btrfs-progs, gzip, dnsmasq
 , squashfsTools, iproute, iptables, ebtables, libcap, dqlite
 , sqlite-replication
+, writeShellScriptBin, apparmor-profiles, apparmor-parser
 }:
 
 buildGoPackage rec {
···
 
     wrapProgram $bin/bin/lxd --prefix PATH ":" ${stdenv.lib.makeBinPath [
       acl rsync gnutar xz btrfs-progs gzip dnsmasq squashfsTools iproute iptables ebtables
+      (writeShellScriptBin "apparmor_parser" ''
+        exec '${apparmor-parser}/bin/apparmor_parser' -I '${apparmor-profiles}/etc/apparmor.d' "$@"
+      '')
     ]}
   '';
 

pkgs/tools/filesystems/lizardfs/default.nix

···
 { stdenv
+, fetchzip
 , fetchFromGitHub
 , cmake
 , makeWrapper
 , python
+, db
 , fuse
 , asciidoc
 , libxml2
···
 , zlib # optional
 }:
 
-stdenv.mkDerivation rec {
+let
+  # See https://github.com/lizardfs/lizardfs/blob/3.12/cmake/Libraries.cmake
+  # We have to download it ourselves, as the build script normally does a download
+  # on-build, which is not good
+  spdlog = fetchzip {
+    name = "spdlog-0.14.0";
+    url = "https://github.com/gabime/spdlog/archive/v0.14.0.zip";
+    sha256 = "13730429gwlabi432ilpnja3sfvy0nn2719vnhhmii34xcdyc57q";
+  };
+in stdenv.mkDerivation rec {
   name = "lizardfs-${version}";
-  version = "3.11.3";
+  version = "3.12.0";
 
   src = fetchFromGitHub {
     owner = "lizardfs";
     repo = "lizardfs";
     rev = "v${version}";
-    sha256 = "1njgj242vgpdqb1di321jfqk4al5lk72x2iyp0nldy7h6r98l2ww";
+    sha256 = "0zk73wmx82ari3m2mv0zx04x1ggsdmwcwn7k6bkl5c0jnxffc4ax";
   };
 
-  buildInputs = 
-    [ cmake fuse asciidoc libxml2 libxslt docbook_xml_dtd_412 docbook_xsl
-      zlib boost pkgconfig judy pam makeWrapper
+  nativeBuildInputs = [ cmake pkgconfig makeWrapper ];
+
+  buildInputs =
+    [ db fuse asciidoc libxml2 libxslt docbook_xml_dtd_412 docbook_xsl
+      zlib boost judy pam
     ];
 
+  patches = [
+    ./remove-download-external.patch
+  ];
+
+  postUnpack = ''
+    mkdir $sourceRoot/external/spdlog-0.14.0
+    cp -R ${spdlog}/* $sourceRoot/external/spdlog-0.14.0/
+    chmod -R 755 $sourceRoot/external/spdlog-0.14.0/
+  '';
+
   postInstall = ''
     wrapProgram $out/sbin/lizardfs-cgiserver \
         --prefix PATH ":" "${python}/bin"
-
-    # mfssnapshot and mfscgiserv are deprecated
-    rm $out/bin/mfssnapshot $out/sbin/mfscgiserv
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/filesystems/lizardfs/remove-download-external.patch

···
+From d3f8111ade372c1eb7f3973031f59198508fb588 Mon Sep 17 00:00:00 2001
+From: Kevin Liu <[e-mail]>
+Date: Thu, 23 Aug 2018 10:31:42 -0400
+Subject: [PATCH] Remove download_external for spdlog
+
+---
+ cmake/Libraries.cmake | 5 -----
+ 1 file changed, 5 deletions(-)
+
+diff --git a/cmake/Libraries.cmake b/cmake/Libraries.cmake
+index 1f951e59..2134444a 100644
+--- a/cmake/Libraries.cmake
++++ b/cmake/Libraries.cmake
+@@ -7,11 +7,6 @@ if(ENABLE_TESTS)
+                     "ef5e700c8a0f3ee123e2e0209b8b4961")
+ endif()
+ 
+-download_external(SPDLOG "spdlog-0.14.0"
+-                  "https://github.com/gabime/spdlog/archive/v0.14.0.zip"
+-                  "f213d83c466aa7044a132e2488d71b11"
+-                  "spdlog-1")
+-
+ # Find standard libraries
+ find_package(Socket REQUIRED)
+ find_package(Threads REQUIRED)

pkgs/tools/filesystems/mtools/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "mtools-4.0.20";
+  name = "mtools-4.0.21";
 
   src = fetchurl {
     url = "mirror://gnu/mtools/${name}.tar.bz2";
-    sha256 = "1vcahr9s6zv1hnrx2bgjnzcas2y951q90r1jvvv4q9v5kwfd6qb0";
+    sha256 = "1kybydx74qgbwpnjvjn49msf8zipchl43d4cq8zzwcyvfkdzw7h2";
   };
 
-  # Prevents errors such as "mainloop.c:89:15: error: expected ')'"
-  # Upstream issue https://lists.gnu.org/archive/html/info-mtools/2014-02/msg00000.html
-  patches = [ ./fix-dos_to_wchar-declaration.patch ] ++
-    stdenv.lib.optional stdenv.isDarwin ./UNUSED-darwin.patch;
+  patches = stdenv.lib.optional stdenv.isDarwin ./UNUSED-darwin.patch;
 
   # fails to find X on darwin
   configureFlags = stdenv.lib.optional stdenv.isDarwin "--without-x";
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    homepage = http://www.gnu.org/software/mtools/;
+    homepage = https://www.gnu.org/software/mtools/;
     description = "Utilities to access MS-DOS disks";
     platforms = platforms.unix;
     license = licenses.gpl3;

pkgs/tools/filesystems/mtools/fix-dos_to_wchar-declaration.patch

···
---- mtools-4.0.20.org/charsetConv.c	2018-11-19 10:16:14.183820865 +0000
-+++ mtools-4.0.20/charsetConv.c	2018-11-19 10:15:39.808451465 +0000
-@@ -266,7 +266,7 @@
- 	free(cp);
- }
- 
--int dos_to_wchar(doscp_t *cp, char *dos, wchar_t *wchar, size_t len)
-+int dos_to_wchar(doscp_t *cp, const char *dos, wchar_t *wchar, size_t len)
- {
- 	int i;
- 

pkgs/tools/filesystems/nixpart/0.4/dmraid.nix

···
   name = "dmraid-1.0.0.rc15";
 
   src = fetchurl {
-    url = "http://people.redhat.com/~heinzm/sw/dmraid/src/old/${name}.tar.bz2";
+    url = "https://people.redhat.com/~heinzm/sw/dmraid/src/old/${name}.tar.bz2";
     sha256 = "01bcaq0sc329ghgj7f182xws7jgjpdc41bvris8fsiprnxc7511h";
   };
 

pkgs/tools/filesystems/nixpart/0.4/pyblock.nix

···
   md5_path = "f6d33a8362dee358517d0a9e2ebdd044";
 
   src = fetchurl rec {
-    url = "http://src.fedoraproject.org/repo/pkgs/python-pyblock/"
+    url = "https://src.fedoraproject.org/repo/pkgs/python-pyblock/"
         + "${name}.tar.bz2/${md5_path}/${name}.tar.bz2";
     sha256 = "f6cef88969300a6564498557eeea1d8da58acceae238077852ff261a2cb1d815";
   };

pkgs/tools/filesystems/nixpart/0.4/pykickstart.nix

···
   md5_path = "d249f60aa89b1b4facd63f776925116d";
 
   src = fetchurl rec {
-    url = "http://src.fedoraproject.org/repo/pkgs/pykickstart/"
+    url = "https://src.fedoraproject.org/repo/pkgs/pykickstart/"
         + "${name}.tar.gz/${md5_path}/${name}.tar.gz";
     sha256 = "e0d0f98ac4c5607e6a48d5c1fba2d50cc804de1081043f9da68cbfc69cad957a";
   };

pkgs/tools/filesystems/smbnetfs/default.nix

···
     maintainers = with maintainers; [ raskin ];
     platforms = platforms.linux;
     license = licenses.gpl2;
-    downloadPage = "http://sourceforge.net/projects/smbnetfs/files/smbnetfs";
+    downloadPage = "https://sourceforge.net/projects/smbnetfs/files/smbnetfs";
     updateWalker = true;
     inherit version;
     homepage = https://sourceforge.net/projects/smbnetfs/;

pkgs/tools/filesystems/smbnetfs/default.upstream

···
-url http://sourceforge.net/projects/smbnetfs/files/smbnetfs/
+url https://sourceforge.net/projects/smbnetfs/files/smbnetfs/
 version_link '[-][0-9.]+[a-z]*/$'
 version_link '[.]tar[.][a-z0-9]+/download$'
 SF_redirect

pkgs/tools/misc/bmon/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, ncurses, confuse
+{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, ncurses, libconfuse
 , libnl }:
 
 stdenv.mkDerivation rec {
···
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
 
-  buildInputs = [ ncurses confuse libnl ];
+  buildInputs = [ ncurses libconfuse libnl ];
 
   meta = with stdenv.lib; {
     description = "Network bandwidth monitor";

pkgs/tools/misc/diskus/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   name = "diskus-${version}";
-  version = "0.4.0";
+  version = "0.5.0";
 
   src = fetchFromGitHub {
     owner = "sharkdp";
     repo = "diskus";
-    rev = "cf4a5e0dc5bf3daedabe4b25343e7eb6238930c0";
-    sha256 = "1w5fnpwdsfaca2177qn0clf8j7zwgzhdckjdl2zdbs5qrdwdqrd2";
+    rev = "v${version}";
+    sha256 = "18scxspi5ncags8bnxq4ah9w8hrlwwlgpq7q9qfh4d81asmbyr8n";
   };
 
-  cargoSha256 = "08wm85cs0fi03a75wp276w5hgch3kd787py51jjcxdanm2viq7zv";
+  cargoSha256 = "1syrmm5qpz7d1h17xpw1wa3d2snaz9n7d1avsjp7xz8s2qcx1wdc";
 
   meta = with stdenv.lib; {
     description = "A minimal, fast alternative to 'du -sh'";

pkgs/tools/misc/mysqltuner/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mysqltuner-${version}";
-  version = "1.6.18";
+  version = "1.7.13";
 
   src = fetchFromGitHub {
     owner  = "major";
     repo   = "MySQLTuner-perl";
     rev    = version;
-    sha256 = "14dblrjqciyx6k7yczfzbaflc7hdxnj0kyy6q0lqfz8imszdkpi2";
+    sha256 = "0zxm2hjvgznbbmsqb8bpcgzc0yq1ikxz1gckirp95ibxid3jdham";
   };
 
   buildInputs = [ perl ];

pkgs/tools/misc/pgcenter/default.nix

···
+{ stdenv, buildGoPackage, fetchFromGitHub }:
+
+buildGoPackage rec {
+  name = "pgcenter-${version}";
+  version = "0.5.0";
+
+  goPackagePath = "github.com/lesovsky/pgcenter";
+
+  src = fetchFromGitHub {
+    owner  = "lesovsky";
+    repo   = "pgcenter";
+    rev    = "v${version}";
+    sha256 = "1bbpzli8hh5356gink6byk085zyfwxi8wigdy5cbadppx4qnk078";
+  };
+
+  goDeps = ./deps.nix;
+
+  meta = with stdenv.lib; {
+    homepage = https://pgcenter.org/;
+    description = "Command-line admin tool for observing and troubleshooting PostgreSQL";
+    license = licenses.bsd3;
+    maintainers = [ maintainers.marsam ];
+  };
+}

pkgs/tools/misc/pgcenter/deps.nix

···
+[
+
+  {
+    goPackagePath = "github.com/inconshreveable/mousetrap";
+    fetch = {
+      type = "git";
+      url = "https://github.com/inconshreveable/mousetrap";
+      rev = "v1.0.0";
+      sha256 = "1mn0kg48xkd74brf48qf5hzp0bc6g8cf5a77w895rl3qnlpfw152";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/jehiah/go-strftime";
+    fetch = {
+      type = "git";
+      url = "https://github.com/jehiah/go-strftime";
+      rev = "1d33003b3869";
+      sha256 = "056zagn4zhmrcqg8y5k5wql01x4ijbxn4pv75bh1bn45by6qx1gv";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/jroimartin/gocui";
+    fetch = {
+      type = "git";
+      url = "https://github.com/jroimartin/gocui";
+      rev = "v0.4.0";
+      sha256 = "1b1cbjg925l1c5v3ls8amni9716190yzf847cqs9wjnj82z8qa47";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/lib/pq";
+    fetch = {
+      type = "git";
+      url = "https://github.com/lib/pq";
+      rev = "v1.0.0";
+      sha256 = "1zqnnyczaf00xi6xh53vq758v5bdlf0iz7kf22l02cal4i6px47i";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/mattn/go-runewidth";
+    fetch = {
+      type = "git";
+      url = "https://github.com/mattn/go-runewidth";
+      rev = "v0.0.3";
+      sha256 = "0lc39b6xrxv7h3v3y1kgz49cgi5qxwlygs715aam6ba35m48yi7g";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/nsf/termbox-go";
+    fetch = {
+      type = "git";
+      url = "https://github.com/nsf/termbox-go";
+      rev = "b66b20ab708e";
+      sha256 = "0wrgnwfdxrspni5q15vzr5q1bxnzb7m6q4xjhllcyddgn2zqprsa";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/pkg/errors";
+    fetch = {
+      type = "git";
+      url = "https://github.com/pkg/errors";
+      rev = "v0.8.0";
+      sha256 = "001i6n71ghp2l6kdl3qq1v2vmghcz3kicv9a5wgcihrzigm75pp5";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/spf13/cobra";
+    fetch = {
+      type = "git";
+      url = "https://github.com/spf13/cobra";
+      rev = "v0.0.3";
+      sha256 = "1q1nsx05svyv9fv3fy6xv6gs9ffimkyzsfm49flvl3wnvf1ncrkd";
+    };
+  }
+
+  {
+    goPackagePath = "github.com/spf13/pflag";
+    fetch = {
+      type = "git";
+      url = "https://github.com/spf13/pflag";
+      rev = "v1.0.2";
+      sha256 = "005598piihl3l83a71ahj10cpq9pbhjck4xishx1b4dzc02r9xr2";
+    };
+  }
+
+  {
+    goPackagePath = "golang.org/x/crypto";
+    fetch = {
+      type = "git";
+      url = "https://go.googlesource.com/crypto";
+      rev = "0e37d006457b";
+      sha256 = "1fj8rvrhgv5j8pmckzphvm3sqkzhcqp3idkxvgv13qrjdfycsa5r";
+    };
+  }
+
+  {
+    goPackagePath = "golang.org/x/sys";
+    fetch = {
+      type = "git";
+      url = "https://go.googlesource.com/sys";
+      rev = "ee1b12c67af4";
+      sha256 = "0cgp0xzbhg3fr77n2qrfmmsvhc287srnwi4mghwcjdxp6rx0s988";
+    };
+  }
+]

pkgs/tools/misc/woeusb/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, makeWrapper
-, coreutils, dosfstools, findutils, gawk, gnugrep, grub2_light, ncurses, ntfs3g, parted, utillinux, wget
+, coreutils, dosfstools, findutils, gawk, gnugrep, grub2_light, ncurses, ntfs3g, parted, p7zip, utillinux, wget
 , wxGTK30 }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "0jzgwh9xv92yns5yi5zpl49zbp3csh6m6iclgq070awpjpsqlqi0";
   };
 
-  buildInputs = [ wxGTK30 autoreconfHook makeWrapper ];
+  nativeBuildInputs = [ autoreconfHook makeWrapper ];
+  buildInputs = [ wxGTK30 ];
 
   postPatch = ''
     # Emulate version smudge filter (see .gitattributes, .gitconfig).
···
     # should be patched with a less useless default PATH, but for now
     # we add everything we need manually.
     wrapProgram "$out/bin/woeusb" \
-      --set PATH '${stdenv.lib.makeBinPath [ coreutils dosfstools findutils gawk gnugrep grub2_light ncurses ntfs3g parted utillinux wget ]}'
+      --set PATH '${stdenv.lib.makeBinPath [ coreutils dosfstools findutils gawk gnugrep grub2_light ncurses ntfs3g parted utillinux wget p7zip ]}'
   '';
 
   doInstallCheck = true;

pkgs/tools/misc/xburst-tools/default.nix

···
-{ stdenv, fetchgit, libusb, libusb1, autoconf, automake, confuse, pkgconfig
+{ stdenv, fetchgit, libusb, libusb1, autoconf, automake, libconfuse, pkgconfig
 , gccCross ? null
 }:
 
···
   # Not to strip cross build binaries (this is for the gcc-cross-wrapper)
   dontCrossStrip = true;
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ libusb libusb1 autoconf automake confuse ] ++
+  nativeBuildInputs = [ autoconf automake pkgconfig ];
+  buildInputs = [ libusb libusb1 libconfuse ] ++
     stdenv.lib.optional (gccCross != null) gccCross;
 
   meta = {

pkgs/tools/misc/yad/default.nix

···
   name = "yad-0.40.0";
 
   src = fetchurl {
-    url = "http://sourceforge.net/projects/yad-dialog/files/${name}.tar.xz";
+    url = "mirror://sourceforge/yad-dialog/files/${name}.tar.xz";
     sha256 = "1x0fsv8nfkm8lchdawnf3zw79jaqbnvhv87sk5r8g86knv8vgl62";
   };
 
···
   '';
 
   meta = {
-    homepage = http://yad-dialog.sourceforge.net/;
+    homepage = https://sourceforge.net/projects/yad-dialog/;
     description = "GUI dialog tool for shell scripts";
     longDescription = ''
       Yad (yet another dialog) is a GUI dialog tool for shell scripts. It is a

pkgs/tools/networking/network-manager/applet.nix

···
 
 let
   pname = "network-manager-applet";
-  version = "1.8.16";
+  version = "1.8.18";
 in stdenv.mkDerivation rec {
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${name}.tar.xz";
-    sha256 = "0lmlkh4yyl9smvkgrzshn127zqfbp9f41f448ks8dlhhm38s38v2";
+    sha256 = "0y31g0lxr93370xi74hbpvcy9m81n5wdkdhq8xy2nqp0y4219p13";
   };
 
   mesonFlags = [

pkgs/tools/security/ecryptfs/default.nix

···
   version = "111";
 
   src = fetchurl {
-    url = "http://launchpad.net/ecryptfs/trunk/${version}/+download/ecryptfs-utils_${version}.orig.tar.gz";
+    url = "https://launchpad.net/ecryptfs/trunk/${version}/+download/ecryptfs-utils_${version}.orig.tar.gz";
     sha256 = "0zwq19siiwf09h7lwa7n7mgmrr8cxifp45lmwgcfr8c1gviv6b0i";
   };
 

pkgs/tools/security/kbfs/default.nix

···
 
 buildGoPackage rec {
   name = "kbfs-${version}";
-  version = "2.6.0";
+  version = "2.10.1";
 
   goPackagePath = "github.com/keybase/kbfs";
   subPackages = [ "kbfsfuse" "kbfsgit/git-remote-keybase" ];
···
     owner = "keybase";
     repo = "kbfs";
     rev = "v${version}";
-    sha256 = "0i4f1bc0gcnax572s749m7zcpy53a0f9yzi4lwc312zzxi7krz2f";
+    sha256 = "0c03jm4pxqh4cfg1d7c833hdl8l57f1sbfqxwdq16y5s2cac1yss";
   };
 
   buildFlags = [ "-tags production" ];

pkgs/tools/security/keybase/default.nix

···
 
 buildGoPackage rec {
   name = "keybase-${version}";
-  version = "2.7.3";
+  version = "2.10.1";
 
   goPackagePath = "github.com/keybase/client";
   subPackages = [ "go/keybase" ];
···
     owner  = "keybase";
     repo   = "client";
     rev    = "v${version}";
-    sha256 = "1sw6v3vf544vp8grw8p287cx078mr9v0v1wffcj6f9p9shlwj7ic";
+    sha256 = "1gfxnqzs8msxmykg1zrhrrl2slmb29gl7b8s4m2g44zxaj91gfi9";
   };
 
   buildInputs = lib.optionals stdenv.isDarwin [

pkgs/tools/security/keybase/gui.nix

···
-{ stdenv, fetchurl, alsaLib, atk, cairo, cups
-, dbus, expat, fontconfig, freetype, gcc, gdk_pixbuf, glib, gnome2, gtk3
-, libnotify, nspr, nss, pango, systemd, xorg }:
+{ stdenv, fetchurl, alsaLib, atk, cairo, cups, udev, hicolor-icon-theme
+, dbus, expat, fontconfig, freetype, gdk_pixbuf, glib, gnome2, gtk3, gnome3
+, libnotify, nspr, nss, pango, systemd, xorg, autoPatchelfHook, wrapGAppsHook }:
 
 let
-  libPath = stdenv.lib.makeLibraryPath [
+  versionSuffix = "20181121195344.99751ac04f";
+in
+
+stdenv.mkDerivation rec {
+  name = "keybase-gui-${version}";
+  version = "2.11.0"; # Find latest version from https://prerelease.keybase.io/deb/dists/stable/main/binary-amd64/Packages
+
+  src = fetchurl {
+    url = "https://s3.amazonaws.com/prerelease.keybase.io/linux_binaries/deb/keybase_${version + "-" + versionSuffix}_amd64.deb";
+    sha256 = "1gh7brdw2p4xfdgc43vrmv0lvki2f3691mfh6lvksy1dv43yb8zl";
+  };
+
+  nativeBuildInputs = [
+    autoPatchelfHook
+    wrapGAppsHook
+  ];
+
+  buildInputs = [
     alsaLib
     atk
     cairo
···
     expat
     fontconfig
     freetype
-    gcc.cc
     gdk_pixbuf
     glib
     gnome2.GConf
+    gnome3.gsettings-desktop-schemas
     gtk3
     libnotify
     nspr
···
     pango
     systemd
     xorg.libX11
-    xorg.libxcb
+    xorg.libXScrnSaver
     xorg.libXcomposite
     xorg.libXcursor
     xorg.libXdamage
···
     xorg.libXi
     xorg.libXrandr
     xorg.libXrender
-    xorg.libXScrnSaver
     xorg.libXtst
+    xorg.libxcb
   ];
-in
-stdenv.mkDerivation rec {
-  name = "keybase-gui-${version}";
-  version = "2.7.0-20180926133747.0d62c866fc";
-  src = fetchurl {
-    url = "https://s3.amazonaws.com/prerelease.keybase.io/linux_binaries/deb/keybase_${version}_amd64.deb";
-    sha256 = "0a0ax3skfw398vcjl7822qp7160lbll1snwdqsa13dy8qrjl1byp";
-  };
-  phases = ["unpackPhase" "installPhase" "fixupPhase"];
+
+  runtimeDependencies = [
+    udev.lib
+  ];
+
+  dontBuild = true;
+  dontConfigure = true;
+  dontPatchElf = true;
+
   unpackPhase = ''
     ar xf $src
     tar xf data.tar.xz
   '';
+
   installPhase = ''
     mkdir -p $out/bin
     mv usr/share $out/share
···
     substituteInPlace $out/share/applications/keybase.desktop \
       --replace run_keybase $out/bin/keybase-gui
   '';
-  postFixup = ''
-    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath "${libPath}:\$ORIGIN" "$out/share/keybase/Keybase"
-  '';
 
   meta = with stdenv.lib; {
     homepage = https://www.keybase.io/;
-    description = "The Keybase official GUI.";
+    description = "The Keybase official GUI";
     platforms = platforms.linux;
     maintainers = with maintainers; [ puffnfresh np ];
     license = licenses.bsd3;

pkgs/tools/security/super/default.nix

···
   '';
 
   patches = [
-   (fetchpatch { url = http://anonscm.debian.org/cgit/users/robert/super.git/plain/debian/patches/14-Fix-unchecked-setuid-call.patch;
+   (fetchpatch { url = https://salsa.debian.org/debian/super/raw/debian/3.30.0-7/debian/patches/14-Fix-unchecked-setuid-call.patch;
                  sha256 = "08m9hw4kyfjv0kqns1cqha4v5hkgp4s4z0q1rgif1fnk14xh7wqh";
                })
   ];
···
   installFlags = "sysconfdir=$(out)/etc localstatedir=$(TMPDIR)";
 
   meta = {
-    homepage = http://www.ucolick.org/~will/;
+    homepage = "https://www.ucolick.org/~will/#super";
     description = "Allows users to execute scripts as if they were root";
     longDescription =
       ''

pkgs/tools/security/wpscan/Gemfile

···
+source 'https://rubygems.org'
+gem 'wpscan', '= 3.4.0'

pkgs/tools/security/wpscan/Gemfile.lock

···
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.2.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    cms_scanner (0.0.41.0)
+      activesupport (~> 5.2)
+      addressable (~> 2.5)
+      nokogiri (~> 1.8.0)
+      opt_parse_validator (~> 0.0.16.4)
+      public_suffix (~> 3.0.0)
+      ruby-progressbar (~> 1.10.0)
+      typhoeus (~> 1.3.0)
+      xmlrpc (~> 0.3)
+      yajl-ruby (~> 1.4.1)
+    concurrent-ruby (1.1.3)
+    ethon (0.11.0)
+      ffi (>= 1.3.0)
+    ffi (1.9.25)
+    i18n (1.1.1)
+      concurrent-ruby (~> 1.0)
+    mini_portile2 (2.3.0)
+    minitest (5.11.3)
+    nokogiri (1.8.5)
+      mini_portile2 (~> 2.3.0)
+    opt_parse_validator (0.0.16.4)
+      activesupport (~> 5.2.1)
+      addressable (~> 2.5.0)
+    public_suffix (3.0.3)
+    ruby-progressbar (1.10.0)
+    thread_safe (0.3.6)
+    typhoeus (1.3.1)
+      ethon (>= 0.9.0)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    wpscan (3.4.0)
+      activesupport (~> 5.2)
+      cms_scanner (~> 0.0.41.0)
+      yajl-ruby (~> 1.3)
+    xmlrpc (0.3.0)
+    yajl-ruby (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  wpscan (= 3.4.0)
+
+BUNDLED WITH
+   1.16.3

pkgs/tools/security/wpscan/default.nix

···
+{ bundlerApp, lib, makeWrapper, curl }:
+
+bundlerApp {
+  pname = "wpscan";
+  gemdir = ./.;
+  exes = [ "wpscan" ];
+
+  buildInputs = [ makeWrapper ];
+  postBuild = ''
+    wrapProgram "$out/bin/wpscan" \
+      --prefix PATH : ${lib.makeBinPath [ curl ]}
+  '';
+
+  meta = with lib; {
+    description = "Black box WordPress vulnerability scanner";
+    homepage    = https://wpscan.org/;
+    license     = licenses.unfreeRedistributable;
+    maintainers = [ maintainers.nyanloutre ];
+    platforms   = platforms.unix;
+  };
+}

pkgs/tools/security/wpscan/gemset.nix

···
+{
+  activesupport = {
+    dependencies = ["concurrent-ruby" "i18n" "minitest" "tzinfo"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ziy6xk31k4fs115cdkba1ys4i8nzcyri7a2jig7nx7k5h7li6l2";
+      type = "gem";
+    };
+    version = "5.2.1";
+  };
+  addressable = {
+    dependencies = ["public_suffix"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0viqszpkggqi8hq87pqp0xykhvz60g99nwmkwsb0v45kc2liwxvk";
+      type = "gem";
+    };
+    version = "2.5.2";
+  };
+  cms_scanner = {
+    dependencies = ["activesupport" "addressable" "nokogiri" "opt_parse_validator" "public_suffix" "ruby-progressbar" "typhoeus" "xmlrpc" "yajl-ruby"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1azsvgg070dng2jaz44zaqkvqyhf3pj131nqa7wdv3bsqp8y7kap";
+      type = "gem";
+    };
+    version = "0.0.41.0";
+  };
+  concurrent-ruby = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "18q9skp5pfq4jwbxzmw8q2rn4cpw6mf4561i2hsjcl1nxdag2jvb";
+      type = "gem";
+    };
+    version = "1.1.3";
+  };
+  ethon = {
+    dependencies = ["ffi"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0y70szwm2p0b9qfvpqrzjrgm3jz0ig65vlbfr6ppc3z0m1h7kv48";
+      type = "gem";
+    };
+    version = "0.11.0";
+  };
+  ffi = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0jpm2dis1j7zvvy3lg7axz9jml316zrn7s0j59vyq3qr127z0m7q";
+      type = "gem";
+    };
+    version = "1.9.25";
+  };
+  i18n = {
+    dependencies = ["concurrent-ruby"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1gcp1m1p6dpasycfz2sj82ci9ggz7lsskz9c9q6gvfwxrl8y9dx7";
+      type = "gem";
+    };
+    version = "1.1.1";
+  };
+  mini_portile2 = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "13d32jjadpjj6d2wdhkfpsmy68zjx90p49bgf8f7nkpz86r1fr11";
+      type = "gem";
+    };
+    version = "2.3.0";
+  };
+  minitest = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0icglrhghgwdlnzzp4jf76b0mbc71s80njn5afyfjn4wqji8mqbq";
+      type = "gem";
+    };
+    version = "5.11.3";
+  };
+  nokogiri = {
+    dependencies = ["mini_portile2"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0byyxrazkfm29ypcx5q4syrv126nvjnf7z6bqi01sqkv4llsi4qz";
+      type = "gem";
+    };
+    version = "1.8.5";
+  };
+  opt_parse_validator = {
+    dependencies = ["activesupport" "addressable"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1m3flpg1d7la1frip3vn0hgm6d91f0ys1jq2bhxr5va1vjbfvgbs";
+      type = "gem";
+    };
+    version = "0.0.16.4";
+  };
+  public_suffix = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "08q64b5br692dd3v0a9wq9q5dvycc6kmiqmjbdxkxbfizggsvx6l";
+      type = "gem";
+    };
+    version = "3.0.3";
+  };
+  ruby-progressbar = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1cv2ym3rl09svw8940ny67bav7b2db4ms39i4raaqzkf59jmhglk";
+      type = "gem";
+    };
+    version = "1.10.0";
+  };
+  thread_safe = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0nmhcgq6cgz44srylra07bmaw99f5271l0dpsvl5f75m44l0gmwy";
+      type = "gem";
+    };
+    version = "0.3.6";
+  };
+  typhoeus = {
+    dependencies = ["ethon"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0cni8b1idcp0dk8kybmxydadhfpaj3lbs99w5kjibv8bsmip2zi5";
+      type = "gem";
+    };
+    version = "1.3.1";
+  };
+  tzinfo = {
+    dependencies = ["thread_safe"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1fjx9j327xpkkdlxwmkl3a8wqj7i4l4jwlrv3z13mg95z9wl253z";
+      type = "gem";
+    };
+    version = "1.2.5";
+  };
+  wpscan = {
+    dependencies = ["activesupport" "cms_scanner" "yajl-ruby"];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "17mqqaiawp3apdfw4l6r2wp0a4f0rp8wdqd2426xkna7vsxgh8gs";
+      type = "gem";
+    };
+    version = "3.4.0";
+  };
+  xmlrpc = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1s744iwblw262gj357pky3d9fcx9hisvla7rnw29ysn5zsb6i683";
+      type = "gem";
+    };
+    version = "0.3.0";
+  };
+  yajl-ruby = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "16v0w5749qjp13xhjgr2gcsvjv6mf35br7iqwycix1n2h7kfcckf";
+      type = "gem";
+    };
+    version = "1.4.1";
+  };
+}

pkgs/tools/system/dfc/default.nix

···
 {stdenv, fetchurl, cmake, gettext}:
 
 stdenv.mkDerivation rec {
-  name = "dfc-3.0.5";
+  name = "dfc-${version}";
+  version = "3.1.1";
 
   src = fetchurl {
-    url = "https://projects.gw-computing.net/attachments/download/467/${name}.tar.gz";
-    sha256 = "0yl5dl1nydinji71zz37c7myg3vg9jzxq89rcjqlfcy5dcfpm51w";
+    url = "https://projects.gw-computing.net/attachments/download/615/${name}.tar.gz";
+    sha256 = "0m1fd7l85ckb7bq4c5c3g257bkjglm8gq7x42pkmpp87fkknc94n";
   };
 
-  buildInputs = [ cmake gettext ];
+  nativeBuildInputs = [ cmake gettext ];
 
   meta = {
     homepage = https://projects.gw-computing.net/projects/dfc;
     description = "Displays file system space usage using graphs and colors";
-    license="free";
+    license = stdenv.lib.licenses.bsd3;
     maintainers = with stdenv.lib.maintainers; [qknight];
-    platforms = with stdenv.lib.platforms; all;
+    platforms = stdenv.lib.platforms.all;
   };
 }
-

pkgs/tools/system/hardlink/default.nix

···
   meta = with stdenv.lib; {
     description = "Consolidate duplicate files via hardlinks";
     homepage = https://pagure.io/hardlink;
-    repositories.git = http://src.fedoraproject.org/cgit/rpms/hardlink.git;
+    repositories.git = https://src.fedoraproject.org/cgit/rpms/hardlink.git;
     license = licenses.gpl2Plus;
     platforms = platforms.unix;
   };

pkgs/tools/system/ipmiutil/default.nix

···
     maintainers = with maintainers; [ raskin ];
     platforms = platforms.linux;
     license = licenses.bsd3;
-    downloadPage = "http://sourceforge.net/projects/ipmiutil/files/ipmiutil/";
+    downloadPage = "https://sourceforge.net/projects/ipmiutil/files/ipmiutil/";
     inherit version;
   };
 }

pkgs/tools/system/ipmiutil/default.upstream

···
-url http://sourceforge.net/projects/ipmiutil/files/
+url https://sourceforge.net/projects/ipmiutil/files/
 SF_version_tarball
 SF_redirect
 minimize_overwrite

pkgs/tools/system/smartmontools/default.nix

···
   dbrev = "4548";
   drivedbBranch = "RELEASE_${builtins.replaceStrings ["."] ["_"] version}_DRIVEDB";
   driverdb = fetchurl {
-    url    = "http://sourceforge.net/p/smartmontools/code/${dbrev}/tree/branches/${drivedbBranch}/smartmontools/drivedb.h?format=raw";
+    url    = "https://sourceforge.net/p/smartmontools/code/${dbrev}/tree/branches/${drivedbBranch}/smartmontools/drivedb.h?format=raw";
     sha256 = "0nwk4ir0c40b01frqm7a0lvljh5k9yhslc3j4485zjsx3v5w269f";
     name   = "smartmontools-drivedb.h";
   };
···
 
   meta = with stdenv.lib; {
     description = "Tools for monitoring the health of hard drives";
-    homepage    = http://smartmontools.sourceforge.net/;
+    homepage    = https://www.smartmontools.org/;
     license     = licenses.gpl2Plus;
     maintainers = with maintainers; [ peti ];
     platforms   = with platforms; linux ++ darwin;

pkgs/tools/text/vale/default.nix

···
 
 buildGoPackage rec {
   name = "vale-${version}";
-  version = "1.0.3";
-  rev    = "v${version}";
+  version = "1.2.6";
 
   goPackagePath = "github.com/errata-ai/vale";
 
   src = fetchFromGitHub {
-    inherit rev;
     owner  = "errata-ai";
     repo   = "vale";
-    sha256 = "132zzgry19alcdn3m3q62sp2lm3yxc4kil12lm309jl7b3n0850h";
+    rev    = "v${version}";
+    sha256 = "1mhynasikncwz9dkk9z27qvwk03j7q0vx0wjnqg69pd97lgrp7zp";
   };
 
   goDeps = ./deps.nix;
 
   meta = with stdenv.lib; {
-    homepage = https://errata.ai/vale/getting-started/;
+    homepage = https://errata-ai.github.io/vale/;
     description = "Vale is an open source linter for prose";
     license = licenses.mit;
     maintainers = [ maintainers.marsam ];

pkgs/top-level/all-packages.nix

···
     ... # For hash agility
   }@args: fetchzip ({
     inherit name;
-    url = "http://repo.or.cz/${repo}.git/snapshot/${rev}.tar.gz";
-    meta.homepage = "http://repo.or.cz/${repo}.git/";
+    url = "https://repo.or.cz/${repo}.git/snapshot/${rev}.tar.gz";
+    meta.homepage = "https://repo.or.cz/${repo}.git/";
   } // removeAttrs args [ "repo" "rev" ]) // { inherit rev; };
 
   fetchNuGet = callPackage ../build-support/fetchnuget { };
···
   chkcrontab = callPackage ../tools/admin/chkcrontab { };
 
   cozy = callPackage ../applications/audio/cozy-audiobooks { };
+
+  deskew = callPackage ../applications/graphics/deskew { };
 
   diskus = callPackage ../tools/misc/diskus { };
 
···
   psstop = callPackage ../tools/system/psstop { };
 
   parallel-rust = callPackage ../tools/misc/parallel-rust { };
+
+  pyCA = python3Packages.callPackage ../applications/video/pyca {};
 
   scour = with python3Packages; toPythonApplication scour;
 
···
 
   fuse-7z-ng = callPackage ../tools/filesystems/fuse-7z-ng { };
 
+  fusee-launcher = callPackage ../development/tools/fusee-launcher { };
+
   fwknop = callPackage ../tools/security/fwknop { };
 
   exfat = callPackage ../tools/filesystems/exfat { };
···
   multitail = callPackage ../tools/misc/multitail { };
 
   mxt-app = callPackage ../misc/mxt-app { };
+
+  mxisd = callPackage ../servers/mxisd { };
 
   nagstamon = callPackage ../tools/misc/nagstamon {
     pythonPackages = python3Packages;
···
 
   pg_top = callPackage ../tools/misc/pg_top { };
 
+  pgcenter = callPackage ../tools/misc/pgcenter { };
+
   pgmetrics = callPackage ../tools/misc/pgmetrics { };
 
   pdsh = callPackage ../tools/networking/pdsh {
···
 
   woof = callPackage ../tools/misc/woof { };
 
+  wpscan = callPackage ../tools/security/wpscan { };
+
   wsmancli = callPackage ../tools/system/wsmancli {};
 
   wolfebin = callPackage ../tools/networking/wolfebin {
···
   cointop = callPackage ../applications/misc/cointop { };
 
   commoncpp2 = callPackage ../development/libraries/commoncpp2 { };
-
-  confuse = callPackage ../development/libraries/confuse { };
 
   coredumper = callPackage ../development/libraries/coredumper { };
 
···
     packages = [];
   };
 
-  rstudioWrapper = callPackage ../development/r-modules/wrapper-rstudio.nix {
+  rstudioWrapper = libsForQt5.callPackage ../development/r-modules/wrapper-rstudio.nix {
     recommendedPackages = with rPackages; [
       boot class cluster codetools foreign KernSmooth lattice MASS
       Matrix mgcv nlme nnet rpart spatial survival
···
   lohit-fonts = recurseIntoAttrs ( callPackages ../data/fonts/lohit-fonts { } );
 
   maia-icon-theme = callPackage ../data/icons/maia-icon-theme { };
+
+  mailcap = callPackage ../data/misc/mailcap { };
 
   marathi-cursive = callPackage ../data/fonts/marathi-cursive { };
 
···
 
   poezio = python3Packages.poezio;
 
-  pommed = callPackage ../os-specific/linux/pommed {};
-
   pommed_light = callPackage ../os-specific/linux/pommed-light {};
 
   polymake = callPackage ../applications/science/math/polymake { };
···
 
   scs = callPackage ../development/libraries/science/math/scs { };
 
-  sage = callPackage ../applications/science/math/sage {
-    nixpkgs = pkgs;
-  };
+  sage = callPackage ../applications/science/math/sage { };
   sageWithDoc = sage.override { withDoc = true; };
 
   suitesparse_4_2 = callPackage ../development/libraries/science/math/suitesparse/4.2.nix { };
···
   vimUtils = callPackage ../misc/vim-plugins/vim-utils.nix { };
 
   vimPlugins = recurseIntoAttrs (callPackage ../misc/vim-plugins {
-    llvmPackages = llvmPackages_39;
+    llvmPackages = llvmPackages_6;
   });
 
   vimprobable2-unwrapped = callPackage ../applications/networking/browsers/vimprobable2 {

pkgs/top-level/haskell-packages.nix

···
     };
     ghc844 = callPackage ../development/compilers/ghc/8.4.4.nix {
       bootPkgs = packages.ghc822Binary;
+      inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_5;
       llvmPackages = pkgs.llvmPackages_5;
     };
     ghc861 = callPackage ../development/compilers/ghc/8.6.1.nix {
       bootPkgs = packages.ghc822;
+      inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_6;
       llvmPackages = pkgs.llvmPackages_6;
     };
     ghc862 = callPackage ../development/compilers/ghc/8.6.2.nix {
       bootPkgs = packages.ghc822;
+      inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_6;
       llvmPackages = pkgs.llvmPackages_6;
     };
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
       bootPkgs = packages.ghc822Binary;
+      inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_5;
       llvmPackages = pkgs.llvmPackages_5;
     };

pkgs/top-level/python-packages.nix

···
 
   setuptools-git = callPackage ../development/python-modules/setuptools-git { };
 
+  sievelib = callPackage ../development/python-modules/sievelib { };
+
   watchdog = callPackage ../development/python-modules/watchdog { };
 
   zope_deprecation = callPackage ../development/python-modules/zope_deprecation { };
···
 
   simplejson = callPackage ../development/python-modules/simplejson { };
 
+  simplekml = callPackage ../development/python-modules/simplekml { };
+
   slimit = callPackage ../development/python-modules/slimit { };
 
   snowballstemmer = callPackage ../development/python-modules/snowballstemmer { };
···
 
   tvdb_api = callPackage ../development/python-modules/tvdb_api { };
 
+  sdnotify = callPackage ../development/python-modules/sdnotify { };
+
   tvnamer = callPackage ../development/python-modules/tvnamer { };
 
   threadpool = callPackage ../development/python-modules/threadpool { };
···
   qasm2image = callPackage ../development/python-modules/qasm2image { };
 
   simpy = callPackage ../development/python-modules/simpy { };
+
+  yattag = callPackage ../development/python-modules/yattag { };
 
   z3 = (toPythonModule (pkgs.z3.override {
     inherit python;