Merge remote-tracking branch 'upstream/master' into HEAD

lib/licenses.nix

···
     fullName = "DOC License";
   };
 
+  eapl = {
+    fullName = "EPSON AVASYS PUBLIC LICENSE";
+    url = http://avasys.jp/hp/menu000000700/hpg000000603.htm;
+    free = false;
+  };
+
   efl10 = spdx {
     spdxId = "EFL-1.0";
     fullName = "Eiffel Forum License v1.0";
···
   fdl13 = spdx {
     spdxId = "GFDL-1.3";
     fullName = "GNU Free Documentation License v1.3";
+  };
+
+  ffsl = {
+    fullName = "Floodgap Free Software License";
+    url = http://www.floodgap.com/software/ffsl/license.html;
   };
 
   free = {

lib/maintainers.nix

···
   kiloreux = "Kiloreux Emperex <[e-mail]>";
   kkallio = "Karn Kallio <[e-mail]>";
   knedlsepp = "Josef Kemetmüller <[e-mail]>";
-  konimex = "Muhammad Herdiansyah <[e-mail]>";
+  konimex = "Muhammad Herdiansyah <[e-mail]>";
   koral = "Koral <[e-mail]>";
   kovirobi = "Kovacsics Robert <[e-mail]>";
   kragniz = "Louis Taylor <[e-mail]>";
···
   thammers = "Tobias Hammerschmidt <[e-mail]>";
   the-kenny = "Moritz Ulrich <[e-mail]>";
   theuni = "Christian Theune <[e-mail]>";
+  ThomasMader = "Thomas Mader <[e-mail]>";
   thoughtpolice = "Austin Seipp <[e-mail]>";
   timbertson = "Tim Cuthbertson <[e-mail]>";
   titanous = "Jonathan Rudenberg <[e-mail]>";
···
   wjlroe = "William Roe <[e-mail]>";
   wkennington = "William A. Kennington III <[e-mail]>";
   wmertens = "Wout Mertens <[e-mail]>";
+  woffs = "Frank Doepper <[e-mail]>";
   womfoo = "Kranium Gikos Mendoza <[e-mail]>";
   wscott = "Wayne Scott <[e-mail]>";
   wyvie = "Elijah Rum <[e-mail]>";

nixos/modules/installer/cd-dvd/sd-image-aarch64.nix

···
   boot.loader.generic-extlinux-compatible.enable = true;
 
   boot.kernelPackages = pkgs.linuxPackages_latest;
-  boot.kernelParams = ["console=ttyS0,115200n8" "console=tty0"];
+  # Increase the amount of CMA to ensure the virtual console on the RPi3 works.
+  boot.kernelParams = ["cma=32M" "console=ttyS0,115200n8" "console=tty0"];
   boot.consoleLogLevel = 7;
 
   # FIXME: this probably should be in installation-device.nix

nixos/modules/installer/tools/nix-fallback-paths.nix

···
 {
-  x86_64-linux = "/nix/store/xrqssm90gsrnqdn79rpfcs6dwx8597d2-nix-1.11.14";
-  i686-linux = "/nix/store/3vjphivqs2iy6m9yb3bd80nd3518510k-nix-1.11.14";
-  x86_64-darwin = "/nix/store/4j9jacx8mjd4jlj53wvymyhxq7dqyj5d-nix-1.11.14";
+  x86_64-linux = "/nix/store/b4s1gxiis1ryvybnjhdjvgc5sr1nq0ys-nix-1.11.15";
+  i686-linux = "/nix/store/kgb5hs7qw13bvb6icramv1ry9dard3h9-nix-1.11.15";
+  x86_64-darwin = "/nix/store/dgwz3dxdzs2wwd7pg7cdhvl8rv0qpnbj-nix-1.11.15";
 }

nixos/modules/installer/tools/nixos-install.sh

···
 binary_caches="$(@perl@/bin/perl -I @nix@/lib/perl5/site_perl/*/* -e 'use Nix::Config; Nix::Config::readConfig; print $Nix::Config::config{"binary-caches"};')"
 extraBuildFlags+=(--option "binary-caches" "$binary_caches")
 
-nixpkgs="$(readlink -f "$(nix-instantiate --find-file nixpkgs)")"
-export NIX_PATH="nixpkgs=$nixpkgs:nixos-config=$mountPoint/$NIXOS_CONFIG"
+# We only need nixpkgs in the path if we don't already have a system closure to install
+if [[ -z "$closure" ]]; then
+    nixpkgs="$(readlink -f "$(nix-instantiate --find-file nixpkgs)")"
+    export NIX_PATH="nixpkgs=$nixpkgs:nixos-config=$mountPoint/$NIXOS_CONFIG"
+fi
 unset NIXOS_CONFIG
 
 # TODO: do I need to set NIX_SUBSTITUTERS here or is the --option binary-caches above enough?
···
 }
 
 system_closure="$tmpdir/system.closure"
+# Use a FIFO for piping nix-store --export into nix-store --import, saving disk
+# I/O and space. nix-store --import is run by nixos-prepare-root.
+mkfifo $system_closure
 
 if [ -z "$closure" ]; then
     expr="(import <nixpkgs/nixos> {}).system"
···
     system_root=$closure
     # Create a temporary file ending in .closure (so nixos-prepare-root knows to --import it) to transport the store closure
     # to the filesytem we're preparing. Also delete it on exit!
-    nix-store --export $(nix-store -qR $closure) > $system_closure
+    # Run in background to avoid blocking while trying to write to the FIFO
+    # $system_closure refers to
+    nix-store --export $(nix-store -qR $closure) > $system_closure &
 fi
 
 channel_root="$(nix-env -p /nix/var/nix/profiles/per-user/root/channels -q nixos --no-name --out-path 2>/dev/null || echo -n "")"

nixos/modules/programs/mtr.nix

···
   };
 
   config = mkIf cfg.enable {
-    security.wrappers.mtr = {
-      source = "${pkgs.mtr}/bin/mtr";
+    environment.systemPackages = with pkgs; [ mtr ];
+    security.wrappers.mtr-packet = {
+      source = "${pkgs.mtr}/bin/mtr-packet";
       capabilities = "cap_net_raw+p";
     };
   };

nixos/modules/rename.nix

···
       "Set the option `services.xserver.displayManager.sddm.package' instead.")
     (mkRemovedOptionModule [ "fonts" "fontconfig" "forceAutohint" ] "")
     (mkRemovedOptionModule [ "fonts" "fontconfig" "renderMonoTTFAsBitmap" ] "")
-    (mkRemovedOptionModule [ "boot" "zfs" "enableUnstable" ] "0.7.0 is now the default")
 
     # ZSH
     (mkRenamedOptionModule [ "programs" "zsh" "enableSyntaxHighlighting" ] [ "programs" "zsh" "syntaxHighlighting" "enable" ])

nixos/modules/services/mail/dovecot.nix

···
       }
     '')
 
+    ''
+      protocol imap {
+        namespace inbox {
+          inbox=yes
+          ${concatStringsSep "\n" (map mailboxConfig cfg.mailboxes)}
+        }
+      }
+    ''
+
+    (optionalString cfg.enableQuota ''
+      mail_plugins = $mail_plugins quota
+      service quota-status {
+        executable = ${dovecotPkg}/libexec/dovecot/quota-status -p postfix
+        inet_listener {
+          port = ${cfg.quotaPort}
+        }
+        client_limit = 1
+      }
+
+      protocol imap {
+        mail_plugins = $mail_plugins imap_quota
+      }
+
+      plugin {
+        quota_rule = *:storage=${cfg.quotaGlobalPerUser} 
+        quota = maildir:User quota # per virtual mail user quota # BUG/FIXME broken, we couldn't get this working
+        quota_status_success = DUNNO
+        quota_status_nouser = DUNNO
+        quota_status_overquota = "552 5.2.2 Mailbox is full"
+        quota_grace = 10%%
+      }
+    '')
+
     cfg.extraConfig
   ];
 
···
     paths = map (pkg: "${pkg}/lib/dovecot") ([ dovecotPkg ] ++ map (module: module.override { dovecot = dovecotPkg; }) cfg.modules);
   };
 
+  mailboxConfig = mailbox: ''
+    mailbox ${mailbox.name} {
+      auto = ${toString mailbox.auto}
+  '' + optionalString (mailbox.specialUse != null) ''
+      special_use = \${toString mailbox.specialUse}
+  '' + "}";
+
+  mailboxes = { lib, pkgs, ... }: {
+    options = {
+      name = mkOption {
+        type = types.str;
+        example = "Spam";
+        description = "The name of the mailbox.";
+      };
+      auto = mkOption {
+        type = types.enum [ "no" "create" "subscribe" ];
+        default = "no";
+        example = "subscribe";
+        description = "Whether to automatically create or create and subscribe to the mailbox or not.";
+      };
+      specialUse = mkOption {
+        type = types.nullOr (types.enum [ "All" "Archive" "Drafts" "Flagged" "Junk" "Sent" "Trash" ]);
+        default = null;
+        example = "Junk";
+        description = "Null if no special use flag is set. Other than that every use flag mentioned in the RFC is valid.";
+      };
+    };
+  };
 in
 {
 
···
 
     enablePop3 = mkOption {
       type = types.bool;
-      default = true;
+      default = false;
       description = "Start the POP3 listener (when Dovecot is enabled).";
     };
 
···
       description = "Default group to store mail for virtual users.";
     };
 
+    createMailUser = mkOption {
+      type = types.bool;
+      default = true;
+      description = ''Whether to automatically create the user
+        given in <option>services.dovecot.user</option> and the group
+        given in <option>services.dovecot.group</option>.'';
+    };
+
     modules = mkOption {
       type = types.listOf types.package;
       default = [];
···
       default = false;
       description = "Show the PAM failure message on authentication error (useful for OTPW).";
     };
+
+    mailboxes = mkOption {
+      type = types.listOf (types.submodule mailboxes);
+      default = [];
+      example = [ { name = "Spam"; specialUse = "Junk"; auto = "create"; } ];
+      description = "Configure mailboxes and auto create or subscribe them.";
+    };
+
+    enableQuota = mkOption {
+      type = types.bool;
+      default = false;
+      example = true;
+      description = "Whether to enable the dovecot quota service.";
+    };
+
+    quotaPort = mkOption {
+      type = types.str;
+      default = "12340";
+      description = ''
+        The Port the dovecot quota service binds to.
+        If using postfix, add check_policy_service inet:localhost:12340 to your smtpd_recipient_restrictions in your postfix config.
+      '';
+    };
+    quotaGlobalPerUser = mkOption {
+      type = types.str;
+      default = "100G";
+      example = "10G";
+      description = "Quota limit for the user in bytes. Supports suffixes b, k, M, G, T and %.";
+    };
+
   };
 
 
···
            uid = config.ids.uids.dovecot2;
            description = "Dovecot user";
            group = cfg.group;
+         }
+      ++ optional cfg.createMailUser
+         { name = cfg.mailUser;
+           description = "Virtual Mail User";
+           group = cfg.mailGroup;
          };
 
     users.extraGroups = optional (cfg.group == "dovecot2")
       { name = "dovecot2";
         gid = config.ids.gids.dovecot2;
+      }
+    ++ optional cfg.createMailUser
+      { name = cfg.mailGroup;
       };
 
     environment.etc."dovecot/modules".source = modulesDir;

nixos/modules/services/misc/geoip-updater.nix

···
 
     assertions = [
       { assertion = (builtins.filter
-          (x: builtins.match ".*\.(gz|xz)$" x == null) cfg.databases) == [];
+          (x: builtins.match ".*\\.(gz|xz)$" x == null) cfg.databases) == [];
         message = ''
           services.geoip-updater.databases supports only .gz and .xz databases.
 
···
           ${toString cfg.databases}
 
           Offending element(s):
-          ${toString (builtins.filter (x: builtins.match ".*\.(gz|xz)$" x == null) cfg.databases)};
+          ${toString (builtins.filter (x: builtins.match ".*\\.(gz|xz)$" x == null) cfg.databases)};
         '';
       }
     ];

nixos/modules/services/networking/namecoind.nix

···
 
       serviceConfig = {
         User  = "namecoin";
-        Griup = "namecoin";
+        Group = "namecoin";
         ExecStart  = "${pkgs.altcoins.namecoind}/bin/namecoind -conf=${configFile} -datadir=${dataDir} -printtoconsole";
         ExecStop   = "${pkgs.coreutils}/bin/kill -KILL $MAINPID";
         ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

nixos/modules/services/networking/supplicant.nix

···
 
       default = { };
 
-      example = {
-        "wlan0 wlan1" = {
-          configFile = "/etc/wpa_supplicant";
-          userControlled.group = "network";
-          extraConf = ''
-            ap_scan=1
-            p2p_disabled=1
-          '';
-          extraCmdArgs = "-u -W";
-          bridge = "br0";
-        };
-      };
+      example = literalExample ''
+        { "wlan0 wlan1" = {
+            configFile = "/etc/wpa_supplicant";
+            userControlled.group = "network";
+            extraConf = '''
+              ap_scan=1
+              p2p_disabled=1
+            ''';
+            extraCmdArgs = "-u -W";
+            bridge = "br0";
+          };
+        }
+      '';
 
       description = ''
         Interfaces for which to start <command>wpa_supplicant</command>.

nixos/modules/services/security/tor.nix

···
       GeoIPv6File ${pkgs.tor.geoip}/share/tor/geoip6
     ''}
 
-    ${optint "ControlPort" (toString cfg.controlPort)}
+    ${optint "ControlPort" cfg.controlPort}
   ''
   # Client connection config
   + optionalString cfg.client.enable  ''

nixos/modules/tasks/filesystems/zfs.nix

···
 
   kernel = config.boot.kernelPackages;
 
-  packages = {
+  packages = if config.boot.zfs.enableUnstable then {
+    spl = kernel.splUnstable;
+    zfs = kernel.zfsUnstable;
+    zfsUser = pkgs.zfsUnstable;
+  } else {
     spl = kernel.spl;
     zfs = kernel.zfs;
     zfsUser = pkgs.zfs;
···
 
   options = {
     boot.zfs = {
+      enableUnstable = mkOption {
+        type = types.bool;
+        default = false;
+        description = ''
+          Use the unstable zfs package. This might be an option, if the latest
+          kernel is not yet supported by a published release of ZFS. Enabling
+          this option will install a development version of ZFS on Linux. The
+          version will have already passed an extensive test suite, but it is
+          more likely to hit an undiscovered bug compared to running a released
+          version of ZFS on Linux.
+          '';
+      };
+
       extraPools = mkOption {
         type = types.listOf types.str;
         default = [];

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

···
     before = ["sshd.service"];
     wants = ["local-fs.target" "network-online.target" "network.target"];
     wantedBy = [ "sshd.service" "multi-user.target" ];
-    path = with pkgs; [ ethtool ];
+    path = with pkgs; [ ethtool openssh ];
     serviceConfig = {
       ExecStart = "${gce}/bin/google_instance_setup --debug";
       Type = "oneshot";

nixos/release.nix

···
   # Run the tests for each platform.  You can run a test by doing
   # e.g. ‘nix-build -A tests.login.x86_64-linux’, or equivalently,
   # ‘nix-build tests/login.nix -A result’.
+  tests.acme = callTest tests/acme.nix {};
   tests.avahi = callTest tests/avahi.nix {};
   tests.bittorrent = callTest tests/bittorrent.nix {};
   tests.blivet = callTest tests/blivet.nix {};

nixos/tests/acme.nix

···
+let
+  commonConfig = { config, lib, pkgs, nodes, ... }: {
+    networking.nameservers = [
+      nodes.letsencrypt.config.networking.primaryIPAddress
+    ];
+
+    nixpkgs.overlays = lib.singleton (self: super: {
+      cacert = super.cacert.overrideDerivation (drv: {
+        installPhase = (drv.installPhase or "") + ''
+          cat "${nodes.letsencrypt.config.test-support.letsencrypt.caCert}" \
+            >> "$out/etc/ssl/certs/ca-bundle.crt"
+        '';
+      });
+
+      pythonPackages = (super.python.override {
+        packageOverrides = lib.const (pysuper: {
+          certifi = pysuper.certifi.overridePythonAttrs (attrs: {
+            postPatch = (attrs.postPatch or "") + ''
+              cat "${self.cacert}/etc/ssl/certs/ca-bundle.crt" \
+                > certifi/cacert.pem
+            '';
+          });
+        });
+      }).pkgs;
+    });
+  };
+
+in import ./make-test.nix {
+  name = "acme";
+
+  nodes = {
+    letsencrypt = ./common/letsencrypt.nix;
+
+    webserver = { config, pkgs, ... }: {
+      imports = [ commonConfig ];
+      networking.firewall.allowedTCPPorts = [ 80 443 ];
+
+      networking.extraHosts = ''
+        ${config.networking.primaryIPAddress} example.com
+      '';
+
+      services.nginx.enable = true;
+      services.nginx.virtualHosts."example.com" = {
+        enableACME = true;
+        forceSSL = true;
+        locations."/".root = pkgs.runCommand "docroot" {} ''
+          mkdir -p "$out"
+          echo hello world > "$out/index.html"
+        '';
+      };
+    };
+
+    client = commonConfig;
+  };
+
+  testScript = ''
+    $letsencrypt->waitForUnit("boulder.service");
+    startAll;
+    $webserver->waitForUnit("acme-certificates.target");
+    $client->succeed('curl https://example.com/ | grep -qF "hello world"');
+  '';
+}

nixos/tests/common/letsencrypt.nix

···
+# Fully pluggable module to have Letsencrypt's Boulder ACME service running in
+# a test environment.
+#
+# The certificate for the ACME service is exported as:
+#
+#   config.test-support.letsencrypt.caCert
+#
+# This value can be used inside the configuration of other test nodes to inject
+# the snakeoil certificate into security.pki.certificateFiles or into package
+# overlays.
+#
+# Another value that's needed if you don't use a custom resolver (see below for
+# notes on that) is to add the letsencrypt node as a nameserver to every node
+# that needs to acquire certificates using ACME, because otherwise the API host
+# for letsencrypt.org can't be resolved.
+#
+# A configuration example of a full node setup using this would be this:
+#
+# {
+#   letsencrypt = import ./common/letsencrypt.nix;
+#
+#   example = { nodes, ... }: {
+#     networking.nameservers = [
+#       nodes.letsencrypt.config.networking.primaryIPAddress
+#     ];
+#     security.pki.certificateFiles = [
+#       nodes.letsencrypt.config.test-support.letsencrypt.caCert
+#     ];
+#   };
+# }
+#
+# By default, this module runs a local resolver, generated using resolver.nix
+# from the same directory to automatically discover all zones in the network.
+#
+# If you do not want this and want to use your own resolver, you can just
+# override networking.nameservers like this:
+#
+# {
+#   letsencrypt = { nodes, ... }: {
+#     imports = [ ./common/letsencrypt.nix ];
+#     networking.nameservers = [
+#       nodes.myresolver.config.networking.primaryIPAddress
+#     ];
+#   };
+#
+#   myresolver = ...;
+# }
+#
+# Keep in mind, that currently only _one_ resolver is supported, if you have
+# more than one resolver in networking.nameservers only the first one will be
+# used.
+#
+# Also make sure that whenever you use a resolver from a different test node
+# that it has to be started _before_ the ACME service.
+{ config, pkgs, lib, ... }:
+
+let
+  softhsm = pkgs.stdenv.mkDerivation rec {
+    name = "softhsm-${version}";
+    version = "1.3.8";
+
+    src = pkgs.fetchurl {
+      url = "https://dist.opendnssec.org/source/${name}.tar.gz";
+      sha256 = "0flmnpkgp65ym7w3qyg78d3fbmvq3aznmi66rgd420n33shf7aif";
+    };
+
+    configureFlags = [ "--with-botan=${pkgs.botan}" ];
+    buildInputs = [ pkgs.sqlite ];
+  };
+
+  pkcs11-proxy = pkgs.stdenv.mkDerivation {
+    name = "pkcs11-proxy";
+
+    src = pkgs.fetchFromGitHub {
+      owner = "SUNET";
+      repo = "pkcs11-proxy";
+      rev = "944684f78bca0c8da6cabe3fa273fed3db44a890";
+      sha256 = "1nxgd29y9wmifm11pjcdpd2y293p0dgi0x5ycis55miy97n0f5zy";
+    };
+
+    postPatch = "patchShebangs mksyscalls.sh";
+
+    nativeBuildInputs = [ pkgs.cmake ];
+    buildInputs = [ pkgs.openssl pkgs.libseccomp ];
+  };
+
+  mkGoDep = { goPackagePath, url ? "https://${goPackagePath}", rev, sha256 }: {
+    inherit goPackagePath;
+    src = pkgs.fetchgit { inherit url rev sha256; };
+  };
+
+  goose = let
+    owner = "liamstask";
+    repo = "goose";
+    rev = "8488cc47d90c8a502b1c41a462a6d9cc8ee0a895";
+    version = "20150116";
+
+  in pkgs.buildGoPackage rec {
+    name = "${repo}-${version}";
+
+    src = pkgs.fetchFromBitbucket {
+      name = "${name}-src";
+      inherit rev owner repo;
+      sha256 = "1jy0pscxjnxjdg3hj111w21g8079rq9ah2ix5ycxxhbbi3f0wdhs";
+    };
+
+    goPackagePath = "bitbucket.org/${owner}/${repo}";
+    subPackages = [ "cmd/goose" ];
+    extraSrcs = map mkGoDep [
+      { goPackagePath = "github.com/go-sql-driver/mysql";
+        rev = "2e00b5cd70399450106cec6431c2e2ce3cae5034";
+        sha256 = "085g48jq9hzmlcxg122n0c4pi41sc1nn2qpx1vrl2jfa8crsppa5";
+      }
+      { goPackagePath = "github.com/kylelemons/go-gypsy";
+        rev = "08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8";
+        sha256 = "1djv7nii3hy451n5jlslk0dblqzb1hia1cbqpdwhnps1g8hqjy8q";
+      }
+      { goPackagePath = "github.com/lib/pq";
+        rev = "ba5d4f7a35561e22fbdf7a39aa0070f4d460cfc0";
+        sha256 = "1mfbqw9g00bk24bfmf53wri5c2wqmgl0qh4sh1qv2da13a7cwwg3";
+      }
+      { goPackagePath = "github.com/mattn/go-sqlite3";
+        rev = "2acfafad5870400156f6fceb12852c281cbba4d5";
+        sha256 = "1rpgil3w4hh1cibidskv1js898hwz83ps06gh0hm3mym7ki8d5h7";
+      }
+      { goPackagePath = "github.com/ziutek/mymysql";
+        rev = "0582bcf675f52c0c2045c027fd135bd726048f45";
+        sha256 = "0bkc9x8sgqbzgdimsmsnhb0qrzlzfv33fgajmmjxl4hcb21qz3rf";
+      }
+      { goPackagePath = "golang.org/x/net";
+        url = "https://go.googlesource.com/net";
+        rev = "10c134ea0df15f7e34d789338c7a2d76cc7a3ab9";
+        sha256 = "14cbr2shl08gyg85n5gj7nbjhrhhgrd52h073qd14j97qcxsakcz";
+      }
+    ];
+  };
+
+  boulder = let
+    owner = "letsencrypt";
+    repo = "boulder";
+    rev = "9866abab8962a591f06db457a4b84c518cc88243";
+    version = "20170510";
+
+  in pkgs.buildGoPackage rec {
+    name = "${repo}-${version}";
+
+    src = pkgs.fetchFromGitHub {
+      name = "${name}-src";
+      inherit rev owner repo;
+      sha256 = "170m5cjngbrm36wi7wschqw8jzs7kxpcyzmshq3pcrmcpigrhna1";
+    };
+
+    postPatch = ''
+      # compat for go < 1.8
+      sed -i -e 's/time\.Until(\([^)]\+\))/\1.Sub(time.Now())/' \
+        test/ocsp/helper/helper.go
+
+      find test -type f -exec sed -i -e '/libpkcs11-proxy.so/ {
+        s,/usr/local,${pkcs11-proxy},
+      }' {} +
+
+      sed -i -r \
+        -e '/^def +install/a \    return True' \
+        -e 's,exec \./bin/,,' \
+        test/startservers.py
+
+      cat "${snakeOilCa}/ca.key" > test/test-ca.key
+      cat "${snakeOilCa}/ca.pem" > test/test-ca.pem
+    '';
+
+    goPackagePath = "github.com/${owner}/${repo}";
+    buildInputs = [ pkgs.libtool ];
+  };
+
+  boulderSource = "${boulder.out}/share/go/src/${boulder.goPackagePath}";
+
+  softHsmConf = pkgs.writeText "softhsm.conf" ''
+    0:/var/lib/softhsm/slot0.db
+    1:/var/lib/softhsm/slot1.db
+  '';
+
+  snakeOilCa = pkgs.runCommand "snakeoil-ca" {
+    buildInputs = [ pkgs.openssl ];
+  } ''
+    mkdir "$out"
+    openssl req -newkey rsa:4096 -x509 -sha256 -days 36500 \
+      -subj '/CN=Snakeoil CA' -nodes \
+      -out "$out/ca.pem" -keyout "$out/ca.key"
+  '';
+
+  createAndSignCert = fqdn: let
+    snakeoilCertConf = pkgs.writeText "snakeoil.cnf" ''
+      [req]
+      default_bits = 4096
+      prompt = no
+      default_md = sha256
+      req_extensions = req_ext
+      distinguished_name = dn
+      [dn]
+      CN = ${fqdn}
+      [req_ext]
+      subjectAltName = DNS:${fqdn}
+    '';
+  in pkgs.runCommand "snakeoil-certs-${fqdn}" {
+    buildInputs = [ pkgs.openssl ];
+  } ''
+    mkdir "$out"
+    openssl genrsa -out "$out/snakeoil.key" 4096
+    openssl req -new -key "$out/snakeoil.key" \
+      -config ${lib.escapeShellArg snakeoilCertConf} \
+      -out snakeoil.csr
+    openssl x509 -req -in snakeoil.csr -sha256 -set_serial 666 \
+      -CA "${snakeOilCa}/ca.pem" -CAkey "${snakeOilCa}/ca.key" \
+      -extfile ${lib.escapeShellArg snakeoilCertConf} \
+      -out "$out/snakeoil.pem" -days 36500
+  '';
+
+  wfeCerts = createAndSignCert wfeDomain;
+  wfeDomain = "acme-v01.api.letsencrypt.org";
+  wfeCertFile = "${wfeCerts}/snakeoil.pem";
+  wfeKeyFile = "${wfeCerts}/snakeoil.key";
+
+  siteCerts = createAndSignCert siteDomain;
+  siteDomain = "letsencrypt.org";
+  siteCertFile = "${siteCerts}/snakeoil.pem";
+  siteKeyFile = "${siteCerts}/snakeoil.key";
+
+  # Retrieved via:
+  # curl -s -I https://acme-v01.api.letsencrypt.org/terms \
+  #   | sed -ne 's/^[Ll]ocation: *//p'
+  tosUrl = "https://letsencrypt.org/documents/LE-SA-v1.1.1-August-1-2016.pdf";
+  tosPath = builtins.head (builtins.match "https?://[^/]+(.*)" tosUrl);
+
+  tosFile = pkgs.fetchurl {
+    url = tosUrl;
+    sha256 = "08b2gacdz23mzji2pjr1pwnk82a84rzvr36isif7mmi9kydl6wv3";
+  };
+
+  resolver = let
+    message = "You need to define a resolver for the letsencrypt test module.";
+    firstNS = lib.head config.networking.nameservers;
+  in if config.networking.nameservers == [] then throw message else firstNS;
+
+  cfgDir = pkgs.stdenv.mkDerivation {
+    name = "boulder-config";
+    src = "${boulderSource}/test/config";
+    nativeBuildInputs = [ pkgs.jq ];
+    phases = [ "unpackPhase" "patchPhase" "installPhase" ];
+    postPatch = ''
+      sed -i -e 's/5002/80/' -e 's/5002/443/' va.json
+      sed -i -e '/listenAddress/s/:4000/:80/' wfe.json
+      sed -i -r \
+        -e ${lib.escapeShellArg "s,http://boulder:4000/terms/v1,${tosUrl},g"} \
+        -e 's,http://(boulder|127\.0\.0\.1):4000,https://${wfeDomain},g' \
+        -e '/dnsResolver/s/127\.0\.0\.1:8053/${resolver}:53/' \
+        *.json
+      if grep 4000 *.json; then exit 1; fi
+
+      # Change all ports from 1909X to 909X, because the 1909X range of ports is
+      # allocated by startservers.py in order to intercept gRPC communication.
+      sed -i -e 's/\<1\(909[0-9]\)\>/\1/' *.json
+
+      # Patch out all additional issuer certs
+      jq '. + {ca: (.ca + {Issuers:
+        [.ca.Issuers[] | select(.CertFile == "test/test-ca.pem")]
+      })}' ca.json > tmp
+      mv tmp ca.json
+    '';
+    installPhase = "cp -r . \"$out\"";
+  };
+
+  components = {
+    gsb-test-srv.args = "-apikey my-voice-is-my-passport";
+    gsb-test-srv.waitForPort = 6000;
+    gsb-test-srv.first = true;
+    boulder-sa.args = "--config ${cfgDir}/sa.json";
+    boulder-wfe.args = "--config ${cfgDir}/wfe.json";
+    boulder-ra.args = "--config ${cfgDir}/ra.json";
+    boulder-ca.args = "--config ${cfgDir}/ca.json";
+    boulder-va.args = "--config ${cfgDir}/va.json";
+    boulder-publisher.args = "--config ${cfgDir}/publisher.json";
+    boulder-publisher.waitForPort = 9091;
+    ocsp-updater.args = "--config ${cfgDir}/ocsp-updater.json";
+    ocsp-updater.after = [ "boulder-publisher" ];
+    ocsp-responder.args = "--config ${cfgDir}/ocsp-responder.json";
+    ct-test-srv = {};
+    mail-test-srv.args = "--closeFirst 5";
+  };
+
+  commonPath = [ softhsm pkgs.mariadb goose boulder ];
+
+  mkServices = a: b: with lib; listToAttrs (concatLists (mapAttrsToList a b));
+
+  componentServices = mkServices (name: attrs: let
+    mkSrvName = n: "boulder-${n}.service";
+    firsts = lib.filterAttrs (lib.const (c: c.first or false)) components;
+    firstServices = map mkSrvName (lib.attrNames firsts);
+    firstServicesNoSelf = lib.remove "boulder-${name}.service" firstServices;
+    additionalAfter = firstServicesNoSelf ++ map mkSrvName (attrs.after or []);
+    needsPort = attrs ? waitForPort;
+    inits = map (n: "boulder-init-${n}.service") [ "mysql" "softhsm" ];
+    portWaiter = {
+      name = "boulder-${name}";
+      value = {
+        description = "Wait For Port ${toString attrs.waitForPort} (${name})";
+        after = [ "boulder-real-${name}.service" "bind.service" ];
+        requires = [ "boulder-real-${name}.service" ];
+        requiredBy = [ "boulder.service" ];
+        serviceConfig.Type = "oneshot";
+        serviceConfig.RemainAfterExit = true;
+        script = let
+          netcat = "${pkgs.netcat-openbsd}/bin/nc";
+          portCheck = "${netcat} -z 127.0.0.1 ${toString attrs.waitForPort}";
+        in "while ! ${portCheck}; do :; done";
+      };
+    };
+  in lib.optional needsPort portWaiter ++ lib.singleton {
+    name = if needsPort then "boulder-real-${name}" else "boulder-${name}";
+    value = {
+      description = "Boulder ACME Component (${name})";
+      after = inits ++ additionalAfter;
+      requires = inits;
+      requiredBy = [ "boulder.service" ];
+      path = commonPath;
+      environment.GORACE = "halt_on_error=1";
+      environment.SOFTHSM_CONF = softHsmConf;
+      environment.PKCS11_PROXY_SOCKET = "tcp://127.0.0.1:5657";
+      serviceConfig.WorkingDirectory = boulderSource;
+      serviceConfig.ExecStart = "${boulder}/bin/${name} ${attrs.args or ""}";
+      serviceConfig.Restart = "on-failure";
+    };
+  }) components;
+
+in {
+  imports = [ ./resolver.nix ];
+
+  options.test-support.letsencrypt.caCert = lib.mkOption {
+    type = lib.types.path;
+    description = ''
+      A certificate file to use with the <literal>nodes</literal> attribute to
+      inject the snakeoil CA certificate used in the ACME server into
+      <option>security.pki.certificateFiles</option>.
+    '';
+  };
+
+  config = {
+    test-support = {
+      resolver.enable = let
+        isLocalResolver = config.networking.nameservers == [ "127.0.0.1" ];
+      in lib.mkOverride 900 isLocalResolver;
+      letsencrypt.caCert = "${snakeOilCa}/ca.pem";
+    };
+
+    # This has priority 140, because modules/testing/test-instrumentation.nix
+    # already overrides this with priority 150.
+    networking.nameservers = lib.mkOverride 140 [ "127.0.0.1" ];
+    networking.firewall.enable = false;
+
+    networking.extraHosts = ''
+      127.0.0.1 ${toString [
+        "sa.boulder" "ra.boulder" "wfe.boulder" "ca.boulder" "va.boulder"
+        "publisher.boulder" "ocsp-updater.boulder" "admin-revoker.boulder"
+        "boulder" "boulder-mysql" wfeDomain
+      ]}
+      ${config.networking.primaryIPAddress} ${wfeDomain} ${siteDomain}
+    '';
+
+    services.mysql.enable = true;
+    services.mysql.package = pkgs.mariadb;
+
+    services.nginx.enable = true;
+    services.nginx.recommendedProxySettings = true;
+    services.nginx.virtualHosts.${wfeDomain} = {
+      onlySSL = true;
+      enableACME = false;
+      sslCertificate = wfeCertFile;
+      sslCertificateKey = wfeKeyFile;
+      locations."/".proxyPass = "http://127.0.0.1:80";
+    };
+    services.nginx.virtualHosts.${siteDomain} = {
+      onlySSL = true;
+      enableACME = false;
+      sslCertificate = siteCertFile;
+      sslCertificateKey = siteKeyFile;
+      locations.${tosPath}.extraConfig = "alias ${tosFile};";
+    };
+
+    systemd.services = {
+      pkcs11-daemon = {
+        description = "PKCS11 Daemon";
+        after = [ "boulder-init-softhsm.service" ];
+        before = map (n: "${n}.service") (lib.attrNames componentServices);
+        wantedBy = [ "multi-user.target" ];
+        environment.SOFTHSM_CONF = softHsmConf;
+        environment.PKCS11_DAEMON_SOCKET = "tcp://127.0.0.1:5657";
+        serviceConfig.ExecStart = let
+          softhsmLib = "${softhsm}/lib/softhsm/libsofthsm.so";
+        in "${pkcs11-proxy}/bin/pkcs11-daemon ${softhsmLib}";
+      };
+
+      boulder-init-mysql = {
+        description = "Boulder ACME Init (MySQL)";
+        after = [ "mysql.service" ];
+        serviceConfig.Type = "oneshot";
+        serviceConfig.RemainAfterExit = true;
+        serviceConfig.WorkingDirectory = boulderSource;
+        path = commonPath;
+        script = "${pkgs.bash}/bin/sh test/create_db.sh";
+      };
+
+      boulder-init-softhsm = {
+        description = "Boulder ACME Init (SoftHSM)";
+        environment.SOFTHSM_CONF = softHsmConf;
+        serviceConfig.Type = "oneshot";
+        serviceConfig.RemainAfterExit = true;
+        serviceConfig.WorkingDirectory = boulderSource;
+        preStart = "mkdir -p /var/lib/softhsm";
+        path = commonPath;
+        script = ''
+          softhsm --slot 0 --init-token \
+            --label intermediate --pin 5678 --so-pin 1234
+          softhsm --slot 0 --import test/test-ca.key \
+            --label intermediate_key --pin 5678 --id FB
+          softhsm --slot 1 --init-token \
+            --label root --pin 5678 --so-pin 1234
+          softhsm --slot 1 --import test/test-root.key \
+            --label root_key --pin 5678 --id FA
+        '';
+      };
+
+      boulder = {
+        description = "Boulder ACME Server";
+        after = map (n: "${n}.service") (lib.attrNames componentServices);
+        wantedBy = [ "multi-user.target" ];
+        serviceConfig.Type = "oneshot";
+        serviceConfig.RemainAfterExit = true;
+        script = let
+          ports = lib.range 8000 8005 ++ lib.singleton 80;
+          netcat = "${pkgs.netcat-openbsd}/bin/nc";
+          mkPortCheck = port: "${netcat} -z 127.0.0.1 ${toString port}";
+          checks = "(${lib.concatMapStringsSep " && " mkPortCheck ports})";
+        in "while ! ${checks}; do :; done";
+      };
+    } // componentServices;
+  };
+}

nixos/tests/common/resolver.nix

···
+# This module automatically discovers zones in BIND and NSD NixOS
+# configurations and creates zones for all definitions of networking.extraHosts
+# (except those that point to 127.0.0.1 or ::1) within the current test network
+# and delegates these zones using a fake root zone served by a BIND recursive
+# name server.
+{ config, nodes, pkgs, lib, ... }:
+
+{
+  options.test-support.resolver.enable = lib.mkOption {
+    type = lib.types.bool;
+    default = true;
+    internal = true;
+    description = ''
+      Whether to enable the resolver that automatically discovers zone in the
+      test network.
+
+      This option is <literal>true</literal> by default, because the module
+      defining this option needs to be explicitly imported.
+
+      The reason this option exists is for the
+      <filename>nixos/tests/common/letsencrypt.nix</filename> module, which
+      needs that option to disable the resolver once the user has set its own
+      resolver.
+    '';
+  };
+
+  config = lib.mkIf config.test-support.resolver.enable {
+    networking.firewall.enable = false;
+    services.bind.enable = true;
+    services.bind.cacheNetworks = lib.mkForce [ "any" ];
+    services.bind.forwarders = lib.mkForce [];
+    services.bind.zones = lib.singleton {
+      name = ".";
+      file = let
+        addDot = zone: zone + lib.optionalString (!lib.hasSuffix "." zone) ".";
+        mkNsdZoneNames = zones: map addDot (lib.attrNames zones);
+        mkBindZoneNames = zones: map (zone: addDot zone.name) zones;
+        getZones = cfg: mkNsdZoneNames cfg.services.nsd.zones
+                     ++ mkBindZoneNames cfg.services.bind.zones;
+
+        getZonesForNode = attrs: {
+          ip = attrs.config.networking.primaryIPAddress;
+          zones = lib.filter (zone: zone != ".") (getZones attrs.config);
+        };
+
+        zoneInfo = lib.mapAttrsToList (lib.const getZonesForNode) nodes;
+
+        # A and AAAA resource records for all the definitions of
+        # networking.extraHosts except those for 127.0.0.1 or ::1.
+        #
+        # The result is an attribute set with keys being the host name and the
+        # values are either { ipv4 = ADDR; } or { ipv6 = ADDR; } where ADDR is
+        # the IP address for the corresponding key.
+        recordsFromExtraHosts = let
+          getHostsForNode = lib.const (n: n.config.networking.extraHosts);
+          allHostsList = lib.mapAttrsToList getHostsForNode nodes;
+          allHosts = lib.concatStringsSep "\n" allHostsList;
+
+          reIp = "[a-fA-F0-9.:]+";
+          reHost = "[a-zA-Z0-9.-]+";
+
+          matchAliases = str: let
+            matched = builtins.match "[ \t]+(${reHost})(.*)" str;
+            continue = lib.singleton (lib.head matched)
+                    ++ matchAliases (lib.last matched);
+          in if matched == null then [] else continue;
+
+          matchLine = str: let
+            result = builtins.match "[ \t]*(${reIp})[ \t]+(${reHost})(.*)" str;
+          in if result == null then null else {
+            ipAddr = lib.head result;
+            hosts = lib.singleton (lib.elemAt result 1)
+                 ++ matchAliases (lib.last result);
+          };
+
+          skipLine = str: let
+            rest = builtins.match "[^\n]*\n(.*)" str;
+          in if rest == null then "" else lib.head rest;
+
+          getEntries = str: acc: let
+            result = matchLine str;
+            next = getEntries (skipLine str);
+            newEntry = acc ++ lib.singleton result;
+            continue = if result == null then next acc else next newEntry;
+          in if str == "" then acc else continue;
+
+          isIPv6 = str: builtins.match ".*:.*" str != null;
+          loopbackIps = [ "127.0.0.1" "::1" ];
+          filterLoopback = lib.filter (e: !lib.elem e.ipAddr loopbackIps);
+
+          allEntries = lib.concatMap (entry: map (host: {
+            inherit host;
+            ${if isIPv6 entry.ipAddr then "ipv6" else "ipv4"} = entry.ipAddr;
+          }) entry.hosts) (filterLoopback (getEntries (allHosts + "\n") []));
+
+          mkRecords = entry: let
+            records = lib.optional (entry ? ipv6) "AAAA ${entry.ipv6}"
+                   ++ lib.optional (entry ? ipv4) "A ${entry.ipv4}";
+            mkRecord = typeAndData: "${entry.host}. IN ${typeAndData}";
+          in lib.concatMapStringsSep "\n" mkRecord records;
+
+        in lib.concatMapStringsSep "\n" mkRecords allEntries;
+
+        # All of the zones that are subdomains of existing zones.
+        # For example if there is only "example.com" the following zones would
+        # be 'subZones':
+        #
+        #  * foo.example.com.
+        #  * bar.example.com.
+        #
+        # While the following would *not* be 'subZones':
+        #
+        #  * example.com.
+        #  * com.
+        #
+        subZones = let
+          allZones = lib.concatMap (zi: zi.zones) zoneInfo;
+          isSubZoneOf = z1: z2: lib.hasSuffix z2 z1 && z1 != z2;
+        in lib.filter (z: lib.any (isSubZoneOf z) allZones) allZones;
+
+        # All the zones without 'subZones'.
+        filteredZoneInfo = map (zi: zi // {
+          zones = lib.filter (x: !lib.elem x subZones) zi.zones;
+        }) zoneInfo;
+
+      in pkgs.writeText "fake-root.zone" ''
+        $TTL 3600
+        . IN SOA ns.fakedns. admin.fakedns. ( 1 3h 1h 1w 1d )
+        ns.fakedns. IN A ${config.networking.primaryIPAddress}
+        . IN NS ns.fakedns.
+        ${lib.concatImapStrings (num: { ip, zones }: ''
+          ns${toString num}.fakedns. IN A ${ip}
+          ${lib.concatMapStrings (zone: ''
+          ${zone} IN NS ns${toString num}.fakedns.
+          '') zones}
+        '') (lib.filter (zi: zi.zones != []) filteredZoneInfo)}
+        ${recordsFromExtraHosts}
+      '';
+    };
+  };
+}

pkgs/applications/altcoins/go-ethereum.nix

···
 
 buildGoPackage rec {
   name = "go-ethereum-${version}";
-  version = "1.6.7";
+  version = "1.7.0";
   goPackagePath = "github.com/ethereum/go-ethereum";
 
   # Fixes Cgo related build failures (see https://github.com/NixOS/nixpkgs/issues/25959 )
···
     owner = "ethereum";
     repo = "go-ethereum";
     rev = "v${version}";
-    sha256 = "19cq0pmif4y33v34jzvam4mcszl8vf2saf2gzfz01l4x1iv4hf1r";
+    sha256 = "0ybjaiyrfb320rab6a5r9iiqvkrcd8b2qvixzx0kjmc4a7l1q5zh";
   };
 
   # Fix cyclic referencing on Darwin
···
     done
   '';
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = https://ethereum.github.io/go-ethereum/;
     description = "Official golang implementation of the Ethereum protocol";
-    license = with lib.licenses; [ lgpl3 gpl3 ];
+    license = with licenses; [ lgpl3 gpl3 ];
+    maintainers = [ maintainers.adisbladis ];
   };
 }

pkgs/applications/audio/mopidy-gmusic/default.nix

···
     mopidy
     pythonPackages.requests
     pythonPackages.gmusicapi
-    pythonPackages.cachetools
+    pythonPackages.cachetools_1
   ];
 
   doCheck = false;

pkgs/applications/editors/atom/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "atom-${version}";
-  version = "1.19.7";
+  version = "1.20.0";
 
   src = fetchurl {
     url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "0ividd7bmx0fqz1ykcx5cbnd6qyms1h7r662pcclyzzm3vxj9zif";
+    sha256 = "1jzpa44ny78djdxc8d2w4jz1m68xmi8bzq87q3wmdffa4g9z4aa0";
     name = "${name}.deb";
   };
 

pkgs/applications/editors/emacs/macport.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  emacsVersion = "25.2";
+  emacsVersion = "25.3";
   emacsName = "emacs-${emacsVersion}";
-  macportVersion = "6.3";
+  macportVersion = "6.7";
   name = "emacs-mac-${emacsVersion}-${macportVersion}";
 
   builder = ./builder.sh;
 
   src = fetchurl {
     url = "mirror:///gnu/emacs/${emacsName}.tar.xz";
-    sha256 = "1ykkq0xl28ljdg61bm6gzy04ww86ajms98gix72qg6cpr6a53dar";
+    sha256 = "02y00y9q42g1iqgz5qhmsja75hwxd88yrn9zp14lanay0zkwafi5";
   };
 
   macportSrc = fetchurl {
     url = "ftp://ftp.math.s.chiba-u.ac.jp/emacs/${emacsName}-mac-${macportVersion}.tar.gz";
-    sha256 = "1dz11frk3ya3842lb89ixzpns9bz5f9njxdkyvjy75gfymqfhhzv";
+    sha256 = "0fivrasvigszr31w8wg8kb808hmqv2cc8klrm9n0hdxwg5fs5d0y";
   };
 
   hiresSrc = fetchurl {

pkgs/applications/editors/sublime3/default.nix

···
 assert gksuSupport -> gksu != null;
 
 let
-  build = "3126";
+  build = "3143";
   libPath = stdenv.lib.makeLibraryPath [glib xorg.libX11 gtk2 cairo pango];
   redirects = [ "/usr/bin/pkexec=${pkexecPath}" ]
     ++ stdenv.lib.optional gksuSupport "/usr/bin/gksudo=${gksu}/bin/gksudo";
···
         fetchurl {
           name = "sublimetext-${build}.tar.bz2";
           url = "https://download.sublimetext.com/sublime_text_3_build_${build}_x32.tar.bz2";
-          sha256 = "0acff4wj1s61x3xszdd93lkhaqa26lb7ryqdxnbphxzhf2jfzzwj";
+          sha256 = "0dgpx4wij2m77f478p746qadavab172166bghxmj7fb61nvw9v5i";
         }
       else
         fetchurl {
           name = "sublimetext-${build}.tar.bz2";
           url = "https://download.sublimetext.com/sublime_text_3_build_${build}_x64.tar.bz2";
-          sha256 = "0ykj33fq86iv7f9zx76h90pl9y86iri0idhlj09a6prhk8p17nqq";
+          sha256 = "06b554d2cvpxc976rvh89ix3kqc7klnngvk070xrs8wbyb221qcw";
         };
 
     dontStrip = true;

pkgs/applications/graphics/PythonMagick/default.nix

···
 
   src = fetchurl {
     url = "mirror://imagemagick/python/releases/PythonMagick-${version}.tar.xz";
-    sha256 = "0vkgpmrdz530nyvmjahpdrvcj7fd7hvsp15d485hq6103qycisv8";
+    sha256 = "137278mfb5079lns2mmw73x8dhpzgwha53dyl00mmhj2z25varpn";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/applications/graphics/awesomebump/default.nix

···
         --run "cd $d"
     '';
 
+  # RPATH in /tmp hack
+  preFixup = ''
+    rm -r $NIX_BUILD_TOP/__nix_qt5__
+  '';
+
   meta = {
     homepage = https://github.com/kmkolasinski/AwesomeBump;
     description = "A program to generate normal, height, specular or ambient occlusion textures from a single image";

pkgs/applications/graphics/gocr/default.nix

···
     sha256 = "1dgmcpapy7h68d53q2c5d0bpgzgfb2nw2blndnx9qhc7z12149mw";
   };
 
+  buildFlags = [ "all" "libs" ];
+  installFlags = [ "libdir=/lib/" ]; # Specify libdir so Makefile will also install library.
+
+  preInstall = "mkdir -p $out/lib";
+
   postInstall = ''
+    for i in pgm2asc.h gocr.h; do
+      install -D -m644 src/$i $out/include/gocr/$i
+    done
+  '';
+
+  preFixup = ''
     sed -i -e 's|exec wish|exec ${tk}/bin/wish|' $out/bin/gocr.tcl
   '';
 

pkgs/applications/misc/doomseeker/default.nix

···
 { stdenv, cmake, fetchurl, pkgconfig, qt4, zlib, bzip2 }:
 
 stdenv.mkDerivation rec {
-  name = "doomseeker-1.0";
+  name = "doomseeker-1.1";
 
   src = fetchurl {
     url = "http://doomseeker.drdteam.org/files/${name}_src.tar.bz2";
-    sha256 = "172ybxg720r64hp6aah0hqvxklqv1cf8v7kwx0ng5ap0h20jydbw";
+    sha256 = "0nmq8s842z30ngzikrmfx0xpnk4klxdv37y26chs002rnj010r7h";
   };
 
   buildInputs = [ qt4 zlib bzip2 ];

pkgs/applications/misc/hugo/default.nix

···
 
 buildGoPackage rec {
   name = "hugo-${version}";
-  version = "0.27";
+  version = "0.27.1";
 
   goPackagePath = "github.com/gohugoio/hugo";
 
···
     owner = "gohugoio";
     repo = "hugo";
     rev = "v${version}";
-    sha256 = "1r64pwk5g50gwriawmsgza6j8m4jymg8mwgwh1rplpsdfxqdfrbx";
+    sha256 = "0vxzjwm9dsan314cz0gnj4spssg4w8y6ywsak8n9c6w0l45xf07p";
   };
 
   goDeps = ./deps.nix;

pkgs/applications/misc/josm/default.nix

···
-{ fetchurl, stdenv, makeDesktopItem, unzip, bash, jre8 }:
+{ fetchurl, stdenv, makeDesktopItem, makeWrapper, unzip, bash, jre8 }:
 
 stdenv.mkDerivation rec {
   name = "josm-${version}";
-  version = "12545";
+  version = "12712";
 
   src = fetchurl {
     url = "https://josm.openstreetmap.de/download/josm-snapshot-${version}.jar";
-    sha256 = "0817mjc4118b5hhfvx67bib1lhcg8mdkzibrpa2mb7hrv38q56y4";
+    sha256 = "0lpz4yzkvjpn5g36nibrkh773jnlkiqj6lghsx69i86h0xfb7gqf";
   };
 
-  phases = [ "installPhase" ];
-
-  buildInputs = [ jre8 ];
+  buildInputs = [ jre8 makeWrapper ];
 
   desktopItem = makeDesktopItem {
     name = "josm";
···
     categories = "Education;Geoscience;Maps;";
   };
 
-  installPhase = ''
+  buildCommand = ''
     mkdir -p $out/bin $out/share/java
     cp -v $src $out/share/java/josm.jar
-    cat > $out/bin/josm <<EOF
-    #!${bash}/bin/bash
-    exec ${jre8}/bin/java -jar $out/share/java/josm.jar "\$@"
-    EOF
-    chmod 755 $out/bin/josm
+
+    makeWrapper ${jre8}/bin/java $out/bin/josm \
+      --add-flags "-jar $out/share/java/josm.jar"
 
     mkdir -p $out/share/applications
     cp $desktopItem/share/applications"/"* $out/share/applications

pkgs/applications/misc/k2pdfopt/default.nix

···
-# Build procedure lifted from https://aur.archlinux.org/packages/k2/k2pdfopt/PKGBUILD
-{ stdenv, fetchzip, fetchurl, writeScript, libX11, libXext, autoconf, automake, libtool
-      , leptonica, libpng, libtiff, zlib, openjpeg, freetype, jbig2dec, djvulibre
-      , openssl }:
-
-let
-  mupdf_src = fetchurl {
-    url = http://www.mupdf.com/downloads/archive/mupdf-1.6-source.tar.gz;
-    sha256 = "0qx51rj6alzcagcixm59rvdpm54w6syrwr4184v439jh14ryw4wq";
-  };
-
-  tess_src = fetchurl {
-    url = http://tesseract-ocr.googlecode.com/files/tesseract-ocr-3.02.02.tar.gz;
-    sha256 = "0g81m9y4iydp7kgr56mlkvjdwpp3mb01q385yhdnyvra7z5kkk96";
-  };
+{ stdenv, fetchzip, fetchurl, fetchpatch, cmake, pkgconfig
+, zlib, libpng
+, enableGSL ? true, gsl
+, enableGhostScript ? true, ghostscript
+, enableMuPDF ? true, jbig2dec, openjpeg, freetype, harfbuzz, mupdf
+, enableJPEG2K ? true, jasper
+, enableDJVU ? true, djvulibre
+, enableGOCR ? false, gocr # Disabled by default due to crashes
+, enableTesseract ? true, leptonica, tesseract
+}:
 
-  gocr_src = fetchurl {
-    url = http://www-e.uni-magdeburg.de/jschulen/ocr/gocr-0.49.tar.gz;
-    sha256 = "06hpzp7rkkwfr1fvmc8kcfz9v490i9yir7f7imh13gmka0fr6afc";
-  };
+with stdenv.lib;
 
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
   name = "k2pdfopt-${version}";
-  version = "2.32";
+  version = "2.42";
+
   src = fetchzip {
     url = "http://www.willus.com/k2pdfopt/src/k2pdfopt_v${version}_src.zip";
-    sha256 = "1v3cj5bwpjvy7s66sfqcmkxs91f7nxaykjpdjm2wn87vn6q7n19m";
+    sha256 = "1zag4jmkr0qrcpqqb5davmvdrabhdyz87q4zz0xpfkl6xw2dn9bk";
   };
 
-  buildInputs = [ libX11 libXext autoconf automake libtool leptonica libpng libtiff zlib
-                    openjpeg freetype jbig2dec djvulibre openssl ];
-  NIX_LDFLAGS = "-lX11 -lXext";
+  patches = [ ./k2pdfopt.patch ];
 
-  hardeningDisable = [ "format" ];
+  nativeBuildInputs = [ cmake pkgconfig ];
 
-  k2_pa = ./k2pdfopt.patch;
-  tess_pa = ./tesseract.patch;
+  buildInputs =
+  let
+    mupdf_modded = mupdf.overrideAttrs (attrs: {
+      name = "mupdf-1.10a";
+      src = fetchurl {
+        url = "http://mupdf.com/downloads/archive/mupdf-1.10a-source.tar.gz";
+        sha256 = "0dm8wcs8i29aibzkqkrn8kcnk4q0kd1v66pg48h5c3qqp4v1zk5a";
+      };
+      # Excluded the pdf-*.c files, since they mostly just broke the #includes
+      prePatch = ''
+        cp ${src}/mupdf_mod/{font,stext-device,string}.c source/fitz/
+        cp ${src}/mupdf_mod/font-win32.c source/pdf/
+      '';
+      # Patches from previous 1.10a version in nixpkgs
+      patches = [
+        # Compatibility with new openjpeg
+        (fetchpatch {
+         name = "mupdf-1.9a-openjpeg-2.1.1.patch";
+         url = "https://git.archlinux.org/svntogit/community.git/plain/mupdf/trunk/0001-mupdf-openjpeg.patch?id=5a28ad0a8999a9234aa7848096041992cc988099";
+         sha256 = "1i24qr4xagyapx4bijjfksj4g3bxz8vs5c2mn61nkm29c63knp75";
+        })
 
-  builder = writeScript "builder.sh" ''
-    . ${stdenv}/setup
-    set -e
-
-    plibs=`pwd`/patched_libraries
-
-    tar zxf ${mupdf_src}
-    cp $src/mupdf_mod/font.c $src/mupdf_mod/string.c mupdf-1.6-source/source/fitz/
-    cp $src/mupdf_mod/pdf-* mupdf-1.6-source/source/pdf
-
-    tar zxf ${tess_src}
-    cp $src/tesseract_mod/dawg.cpp tesseract-ocr/dict
-    cp $src/tesseract_mod/tessdatamanager.cpp tesseract-ocr/ccutil
-    cp $src/tesseract_mod/tessedit.cpp tesseract-ocr/ccmain
-    cp $src/tesseract_mod/tesscapi.cpp tesseract-ocr/api
-    cp $src/include_mod/tesseract.h $src/include_mod/leptonica.h tesseract-ocr/api
+        (fetchurl {
+         name = "CVE-2017-5896.patch";
+         url = "http://git.ghostscript.com/?p=mupdf.git;a=patch;h=2c4e5867ee699b1081527bc6c6ea0e99a35a5c27";
+         sha256 = "14k7x47ifx82sds1c06ibzbmcparfg80719jhgwjk6w1vkh4r693";
+        })
+      ];
+    });
+    leptonica_modded = leptonica.overrideAttrs (attrs: {
+      prePatch = ''
+        cp ${src}/leptonica_mod/* src/
+      '';
+    });
+    tesseract_modded = tesseract.overrideAttrs (attrs: {
+      prePatch = ''
+        cp ${src}/tesseract_mod/{ambigs.cpp,ccutil.h,ccutil.cpp} ccutil/
+        cp ${src}/tesseract_mod/dawg.cpp api/
+        cp ${src}/tesseract_mod/{imagedata.cpp,tessdatamanager.cpp} ccstruct/
+        cp ${src}/tesseract_mod/openclwrapper.h opencl/
+        cp ${src}/tesseract_mod/{tessedit.cpp,thresholder.cpp} ccmain/
+        cp ${src}/tesseract_mod/tess_lang_mod_edge.h cube/
+        cp ${src}/tesseract_mod/tesscapi.cpp api/
+        cp ${src}/include_mod/{tesseract.h,leptonica.h} api/
+      '';
+      patches = [ ./tesseract.patch ];
+    });
+  in
+    [ zlib libpng ] ++
+    optional enableGSL gsl ++
+    optional enableGhostScript ghostscript ++
+    optionals enableMuPDF [ jbig2dec openjpeg freetype harfbuzz mupdf_modded ] ++
+    optionals enableJPEG2K [ jasper ] ++
+    optional enableDJVU djvulibre ++
+    optional enableGOCR gocr ++
+    optionals enableTesseract [ leptonica_modded tesseract_modded ];
 
-    cp -a $src k2pdfopt_v2.21
-    chmod -R +w k2pdfopt_v2.21
+  dontUseCmakeBuildDir = true;
 
-    patch -p0 -i $tess_pa
-    patch -p0 -i $k2_pa
+  cmakeFlags = [ "-DCMAKE_C_FLAGS=-I${src}/include_mod" ];
 
-    cd tesseract-ocr
-    ./autogen.sh
-    substituteInPlace "configure" \
-            --replace 'LIBLEPT_HEADERSDIR="/usr/local/include /usr/include"' \
-            'LIBLEPT_HEADERSDIR=${leptonica}/include'
-    ./configure --prefix=$plibs --disable-shared
-    make install
-
-    cd ..
-    tar zxf ${gocr_src}
-    cd gocr-0.49
-    ./configure
-    cp src/{gocr.h,pnm.h,unicode.h,list.h} $plibs/include
-    cp include/config.h $plibs/include
-    make libs
-    cp src/libPgm2asc.a $plibs/lib
-
-    cd ../mupdf-1.6-source
-    make prefix=$plibs install
-    install -Dm644 build/debug/libmujs.a $plibs/lib
-
-    cd ../k2pdfopt_v2.21/k2pdfoptlib
-    gcc -Ofast -Wall -c *.c -I ../include_mod/ -I $plibs/include \
-        -I . -I ../willuslib
-    ar rcs libk2pdfopt.a *.o
-
-    cd ../willuslib
-    gcc -Ofast -Wall -c *.c -I ../include_mod/ -I $plibs/include
-    ar rcs libwillus.a *.o
-
-    cd ..
-    gcc -Wall -Ofast -o k2pdfopt.o -c k2pdfopt.c -I k2pdfoptlib/ -I willuslib/ \
-            -I include_mod/ -I $plibs/include
-    g++ -Ofast k2pdfopt.o -o k2pdfopt -I willuslib/ -I k2pdfoptlib/ -I include_mod/ \
-            -I $plibs/include -L $plibs/lib/ \
-            -L willuslib/ -L k2pdfoptlib/ -lk2pdfopt -lwillus -ldjvulibre -lz -lmupdf  \
-            -ljbig2dec -ljpeg -lopenjp2 -lpng -lfreetype -lpthread -lmujs \
-            -lPgm2asc -llept -ltesseract -lcrypto
-
-    mkdir -p $out/bin
-    cp k2pdfopt $out/bin
+  installPhase = ''
+    install -D -m 755 k2pdfopt $out/bin/k2pdfopt
   '';
 
   meta = with stdenv.lib; {
···
     homepage = http://www.willus.com/k2pdfopt;
     license = licenses.gpl3;
     platforms = platforms.linux;
-    maintainers = [ maintainers.bosu ];
+    maintainers = with maintainers; [ bosu danielfullmer ];
   };
 }
 

pkgs/applications/misc/k2pdfopt/k2pdfopt.patch

···
-diff -aur k2pdfopt_v2.21/willuslib/array.c k2pdfopt_v2.21.new/willuslib/array.c
---- k2pdfopt_v2.21/willuslib/array.c	2014-05-23 16:29:58.000000000 -0300
-+++ k2pdfopt_v2.21.new/willuslib/array.c	2014-07-26 11:35:49.829825567 -0300
-@@ -1055,7 +1055,7 @@
- void arrayf_sort(float *a,int n)
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 4a2378b..502c477 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -52,6 +52,7 @@ endif(JPEG_FOUND)
+ include(FindJasper)
+ if(JASPER_FOUND)
+   set(HAVE_JASPER_LIB 1)
++  set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${JASPER_LIBRARY})
+ endif(JASPER_FOUND)
  
-     {
--    sort(a,(long)n);
-+    willus_sort(a,(long)n);
-     }
+ # paths from willuslib/wgs.c
+@@ -66,8 +67,12 @@ else()
+   message(STATUS "Could NOT find ghostscript executable")
+ endif(GHOSTSCRIPT_EXECUTABLE)
  
+-# willus.h
+-# HAVE_GSL_LIB
++pkg_check_modules(GSL gsl)
++if(MUPDF_FOUND)
++  set(HAVE_GSL_LIB 1)
++  include_directories(SYSTEM ${GSL_INCLUDEDIR})
++  set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${GSL_LDFLAGS})
++endif(MUPDF_FOUND)
  
-diff -aur k2pdfopt_v2.21/willuslib/math.c k2pdfopt_v2.21.new/willuslib/math.c
---- k2pdfopt_v2.21/willuslib/math.c	2013-08-15 21:33:50.000000000 -0300
-+++ k2pdfopt_v2.21.new/willuslib/math.c	2014-07-26 11:36:02.853170659 -0300
-@@ -532,7 +532,7 @@
  
+ # libfreetype6 (>= 2.3.9), libjbig2dec0, libjpeg8 (>= 8c), libx11-6, libxext6, zlib1g (>= 1:1.2.0)
+@@ -80,7 +85,7 @@ if(MUPDF_FOUND)
+   include_directories(SYSTEM ${MUPDF_INCLUDEDIR})
+   message(STATUS "mupdf libraries: ${MUPDF_LDFLAGS}")
+   set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${MUPDF_LDFLAGS} 
+-    -lmupdf-js-none -lopenjpeg -ljbig2dec -ljpeg -lfreetype
++    -lopenjp2 -ljbig2dec -ljpeg -lfreetype -lharfbuzz
+   )
+ endif(MUPDF_FOUND)
  
+@@ -91,9 +96,25 @@ if(DJVU_FOUND)
+   set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${DJVU_LDFLAGS})
+ endif(DJVU_FOUND)
  
--void sort(float *x,int n)
-+void willus_sort(float *x,int n)
+-# HAVE_GOCR_LIB
+-# HAVE_LEPTONICA_LIB
+-# HAVE_TESSERACT_LIB
++find_library(GOCR_LIB NAMES Pgm2asc)
++if(GOCR_LIB)
++  set(HAVE_GOCR_LIB 1)
++  set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${GOCR_LIB})
++endif(GOCR_LIB)
++
++pkg_check_modules(LEPTONICA lept)
++if(LEPTONICA_FOUND)
++  set(HAVE_LEPTONICA_LIB 1)
++  include_directories(SYSTEM ${LEPTONICA_INCLUDEDIR})
++  set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${LEPTONICA_LDFLAGS})
++endif(LEPTONICA_FOUND)
++
++pkg_check_modules(TESSERACT tesseract)
++if(TESSERACT_FOUND)
++  set(HAVE_TESSERACT_LIB 1)
++  include_directories(SYSTEM ${TESSERACT_INCLUDEDIR})
++  set(K2PDFOPT_LIB ${K2PDFOPT_LIB} ${TESSERACT_LDFLAGS})
++endif(TESSERACT_FOUND)
  
-     {
-     int top,n1;
-diff -aur k2pdfopt_v2.21/willuslib/ocrjocr.c k2pdfopt_v2.21.new/willuslib/ocrjocr.c
---- k2pdfopt_v2.21/willuslib/ocrjocr.c	2012-11-12 13:09:42.000000000 -0300
-+++ k2pdfopt_v2.21.new/willuslib/ocrjocr.c	2014-07-26 11:36:46.699837185 -0300
+ # ---- Describe project
+ 
+diff --git a/willuslib/CMakeLists.txt b/willuslib/CMakeLists.txt
+index 463bbc9..8043db5 100644
+--- a/willuslib/CMakeLists.txt
++++ b/willuslib/CMakeLists.txt
+@@ -6,7 +6,7 @@ include_directories(..)
+ set(WILLUSLIB_SRC
+     ansi.c array.c bmp.c bmpdjvu.c bmpmupdf.c dtcompress.c filelist.c
+     fontdata.c fontrender.c gslpolyfit.c linux.c math.c mem.c ocr.c
+-    ocrjocr.c ocrtess.c pdfwrite.c point2d.c render.c strbuf.c string.c
++    ocrgocr.c ocrtess.c pdfwrite.c point2d.c render.c strbuf.c string.c
+     token.c wfile.c wgs.c wgui.c willusversion.c win.c winbmp.c
+     wincomdlg.c winmbox.c winshell.c wmupdf.c wmupdfinfo.c wpdf.c wsys.c
+     wzfile.c wleptonica.c
+diff --git a/willuslib/ocrgocr.c b/willuslib/ocrgocr.c
+index 6027e9a..fbe10f0 100644
+--- a/willuslib/ocrgocr.c
++++ b/willuslib/ocrgocr.c
 @@ -29,6 +29,8 @@
  #ifdef HAVE_GOCR_LIB
  #include <gocr.h>
  
-+job_t *JOB;
++job_t *OCR_JOB;
 +
  /*
  ** bmp8 must be grayscale
  ** (x1,y1) and (x2,y2) from top left of bitmap
-@@ -66,6 +68,7 @@
+@@ -63,6 +65,7 @@ void gocr_single_word_from_bmp8(char *text,int maxlen,WILLUSBITMAP *bmp8,
      h=y2-y1+1;
      dh=h+bw*2;
      job=&_job;
-+    JOB=job;
++    OCR_JOB=job;
      job_init(job);
      job_init_image(job);
      // willus_mem_alloc_warn((void **)&job->src.p.p,w*h,funcname,10);
-diff -aur k2pdfopt_v2.21/willuslib/string.c k2pdfopt_v2.21.new/willuslib/string.c
---- k2pdfopt_v2.21/willuslib/string.c	2014-02-03 00:37:44.000000000 -0300
-+++ k2pdfopt_v2.21.new/willuslib/string.c	2014-07-26 11:37:01.766506277 -0300
-@@ -81,7 +81,7 @@
- ** Returns NULL if EOF, otherwise returns pointer to the string.
- **
- */
--char *get_line(char *buf,int max,FILE *f)
-+char *willus_get_line(char *buf,int max,FILE *f)
- 
-     {
-     int     i;
-diff -aur k2pdfopt_v2.21/willuslib/willus.h k2pdfopt_v2.21.new/willuslib/willus.h
---- k2pdfopt_v2.21/willuslib/willus.h	2014-07-25 15:03:51.000000000 -0300
-+++ k2pdfopt_v2.21.new/willuslib/willus.h	2014-07-26 11:37:56.316506038 -0300
-@@ -214,9 +214,6 @@
- ** CMAKE handles the defines, not this source
- ** (Mod from Dirk Thierbach, 31-Dec-2013)
- */
--#ifdef USE_CMAKE
--#include "config.h"
--#else /* USE_CMAKE */
- 
- #ifndef HAVE_Z_LIB
- #define HAVE_Z_LIB
-@@ -268,7 +265,6 @@
- #undef HAVE_GSL_LIB
- #endif
- 
--#endif /* USE_CMAKE */
- /*
- ** Consistency check
- */
-@@ -533,7 +529,7 @@
-                       int *n,FILE *err);
- int    readxyz_ex    (char *filename,double **x,double **y,double **z,
-                       int *n,FILE *err,int ignore_after_semicolon);
--void   sort          (float *x,int n);
-+void   willus_sort          (float *x,int n);
- void   sortd         (double *x,int n);
- void   sorti         (int *x,int n);
- void   sortxy        (float *x,float *y,int n);
-@@ -602,7 +598,7 @@
- /* string.c */
- void   clean_line    (char *buf);
- void   clean_line_end(char *buf);
--char  *get_line      (char *buf,int max,FILE *f);
-+char  *willus_get_line      (char *buf,int max,FILE *f);
- char  *get_line_cf   (char *buf,int max,FILE *f);
- int   mem_get_line_cf(char *buf,int maxlen,char *cptr,long *cindex,long csize);
- int    in_string     (char *buffer,char *pattern);

pkgs/applications/misc/k2pdfopt/tesseract.patch

···
-diff -aur tesseract-ocr/api/Makefile.am tesseract-ocr.new/api/Makefile.am
---- tesseract-ocr/api/Makefile.am	2012-10-09 14:18:39.000000000 -0300
-+++ tesseract-ocr.new/api/Makefile.am	2014-03-20 18:43:13.926030341 -0300
-@@ -36,7 +36,7 @@
+diff --git a/api/Makefile.am b/api/Makefile.am
+index d8c1e54..46ead13 100644
+--- a/api/Makefile.am
++++ b/api/Makefile.am
+@@ -42,7 +42,7 @@ libtesseract_api_la_CPPFLAGS = $(AM_CPPFLAGS)
  if VISIBILITY
  libtesseract_api_la_CPPFLAGS += -DTESS_EXPORTS
  endif
--libtesseract_api_la_SOURCES = baseapi.cpp capi.cpp
-+libtesseract_api_la_SOURCES = baseapi.cpp capi.cpp tesscapi.cpp
+-libtesseract_api_la_SOURCES = baseapi.cpp capi.cpp renderer.cpp pdfrenderer.cpp
++libtesseract_api_la_SOURCES = baseapi.cpp capi.cpp renderer.cpp pdfrenderer.cpp tesscapi.cpp
  
  lib_LTLIBRARIES += libtesseract.la
  libtesseract_la_LDFLAGS = 

pkgs/applications/misc/pitz/default.nix

···
-{ stdenv, fetchurl, buildPythonApplication, tempita, jinja2, pyyaml, clepy, mock
-, nose, decorator, docutils
-}:
-
-# TODO: pitz has a pitz-shell utility that depends on ipython, but it just
-# errors out and dies (it probably depends on an old ipython version):
-#
-#   from IPython.Shell import IPShellEmbed
-#   ImportError: No module named Shell
-#
-# pitz-shell is not the primary interface, so it is not critical to have it
-# working. Concider fixing pitz upstream.
-
-buildPythonApplication rec {
-  name = "pitz-1.2.4";
-  namePrefix = "";
-
-  src = fetchurl {
-    url = "mirror://pypi/p/pitz/${name}.tar.gz";
-    sha256 = "1k7f3h4acllzqy3mjqnjd4w5jskp03s79b7dx3c85vlmd7824smr";
-  };
-
-  # propagatedBuildInputs is needed for pitz to find its dependencies at
-  # runtime. If we use buildInputs it would just build, not run.
-  propagatedBuildInputs = [ tempita jinja2 pyyaml clepy mock nose decorator docutils ];
-
-  meta = with stdenv.lib; {
-    description = "Distributed bugtracker";
-    license = licenses.bsd3;
-    homepage = http://pitz.tplus1.com/;
-    platforms = platforms.linux;
-    maintainers = [ maintainers.bjornfor ];
-  };
-}

pkgs/applications/networking/browsers/chromium/browser.nix

···
   sandboxExecutableName = "__chromium-suid-sandbox";
 
   installPhase = ''
-    mkdir -p "$libExecPath/swiftshader"
+    mkdir -p "$libExecPath"
     cp -v "$buildPath/"*.pak "$buildPath/"*.bin "$libExecPath/"
     cp -v "$buildPath/icudtl.dat" "$libExecPath/"
     cp -vLR "$buildPath/locales" "$buildPath/resources" "$libExecPath/"
-    cp -v "$buildPath/swiftshader/"*.so "$libExecPath/swiftshader/"
     cp -v "$buildPath/chrome" "$libExecPath/$packageName"
 
     if [ -e "$buildPath/libwidevinecdmadapter.so" ]; then

pkgs/applications/networking/browsers/chromium/common.nix

···
 
     patches = [
       ./patches/nix_plugin_paths_52.patch
-      ./patches/chromium-gn-bootstrap-r8.patch
+      ./patches/chromium-gn-bootstrap-r14.patch
+      ./patches/chromium-gcc-r1.patch
+      ./patches/chromium-atk-r1.patch
+      ./patches/chromium-gcc5-r1.patch
       # To enable ChromeCast, go to chrome://flags and set "Load Media Router Component Extension" to Enabled
       # Fixes Chromecast: https://bugs.chromium.org/p/chromium/issues/detail?id=734325
       ./patches/fix_network_api_crash.patch

pkgs/applications/networking/browsers/chromium/patches/chromium-atk-r1.patch

···
+--- a/content/browser/accessibility/browser_accessibility_auralinux.cc.orig	2017-07-27 06:28:01.090257874 +0000
++++ b/content/browser/accessibility/browser_accessibility_auralinux.cc	2017-07-27 06:28:21.174653680 +0000
+@@ -571,7 +571,7 @@
+ // it's best to leave this out rather than break people's builds:
+ #if defined(ATK_CHECK_VERSION)
+ #if ATK_CHECK_VERSION(2, 16, 0)
+-      atk_state_set_add_state(atk_state_set, ATK_STATE_READ_ONLY);
++      atk_state_set_add_state(state_set, ATK_STATE_READ_ONLY);
+ #endif
+ #endif
+       break;

pkgs/applications/networking/browsers/chromium/patches/chromium-gcc-r1.patch

···
+diff --git a/base/numerics/safe_math_shared_impl.h b/base/numerics/safe_math_shared_impl.h
+index 99f230ce7e9a..de2415d402f5 100644
+--- a/base/numerics/safe_math_shared_impl.h
++++ b/base/numerics/safe_math_shared_impl.h
+@@ -21,8 +21,7 @@
+ #if !defined(__native_client__) &&                         \
+     ((defined(__clang__) &&                                \
+       ((__clang_major__ > 3) ||                            \
+-       (__clang_major__ == 3 && __clang_minor__ >= 4))) || \
+-     (defined(__GNUC__) && __GNUC__ >= 5))
++       (__clang_major__ == 3 && __clang_minor__ >= 4))))
+ #include "base/numerics/safe_math_clang_gcc_impl.h"
+ #define BASE_HAS_OPTIMIZED_SAFE_MATH (1)
+ #else

pkgs/applications/networking/browsers/chromium/patches/chromium-gcc5-r1.patch

···
+--- a/chrome/browser/devtools/devtools_file_system_indexer.cc
++++ b/chrome/browser/devtools/devtools_file_system_indexer.cc
+@@ -34,7 +34,6 @@ using base::TimeDelta;
+ using base::TimeTicks;
+ using content::BrowserThread;
+ using std::map;
+-using std::set;
+ using std::string;
+ using std::vector;
+ 
+@@ -191,7 +190,7 @@ vector<FilePath> Index::Search(const string& query) {
+     if (trigram != kUndefinedTrigram)
+       trigrams.push_back(trigram);
+   }
+-  set<FileId> file_ids;
++  std::set<FileId> file_ids;
+   bool first = true;
+   vector<Trigram>::const_iterator it = trigrams.begin();
+   for (; it != trigrams.end(); ++it) {
+@@ -203,7 +202,7 @@ vector<FilePath> Index::Search(const string& query) {
+       first = false;
+       continue;
+     }
+-    set<FileId> intersection = base::STLSetIntersection<set<FileId> >(
++    std::set<FileId> intersection = base::STLSetIntersection<std::set<FileId> >(
+         file_ids, index_[trigram]);
+     file_ids.swap(intersection);
+   }
+diff --git a/third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferContents.h b/third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferContents.h
+index 94bb9161ec85..e40c6387f72e 100644
+--- a/third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferContents.h
++++ b/third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferContents.h
+@@ -63,7 +63,7 @@ class WTF_EXPORT ArrayBufferContents {
+           allocation_length_(0),
+           data_(data),
+           data_length_(0),
+-          kind_(AllocationKind::kNormal),
++          kind_(WTF::ArrayBufferContents::AllocationKind::kNormal),
+           deleter_(deleter) {}
+     DataHandle(void* allocation_base,
+                size_t allocation_length,
+@@ -94,11 +94,11 @@ class WTF_EXPORT ArrayBufferContents {
+              reinterpret_cast<uintptr_t>(allocation_base_) +
+                  allocation_length_);
+       switch (kind_) {
+-        case AllocationKind::kNormal:
++        case WTF::ArrayBufferContents::AllocationKind::kNormal:
+           DCHECK(deleter_);
+           deleter_(data_);
+           return;
+-        case AllocationKind::kReservation:
++        case WTF::ArrayBufferContents::AllocationKind::kReservation:
+           ReleaseReservedMemory(allocation_base_, allocation_length_);
+           return;
+       }
+--- a/third_party/webrtc/modules/audio_processing/aec3/aec_state.cc.orig	2017-08-15 12:45:59.433532111 +0000
++++ b/third_party/webrtc/modules/audio_processing/aec3/aec_state.cc	2017-08-15 17:52:59.691328825 +0000
+@@ -10,7 +10,7 @@
+ 
+ #include "webrtc/modules/audio_processing/aec3/aec_state.h"
+ 
+-#include <math.h>
++#include <cmath>
+ #include <numeric>
+ #include <vector>
+ 

pkgs/applications/networking/browsers/chromium/patches/chromium-gn-bootstrap-r14.patch

···
+commit 96c271f8ab2be7ea4199078ea65ac50c6ada4685
+Author: Pawel Hajdan, Jr <[e-mail]>
+Date:   Wed Jul 26 21:51:54 2017 +0000
+
+    wip
+
+diff --git a/tools/gn/bootstrap/bootstrap.py b/tools/gn/bootstrap/bootstrap.py
+index 1390560f8e37..ff2ae57c46b0 100755
+--- a/tools/gn/bootstrap/bootstrap.py
++++ b/tools/gn/bootstrap/bootstrap.py
+@@ -449,6 +449,7 @@ def write_gn_ninja(path, root_gen_dir, options):
+       'base/metrics/histogram_base.cc',
+       'base/metrics/histogram_functions.cc',
+       'base/metrics/histogram_samples.cc',
++      'base/metrics/histogram_snapshot_manager.cc',
+       'base/metrics/metrics_hashes.cc',
+       'base/metrics/persistent_histogram_allocator.cc',
+       'base/metrics/persistent_memory_allocator.cc',
+@@ -534,7 +535,7 @@ def write_gn_ninja(path, root_gen_dir, options):
+       'base/trace_event/heap_profiler_allocation_context_tracker.cc',
+       'base/trace_event/heap_profiler_allocation_register.cc',
+       'base/trace_event/heap_profiler_event_filter.cc',
+-      'base/trace_event/heap_profiler_event_writer.cc',
++      'base/trace_event/heap_profiler_heap_dump_writer.cc',
+       'base/trace_event/heap_profiler_serialization_state.cc',
+       'base/trace_event/heap_profiler_stack_frame_deduplicator.cc',
+       'base/trace_event/heap_profiler_type_name_deduplicator.cc',

pkgs/applications/networking/browsers/chromium/patches/chromium-gn-bootstrap-r8.patch

···
-Index: tools/gn/bootstrap/bootstrap.py
-diff --git a/tools/gn/bootstrap/bootstrap.py b/tools/gn/bootstrap/bootstrap.py
-index 6f2f5b1264519ea38cc36fb0b7e2cc24c378ca7a..0b03d2626b358fb90ab39d737679ee47bd60303b 100755
---- a/tools/gn/bootstrap/bootstrap.py
-+++ b/tools/gn/bootstrap/bootstrap.py
-@@ -487,6 +487,7 @@ def write_gn_ninja(path, root_gen_dir, options):
-       'base/sys_info.cc',
-       'base/task_runner.cc',
-       'base/task_scheduler/delayed_task_manager.cc',
-+      'base/task_scheduler/environment_config.cc',
-       'base/task_scheduler/post_task.cc',
-       'base/task_scheduler/priority_queue.cc',
-       'base/task_scheduler/scheduler_lock_impl.cc',

pkgs/applications/networking/browsers/chromium/upstream-info.nix

···
 # This file is autogenerated from update.sh in the same directory.
 {
   beta = {
-    sha256 = "1sh3rq36sh4g7blajvqfvs06fs5sbrbdp50qq0cvcj4k3fmb4bd8";
-    sha256bin64 = "1w67y4z57qm5fwniayncly7a4mjmwqir7gfd54ny8lwlf247d43m";
-    version = "60.0.3112.78";
+    sha256 = "09q7s5x22vnmvqyz0f1l6qnaryglmsp0rc63qcg5sfvgv2g17g5x";
+    sha256bin64 = "12z6z8gjxl4mx8j6db8nnlzrj03rh4qwyrvcf4hqcsv7b1armg6j";
+    version = "61.0.3163.79";
   };
   dev = {
-    sha256 = "0yan2dzx1854f3xslif5682rkb82a1li6vxj12z5s5fxqijhj1jq";
-    sha256bin64 = "0ddva2rqnid2gcx3qh72p41wc15869w2w9n0rbdpn662rpl041v1";
-    version = "61.0.3163.25";
+    sha256 = "168i6dcdl13an3vlr2m83q8fcprgckmclkmzwj70jdkp84qx80fq";
+    sha256bin64 = "116vddp01m2ls337zj6r4h1nvybphvldlk9bs8czypx5skn29vbz";
+    version = "62.0.3202.9";
   };
   stable = {
-    sha256 = "1rirhwvccidza4q4z1gqdwcd9v1bymh1m9r2cq8jhiabfrjpjbxl";
-    sha256bin64 = "1lw349ips0sgyls3arv864yq5xykfn9jilwkalvllaq6yvdvcvlk";
-    version = "60.0.3112.90";
+    sha256 = "09q7s5x22vnmvqyz0f1l6qnaryglmsp0rc63qcg5sfvgv2g17g5x";
+    sha256bin64 = "0a0wd06c0v061lnmb8x20gqgsg9zqafp2kq1fl3cjm0ldg9rwayw";
+    version = "61.0.3163.79";
   };
 }

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

···
   # instead, we download localkube ourselves and shove it into the minikube binary. The versions URL that minikube uses is
   # currently https://storage.googleapis.com/minikube/k8s_releases.json
 
-  localkube-version = "1.7.4";
+  localkube-version = "1.7.5";
   localkube-binary = fetchurl {
     url = "https://storage.googleapis.com/minikube/k8sReleases/v${localkube-version}/localkube-linux-amd64";
-    sha256 = "1v9zq6ivcs2qvdmhidvvp0krd1sxgqvqpp4bcl9is85vpdxhk95b";
+    sha256 = "1kn4lwnn961r19hqnkgr13np80zqk2fhp8xkhrvxzq6v6shk7gfz";
   };
 in buildGoPackage rec {
   pname   = "minikube";
   name    = "${pname}-${version}";
-  version = "0.22.0";
+  version = "0.22.1";
 
   goPackagePath = "k8s.io/minikube";
 
···
     owner  = "kubernetes";
     repo   = "minikube";
     rev    = "v${version}";
-    sha256 = "118l98kxzn6npq67nmylanfy9pvd1vd9hvsr2rkzrsvhzzk13kh4";
+    sha256 = "015ffsb7xx82y0dl38gayv2v9v33v99qmssd5djl21dhb3j79yba";
   };
 
   # kubernetes is here only to shut up a loud warning when generating the completions below. minikube checks very eagerly

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

···
-{ stdenv, fetchFromGitHub, which, buildGoPackage }:
+{ stdenv, fetchFromGitHub, which, buildGoPackage, utillinux, coreutils }:
 
 let
-  version = "1.5.0";
+  version = "3.6.0";
   ver = stdenv.lib.elemAt (stdenv.lib.splitString "." version);
   versionMajor = ver 0;
   versionMinor = ver 1;
···
     owner = "openshift";
     repo = "origin";
     rev = "v${version}";
-    sha256 = "0qvyxcyca3888nkgvyvqcmybm95ncwxb3zvrzbg2gz8kx6g6350v";
+    sha256 = "08bdqvsjl6c7dmllyz8n4akb7gyn91znvbph5cgmmk1bhskycy1r";
   };
 
   buildInputs = [ which ];
···
   goPackagePath = null;
   patchPhase = ''
     patchShebangs ./hack
+    substituteInPlace pkg/bootstrap/docker/host/host.go  \
+      --replace 'nsenter --mount=/rootfs/proc/1/ns/mnt findmnt' \
+      'nsenter --mount=/rootfs/proc/1/ns/mnt ${utillinux}/bin/findmnt'
+
+    substituteInPlace pkg/bootstrap/docker/host/host.go  \
+      --replace 'nsenter --mount=/rootfs/proc/1/ns/mnt mount' \
+      'nsenter --mount=/rootfs/proc/1/ns/mnt ${utillinux}/bin/mount'
+
+    substituteInPlace pkg/bootstrap/docker/host/host.go  \
+      --replace 'nsenter --mount=/rootfs/proc/1/ns/mnt mkdir' \
+      'nsenter --mount=/rootfs/proc/1/ns/mnt ${utillinux}/bin/mount'
   '';
 
   buildPhase = ''
     cd go/src/origin-v${version}-src
     # Openshift build require this variables to be set
     # unless there is a .git folder which is not the case with fetchFromGitHub
-    export OS_GIT_VERSION=${version}
+    export OS_GIT_VERSION=v${version}
     export OS_GIT_MAJOR=${versionMajor}
     export OS_GIT_MINOR=${versionMinor}
     make build
···
     description = "Build, deploy, and manage your applications with Docker and Kubernetes";
     license = licenses.asl20;
     homepage = http://www.openshift.org;
-    maintainers = with maintainers; [offline bachp];
+    maintainers = with maintainers; [offline bachp moretea];
     platforms = platforms.linux;
   };
 }

pkgs/applications/networking/dropbox/default.nix

···
 let
   # NOTE: When updating, please also update in current stable,
   # as older versions stop working
-  version = "34.4.20";
+  version = "34.4.22";
   sha256 = {
-    "x86_64-linux" = "04yc0sf4w4p86f2rpph4g4qhd4wxlsyhiwcf4201xadnnjj11gzz";
-    "i686-linux"   = "0ch5yxw1n6mwa6050pd10f5z3ys2yca9n8ccjlqi2d2aa4qcxsmr";
+    "x86_64-linux" = "1ryxj8d5ym2dc18vn2m883jvy9n19xvw5kgfbqxziirb0bip58ba";
+    "i686-linux"   = "1pj7c77196ill8jpwk8f66917v2a7c2xvkd9mssh98c9n321k5j8";
   }."${stdenv.system}" or (throw "system ${stdenv.system} not supported");
 
   arch = {

pkgs/applications/networking/instant-messengers/bitlbee-facebook/default.nix

···
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "bitlbee-facebook-${version}";
-  version = "1.1.1";
+  version = "1.1.2";
 
   src = fetchFromGitHub {
     rev = "v${version}";
-    owner = "jgeboski";
+    owner = "bitlbee";
     repo = "bitlbee-facebook";
-    sha256 = "08ibjqqcrmq1a5nmj8z93rjrdabi0yy2a70p31xalnfrh200m24c";
+    sha256 = "0kz2sc10iq01vn0hvf06bcdc1rsxz1j77z3mw55slf3j08xr07in";
   };
 
   nativeBuildInputs = [ autoconf automake libtool pkgconfig ];
···
   meta = {
     description = "The Facebook protocol plugin for bitlbee";
 
-    homepage = https://github.com/jgeboski/bitlbee-facebook;
+    homepage = https://github.com/bitlbee/bitlbee-facebook;
     license = licenses.gpl2Plus;
     platforms = stdenv.lib.platforms.linux;
   };

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

···
+{ stdenv, lib, perl, perlPackages, coreutils,
+fetchFromGitHub, makeWrapper }:
+
+stdenv.mkDerivation rec {
+  name = "oysttyer-${version}";
+  version = "2.9.1";
+
+  src = fetchFromGitHub {
+    owner  = "oysttyer";
+    repo   = "oysttyer";
+    rev    = "${version}";
+    sha256 = "05bfak4jr8ln4847rkj5qkazqnjym65k1phav3yicbyr3mxywhjw";
+  };
+
+  buildInputs = [
+    perl
+    makeWrapper
+  ];
+
+  propagatedBuildInputs = with perlPackages; [
+    DateTimeFormatDateParse
+    TermReadLineTTYtter
+    TermReadKey
+  ];
+
+  installPhase = ''
+    ${coreutils}/bin/install -Dm755 \
+      oysttyer.pl \
+      $out/bin/oysttyer
+
+    wrapProgram $out/bin/oysttyer \
+      --prefix PERL5LIB : $PERL5LIB
+  '';
+
+  meta = with lib; {
+    inherit version;
+    description = "Perl Console Twitter Client";
+    homepage    = http://oysttyer.github.io/;
+    maintainers = with maintainers; [ woffs ];
+    license = with licenses; [ ffsl ];
+  };
+}

pkgs/applications/networking/instant-messengers/telepathy/kde/0.8.80.nix

···
-[
-{name="ktp-accounts-kcm";key="accounts_kcm";sha256="08b873k455jbs9vd5nsb222pr1kb7gjx3qky769654j696rad5bc";}
-{name="ktp-approver";key="approver";sha256="07qsjxvcjr9i0v7g7cdx3rky1fa8aany5fyfav488kq6nc13fjb1";}
-{name="ktp-auth-handler";key="auth_handler";sha256="00gq5gq7imv7rv8xivl2s1n0k39llpmd5z46rvhai76z7hp8sj4l";}
-{name="ktp-call-ui";key="call_ui";sha256="1dwsq2ixci95byfg1ayy6g2zv0dbc0273r9wb395f220dgqpz7b4";}
-{name="ktp-common-internals";key="common_internals";sha256="049hh045p6nccyrjvagfw183vfa857xdl96q2w1vrj6frimniz9q";}
-{name="ktp-contact-list";key="contact_list";sha256="0xydyyla48y7q8pf84i12l7fx13p0gi8k4jl7nl7jxjsflzidscp";}
-{name="ktp-contact-runner";key="contact_runner";sha256="1bfb772cyzrbwjkglr3bvawp44dcqr59kkgvb6irgha8w7adic3b";}
-{name="ktp-desktop-applets";key="desktop_applets";sha256="150mpk7vq2w47vz2yffhj676k84fn3h8g77xklmyqm1y3f21dx01";}
-{name="ktp-filetransfer-handler";key="filetransfer_handler";sha256="07jgfydhr5hh7z0wkrz6k4gh3li9nmyxhjvxcxsayxrc7gnhazja";}
-{name="ktp-kded-integration-module";key="kded_integration_module";sha256="0axjqsk1h9c71hxpcy8ls7jsb0dsmsm75wdgwx71xrdb9hpqwn9f";}
-{name="ktp-send-file";key="send_file";sha256="0wiqrwhrmccx3ic0aaqlq539jcznkgsrwyn9hdizwsc8f33rxmri";}
-{name="ktp-text-ui";key="text_ui";sha256="0ch6sqvj9hpx3823c1wmziqy6g9v97sj1hihbaf8z8wyb84f0wbl";}
-]

pkgs/applications/networking/instant-messengers/telepathy/kde/default.nix

···
-{ stdenv, fetchurl, fetchgit, automoc4, cmake, gettext, perl, pkgconfig
-, telepathy_qt, kdelibs4, kde_workspace, dbus_glib, dbus_libs, farstream
-, qt-gstreamer1, telepathy_glib, telepathy_logger
-, qjson, flex, bison, qca2 }:
-
-let
-  version = "0.8.80";
-  manifest = import (./. + "/${version}.nix");
-
-  overrides = {
-    call_ui = x : x // {
-      NIX_CFLAGS_COMPILE =
-        "-I${telepathy_glib}/include/telepathy-1.0"
-        + " -I${dbus_glib.dev}/include/dbus-1.0"
-        + " -I${dbus_libs.dev}/include/dbus-1.0";
-    };
-    telepathy_logger_qt = x : x // {
-      NIX_CFLAGS_COMPILE = "-I${dbus_libs.dev}/include/dbus-1.0";
-    };
-  };
-
-  extraBuildInputs = {
-    auth_handler = [ qjson qca2 ];
-    call_ui = [ qt-gstreamer1 telepathy_glib farstream ];
-    contact_applet = [ kde_workspace ];
-    telepathy_logger_qt = [ telepathy_logger qt-gstreamer1 ];
-    text_ui = [ qt-gstreamer1 telepathy_logger qjson ];
-    common_internals = [ telepathy_qt ];
-  };
-
-  extraNativeBuildInputs = {
-    telepathy_logger_qt = [ flex bison ];
-  };
-
-  ktpFun = { name, key, sha256 }:
-  {
-    name = key;
-    value = stdenv.mkDerivation (
-      (stdenv.lib.attrByPath [ key ] (x : x) overrides)
-      {
-        name = "${name}-${version}";
-
-        src = fetchurl {
-          url = "mirror://kde/unstable/kde-telepathy/${version}/src/${name}-${version}.tar.bz2";
-          inherit sha256;
-        };
-
-        nativeBuildInputs =
-          [ automoc4 cmake gettext perl pkgconfig ]
-          ++ (stdenv.lib.attrByPath [ key ] [] extraNativeBuildInputs);
-        buildInputs = [ kdelibs4 telepathy_qt ]
-          ++ stdenv.lib.optional (name != "ktp-common-internals") ktp.common_internals
-          ++ (stdenv.lib.attrByPath [ key ] [] extraBuildInputs);
-
-        meta = {
-          inherit (kdelibs4.meta) platforms;
-          maintainers = [ ];
-        };
-      }
-    );
-  };
-
-  ktp = builtins.listToAttrs (map ktpFun manifest);
-in
-ktp // {
-  inherit version;
-  recurseForDerivations = true;
-  full = stdenv.lib.attrValues ktp;
-}

pkgs/applications/networking/instant-messengers/telepathy/kde/update.sh

···
-#!/bin/sh
-
-usage() {
-  echo "$0 version|directory"
-}
-
-download() {
-  URL=ftp://ftp.kde.org/pub/kde/unstable/kde-telepathy/$1/src
-  destdir=$2
-  if test -n "$KDE_FULL_SESSION"; then
-    kioclient copy $URL $destdir
-  else
-    mkdir $destdir
-    lftp -c "open $URL; lcd $destdir; mget -c *"
-  fi
-}
-
-if [[ -d $1 ]]; then
-  directory=$1
-  version=$(ls $directory/* | head -n1 |
-    sed -e "s,$directory/[^0-9.]*\\([0-9.]\\+\\)\\.tar.*,\\1,")
-  echo "Version $version"
-else
-  version=$1
-  directory=src-$version
-  download $version $directory
-fi
-
-packages=$(ls $directory/* | sed -e "s,$directory/\\(.*\\)-$version.*,\\1,")
-echo $packages
-exec >$version.nix
-echo "["
-for name in $packages; do
-  hash=$(nix-hash --flat --type sha256 --base32 $directory/$name-$version.*)
-  key=${name#ktp-}
-  echo "{name=\"${name}\";key=\"${key//-/_}\";sha256=\"${hash}\";}"
-done
-echo "]"

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

···
 
 python2Packages.buildPythonApplication rec {
   name = "mailnag-${version}";
-  version = "1.1.0";
+  version = "1.2.1";
 
   src = fetchurl {
     url = "https://github.com/pulb/mailnag/archive/v${version}.tar.gz";
-    sha256 = "0li4kvxjmbz3nqg6bysgn2wdazqrd7gm9fym3rd7148aiqqwa91r";
+    sha256 = "ec7ac027d93bc7d88fc270858f5a181453a6ff07f43cab20563d185818801fee";
   };
 
   buildInputs = [
···
         --prefix PYTHONPATH : "$PYTHONPATH"
     done
   '';
+
+  buildPhase = "";
+
+  installPhase = "python2 setup.py install --prefix=$out";
+
+  doCheck = false;
 
   meta = with stdenv.lib; {
     description = "An extensible mail notification daemon";

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

···
 , cyrus_sasl, gss, gpgme, kerberos, libidn, notmuch, openssl, lmdb, libxslt, docbook_xsl }:
 
 stdenv.mkDerivation rec {
-  version = "20170907";
+  version = "20170912";
   name = "neomutt-${version}";
 
   src = fetchFromGitHub {
     owner  = "neomutt";
     repo   = "neomutt";
     rev    = "neomutt-${version}";
-    sha256 = "0j2k5d77j5dvfh0yqihgvynnxxv2s5lf3pl50dr8b5b4jk04b961";
+    sha256 = "0qndszmaihly3pp2wqiqm31nxbv9ys3j05kzffaqhzngfilmar9g";
   };
 
   nativeBuildInputs = [ autoreconfHook docbook_xsl libxslt.bin which ];
···
   meta = with stdenv.lib; {
     description = "A small but very powerful text-based mail client";
     homepage    = http://www.neomutt.org;
-    license     = stdenv.lib.licenses.gpl2Plus;
+    license     = licenses.gpl2Plus;
     maintainers = with maintainers; [ cstrahan erikryb jfrankenau vrthra ];
     platforms   = platforms.unix;
   };

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

···
-{ fetchurl, stdenv, fixDarwinDylibNames, gdb
+{ fetchurl, stdenv, fixDarwinDylibNames
 , pkgconfig, gnupg
 , xapian, gmime, talloc, zlib
 , doxygen, perl
···
 , bash-completion
 , emacs
 , ruby
-, which, dtach, openssl, bash
+, which, dtach, openssl, bash, gdb, man
 }:
+
+with stdenv.lib;
 
 stdenv.mkDerivation rec {
   version = "0.25";
···
     emacs  # (optional) to byte compile emacs code
     ruby  # (optional) ruby bindings
     which dtach openssl bash  # test dependencies
-    ]
-    ++ stdenv.lib.optional stdenv.isDarwin fixDarwinDylibNames
-    ++ stdenv.lib.optional (!stdenv.isDarwin) gdb;
-
-  doCheck = !stdenv.isDarwin;
-  checkTarget = "test";
-
-  patchPhase = ''
-    # XXX: disabling few tests since i have no idea how to make them pass for now
-    rm -f test/T010-help-test.sh \
-          test/T350-crypto.sh \
-          test/T355-smime.sh
+  ]
+  ++ optional stdenv.isDarwin fixDarwinDylibNames
+  ++ optionals (!stdenv.isDarwin) [ gdb man ]; # test dependencies
 
+  postPatch = ''
     find test -type f -exec \
       sed -i \
         -e "1s|#!/usr/bin/env bash|#!${bash}/bin/bash|" \
···
     done
   '';
 
-  preFixup = stdenv.lib.optionalString stdenv.isDarwin ''
+  makeFlags = "V=1";
+
+  preFixup = optionalString stdenv.isDarwin ''
     set -e
 
     die() {
···
     install_name_tool -change "$badname" "$goodname" "$prg"
   '';
 
+  doCheck = !stdenv.isDarwin && (versionAtLeast gmime.version "3.0");
+  checkTarget = "test V=1";
+
   postInstall = ''
     make install-man
   '';
+
   dontGzipMan = true; # already compressed
 
-  meta = with stdenv.lib; {
+  meta = {
     description = "Mail indexer";
     homepage    = https://notmuchmail.org/;
     license     = licenses.gpl3;

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

···
-{ stdenv, fetchgit, cmake, pkgconfig, qtbase, qtwebkit, qtkeychain, sqlite }:
+{ stdenv, fetchgit, cmake, pkgconfig, qtbase, qtwebkit, qtkeychain, sqlite
+, inotify-tools, withGnomeKeyring ? false, makeWrapper, libgnome_keyring }:
 
 stdenv.mkDerivation rec {
   name = "nextcloud-client-${version}";
···
   };
 
   nativeBuildInputs = [ pkgconfig cmake ];
-  buildInputs = [ qtbase qtwebkit qtkeychain sqlite ];
+
+  buildInputs = [ qtbase qtwebkit qtkeychain sqlite ]
+    ++ stdenv.lib.optional stdenv.isLinux inotify-tools
+    ++ stdenv.lib.optional withGnomeKeyring makeWrapper;
+
+  enableParallelBuilding = true;
+
+  dontUseCmakeBuildDir = true;
 
-  preConfigure = ''
-    cmakeFlagsArray+=("-UCMAKE_INSTALL_LIBDIR" "-DOEM_THEME_DIR=$(realpath ./nextcloudtheme)" "../client")
+  cmakeDir = "client";
+
+  cmakeFlags = [
+    "-UCMAKE_INSTALL_LIBDIR"
+    "-DCMAKE_BUILD_TYPE=Release"
+    "-DOEM_THEME_DIR=${src}/nextcloudtheme"
+  ] ++ stdenv.lib.optionals stdenv.isLinux [
+    "-DINOTIFY_LIBRARY=${inotify-tools}/lib/libinotifytools.so"
+    "-DINOTIFY_INCLUDE_DIR=${inotify-tools}/include"
+  ];
+
+  postInstall = stdenv.lib.optionalString (withGnomeKeyring) ''
+    wrapProgram "$out/bin/nextcloud" \
+      --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath [ libgnome_keyring ]}
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/networking/nntp-proxy/default.nix

···
     sha256 = "0jwxh71am83fbnq9mn06jl06rq8qybm506js79xmmc3xbk5pqvy4";
   };
 
-  buildInputs = [ libconfig pkgconfig libevent openssl ];
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ libconfig libevent openssl ];
 
-  installFlags = "INSTALL_DIR=\${out}/bin/";
+  installFlags = [ "INSTALL_DIR=$(out)/bin/" ];
 
-  preInstall = ''
+  prePatch = ''
     mkdir -p $out/bin
     substituteInPlace Makefile \
-      --replace /usr/bin/install $(type -P install)
+      --replace /usr/bin/install $(type -P install) \
+      --replace gcc cc
   '';
 
   meta = {

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

···
 
 stdenv.mkDerivation rec {
   name = "lean-${version}";
-  version = "3.2.0";
+  version = "3.3.0";
 
   src = fetchFromGitHub {
     owner  = "leanprover";
     repo   = "lean";
     rev    = "v${version}";
-    sha256 = "13sb9rwgc9ni2j5zx77imjhkzhix9d7klsdb8cg68c17b20sy1g3";
+    sha256 = "0irh9b4haz0pzzxrb4hwcss91a0xb499kjrcrmr2s59p3zq8bbd9";
   };
 
   buildInputs = [ gmp cmake ];

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

···
-{stdenv, gcc5, fetchurl, xlibs, cmake, subversion, mesa, qt5, boost,
+{stdenv, fetchurl, xlibs, cmake, subversion, mesa, qt5, boost,
  python27, python27Packages}:
 
 stdenv.mkDerivation rec {
···
     sha256 = "1c8h94ja7271ph61zrcgnjgblxppld6v22f7f900prjgzbcfy14m";
   };
 
-  buildInputs = [ gcc5 cmake mesa qt5.qtbase boost ];
+  buildInputs = [ cmake mesa qt5.qtbase boost ];
 
   enableParallelBuilding = true;
 

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

···
+{ stdenv, lib, fetchgit, cmake
+, opencv, gtest, openblas, liblapack
+, cudaSupport ? false, cudatoolkit
+, cudnnSupport ? false, cudnn
+}:
+
+assert cudnnSupport -> cudaSupport;
+
+stdenv.mkDerivation rec {
+  name = "mxnet-${version}";
+  version = "0.11.0";
+
+  # Submodules needed
+  src = fetchgit {
+    url = "https://github.com/apache/incubator-mxnet";
+    rev = "refs/tags/${version}";
+    sha256 = "1qgns0c70a1gfyil96h17ms736nwdkp9kv496gvs9pkzqzvr6cpz";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  buildInputs = [ opencv gtest openblas liblapack ]
+              ++ lib.optional cudaSupport cudatoolkit
+              ++ lib.optional cudnnSupport cudnn;
+
+  cmakeFlags = lib.optional (!cudaSupport) "-DUSE_CUDA=OFF"
+            ++ lib.optional (!cudnnSupport) "-DUSE_CUDNN=OFF";
+
+  installPhase = ''
+    install -Dm755 libmxnet.so $out/lib/libmxnet.so
+    cp -r ../include $out
+  '';
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler";
+    homepage = "https://mxnet.incubator.apache.org/";
+    maintainers = with maintainers; [ abbradar ];
+    license = licenses.asl20;
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/video/streamlink/default.nix

···
 { stdenv, pythonPackages, fetchFromGitHub, rtmpdump, ffmpeg }:
 
 pythonPackages.buildPythonApplication rec {
-  version = "0.7.0";
+  version = "0.8.1";
   name = "streamlink-${version}";
 
   src = fetchFromGitHub {
     owner = "streamlink";
     repo = "streamlink";
     rev = "${version}";
-    sha256 = "0knh7lw6bv1vix3p40hjp5lc0z9pavvx6rncviw5h095rzcw5287";
+    sha256 = "0l09vp108dw6d9d9rri2xwlr49mr5nkrlxbivr4kk5jbaczjp9xm";
   };
 
   buildInputs = with pythonPackages; [ pytest mock ];
 
-  propagatedBuildInputs = (with pythonPackages; [ pycryptodome requests iso-639 iso3166 ]) ++ [ rtmpdump ffmpeg ];
+  propagatedBuildInputs = (with pythonPackages; [ pycryptodome requests iso-639 iso3166 websocket_client ]) ++ [ rtmpdump ffmpeg ];
 
   meta = with stdenv.lib; {
     homepage = https://github.com/streamlink/streamlink;

pkgs/build-support/buildenv/default.nix

···
 
 { buildPackages, runCommand, lib }:
 
-{ name
+lib.makeOverridable
+({ name
 
 , # The manifest file (if any).  A symlink $out/manifest will be
   # created to it.
···
   ''
     ${buildPackages.perl}/bin/perl -w ${./builder.pl}
     eval "$postBuild"
-  ''
+  '')

pkgs/build-support/vm/default.nix

···
             url = mirror://ubuntu/dists/trusty/universe/binary-amd64/Packages.bz2;
             sha256 = "558637eeb8e340b871653e2060effe36e064677eca4eae62d9e4138dd402a610";
           })
-          (fetchurl {
-            url = mirror://ubuntu/dists/trusty-updates/main/binary-amd64/Packages.bz2;
-            sha256 = "03vd582p8b78s8sq6hz3nynn9vr7syccmn77i5mzayvsadb74cfy";
-          })
         ];
       urlPrefix = mirror://ubuntu;
       packages = commonDebPackages ++ [ "diffutils" "libc-bin" ];

pkgs/desktops/kde-4.14/kde-package/4.14.3.nix

···
   {name="baloo";value="0p3awsrc20q79kq04x0vjz84acxz6gjm9jc7j2al4kybkyzx5p4y";}
   {name="kde-baseapps";value="1nz6mm257rd916dklnbrix4r25scylvjil99b1djb35blx1aynqj";}
   {name="kdepimlibs";value="1mv8k0wr0wr0hnlb1al50nmz8d77vbm73p2hhipipgliq6zb3vb5";}
-  {name="kde-workspace";value="00bf708i0vzl47dgcr8mp61n7k0xjzqnlb8j1smliy5bydiaa86g";}
   {name="kfilemetadata";value="0wak1nphnphcam8r6pba7m2gld4w04dkk8qn23myjammv3myc59i";}
   {name="libkcddb";value="0xrmg53p5lh4ral2l5zh96angaf9czhih3zzvwr9qr9h9ks5vrn1";}
   {name="libkdcraw";value="0ksarwq8aaxc77cp0ryfnw1n311wkykzdlhj03rln8jjlbdm3j3q";}
···
   {name="kde-baseapps";value="4.14.3";}
   {name="kdepimlibs";value="4.14.3";}
   {name="kde-runtime";value="4.14.3";}
-  {name="kde-workspace";value="4.11.14";}
   {name="kfilemetadata";value="4.14.3";}
   {name="libkcddb";value="4.14.3";}
   {name="libkdcraw";value="4.14.3";}
···
 }
 { module="kactivities";  split=false;}
 { module="kdepimlibs";  split=false;}
-{ module="kde-workspace"; sane="kde_workspace"; split=false;}
 ];
 }

pkgs/desktops/kde-4.14/kde-workspace.nix

···
-{ stdenv, kde, kdelibs, qimageblitz, libdbusmenu_qt, xorg, lm_sensors
-, pciutils, libraw1394, libusb1, python, libqalculate, akonadi
-, xkeyboard_config, kdepimlibs, pam, boost, gpsd, prison
-, libjpeg, pkgconfig, kactivities, qjson, udev, fetchurl
-}:
-
-kde {
-#todo: wayland, xmms,   libusb isn't found
-#note: xorg.libXft is needed to build kfontview and kfontinst though this isn't reflected in the build log
-  buildInputs =
-    [ kdelibs qimageblitz libdbusmenu_qt xorg.libxcb xorg.xcbutilimage libjpeg
-      xorg.xcbutilrenderutil xorg.xcbutilkeysyms xorg.libpthreadstubs xorg.libXdmcp
-      xorg.libxkbfile xorg.libXcomposite  xorg.libXtst
-      xorg.libXdamage xorg.libXft
-
-      python boost qjson lm_sensors /* gpsd */ libraw1394 pciutils udev
-      akonadi pam libusb1 libqalculate kdepimlibs  prison
-      kactivities
-    ];
-
-  patches = [ ./files/ksysguard-0001-disable-signalplottertest.patch ];
-
-  preConfigure =
-   ''
-     # Fix incorrect path to kde4-config.
-     substituteInPlace startkde.cmake --replace '$bindir/kde4-config' ${kdelibs}/bin/kde4-config
-
-     # Fix the path to the keyboard configuration files.
-     substituteInPlace kcontrol/keyboard/xkb_rules.cpp \
-       --replace /usr/share/X11 ${xkeyboard_config}/etc/X11
-   '';
-
-  NIX_CFLAGS_COMPILE = [ "-fpermissive" ]; # gcc-6
-
-  enableParallelBuilding = false; # frequent problems on Hydra
-
-  meta = {
-    description = "KDE workspace components such as Plasma, Kwin and System Settings";
-    license = stdenv.lib.licenses.gpl2;
-  };
-}

pkgs/development/compilers/dmd/2.067.1.nix

···
     # https://github.com/dlang/dmd/pull/6680
     license = licenses.boost;
     platforms = platforms.unix;
-    broken = true;
   };
 }
 

pkgs/development/compilers/dmd/default.nix

···
 { stdenv, fetchFromGitHub
 , makeWrapper, unzip, which
-, curl, tzdata
+, curl, tzdata, gdb
 # Versions 2.070.2 and up require a working dmd compiler to build:
 , bootstrapDmd }:
 
···
       mv dmd-v${version}-src dmd
       mv druntime-v${version}-src druntime
       mv phobos-v${version}-src phobos
+
+      # Remove cppa test for now because it doesn't work.
+      rm dmd/test/runnable/cppa.d
+      rm dmd/test/runnable/extra-files/cppb.cpp
   '';
 
   # Compile with PIC to prevent colliding modules with binutils 2.28.
···
             --replace MACOSX_DEPLOYMENT_TARGET MACOSX_DEPLOYMENT_TARGET_
     '';
 
-  nativeBuildInputs = [ bootstrapDmd makeWrapper unzip which ];
+  nativeBuildInputs = [ bootstrapDmd makeWrapper unzip which gdb ];
   buildInputs = [ curl tzdata ];
 
   # Buid and install are based on http://wiki.dlang.org/Building_DMD
   buildPhase = ''
       cd dmd
-      make -f posix.mak INSTALL_DIR=$out
+      make -j$NIX_BUILD_CORES -f posix.mak INSTALL_DIR=$out
       ${
           let bits = builtins.toString stdenv.hostPlatform.parsed.cpu.bits;
           osname = if stdenv.hostPlatform.isDarwin then "osx" else stdenv.hostPlatform.parsed.kernel.name; in
           "export DMD=$PWD/generated/${osname}/release/${bits}/dmd"
       }
       cd ../druntime
-      make -f posix.mak PIC=${usePIC} INSTALL_DIR=$out DMD=$DMD
+      make -j$NIX_BUILD_CORES -f posix.mak PIC=${usePIC} INSTALL_DIR=$out DMD=$DMD
       cd ../phobos
-      make -f posix.mak PIC=${usePIC} INSTALL_DIR=$out DMD=$DMD
+      make -j$NIX_BUILD_CORES -f posix.mak PIC=${usePIC} INSTALL_DIR=$out DMD=$DMD
       cd ..
   '';
 
···
           osname = if stdenv.hostPlatform.isDarwin then "osx" else stdenv.hostPlatform.parsed.kernel.name; in
           "export DMD=$PWD/generated/${osname}/release/${bits}/dmd"
       }
+      make -j$NIX_BUILD_CORES -C test -f Makefile PIC=${usePIC} DMD=$DMD BUILD=release SHARED=0
       cd ../druntime
-      make -f posix.mak unittest PIC=${usePIC} DMD=$DMD BUILD=release
+      make -j$NIX_BUILD_CORES -f posix.mak unittest PIC=${usePIC} DMD=$DMD BUILD=release
       cd ../phobos
-      make -f posix.mak unittest PIC=${usePIC} DMD=$DMD BUILD=release
+      make -j$NIX_BUILD_CORES -f posix.mak unittest PIC=${usePIC} DMD=$DMD BUILD=release
       cd ..
   '';
 
···
     # Everything is now Boost licensed, even the backend.
     # https://github.com/dlang/dmd/pull/6680
     license = licenses.boost;
+    maintainers = with maintainers; [ ThomasMader ];
     platforms = platforms.unix;
-    broken = true;
   };
 }

pkgs/development/compilers/emscripten-fastcomp/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, python, ... }:
-
+{ newScope, stdenv, wrapCC, wrapCCWith, symlinkJoin }:
 let
-  rev = "1.37.16";
-  gcc = if stdenv.cc.isGNU then stdenv.cc.cc else stdenv.cc.cc.gcc;
-in
-stdenv.mkDerivation rec {
-  name = "emscripten-fastcomp-${rev}";
-
-  src = fetchFromGitHub {
-    owner = "kripken";
-    repo = "emscripten-fastcomp";
-    sha256 = "0wj9sc0gciaiidcjv6wb0qn6ks06xds7q34351masc7qpvd217by";
-    inherit rev;
-  };
-
-  srcFL = fetchFromGitHub {
-    owner = "kripken";
-    repo = "emscripten-fastcomp-clang";
-    sha256 = "1akdgxzxhzjbhp4d14ajcrp9jrf39x004a726ly2gynqc185l4j7";
-    inherit rev;
-  };
-
-  nativeBuildInputs = [ cmake python ];
-  preConfigure = ''
-    cp -Lr ${srcFL} tools/clang
-    chmod +w -R tools/clang
-  '';
-  cmakeFlags = [
-    "-DCMAKE_BUILD_TYPE=Release"
-    "-DLLVM_TARGETS_TO_BUILD='X86;JSBackend'"
-    "-DLLVM_INCLUDE_EXAMPLES=OFF"
-    "-DLLVM_INCLUDE_TESTS=OFF"
-    # "-DCLANG_INCLUDE_EXAMPLES=OFF"
-    "-DCLANG_INCLUDE_TESTS=OFF"
-  ] ++ (stdenv.lib.optional stdenv.isLinux
-    # necessary for clang to find crtend.o
-    "-DGCC_INSTALL_PREFIX=${gcc}"
-  );
-  enableParallelBuilding = true;
+  callPackage = newScope (self // {inherit stdenv;});
 
-  passthru = {
-    isClang = true;
-    inherit gcc;
+  self = {
+    emscriptenfastcomp-unwrapped = callPackage ./emscripten-fastcomp.nix {};
+    emscriptenfastcomp-wrapped = wrapCCWith stdenv.cc.libc ''
+      # hardening flags break WASM support
+      cat > $out/nix-support/add-hardening.sh
+    '' self.emscriptenfastcomp-unwrapped;
+    emscriptenfastcomp = symlinkJoin {
+      name = "emscriptenfastcomp";
+      paths = [ self.emscriptenfastcomp-wrapped self.emscriptenfastcomp-unwrapped ];
+      preferLocalBuild = false;
+      allowSubstitutes = true;
+      postBuild = ''
+        # replace unwrapped clang-3.9 binary by wrapper
+        ln -sf $out/bin/clang $out/bin/clang-[0-9]*
+      '';
+    };
   };
-
-  meta = with stdenv.lib; {
-    homepage = https://github.com/kripken/emscripten-fastcomp;
-    description = "Emscripten LLVM";
-    platforms = platforms.all;
-    maintainers = with maintainers; [ qknight matthewbauer ];
-    license = stdenv.lib.licenses.ncsa;
-  };
-}
+in self

pkgs/development/compilers/emscripten-fastcomp/emscripten-fastcomp.nix

···
+{ stdenv, fetchFromGitHub, cmake, python, ... }:
+
+let
+  rev = "1.37.16";
+  gcc = if stdenv.cc.isGNU then stdenv.cc.cc else stdenv.cc.cc.gcc;
+in
+stdenv.mkDerivation rec {
+  name = "emscripten-fastcomp-${rev}";
+
+  src = fetchFromGitHub {
+    owner = "kripken";
+    repo = "emscripten-fastcomp";
+    sha256 = "0wj9sc0gciaiidcjv6wb0qn6ks06xds7q34351masc7qpvd217by";
+    inherit rev;
+  };
+
+  srcFL = fetchFromGitHub {
+    owner = "kripken";
+    repo = "emscripten-fastcomp-clang";
+    sha256 = "1akdgxzxhzjbhp4d14ajcrp9jrf39x004a726ly2gynqc185l4j7";
+    inherit rev;
+  };
+
+  nativeBuildInputs = [ cmake python ];
+  preConfigure = ''
+    cp -Lr ${srcFL} tools/clang
+    chmod +w -R tools/clang
+  '';
+  cmakeFlags = [
+    "-DCMAKE_BUILD_TYPE=Release"
+    "-DLLVM_TARGETS_TO_BUILD='X86;JSBackend'"
+    "-DLLVM_INCLUDE_EXAMPLES=OFF"
+    "-DLLVM_INCLUDE_TESTS=OFF"
+    # "-DCLANG_INCLUDE_EXAMPLES=OFF"
+    "-DCLANG_INCLUDE_TESTS=OFF"
+  ] ++ (stdenv.lib.optional stdenv.isLinux
+    # necessary for clang to find crtend.o
+    "-DGCC_INSTALL_PREFIX=${gcc}"
+  );
+  enableParallelBuilding = true;
+
+  passthru = {
+    isClang = true;
+    inherit gcc;
+  };
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/kripken/emscripten-fastcomp;
+    description = "Emscripten LLVM";
+    platforms = platforms.all;
+    maintainers = with maintainers; [ qknight matthewbauer ];
+    license = stdenv.lib.licenses.ncsa;
+  };
+}

pkgs/development/compilers/ghc/7.2.2.nix

···
     ];
     platforms = ["x86_64-linux" "i686-linux"];  # Darwin is unsupported.
     inherit (ghc.meta) license;
+    broken = true;   # broken by 51cf42ad0d3ccb55af182f1f0ee5eb5094ea5995: https://hydra.nixos.org/build/60616815
   };
 
 }

pkgs/development/compilers/ldc/default.nix

···
+{ stdenv, fetchFromGitHub, cmake, llvm, dmd, curl, tzdata, python,
+  lit, gdb, unzip, darwin }:
+
+stdenv.mkDerivation rec {
+  name = "ldc-${version}";
+  version = "1.3.0";
+
+  srcs = [
+  (fetchFromGitHub {
+    owner = "ldc-developers";
+    repo = "ldc";
+    rev = "v${version}";
+    sha256 = "1ac3j4cwwgjpayhijxx4d6478bc3iqksjxkd7xp7byx7k8w1ppdl";
+  })
+  (fetchFromGitHub {
+    owner = "ldc-developers";
+    repo = "druntime";
+    rev = "ldc-v${version}";
+    sha256 = "1m13370wnj3sizqk3sdpzi9am5d24srf27d613qblhqa9n8vwz30";
+  })
+  (fetchFromGitHub {
+    owner = "ldc-developers";
+    repo = "phobos";
+    rev = "ldc-v${version}";
+    sha256 = "0fhcdfi7a00plwj27ysfyv783nhk0kspq7hawf6vbsl3s1nyvn8g";
+  })
+  (fetchFromGitHub {
+    owner = "ldc-developers";
+    repo = "dmd-testsuite";
+    rev = "ldc-v${version}";
+    sha256 = "0dmdkp220gqhxjrmrjfkf0vsvylwfaj70hswavq4q3v4dg17pzmj";
+  })
+  ];
+
+  sourceRoot = ".";
+
+  postUnpack = ''
+      mv ldc-v${version}-src/* .
+
+      mv druntime-ldc-v${version}-src/* runtime/druntime
+
+      mv phobos-ldc-v${version}-src/* runtime/phobos
+
+      mv dmd-testsuite-ldc-v${version}-src/* tests/d2/dmd-testsuite
+
+      # Remove cppa test for now because it doesn't work.
+      rm tests/d2/dmd-testsuite/runnable/cppa.d
+      rm tests/d2/dmd-testsuite/runnable/extra-files/cppb.cpp
+  '';
+
+  postPatch = ''
+      substituteInPlace runtime/phobos/std/net/curl.d \
+          --replace libcurl.so ${curl.out}/lib/libcurl.so
+
+      # Ugly hack to fix the hardcoded path to zoneinfo in the source file.
+      # https://issues.dlang.org/show_bug.cgi?id=15391
+      substituteInPlace runtime/phobos/std/datetime.d \
+          --replace /usr/share/zoneinfo/ ${tzdata}/share/zoneinfo/
+  ''
+
+  + stdenv.lib.optionalString stdenv.hostPlatform.isDarwin ''
+      substituteInPlace driver/tool.cpp \
+          --replace "gcc" "clang"
+  '';
+
+  nativeBuildInputs = [ cmake llvm dmd python lit gdb unzip ]
+
+  ++ stdenv.lib.optional stdenv.hostPlatform.isDarwin (with darwin.apple_sdk.frameworks; [
+    Foundation
+  ]);
+
+  buildInputs = [ curl tzdata stdenv.cc ];
+
+  preConfigure = ''
+    cmakeFlagsArray=("-DINCLUDE_INSTALL_DIR=$out/include/dlang/ldc")
+  '';
+
+  postConfigure = ''
+    export DMD=$PWD/bin/ldc2
+  '';
+
+  makeFlags = [ "DMD=$DMD" ];
+
+  doCheck = true;
+
+  checkPhase = ''
+      ctest -j $NIX_BUILD_CORES -V DMD=$DMD
+  '';
+
+  meta = with stdenv.lib; {
+    description = "The LLVM-based D compiler";
+    homepage = https://github.com/ldc-developers/ldc;
+    # from https://github.com/ldc-developers/ldc/blob/master/LICENSE
+    license = with licenses; [ bsd3 boost mit ncsa gpl2Plus ];
+    maintainers = with maintainers; [ ThomasMader ];
+    platforms = platforms.unix;
+  };
+}

pkgs/development/compilers/llvm/3.7/default.nix

···
-{ newScope, stdenv, cmake, libxml2, python2, isl, fetchurl, overrideCC, wrapCC, ccWrapperFun }:
+{ newScope, stdenv, libstdcxxHook, cmake, libxml2, python2, isl, fetchurl
+, overrideCC, wrapCC, ccWrapperFun, darwin
+}:
+
 let
   callPackage = newScope (self // { inherit stdenv cmake libxml2 python2 isl version fetch; });
 
···
       inherit clang-tools-extra_src stdenv;
     };
 
-    clang = wrapCC self.clang-unwrapped;
+    clang = if stdenv.cc.isGNU then self.libstdcxxClang else self.libcxxClang;
+
+    libstdcxxClang = ccWrapperFun {
+      cc = self.clang-unwrapped;
+      /* FIXME is this right? */
+      inherit (stdenv.cc) libc nativeTools nativeLibc;
+      extraPackages = [ libstdcxxHook ];
+    };
 
     libcxxClang = ccWrapperFun {
       cc = self.clang-unwrapped;
-      isClang = true;
-      inherit (self) stdenv;
       /* FIXME is this right? */
       inherit (stdenv.cc) libc nativeTools nativeLibc;
       extraPackages = [ self.libcxx self.libcxxabi ];
     };
 
-    stdenv = overrideCC stdenv self.clang;
+    stdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.clang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
-    libcxxStdenv = overrideCC stdenv self.libcxxClang;
+    libcxxStdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.libcxxClang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
     lldb = callPackage ./lldb.nix {};
 

pkgs/development/compilers/llvm/3.8/default.nix

···
-{ newScope, stdenv, isl, fetchurl, overrideCC, wrapCC, ccWrapperFun }:
+{ newScope, stdenv, libstdcxxHook, isl, fetchurl, overrideCC, wrapCC, ccWrapperFun, darwin }:
 let
   callPackage = newScope (self // { inherit stdenv isl version fetch; });
 
···
       inherit clang-tools-extra_src stdenv;
     };
 
-    clang = wrapCC self.clang-unwrapped;
+    clang = if stdenv.cc.isGNU then self.libstdcxxClang else self.libcxxClang;
+
+    libstdcxxClang = ccWrapperFun {
+      cc = self.clang-unwrapped;
+      /* FIXME is this right? */
+      inherit (stdenv.cc) libc nativeTools nativeLibc;
+      extraPackages = [ libstdcxxHook ];
+    };
 
     libcxxClang = ccWrapperFun {
       cc = self.clang-unwrapped;
-      isClang = true;
-      inherit (self) stdenv;
       /* FIXME is this right? */
       inherit (stdenv.cc) libc nativeTools nativeLibc;
       extraPackages = [ self.libcxx self.libcxxabi ];
     };
 
-    stdenv = overrideCC stdenv self.clang;
+    stdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.clang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
-    libcxxStdenv = overrideCC stdenv self.libcxxClang;
+    libcxxStdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.libcxxClang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
     lldb = callPackage ./lldb.nix {};
 

pkgs/development/compilers/llvm/3.9/default.nix

···
-{ newScope, stdenv, isl, fetchurl, overrideCC, wrapCC, darwin, ccWrapperFun }:
+{ newScope, stdenv, libstdcxxHook, isl, fetchurl, overrideCC, wrapCC, ccWrapperFun, darwin }:
 let
   callPackage = newScope (self // { inherit stdenv isl version fetch; });
 
···
       inherit clang-tools-extra_src stdenv;
     };
 
-    clang = wrapCC self.clang-unwrapped;
+    clang = if stdenv.cc.isGNU then self.libstdcxxClang else self.libcxxClang;
+
+    libstdcxxClang = ccWrapperFun {
+      cc = self.clang-unwrapped;
+      /* FIXME is this right? */
+      inherit (stdenv.cc) libc nativeTools nativeLibc;
+      extraPackages = [ libstdcxxHook ];
+    };
 
     libcxxClang = ccWrapperFun {
       cc = self.clang-unwrapped;
-      isClang = true;
-      inherit (self) stdenv;
       /* FIXME is this right? */
       inherit (stdenv.cc) libc nativeTools nativeLibc;
       extraPackages = [ self.libcxx self.libcxxabi ];
     };
 
-    stdenv = overrideCC stdenv self.clang;
+    stdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.clang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
-    libcxxStdenv = overrideCC stdenv self.libcxxClang;
+    libcxxStdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.libcxxClang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
     lldb = callPackage ./lldb.nix {};
 

pkgs/development/compilers/llvm/4/default.nix

···
     llvm-manpages = lowPrio self.llvm.man;
     clang-manpages = lowPrio self.clang-unwrapped.man;
 
-    clang = wrapCC self.clang-unwrapped;
+    clang = if stdenv.cc.isGNU then self.libstdcxxClang else self.libcxxClang;
 
-    openmp = callPackage ./openmp.nix {};
+    libstdcxxClang = ccWrapperFun {
+      cc = self.clang-unwrapped;
+      /* FIXME is this right? */
+      inherit (stdenv.cc) libc nativeTools nativeLibc;
+      extraPackages = [ libstdcxxHook ];
+    };
 
     libcxxClang = ccWrapperFun {
       cc = self.clang-unwrapped;
-      isClang = true;
-      inherit (self) stdenv;
       /* FIXME is this right? */
       inherit (stdenv.cc) libc nativeTools nativeLibc;
       extraPackages = [ self.libcxx self.libcxxabi ];
···
     stdenv = stdenv.override (drv: {
       allowedRequisites = null;
       cc = self.clang;
-      # Use the gcc libstdc++ when targeting linux.
-      extraBuildInputs = if stdenv.cc.isGNU then [ libstdcxxHook ] else drv.extraBuildInputs;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
     });
 
-    libcxxStdenv = overrideCC stdenv self.libcxxClang;
+    libcxxStdenv = stdenv.override (drv: {
+      allowedRequisites = null;
+      cc = self.libcxxClang;
+      # Don't include the libc++ and libc++abi from the original stdenv.
+      extraBuildInputs = stdenv.lib.optional stdenv.isDarwin darwin.CF;
+    });
 
     lld = callPackage ./lld.nix {};
 
···
     libcxx = callPackage ./libc++ {};
 
     libcxxabi = callPackage ./libc++abi.nix {};
+
+    openmp = callPackage ./openmp.nix {};
   };
 
 in self

pkgs/development/compilers/ponyc/default.nix

···
 
 stdenv.mkDerivation ( rec {
   name = "ponyc-${version}";
-  version = "0.19.0";
+  version = "0.19.1";
 
   src = fetchFromGitHub {
     owner = "ponylang";
     repo = "ponyc";
     rev = version;
-    sha256 = "05xswxbibkrzm6rf8mvd1y9ysf624ngpj0k0xxcrlsls197sian9";
+    sha256 = "1zd051syn0n6ign4nnxb40xj2s5vqp0s349nkjqv7051xzvlzf1p";
   };
 
   buildInputs = [ llvm makeWrapper which ];

pkgs/development/compilers/tinycc/default.nix

···
 with stdenv.lib;
 
 let
-  date = "20170821";
+  date = "20170911";
+  rev = "870271ea071971002fa556e09e1873db316fa1a9";
+  sha256 = "1a9djm0p7cd5nzqdhch9y48c4wai76x6d4nwx0bj5jz46ws39bs9";
   version = "0.9.27pre-${date}";
-  rev = "b8fe8fc2105455eb5004be89fa8575aa928a18f3";
-  sha256 = "0rsv5pikm7ai2n7r93qlbvkyky23dsgc3sdc83crbcxjjk6xh378";
 in
 
 stdenv.mkDerivation rec {

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

···
   # Fix test trying to access /home directory
   shell-conduit = (overrideCabal super.shell-conduit (drv: {
     postPatch = "sed -i s/home/tmp/ test/Spec.hs";
+
+    # the tests for shell-conduit on Darwin illegitimatey assume non-GNU echo
+    # see: https://github.com/psibi/shell-conduit/issues/12
+    doCheck = !pkgs.stdenv.hostPlatform.isDarwin;
   }));
 
   # https://github.com/froozen/kademlia/issues/2
···
   th-printf = dontCheck super.th-printf;
   thumbnail-plus = dontCheck super.thumbnail-plus;
   tickle = dontCheck super.tickle;
+  tldr = super.tldr.override {
+    # shell-conduit determines what commands are available at compile-time, so
+    # that tldr will not compile unless the shell-conduit it uses is compiled
+    # with git in its environment.
+    shell-conduit = addBuildTool self.shell-conduit pkgs.git;
+  };
   tpdb = dontCheck super.tpdb;
   translatable-intset = dontCheck super.translatable-intset;
   ua-parser = dontCheck super.ua-parser;
···
   # during the install phase for no apparent reason:
   # https://hydra.nixos.org/build/60678124
   Agda = markBroken (super.Agda.override { happy = self.happy_1_19_5; });
+
+  # cryptol-2.5.0 doesn't want happy 1.19.6+.
+  cryptol = super.cryptol.override { happy = self.happy_1_19_5; };
 
   # https://github.com/jtdaugherty/text-zipper/issues/11
   text-zipper = dontCheck super.text-zipper;

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

···
   # https://github.com/aristidb/aws/issues/238
   aws = doJailbreak super.aws;
 
-  # https://github.com/jgm/pandoc/issues/3876
-  pandoc = let fixSetup = pkgs.fetchpatch {
-                            url = "https://github.com/jgm/pandoc/pull/3899.patch";
-                            sha256 = "0lk9vs2l1wc1kr0y8fkdcarfi4sjd3dl81r52n39r25xx9kqawv7";
-                          };
-           in overrideCabal super.pandoc (drv: {
-                editedCabalFile = null;
-                patches = drv.patches or [] ++ [fixSetup];
-                setupHaskellDepends = drv.setupHaskellDepends or [self.Cabal_1_24_2_0];
-                preCompileBuildDriver = "setupCompileFlags+=' -package=Cabal-1.24.2.0'";
-              });
-
   # LTS-9 versions do not compile.
   path = dontCheck super.path;
   path-io = super.path-io_1_3_3;
   trifecta = super.trifecta_1_7_1_1;
   aeson-compat = dontCheck super.aeson-compat_0_3_7_1;  # test suite needs QuickCheck 2.10.*
-  binary-orphans = dontCheck super.binary-orphans_0_1_7_0; # test suite needs QuickCheck 2.10.*
+  binary-orphans = dontCheck super.binary-orphans_0_1_8_0; # test suite needs QuickCheck 2.10.*
 
 }

pkgs/development/haskell-modules/configuration-hackage2nix.yaml

···
   - ghcjs-base-0
 
 default-package-overrides:
-  # LTS Haskell 9.3
+  # LTS Haskell 9.4
   - abstract-deque ==0.3
   - abstract-deque-tests ==0.3
   - abstract-par ==0.3.3
···
   - aeson-pretty ==0.8.5
   - aeson-qq ==0.8.2
   - aeson-utils ==0.3.0.2
-  - Agda ==2.5.2
+  - Agda ==2.5.3
   - airship ==0.6.0
   - alarmclock ==0.4.0.3
   - alerta ==0.1.0.4
-  - alex ==3.2.2
+  - alex ==3.2.3
   - algebraic-graphs ==0.0.5
   - alsa-core ==0.5.0.1
   - alsa-mixer ==0.2.0.3
···
   - concurrent-output ==1.9.2
   - concurrent-split ==0.0.1
   - concurrent-supply ==0.1.8
-  - conduit ==1.2.11
+  - conduit ==1.2.12
   - conduit-combinators ==1.1.1
   - conduit-connection ==0.1.0.3
-  - conduit-extra ==1.1.16
+  - conduit-extra ==1.1.17
   - conduit-iconv ==0.1.1.2
   - conduit-parse ==0.1.2.1
   - ConfigFile ==1.1.4
···
   - data-diverse-lens ==0.1.1.0
   - data-dword ==0.3.1.1
   - data-endian ==0.1.1
-  - data-fix ==0.0.6
+  - data-fix ==0.0.7
   - data-has ==0.2.1.0
   - data-hash ==0.2.0.1
   - data-inttrie ==0.1.2
···
   - Decimal ==0.4.2
   - declarative ==0.5.1
   - deepseq-generics ==0.2.0.0
-  - dejafu ==0.7.1.2
+  - dejafu ==0.7.1.3
   - dependent-map ==0.2.4.0
   - dependent-sum ==0.4
   - derive ==2.6.3
···
   - dmenu-pkill ==0.1.0.1
   - dmenu-pmount ==0.1.0.1
   - dmenu-search ==0.1.0.1
-  - dns ==2.0.12
+  - dns ==2.0.13
   - do-list ==1.0.1
   - dockerfile ==0.1.0.1
   - docopt ==0.7.0.5
···
   - filemanip ==0.3.6.3
   - fileplow ==0.1.0.0
   - filter-logger ==0.6.0.0
-  - find-clumpiness ==0.2.2.0
+  - find-clumpiness ==0.2.3.0
   - fingertree ==0.1.1.0
   - fingertree-psqueue ==0.3
   - finite-typelits ==0.1.2.0
···
   - hamlet ==1.2.0
   - HandsomeSoup ==0.4.2
   - handwriting ==0.1.0.3
-  - hapistrano ==0.3.2.4
+  - hapistrano ==0.3.3.0
   - happstack-hsp ==7.3.7.3
   - happstack-jmacro ==7.0.12
   - happstack-server ==7.4.6.4
   - happstack-server-tls ==7.1.6.4
-  - happy >1.19.6
-  - harp ==0.4.2
+  - happy ==1.19.7
+  - harp ==0.4.3
   - hasbolt ==0.1.2.1
   - hashable ==1.2.6.1
   - hashable-time ==0.2.0.1
   - hashmap ==1.3.2
-  - hashtables ==1.2.1.1
+  - hashtables ==1.2.2.0
   - haskeline ==0.7.4.0
   - haskell-gi ==0.20.3
   - haskell-gi-base ==0.20.4
···
   - hsemail ==2
   - HSet ==0.0.1
   - hset ==2.2.0
-  - hsexif ==0.6.1.2
+  - hsexif ==0.6.1.3
   - hsignal ==0.2.7.5
   - hsinstall ==1.6
   - hslogger ==1.2.10
···
   - instance-control ==0.1.1.1
   - integer-logarithms ==1.0.2
   - integration ==0.2.1
-  - intero ==0.1.21
+  - intero ==0.1.23
   - interpolate ==0.1.1
   - interpolatedstring-perl6 ==1.0.0
   - interpolation ==0.1.0.1
···
   - io-region ==0.1.1
   - io-storage ==0.3
   - io-streams ==1.4.1.0
-  - io-streams-haproxy ==1.0.0.1
+  - io-streams-haproxy ==1.0.0.2
   - ip6addr ==0.5.3
   - iproute ==1.7.1
   - IPv6Addr ==1.0.1
···
   - json-builder ==0.3
   - json-rpc-generic ==0.2.1.2
   - json-schema ==0.7.4.1
-  - json-stream ==0.4.1.4
+  - json-stream ==0.4.1.5
   - JuicyPixels ==3.2.8.3
   - JuicyPixels-extra ==0.2.1
   - JuicyPixels-scale-dct ==0.1.1.2
···
   - log-postgres ==0.7.0.2
   - logfloat ==0.13.3.3
   - logger-thread ==0.1.0.2
-  - logging-effect ==1.2.0
+  - logging-effect ==1.2.1
   - logging-facade ==0.3.0
   - logging-facade-syslog ==1
   - logict ==0.6.0.2
···
   - median-stream ==0.7.0.0
   - mega-sdist ==0.3.0.2
   - megaparsec ==5.3.1
-  - memory ==0.14.6
+  - memory ==0.14.7
   - MemoTrie ==0.6.8
   - mersenne-random-pure64 ==0.2.2.0
   - messagepack ==0.5.4
···
   - monad-extras ==0.6.0
   - monad-http ==0.1.0.0
   - monad-journal ==0.7.2
-  - monad-logger ==0.3.25
+  - monad-logger ==0.3.25.1
   - monad-logger-json ==0.1.0.0
   - monad-logger-prefix ==0.1.6
   - monad-logger-syslog ==0.1.4.0
···
   - Only ==0.1
   - oo-prototypes ==0.1.0.0
   - opaleye ==0.5.4.0
-  - opaleye-trans ==0.3.5
+  - opaleye-trans ==0.3.6
   - open-browser ==0.2.1.0
   - open-witness ==0.4.0.1
   - OpenAL ==1.7.0.4
···
   - OpenGLRaw ==3.2.5.0
   - openpgp-asciiarmor ==0.1
   - opensource ==0.1.0.0
-  - openssl-streams ==1.2.1.1
+  - openssl-streams ==1.2.1.3
   - operational ==0.2.3.5
   - operational-class ==0.3.0.0
   - opml-conduit ==0.6.0.3
···
   - pagerduty ==0.0.8
   - pagination ==0.2.1
   - palette ==0.1.0.5
-  - pandoc ==1.19.2.1
+  - pandoc ==1.19.2.4
   - pandoc-citeproc ==0.10.5.1
   - pandoc-types ==1.17.0.5
   - pango ==0.13.3.1
···
   - partial-order ==0.1.2.1
   - patat ==0.5.2.2
   - path ==0.5.13
-  - path-extra ==0.0.3
+  - path-extra ==0.0.5
   - path-io ==1.2.2
   - path-pieces ==0.2.1
   - pathtype ==0.8
···
   - pipes-bytestring ==2.1.6
   - pipes-cacophony ==0.5.0
   - pipes-category ==0.2.0.1
-  - pipes-concurrency ==2.0.7
+  - pipes-concurrency ==2.0.8
   - pipes-extras ==1.0.10
   - pipes-fluid ==0.5.0.3
-  - pipes-group ==1.0.7
+  - pipes-group ==1.0.8
   - pipes-misc ==0.3.0.0
   - pipes-mongodb ==0.1.0.0
   - pipes-parse ==3.0.8
···
   - pkcs10 ==0.2.0.0
   - placeholders ==0.1
   - plan-b ==0.2.1
-  - plot ==0.2.3.7
+  - plot ==0.2.3.8
   - plot-gtk ==0.2.0.4
   - plot-gtk-ui ==0.3.0.2
   - plot-gtk3 ==0.1.0.2
···
   - safe-exceptions ==0.1.6.0
   - safe-exceptions-checked ==0.1.0
   - safecopy ==0.9.3.3
-  - safeio ==0.0.3.0
+  - safeio ==0.0.4.0
   - SafeSemaphore ==0.10.1
   - sample-frame ==0.0.3
   - sample-frame-np ==0.0.4.1
···
   - search-algorithms ==0.2.0
   - securemem ==0.1.9
   - SegmentTree ==0.3
-  - selda ==0.1.10.1
-  - selda-postgresql ==0.1.6.0
+  - selda ==0.1.11.0
+  - selda-postgresql ==0.1.7.0
   - selda-sqlite ==0.1.6.0
   - semigroupoid-extras ==5
   - semigroupoids ==5.2.1
···
   - smoothie ==0.4.2.7
   - smtp-mail ==0.1.4.6
   - snap-blaze ==0.2.1.5
-  - snap-core ==1.0.3.0
-  - snap-server ==1.0.3.0
+  - snap-core ==1.0.3.1
+  - snap-server ==1.0.3.1
   - snowflake ==0.1.1.1
   - snowtify ==0.1.0.3
   - soap ==0.2.3.5
···
   - svg-tree ==0.6.2
   - SVGFonts ==1.6.0.2
   - swagger ==0.3.0
-  - swagger2 ==2.1.4.1
+  - swagger2 ==2.1.5
   - syb ==0.7
   - symbol ==0.2.4
   - symengine ==0.1.2.0
···
   - text-region ==0.3.0.0
   - text-show ==3.6
   - text-show-instances ==3.6
-  - text-zipper ==0.10
+  - text-zipper ==0.10.1
   - textlocal ==0.1.0.5
   - tf-random ==0.5
   - tfp ==1.0.0.2
-  - th-abstraction ==0.2.5.0
+  - th-abstraction ==0.2.6.0
   - th-data-compat ==0.0.2.4
   - th-desugar ==1.6
   - th-expand-syns ==0.4.3.0
···
   - type-operators ==0.1.0.4
   - type-spec ==0.3.0.1
   - TypeCompose ==0.9.12
-  - typed-process ==0.1.0.1
+  - typed-process ==0.1.1
   - typelits-witnesses ==0.2.3.0
   - typography-geometry ==1.0.0.1
   - tz ==0.1.3.0
···
   - union-find ==0.2
   - uniplate ==1.6.12
   - uniq-deep ==1.1.0.0
-  - Unique ==0.4.6.1
+  - Unique ==0.4.7.1
   - unique ==0
   - unit-constraint ==0.0.0
   - units ==2.4
···
   - uuid-types ==1.0.3
   - vado ==0.0.9
   - validate-input ==0.4.0.0
-  - validation ==0.5.4
+  - validation ==0.5.5
   - validationt ==0.2.0.0
   - varying ==0.7.0.3
   - vault ==0.3.0.7
···
   - wai-cors ==0.2.5
   - wai-eventsource ==3.0.0
   - wai-extra ==3.0.20.0
-  - wai-handler-launch ==3.0.2.2
+  - wai-handler-launch ==3.0.2.3
   - wai-logger ==2.3.0
   - wai-middleware-auth ==0.1.2.1
   - wai-middleware-caching ==0.1.0.2
···
   - xmlgen ==0.6.2.1
   - xmonad ==0.13
   - xmonad-contrib ==0.13
-  - xmonad-extras ==0.13.0
+  - xmonad-extras ==0.13.1
   - xss-sanitize ==0.3.5.7
   - xturtle ==0.2.0.0
   - yackage ==0.8.1
···
   - YampaSynth ==0.2
   - yes-precure5-command ==5.5.3
   - yesod ==1.4.5
-  - yesod-auth ==1.4.18
+  - yesod-auth ==1.4.19
   - yesod-auth-account ==1.4.3
   - yesod-auth-basic ==0.1.0.2
   - yesod-auth-fb ==1.8.1
···
   - yesod-default ==1.2.0
   - yesod-eventsource ==1.4.1
   - yesod-fb ==0.4.0
-  - yesod-form ==1.4.15
+  - yesod-form ==1.4.16
   - yesod-form-bootstrap4 ==0.1.0.1
   - yesod-form-richtext ==0.1.0.2
   - yesod-gitrepo ==0.2.1.0

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

···
      }) {};
 
   "Agda" = callPackage
-    ({ mkDerivation, alex, array, base, binary, boxes, bytestring
-     , containers, cpphs, data-hash, deepseq, directory, EdisonCore
-     , edit-distance, emacs, equivalence, filepath, geniplate-mirror
-     , gitrev, happy, hashable, hashtables, haskeline, ieee754
-     , monadplus, mtl, murmur-hash, parallel, pretty, process
-     , regex-tdfa, strict, template-haskell, text, time, transformers
-     , transformers-compat, unordered-containers, xhtml, zlib
+    ({ mkDerivation, alex, array, async, base, binary, blaze-html
+     , boxes, bytestring, containers, cpphs, data-hash, deepseq
+     , directory, EdisonCore, edit-distance, emacs, equivalence
+     , filepath, geniplate-mirror, gitrev, happy, hashable, hashtables
+     , haskeline, ieee754, monadplus, mtl, murmur-hash, parallel, pretty
+     , process, regex-tdfa, stm, strict, template-haskell, text, time
+     , transformers, unordered-containers, uri-encode, zlib
      }:
      mkDerivation {
        pname = "Agda";
-       version = "2.5.2";
-       sha256 = "0f8ld7sqkfhirhs886kp090iaq70qxsj8ms8farc80vzpz1ww4nq";
-       revision = "3";
-       editedCabalFile = "10j2hf2g9vv2xibywgd8s96x05clfxr4wli00011vkhblr4p9br8";
+       version = "2.5.3";
+       sha256 = "0r80vw7vnvbgq47y50v050malv7zvv2p2kg6f47i04r0b2ix855a";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         array base binary boxes bytestring containers data-hash deepseq
-         directory EdisonCore edit-distance equivalence filepath
-         geniplate-mirror gitrev hashable hashtables haskeline ieee754
-         monadplus mtl murmur-hash parallel pretty process regex-tdfa strict
-         template-haskell text time transformers transformers-compat
-         unordered-containers xhtml zlib
+         array async base binary blaze-html boxes bytestring containers
+         data-hash deepseq directory EdisonCore edit-distance equivalence
+         filepath geniplate-mirror gitrev hashable hashtables haskeline
+         ieee754 monadplus mtl murmur-hash parallel pretty process
+         regex-tdfa stm strict template-haskell text time transformers
+         unordered-containers uri-encode zlib
        ];
        libraryToolDepends = [ alex cpphs happy ];
        executableHaskellDepends = [ base directory filepath process ];
···
      }:
      mkDerivation {
        pname = "Gene-CluEDO";
-       version = "0.0.0.1";
-       sha256 = "045h6p6n5rw6qb498hrgzgfddlj5hiij3zmbbs6p9nb9c6h03y48";
+       version = "0.0.0.2";
+       sha256 = "1gl5walv8mslb5rz9lf5s882ij4596shklqgjybckqajqwimblpd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "Gifcurry" = callPackage
-    ({ mkDerivation, base, cmdargs, directory, filepath, gtk3, process
-     , temporary, text
+    ({ mkDerivation, base, cmdargs, directory, filepath, gi-gdk
+     , gi-glib, gi-gobject, gi-gtk, haskell-gi-base, process, temporary
+     , text
      }:
      mkDerivation {
        pname = "Gifcurry";
-       version = "2.1.0.0";
-       sha256 = "030p4ihh3zdjy0f687ffpnsf1zjb7mhwih47718fj2pawi4hkksi";
+       version = "2.2.0.0";
+       sha256 = "19f5prpnf3c3ga85ad1s1q5nl78n67iva5cwppkqklc15w0ad3rs";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          base directory filepath process temporary text
        ];
        executableHaskellDepends = [
-         base cmdargs directory filepath gtk3 process temporary text
+         base cmdargs directory filepath gi-gdk gi-glib gi-gobject gi-gtk
+         haskell-gi-base process temporary text
        ];
        homepage = "https://github.com/lettier/gifcurry";
-       description = "Create animated GIFs, overlaid with optional text, from video files";
-       license = stdenv.lib.licenses.asl20;
+       description = "GIF creation utility";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
 
   "Hoed" = callPackage
     ({ mkDerivation, array, base, bytestring, cereal, containers
-     , directory, filepath, FPretty, libgraph, mtl, process, RBTree
-     , regex-posix, template-haskell, threepenny-gui, time
+     , directory, filepath, libgraph, mtl, process, regex-posix, time
      }:
      mkDerivation {
        pname = "Hoed";
-       version = "0.3.6";
-       sha256 = "1nsiqcwx9xiz3774c0kv036v8pz53jzl9pfxyhm6ci8ag83za245";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.4.0";
+       sha256 = "0l01viv04dkxinysd7wbzn7k5rm8c21ix8k5a4p940hml879m9f1";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         array base bytestring cereal containers directory filepath FPretty
-         libgraph mtl process RBTree regex-posix template-haskell
-         threepenny-gui time
+         array base bytestring cereal containers directory filepath libgraph
+         mtl process regex-posix time
        ];
        homepage = "https://wiki.haskell.org/Hoed";
        description = "Lightweight algorithmic debugging";
···
      }:
      mkDerivation {
        pname = "PTQ";
-       version = "0.0.7";
-       sha256 = "0pfd5y8plxicdchkbij0nqj6zwxw3fcy5cz1ji5bky9g3bmz9mhm";
+       version = "0.0.8";
+       sha256 = "0mbyf63s19rps7p74b4fazbfccpjzx40l1fjszv38kprrg7jff2s";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }) {};
 
   "SCalendar" = callPackage
-    ({ mkDerivation, base, containers, hspec, QuickCheck, text, time }:
+    ({ mkDerivation, base, containers, hspec, QuickCheck, scalendar
+     , text, time
+     }:
      mkDerivation {
        pname = "SCalendar";
-       version = "1.0.0";
-       sha256 = "0w69p3min1iijbk5cv645v5cizd2k5xwdzr52l7fg72bv17l0xcx";
+       version = "1.1.0";
+       sha256 = "139lggc8f7sw703asdyxqbja0jfcgphx0l5si1046lsryinvywa9";
        libraryHaskellDepends = [ base containers text time ];
        testHaskellDepends = [
-         base containers hspec QuickCheck text time
+         base containers hspec QuickCheck scalendar text time
        ];
-       homepage = "https://github.com/stackbuilders/scalendar";
+       homepage = "https://www.researchgate.net/publication/311582722_Method_of_Managing_Resources_in_a_Telecommunication_Network_or_a_Computing_System";
        description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        pname = "SciFlow";
        version = "0.6.0";
        sha256 = "1b57sa2gx3jj00239sq62qmywjykc80lkk587lwzrdp9w5ycl4sb";
+       revision = "1";
+       editedCabalFile = "1nsakdi9y5nnwm8x9f2a1cvf55k0wnva3wkd9nmz9my8mlk2jfi3";
        libraryHaskellDepends = [
          aeson base bytestring cereal cereal-text containers
          data-default-class directory exceptions executable-path fgl
···
      }:
      mkDerivation {
        pname = "Unique";
-       version = "0.4.6.1";
-       sha256 = "1yc45a81rfhg8vw1wbdgb4x8fdr1diycnyvby7npy2187cw4i5lb";
-       libraryHaskellDepends = [
-         base containers extra hashable unordered-containers
-       ];
-       testHaskellDepends = [ base containers hspec QuickCheck ];
-       description = "It provides the functionality like unix \"uniq\" utility";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "Unique_0_4_7_1" = callPackage
-    ({ mkDerivation, base, containers, extra, hashable, hspec
-     , QuickCheck, unordered-containers
-     }:
-     mkDerivation {
-       pname = "Unique";
        version = "0.4.7.1";
        sha256 = "1a912180fk2xhz6md50n21xz0z89n9ylansyqxq034jgsfkz8b7s";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base containers hspec QuickCheck ];
        description = "It provides the functionality like unix \"uniq\" utility";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "Unixutils" = callPackage
···
      }:
      mkDerivation {
        pname = "Villefort";
-       version = "0.1.1.13";
-       sha256 = "02qlhg1i5z9z0zdbczygf4px477zg91a8gk5va5i7mcsgznqzv7d";
+       version = "0.1.1.14";
+       sha256 = "020ialav8dxbzkyra8sjip397l50j7d3gy3m44jf4wgiyk3d9jpj";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "Win32-notify";
        version = "0.3.0.1";
        sha256 = "0zzbb00rykl8y1prkcm3paaamhmdrqji34070b9zg7sg2pc5k4f4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers directory Win32 ];
+       executableHaskellDepends = [ base directory ];
+       description = "A binding to part of the Win32 library for file notification";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "Win32-notify_0_3_0_3" = callPackage
+    ({ mkDerivation, base, containers, directory, Win32 }:
+     mkDerivation {
+       pname = "Win32-notify";
+       version = "0.3.0.3";
+       sha256 = "05j10i83354cqbi8yzq5rgkkd6rmxsvy1b0sbwz3pkmidkhdn88c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers directory Win32 ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "aern2-mp" = callPackage
+    ({ mkDerivation, base, convertible, hmpfr, hspec, integer-gmp
+     , integer-logarithms, lens, mixed-types-num, QuickCheck, regex-tdfa
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "aern2-mp";
+       version = "0.1.0.1";
+       sha256 = "0l217dh94j8cf16rsv3408551qslwzjy068ni0m88i2cwliq9pyi";
+       libraryHaskellDepends = [
+         base convertible hmpfr hspec integer-gmp integer-logarithms lens
+         mixed-types-num QuickCheck regex-tdfa template-haskell
+       ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       homepage = "https://github.com/michalkonecny/aern2";
+       description = "Multi-precision floats via MPFR";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "aern2-real" = callPackage
+    ({ mkDerivation, aern2-mp, aeson, base, bytestring, containers
+     , convertible, elm-bridge, hspec, lens, mixed-types-num, QuickCheck
+     , random, stm, transformers
+     }:
+     mkDerivation {
+       pname = "aern2-real";
+       version = "0.1.0.1";
+       sha256 = "0xvag7xzs5azcivlcp641p6wzf6pimz74fvwcl3rmrbah1ij1qv0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aern2-mp aeson base bytestring containers convertible hspec lens
+         mixed-types-num QuickCheck stm transformers
+       ];
+       executableHaskellDepends = [
+         aern2-mp base elm-bridge mixed-types-num QuickCheck random
+       ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       homepage = "https://github.com/michalkonecny/aern2";
+       description = "Exact real numbers via Cauchy sequences and MPFR";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "aeson_0_7_0_6" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
      , dlist, ghc-prim, hashable, HUnit, mtl, old-locale, QuickCheck
···
      }:
      mkDerivation {
        pname = "alex";
-       version = "3.2.2";
-       sha256 = "16v259aqgsj2lgia210f05zx6drbyad9958hk3cn9i27k7cmlkis";
+       version = "3.2.3";
+       sha256 = "0bi1cs9b8ir33h1fl6x2xw4ymygapqbr713ridpf7rmk2wa7jqqs";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "alex-prelude" = callPackage
+    ({ mkDerivation, base, time }:
+     mkDerivation {
+       pname = "alex-prelude";
+       version = "0.1.1.1";
+       sha256 = "1ngxkr7jvy48pgq0sjqpi7a84qjm4fjny64hxksyvbj08l2rn7ha";
+       libraryHaskellDepends = [ base time ];
+       homepage = "https://www.asayers.com/";
+       description = "Collection of useful functions for writing console applications";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "alex-tools" = callPackage
     ({ mkDerivation, base, deepseq, template-haskell, text }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "amqp_0_16_0" = callPackage
+  "amqp_0_17_0" = callPackage
     ({ mkDerivation, base, binary, bytestring, clock, connection
      , containers, data-binary-ieee754, hspec, hspec-expectations
      , monad-control, network, network-uri, split, stm, text, vector
···
      }:
      mkDerivation {
        pname = "amqp";
-       version = "0.16.0";
-       sha256 = "100krph1yaazxcs74r6v5785l50886rsbip98w8p4rzqgcya311a";
+       version = "0.17.0";
+       sha256 = "18g63nx7ksbqs45nr3nfw0hii9niw0bw5s35vk4xnchhj9f3ibwr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, pretty-show, text }:
      mkDerivation {
        pname = "assert-failure";
-       version = "0.1.1.0";
-       sha256 = "09djlhhyn9w822a5r41y7gk4cqk74a2fy7skzml2bah2an166gm1";
+       version = "0.1.2.1";
+       sha256 = "1fjn40d555ryz9fffbx3qizrh3y018kalz6b4w8gdxapvpszj0sc";
+       enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base pretty-show text ];
        homepage = "https://github.com/Mikolaj/assert-failure";
        description = "Syntactic sugar improving 'assert' and 'error'";
···
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
        pname = "basement";
-       version = "0.0.0";
-       sha256 = "1agqj5yp0nf7117qx62xp5mncans5szscbp6gz6ifhhsl6lng3k1";
+       version = "0.0.2";
+       sha256 = "01jvdi7xb61jgrq64ll325mvhibmm2q8nllq7aicy13mwxqgcyac";
        libraryHaskellDepends = [ base ghc-prim ];
        homepage = "https://github.com/haskell-foundation/foundation";
        description = "Foundation scrap box of array & string";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "binary-orphans_0_1_7_0" = callPackage
+  "binary-orphans_0_1_8_0" = callPackage
     ({ mkDerivation, aeson, base, binary, case-insensitive, hashable
      , QuickCheck, quickcheck-instances, scientific, tagged, tasty
      , tasty-quickcheck, text, text-binary, time, unordered-containers
···
      }:
      mkDerivation {
        pname = "binary-orphans";
-       version = "0.1.7.0";
-       sha256 = "1pv10g4a9sxjrsp2fj0w4n1sklxk2nf5w9q6na308smngbx3k1f9";
-       revision = "1";
-       editedCabalFile = "0k0griirhzac9h5wcf1331dmpxn32qdzx8pablaf1ny9r6pbjigy";
+       version = "0.1.8.0";
+       sha256 = "1k6067wn9zki7xvbslvxx8cq1wrmz3kjb3q3x8mxycc9v765fxgi";
        libraryHaskellDepends = [
          aeson base binary case-insensitive hashable scientific tagged text
          text-binary time unordered-containers vector
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "byteunits" = callPackage
+    ({ mkDerivation, base, Cabal, QuickCheck, safe }:
+     mkDerivation {
+       pname = "byteunits";
+       version = "0.2.0.2";
+       sha256 = "1n0gbjjhxx6rv07sck3bx70bd96pkgl0vx5qyqbby9gdfndil4vl";
+       libraryHaskellDepends = [ base safe ];
+       testHaskellDepends = [ base Cabal QuickCheck ];
+       description = "Human friendly conversion between byte units (KB, MB, GB...)";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "bzlib" = callPackage
     ({ mkDerivation, base, bytestring, bzip2 }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "canteven-http";
-       version = "0.1.4.0";
-       sha256 = "0zxs8ciyv3zb109an3qkw2c7kbg0zgs6cx1phndyl61wxf6vbqa6";
+       version = "0.1.5.1";
+       sha256 = "0rb77g2g9ddzypswwgjqw8dg31m2q70p765jbq4g5jj4jynm2vdb";
        libraryHaskellDepends = [
          base bytestring canteven-log directory exceptions filepath
          http-types mime-types monad-logger template-haskell text time
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "chart-unit_0_5_2" = callPackage
+  "chart-unit_0_5_3" = callPackage
     ({ mkDerivation, base, colour, containers, data-default
      , diagrams-lib, diagrams-rasterific, diagrams-svg, foldl
      , formatting, lens, linear, mwc-probability, mwc-random, numhask
···
      }:
      mkDerivation {
        pname = "chart-unit";
-       version = "0.5.2";
-       sha256 = "1fslw870412dpc333hhxqhly7lz5gr8m2x7bvndfj4a98mmsv056";
+       version = "0.5.3";
+       sha256 = "0kr57pv63xlx2xnc0cj0da1bc5cf8icnw81lbndrdxh126si50k5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "chronos";
        version = "0.4";
        sha256 = "0lc7qb1ky15sxmvndfjcmmy6j913ncnzq0hjx9mbqljvg7di0yal";
+       revision = "1";
+       editedCabalFile = "1mk6kn0gs7azv7c9bcal8k6zzlpska0x9akk91la2xvg298sy6a5";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring hashable primitive text vector
        ];
···
      }:
      mkDerivation {
        pname = "cloudi";
-       version = "1.7.1";
-       sha256 = "12kk359wfkwsc62bb6f0ak5gzkwdw4gmcfmj9ryqrjcc2irlnbk1";
+       version = "1.7.2";
+       sha256 = "1w6rdmb5a50vdski2k4xwysrbxaycybijgak0hvpsjhnf16yb04f";
        libraryHaskellDepends = [
          array base binary bytestring containers network time unix zlib
        ];
···
      }:
      mkDerivation {
        pname = "cmark-sections";
-       version = "0.2.0.0";
-       sha256 = "0xrss1vlbcswk2izpjh34vxnkjaim6pxih00vv13hcarip17qs4f";
+       version = "0.3.0";
+       sha256 = "1zc7gcncmbq5ph17hlwxdikjvx6ccywkbs60523ybp7dagch4cfs";
        libraryHaskellDepends = [
          base base-prelude cmark containers microlens split text
        ];
···
   "cmv" = callPackage
     ({ mkDerivation, aeson, base, BiobaseInfernal, BiobaseTypes
      , BiobaseXNA, BioHMM, bytestring, cmdargs, colour, containers
-     , diagrams-cairo, diagrams-lib, directory, either-unwrap, filepath
-     , mtl, parsec, ParsecTools, PrimitiveArray, StockholmAlignment
-     , SVGFonts, template-haskell, text, vector
+     , diagrams-cairo, diagrams-core, diagrams-lib, directory
+     , either-unwrap, filepath, mtl, parsec, ParsecTools, PrimitiveArray
+     , StockholmAlignment, SVGFonts, template-haskell, text, vector
      }:
      mkDerivation {
        pname = "cmv";
-       version = "1.0.2";
-       sha256 = "107cwha465c7i2yi1k9m2csf9kdszrix7295d1q0dhklwi0fll8d";
+       version = "1.0.3";
+       sha256 = "1ahvr926iwg7r9ljflng28gwm39g2j42r754hbqg8ph5n0h0nlxj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base BiobaseInfernal BiobaseTypes BiobaseXNA BioHMM colour
-         containers diagrams-cairo diagrams-lib directory either-unwrap
-         filepath mtl parsec ParsecTools PrimitiveArray StockholmAlignment
-         SVGFonts text vector
+         containers diagrams-cairo diagrams-core diagrams-lib directory
+         either-unwrap filepath mtl parsec ParsecTools PrimitiveArray
+         StockholmAlignment SVGFonts text vector
        ];
        executableHaskellDepends = [
          aeson base BiobaseInfernal BiobaseXNA BioHMM bytestring cmdargs
···
      }:
      mkDerivation {
        pname = "composite-aeson";
-       version = "0.5.1.0";
-       sha256 = "05v87hj60b3bcvq1jr45svs3z0q2ix5jkkk5kyd4fx95y63l1viw";
+       version = "0.5.2.0";
+       sha256 = "12r2kkn6gxp5aj3fzdyfazi2nzgfvvk6cp9rb5y0ak2llvsh5jm4";
        libraryHaskellDepends = [
          aeson aeson-better-errors base composite-base containers
          contravariant generic-deriving hashable lens mmorph mtl profunctors
···
      }:
      mkDerivation {
        pname = "composite-aeson-refined";
-       version = "0.5.1.0";
-       sha256 = "1q7a210fnnypmb7m9jmqvfxzlb4aiy773vcmy7sv3qfnqys0ychm";
+       version = "0.5.2.0";
+       sha256 = "02kx3dsqfqwn07lxhvj6gxw4p0h5yv8r1nndzi6d8lil38rx9gap";
        libraryHaskellDepends = [
          aeson-better-errors base composite-aeson mtl refined
        ];
···
      }:
      mkDerivation {
        pname = "composite-base";
-       version = "0.5.1.0";
-       sha256 = "0ba25lw2kcn159w10kpbg5zhbiz6ka9kxcwsahw99030lm01d4rb";
+       version = "0.5.2.0";
+       sha256 = "1s19y7cnsk7k0hsc124xnvcj35vmdk1yqwvv15xf2qilvp3ppzxw";
        libraryHaskellDepends = [
          base exceptions lens monad-control mtl profunctors template-haskell
          text transformers transformers-base vinyl
···
      }:
      mkDerivation {
        pname = "composite-ekg";
-       version = "0.5.1.0";
-       sha256 = "06jyl3vry7i0hypkzdm8zmf6h14s7vrl3322wpbjn72x1sd2cqsp";
+       version = "0.5.2.0";
+       sha256 = "0bymnfw5d3nzwrbmnq1jpdvvm86p7c3y7s779dlpmdcsq2wxvp92";
        libraryHaskellDepends = [
          base composite-base ekg ekg-core lens text vinyl
        ];
···
      }:
      mkDerivation {
        pname = "composite-opaleye";
-       version = "0.5.1.0";
-       sha256 = "1gyhjsa2144r402jlvm5g7c3gfbjlg5cr3ja51l7bavvsgvp28br";
+       version = "0.5.2.0";
+       sha256 = "1k2h9acbk4g8rfqpg9r689k5nr8cgj385797mkca3f76xrzlxbfl";
        libraryHaskellDepends = [
          base bytestring composite-base lens opaleye postgresql-simple
          product-profunctors profunctors template-haskell text vinyl
···
     ({ mkDerivation, base, containers, criterion, deepseq, exceptions
      , hspec, kan-extensions, lifted-base, mmorph, monad-control, mtl
      , mwc-random, primitive, QuickCheck, resourcet, safe, split
-     , transformers, transformers-base, vector
-     }:
-     mkDerivation {
-       pname = "conduit";
-       version = "1.2.11";
-       sha256 = "1xx8vj2azbzr2skcrpcy02hgnik01i6hcx01h0mjd4fr0hzl4rhb";
-       libraryHaskellDepends = [
-         base exceptions lifted-base mmorph monad-control mtl primitive
-         resourcet transformers transformers-base
-       ];
-       testHaskellDepends = [
-         base containers exceptions hspec mtl QuickCheck resourcet safe
-         split transformers
-       ];
-       benchmarkHaskellDepends = [
-         base containers criterion deepseq hspec kan-extensions mwc-random
-         transformers vector
-       ];
-       homepage = "http://github.com/snoyberg/conduit";
-       description = "Streaming data processing library";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "conduit_1_2_12" = callPackage
-    ({ mkDerivation, base, containers, criterion, deepseq, exceptions
-     , hspec, kan-extensions, lifted-base, mmorph, monad-control, mtl
-     , mwc-random, primitive, QuickCheck, resourcet, safe, split
      , transformers, transformers-base, transformers-compat, vector
      }:
      mkDerivation {
···
        homepage = "http://github.com/snoyberg/conduit";
        description = "Streaming data processing library";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "conduit-algorithms" = callPackage
···
      }:
      mkDerivation {
        pname = "conduit-algorithms";
-       version = "0.0.3.0";
-       sha256 = "1bcn3gmq3dd23biw7widf1pmx7063yn5xn949cviw4nmfshrqahp";
+       version = "0.0.4.0";
+       sha256 = "0d142r0ljcdyd6z92k4nn19a0sain4fdqmfdr1wiibwq4bdcfzqw";
        libraryHaskellDepends = [
          async base bytestring bzlib-conduit conduit conduit-combinators
          conduit-extra containers deepseq directory filepath mtl resourcet
···
      }:
      mkDerivation {
        pname = "conduit-extra";
-       version = "1.1.16";
-       sha256 = "1mgqc34i6ccq5bjkkn943gfa3w0lhddi3am0fd5afnazrnxc2wmx";
-       libraryHaskellDepends = [
-         async attoparsec base blaze-builder bytestring conduit directory
-         exceptions filepath monad-control network primitive process
-         resourcet stm streaming-commons text transformers transformers-base
-       ];
-       testHaskellDepends = [
-         async attoparsec base blaze-builder bytestring bytestring-builder
-         conduit directory exceptions hspec process QuickCheck resourcet stm
-         streaming-commons text transformers transformers-base
-       ];
-       benchmarkHaskellDepends = [
-         base blaze-builder bytestring bytestring-builder conduit criterion
-         transformers
-       ];
-       homepage = "http://github.com/snoyberg/conduit";
-       description = "Batteries included conduit: adapters for common libraries";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "conduit-extra_1_1_17" = callPackage
-    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
-     , bytestring-builder, conduit, criterion, directory, exceptions
-     , filepath, hspec, monad-control, network, primitive, process
-     , QuickCheck, resourcet, stm, streaming-commons, text, transformers
-     , transformers-base
-     }:
-     mkDerivation {
-       pname = "conduit-extra";
        version = "1.1.17";
        sha256 = "01haq94kf4jsqrhs6j2kkvxrw4iqhvhnd9rcrqpkdbp1dil493kn";
        libraryHaskellDepends = [
···
        homepage = "http://github.com/snoyberg/conduit";
        description = "Batteries included conduit: adapters for common libraries";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "conduit-find" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "continued-fraction" = callPackage
+    ({ mkDerivation, base, criterion, hspec, recursion-schemes }:
+     mkDerivation {
+       pname = "continued-fraction";
+       version = "0.1.0.0";
+       sha256 = "1vip1ask3zyhy9n0vacx5ipww2m2wxkdhnp2j20c0i2g1jrpspx7";
+       libraryHaskellDepends = [ base recursion-schemes ];
+       testHaskellDepends = [ base hspec ];
+       benchmarkHaskellDepends = [ base criterion ];
+       homepage = "https://github.com/vmchale/continued-fractions#readme";
+       description = "Types and functions for working with continued fractions in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "continued-fractions" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "cryptol";
        version = "2.5.0";
        sha256 = "1w8w4srdvnd8dwjbip45bdqsgpg5xmw2nrw1asnk857bgdhjh2ci";
+       revision = "1";
+       editedCabalFile = "0zd7ly5xy61z401bhw49r13wkcmrl7lsbc0245yas23j4bdmpbdr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "data-fix";
-       version = "0.0.6";
-       sha256 = "10shw0c7c3v3qy27c8mahr56bzciikqmafpm01r7792i84glb10g";
-       libraryHaskellDepends = [ base ];
-       homepage = "https://github.com/anton-k/data-fix";
-       description = "Fixpoint data types";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "data-fix_0_0_7" = callPackage
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "data-fix";
        version = "0.0.7";
        sha256 = "04k9cmb197majyw6xna8zfkhgfyxfdiz2sgb0jy5jyfpiz3cr60h";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/anton-k/data-fix";
        description = "Fixpoint data types";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "data-fix-cse" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "data-foldapp" = callPackage
+    ({ mkDerivation, base, containers }:
+     mkDerivation {
+       pname = "data-foldapp";
+       version = "0.1.0.0";
+       sha256 = "0m2rwai52q712fxkpk4k23cc8x9dx87c8wwwsg9w5y5pxq78csn8";
+       libraryHaskellDepends = [ base containers ];
+       homepage = "https://github.com/erisco/data-foldapp";
+       description = "Fold function applications. Framework for variadic functions.";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "data-forest" = callPackage
     ({ mkDerivation, base, doctest }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "dejafu";
-       version = "0.7.1.2";
-       sha256 = "07ilcx6j4y587vda3y6maqjzn00zx9lz7mlgp2c1rhikbyk5dn03";
+       version = "0.7.1.3";
+       sha256 = "1bb629li526ji0kk3vkyrf5kim5m42k9vfhdhjcizdw85dlbxqgn";
        libraryHaskellDepends = [
          base concurrency containers deepseq exceptions leancheck mtl random
          ref-fd semigroups transformers transformers-base
···
        pname = "diagrams-builder";
        version = "0.8.0.1";
        sha256 = "072vzskwp20qb768rv87876ngn6gnj959m91vpzri9ls9jx0x6vf";
-       revision = "2";
-       editedCabalFile = "0hrpic80rh8xyld8fhblvwykkg82nlp7j9xmcf5403wnqgprna97";
+       revision = "3";
+       editedCabalFile = "00lpy8ch7zjc2z3ifwg8j1jfsrf4sg1fk9pngykl8bqb79hm5h3i";
        configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
        isLibrary = true;
        isExecutable = true;
···
        pname = "diagrams-cairo";
        version = "1.4";
        sha256 = "10gabibjg1hb83pm7qbqxmskrvrb52m5wdb8fcqwy9d3vfzwhkm9";
-       revision = "1";
-       editedCabalFile = "0xqjwxvhk45c202vlkbcl3kmp6rvwpyb1lzk4j3wnh5b9210v0y7";
+       revision = "2";
+       editedCabalFile = "1h21l3wa4vbl7p6n7sk949jpxvxikkhf81y2qjqgn904564w73r6";
        libraryHaskellDepends = [
          array base bytestring cairo colour containers data-default-class
          diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "diagrams-svg_1_4_1_1" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, colour
+     , containers, diagrams-core, diagrams-lib, filepath, hashable
+     , JuicyPixels, lens, monoid-extras, mtl, optparse-applicative
+     , semigroups, split, svg-builder, text
+     }:
+     mkDerivation {
+       pname = "diagrams-svg";
+       version = "1.4.1.1";
+       sha256 = "1ans2lliaxqbx2q2459kiv59ff307vz6plqnh082pxhvmk36h1n8";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring colour containers diagrams-core
+         diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl
+         optparse-applicative semigroups split svg-builder text
+       ];
+       homepage = "http://projects.haskell.org/diagrams/";
+       description = "SVG backend for diagrams drawing EDSL";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "diagrams-tikz" = callPackage
     ({ mkDerivation, base, diagrams-core, diagrams-lib, dlist, mtl }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "distributed-process-lifted";
-       version = "0.2.0.1";
-       sha256 = "0l19lf97m68xf1484srx2cnsprw9hqp0z0b58gjkpp4b2ki9cbcz";
+       version = "0.3.0.0";
+       sha256 = "1n0jic03x959rnkaavcywhz0zbqhaya53y0ydh13qs83a1y13m7i";
        libraryHaskellDepends = [
          base deepseq distributed-process distributed-process-monad-control
          lifted-base monad-control mtl network-transport transformers
···
      }:
      mkDerivation {
        pname = "distributed-process-zookeeper";
-       version = "0.2.2.0";
-       sha256 = "0a3rd4wzwmnvsq3lq0p86rnf98gzwa4xan1gpqs40kppw17h85fz";
+       version = "0.2.3.0";
+       sha256 = "08dbqmzg80mffa4a3xls99mrk0i9zsx5f5s2nv8x35dlirdlbiwh";
+       revision = "1";
+       editedCabalFile = "1mvhc7lb4ssmjy24945fj7x185y665qn1gy9bldslfck3rdzi19n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dns";
-       version = "2.0.12";
-       sha256 = "0c5w2s8cvid9nk9ldd759k0p54pnb10ld3iin1w1b4lqi08cnnwk";
-       libraryHaskellDepends = [
-         attoparsec base binary bytestring conduit conduit-extra containers
-         iproute mtl network random resourcet safe
-       ];
-       testHaskellDepends = [
-         attoparsec base binary bytestring bytestring-builder conduit
-         conduit-extra containers doctest hspec iproute mtl network random
-         resourcet safe word8
-       ];
-       testTarget = "spec";
-       description = "DNS library in Haskell";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "dns_2_0_13" = callPackage
-    ({ mkDerivation, attoparsec, base, binary, bytestring
-     , bytestring-builder, conduit, conduit-extra, containers, doctest
-     , hspec, iproute, mtl, network, random, resourcet, safe, word8
-     }:
-     mkDerivation {
-       pname = "dns";
        version = "2.0.13";
        sha256 = "0rrv49rvnpd1pf37imhm82ngy9z0vk80sz0zvikpccc0parbmvx0";
        libraryHaskellDepends = [
···
        testTarget = "spec";
        description = "DNS library in Haskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "dnscache" = callPackage
···
      }:
      mkDerivation {
        pname = "expressions";
-       version = "0.1.1";
-       sha256 = "0vbykw97f1zb4nlj1ibamyk4bi0467ldlxwlknhr5b940dfs3rmy";
+       version = "0.1.2";
+       sha256 = "0xl0302n98ijizv30bmj6dkmafam74rnn7n77q176ql22mjr0yfn";
        libraryHaskellDepends = [
          attoparsec base containers lattices singletons text transformers
        ];
        testHaskellDepends = [
          base QuickCheck singletons tasty tasty-quickcheck text
        ];
-       description = "Expressions and Formulas a la carte";
+       description = "Expressions and Formulae a la carte";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "file-embed_0_0_10_1" = callPackage
+    ({ mkDerivation, base, bytestring, directory, filepath
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "file-embed";
+       version = "0.0.10.1";
+       sha256 = "0lj164cnzqyd487mli91nnr7137a4h4qsasfwsnsh77sx12fpk9k";
+       libraryHaskellDepends = [
+         base bytestring directory filepath template-haskell
+       ];
+       testHaskellDepends = [ base filepath ];
+       homepage = "https://github.com/snoyberg/file-embed";
+       description = "Use Template Haskell to embed file contents directly";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "file-embed-poly" = callPackage
     ({ mkDerivation, base, bytestring, directory, file-embed, filepath
      , hspec, template-haskell
···
 
   "find-clumpiness" = callPackage
     ({ mkDerivation, aeson, base, BiobaseNewick, bytestring, clumpiness
-     , containers, listsafe, mtl, optparse-applicative, text, text-show
-     , tree-fun, unordered-containers, vector
+     , containers, hierarchical-clustering, listsafe, mtl
+     , optparse-applicative, text, text-show, tree-fun
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "find-clumpiness";
-       version = "0.2.2.0";
-       sha256 = "174i1yhd7z884xfci8ml9kbcm0qpnsbryj8vchrd7rwi63ya0rbw";
+       version = "0.2.3.0";
+       sha256 = "08aby19vx6mvv606f66yi89bbg7x487drzzbax8437xm7k2fpg73";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base BiobaseNewick bytestring clumpiness containers listsafe
-         mtl text text-show tree-fun unordered-containers vector
+         aeson base BiobaseNewick bytestring clumpiness containers
+         hierarchical-clustering listsafe mtl text text-show tree-fun
+         unordered-containers vector
        ];
        executableHaskellDepends = [
          aeson base BiobaseNewick bytestring clumpiness containers
···
        libraryHaskellDepends = [ base deepseq ];
        homepage = "https://github.com/mniip/finite-typelits";
        description = "A type inhabited by finitely many values, indexed by type-level naturals";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "firefly" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, bytestring
+     , case-insensitive, containers, cookie, http-types, mtl, regex-pcre
+     , text, transformers, wai, warp
+     }:
+     mkDerivation {
+       pname = "firefly";
+       version = "0.1.0.0";
+       sha256 = "0m7a7n9iw5ylw4w0awwsbafck5gn7jap3jd34064in6qp009s05v";
+       libraryHaskellDepends = [
+         aeson base blaze-html bytestring case-insensitive containers cookie
+         http-types mtl regex-pcre text transformers wai warp
+       ];
+       homepage = "https://github.com/ChrisPenner/firefly#readme";
+       description = "A simple HTTP server framework";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "firefly-example" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, firefly, mtl, text, wai
+     }:
+     mkDerivation {
+       pname = "firefly-example";
+       version = "0.1.0.0";
+       sha256 = "1z8xr575dqpdb2rhbin1ib1wmswnkrxcrjdrgd3wjw524iq4b51m";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base blaze-html firefly mtl text wai
+       ];
+       homepage = "https://github.com/ChrisPenner/Firefly#readme";
+       description = "A simple example using Firefly";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        license = stdenv.lib.licenses.isc;
      }) {};
 
+  "fn_0_3_0_2" = callPackage
+    ({ mkDerivation, base, blaze-builder, bytestring, directory
+     , filepath, hspec, http-types, resourcet, text
+     , unordered-containers, wai, wai-extra
+     }:
+     mkDerivation {
+       pname = "fn";
+       version = "0.3.0.2";
+       sha256 = "0pxfwyfigj449qd01xb044gz1h63f3lvmpq6xij09xhkm8bv0d0y";
+       libraryHaskellDepends = [
+         base blaze-builder bytestring directory filepath http-types
+         resourcet text unordered-containers wai wai-extra
+       ];
+       testHaskellDepends = [
+         base directory filepath hspec http-types resourcet text
+         unordered-containers wai wai-extra
+       ];
+       homepage = "http://github.com/positiondev/fn#readme";
+       description = "A functional web framework";
+       license = stdenv.lib.licenses.isc;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "fn-extra" = callPackage
     ({ mkDerivation, base, blaze-builder, bytestring
      , digestive-functors, directory, either, fn, heist, http-types
-     , lens, mtl, resourcet, text, wai, wai-extra, wai-util, xmlhtml
+     , lens, map-syntax, mtl, resourcet, text, wai, wai-extra, wai-util
+     , xmlhtml
      }:
      mkDerivation {
        pname = "fn-extra";
-       version = "0.3.0.1";
-       sha256 = "01zjzykfh1gv14lx3xb8vmchk3qywlnarlfn2h2mbf69xns73fjs";
+       version = "0.3.0.2";
+       sha256 = "1wbhfaddqhp68gh7906w4lnnlz2zfqrfl71kf5w5pb3nhkbjx3g1";
        libraryHaskellDepends = [
          base blaze-builder bytestring digestive-functors directory either
-         fn heist http-types lens mtl resourcet text wai wai-extra wai-util
-         xmlhtml
+         fn heist http-types lens map-syntax mtl resourcet text wai
+         wai-extra wai-util xmlhtml
        ];
        homepage = "http://github.com/positiondev/fn#readme";
        description = "Extras for Fn, a functional web framework";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "formatting_6_2_5" = callPackage
+    ({ mkDerivation, base, clock, old-locale, scientific, text
+     , text-format, time
+     }:
+     mkDerivation {
+       pname = "formatting";
+       version = "6.2.5";
+       sha256 = "0k4z8b9x91m243kplx9gap1rqyvdszf3241aq7pkqwrybbzgm8yh";
+       libraryHaskellDepends = [
+         base clock old-locale scientific text text-format time
+       ];
+       description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "forml" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, cereal
      , containers, directory, file-embed, ghc-prim, GraphSCC, hslogger
···
        homepage = "https://github.com/haskell-foundation/foundation";
        description = "Alternative prelude with batteries and no dependencies";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "foundation_0_0_15" = callPackage
+    ({ mkDerivation, base, basement, criterion, ghc-prim }:
+     mkDerivation {
+       pname = "foundation";
+       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
+       sha256 = "05xl96lc7qi2sdkfc0s5rcrp84cbsyz0r0v3dffmgnv4n1f06cdh";
+       libraryHaskellDepends = [ base basement ghc-prim ];
+       testHaskellDepends = [ base basement ];
+       benchmarkHaskellDepends = [ base basement criterion ];
+       homepage = "https://github.com/haskell-foundation/foundation";
+       description = "Alternative prelude with batteries and no dependencies";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "foundation-edge" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ghcjs-base-stub_0_1_0_3" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, containers, deepseq
+     , ghc-prim, primitive, scientific, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "ghcjs-base-stub";
+       version = "0.1.0.3";
+       sha256 = "1b9hvqzqiaq5f8daahayjh1rw2izpfssq1bvj9iis2v3ihh8hl01";
+       libraryHaskellDepends = [
+         aeson attoparsec base containers deepseq ghc-prim primitive
+         scientific text transformers unordered-containers vector
+       ];
+       homepage = "https://github.com/louispan/javascript-stub#readme";
+       description = "Allow GHCJS projects to compile under GHC and develop using intero";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ghcjs-codemirror" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "ginger_0_7_0_0" = callPackage
+  "ginger_0_7_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, data-default, filepath
      , http-types, mtl, parsec, safe, scientific, tasty, tasty-hunit
      , tasty-quickcheck, text, time, transformers, unordered-containers
···
      }:
      mkDerivation {
        pname = "ginger";
-       version = "0.7.0.0";
-       sha256 = "0sxg3mc47f578srkcvgd5p52abxqmrbbydm3ngh16jpz998y8cm4";
+       version = "0.7.1.0";
+       sha256 = "0022qv80dkjns825361laaksccay56q6zmcrbhjrc4j25nys29n8";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "hapistrano";
-       version = "0.3.2.4";
-       sha256 = "08p1060m9wjxgxai5zxhzv40c0h9xsdvcbdg33b20hzyapzgq6kl";
-       revision = "1";
-       editedCabalFile = "0cvbn9a7jhq8nr1cwfij5bm030d662s5hn287q5w5wx5xmmzsn9m";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base filepath mtl path process time transformers
-       ];
-       executableHaskellDepends = [
-         aeson async base optparse-applicative path path-io stm yaml
-       ];
-       testHaskellDepends = [
-         base directory filepath hspec mtl path path-io process temporary
-       ];
-       homepage = "https://github.com/stackbuilders/hapistrano";
-       description = "A deployment library for Haskell applications";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "hapistrano_0_3_3_0" = callPackage
-    ({ mkDerivation, aeson, async, base, directory, filepath, hspec
-     , mtl, optparse-applicative, path, path-io, process, stm, temporary
-     , time, transformers, yaml
-     }:
-     mkDerivation {
-       pname = "hapistrano";
        version = "0.3.3.0";
        sha256 = "1skpygsnzl940703fxd103lxhyi4cjpp5il9kwjqfavsnbfi0c46";
        isLibrary = true;
···
        homepage = "https://github.com/stackbuilders/hapistrano";
        description = "A deployment library for Haskell applications";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "happindicator" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "harp";
-       version = "0.4.2";
-       sha256 = "1wwwy7375nbqshwg4i49ypav8a632awsr9xlmjp5q7iqs0v65akz";
-       libraryHaskellDepends = [ base ];
-       homepage = "https://github.com/seereason/harp";
-       description = "HaRP allows pattern-matching with regular expressions";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "harp_0_4_3" = callPackage
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "harp";
        version = "0.4.3";
        sha256 = "17d9isgwdvrmycbj3ddmmn0810kh4m8b8lmaz4qc8i51i5li8ja7";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/seereason/harp";
        description = "HaRP allows pattern-matching with regular expressions";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "harpy" = callPackage
···
     ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:
      mkDerivation {
        pname = "hashtables";
-       version = "1.2.1.1";
-       sha256 = "0lg9fb73w4awpcfr161xpz8y6z9lkfb5jii5ak34a1iijd55azr2";
+       version = "1.2.2.0";
+       sha256 = "0v7kfm04pynj66rkzyzvygxqv3xr3dj3h2aw0qj3h2zzjp33ybbf";
        libraryHaskellDepends = [
          base ghc-prim hashable primitive vector
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "haskell-import-graph_1_0_3" = callPackage
+    ({ mkDerivation, base, classy-prelude, ghc, graphviz, process, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "haskell-import-graph";
+       version = "1.0.3";
+       sha256 = "1fh3nn4hqcj6lc3m1zlxykxk2dbchh3cdz63k8zfpl7dr2d91132";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base classy-prelude ghc graphviz process text transformers
+       ];
+       executableHaskellDepends = [ base ];
+       homepage = "https://github.com/ncaq/haskell-import-graph#readme";
+       description = "create haskell import graph for graphviz";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "haskell-in-space" = callPackage
     ({ mkDerivation, base, HGL, random }:
      mkDerivation {
···
        pname = "haskell-src-exts-observe";
        version = "0.1.0";
        sha256 = "06vqd9ljmlx96xx6gyhfag2fsxwdzab0sy1gry2d24mbppbaa1x1";
+       revision = "1";
+       editedCabalFile = "1n4f4yylk09g95040g6pbcygzp95yadihv0sxr4sj87j0d4xa6fc";
        libraryHaskellDepends = [ base haskell-src-exts Hoed ];
        homepage = "https://github.com/pepeiborra/haskell-src-exts-observe";
        description = "Observable orphan instances for haskell-src-exts";
···
   "haskey" = callPackage
     ({ mkDerivation, async, base, binary, bytestring, containers
      , directory, exceptions, filepath, focus, haskey-btree, HUnit
-     , list-t, lz4, mtl, QuickCheck, semigroups, stm, stm-containers
-     , temporary, test-framework, test-framework-hunit
+     , list-t, lz4, mtl, QuickCheck, random, semigroups, stm
+     , stm-containers, temporary, test-framework, test-framework-hunit
      , test-framework-quickcheck2, text, transformers, unix, vector
      , xxhash-ffi
      }:
      mkDerivation {
        pname = "haskey";
-       version = "0.1.0.1";
-       sha256 = "08kd48a67m1p55i3d4fla6zdpaqzq49piswhqwj1jnks4sj18ran";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.2.0.0";
+       sha256 = "1c0snqs740gqwfzlpyhr8zggaplmba6mzj8cnl8r47sgn006q95i";
        libraryHaskellDepends = [
          base binary bytestring containers directory exceptions filepath
          focus haskey-btree list-t lz4 mtl semigroups stm stm-containers
          transformers unix xxhash-ffi
        ];
-       executableHaskellDepends = [
-         async base bytestring haskey-btree text
-       ];
        testHaskellDepends = [
-         base binary bytestring containers directory exceptions haskey-btree
-         HUnit mtl QuickCheck temporary test-framework test-framework-hunit
-         test-framework-quickcheck2 transformers vector
+         async base binary bytestring containers directory exceptions
+         haskey-btree HUnit mtl QuickCheck random temporary test-framework
+         test-framework-hunit test-framework-quickcheck2 text transformers
+         vector
        ];
        homepage = "https://github.com/haskell-haskey";
-       description = "A transcatoinal, ACID compliant, embeddable key-value store";
+       description = "A transactional, ACID compliant, embeddable key-value store";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "haskey-btree" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, data-ordlist
-     , focus, hashable, HUnit, list-t, mtl, QuickCheck, semigroups, stm
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , hashable, HUnit, mtl, QuickCheck, semigroups, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, text
      , transformers, vector
      }:
      mkDerivation {
        pname = "haskey-btree";
-       version = "0.1.0.0";
-       sha256 = "1kr9ihgvbxirbvs638y5sfmx41mj685jmcka87ics7w9ppcpkbsw";
+       version = "0.2.0.0";
+       sha256 = "00gp5fh64b26bqrchdrpdl8s46fdzglsqi07xf0cfrfcm867az23";
        libraryHaskellDepends = [
-         base binary bytestring containers focus hashable list-t mtl
-         semigroups stm transformers vector
+         base binary bytestring containers hashable mtl semigroups text
+         transformers vector
        ];
        testHaskellDepends = [
          base binary bytestring containers data-ordlist HUnit mtl QuickCheck
···
        ];
        homepage = "https://github.com/haskell-haskey/haskey-btree";
        description = "B+-tree implementation in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "haskey-mtl" = callPackage
+    ({ mkDerivation, base, binary, exceptions, haskey, haskey-btree
+     , lens, mtl, text, transformers
+     }:
+     mkDerivation {
+       pname = "haskey-mtl";
+       version = "0.2.0.0";
+       sha256 = "1n3j4avydrr2w0sa0zjsc2jvmr9fmyxz5s54y6zam40a2cg2wc2l";
+       libraryHaskellDepends = [
+         base exceptions haskey haskey-btree mtl transformers
+       ];
+       testHaskellDepends = [
+         base binary exceptions haskey haskey-btree lens mtl text
+         transformers
+       ];
+       homepage = "https://github.com/haskell-haskey";
+       description = "A monad transformer supporting Haskey transactions";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
 
   "haste-compiler" = callPackage
     ({ mkDerivation, array, base, bin-package-db, binary, blaze-builder
-     , bytestring, bzlib, Cabal, containers, data-binary-ieee754
-     , directory, either, filepath, ghc, ghc-paths, ghc-prim, ghc-simple
-     , HTTP, monads-tf, mtl, network, network-uri, process, random
-     , shellmate, system-fileio, tar, terminfo, transformers, unix
-     , utf8-string, websockets
+     , bytestring, bzlib, Cabal, containers, cryptonite, directory
+     , either, filepath, ghc, ghc-paths, ghc-prim, ghc-simple, HTTP, mtl
+     , network, network-uri, process, random, shellmate
+     , shellmate-extras, system-fileio, tar, terminfo, transformers
+     , unix, utf8-string
      }:
      mkDerivation {
        pname = "haste-compiler";
-       version = "0.5.5.1";
-       sha256 = "0p46yhd9hj7jnbkqwyms6b7kgjk8bdx1r6q1aspfq9001z71sgf9";
+       version = "0.6.0.0";
+       sha256 = "0n169k2kcpkcms701hg0h6kqjdq9jxpkm9zh72nj8530xmhckirs";
        configureFlags = [ "-fportable" ];
-       isLibrary = true;
+       isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base binary bytestring containers data-binary-ieee754 directory
-         filepath ghc ghc-paths ghc-prim monads-tf network network-uri
-         process random shellmate transformers utf8-string websockets
-       ];
        executableHaskellDepends = [
          array base bin-package-db binary blaze-builder bytestring bzlib
-         Cabal containers directory either filepath ghc ghc-paths ghc-prim
-         ghc-simple HTTP mtl network network-uri process random shellmate
-         system-fileio tar terminfo transformers unix utf8-string
+         Cabal containers cryptonite directory either filepath ghc ghc-paths
+         ghc-prim ghc-simple HTTP mtl network network-uri process random
+         shellmate shellmate-extras system-fileio tar terminfo transformers
+         unix utf8-string
        ];
        homepage = "http://haste-lang.org/";
        description = "Haskell To ECMAScript compiler";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
+       broken = true;
+     }) {bin-package-db = null;};
 
   "haste-gapi" = callPackage
     ({ mkDerivation, base, data-default, haste-compiler, transformers
···
     ({ mkDerivation, base, ghc-prim, integer-gmp, QuickCheck }:
      mkDerivation {
        pname = "hgmp";
-       version = "0.1.0.1";
-       sha256 = "0fkcp3l34si7v286dza3yhw2bjpx6vpwqnkqnp9lv18jwxak7xji";
-       revision = "1";
-       editedCabalFile = "0fmzm7m0z1jzpi7c1k8gk843d9jqljrkrb25yzs1kpbrg0ylpi3c";
+       version = "0.1.1";
+       sha256 = "1hisbcpz47x2lbqf8vzwis7qw7xhvx22lv7dcyhm9vsmsh5741dr";
        libraryHaskellDepends = [ base ghc-prim integer-gmp ];
        testHaskellDepends = [ base QuickCheck ];
        homepage = "https://code.mathr.co.uk/hgmp";
···
      }:
      mkDerivation {
        pname = "higher-leveldb";
-       version = "0.4.0.0";
-       sha256 = "116cpw9b0j82ik3242cqm82515dgixl4gj2s1qsmrn2w5yx1qrvd";
+       version = "0.4.0.1";
+       sha256 = "0ia3ssxr414jqvb4gzkaaa4a8d3rd7b395cfh0m2hz2jn6q7z651";
        libraryHaskellDepends = [
          base bytestring cereal data-default exceptions leveldb-haskell
          lifted-base monad-control mtl resourcet transformers
···
        pname = "hledger-api";
        version = "1.3.1";
        sha256 = "149v81qslajzkr13ba7j4qqliagaq88v3d3pw301haf4v3wz9sv4";
+       revision = "1";
+       editedCabalFile = "11rsyhfxjr87j9m3frnkq6mssj6isay29v61l280a1bd5r58zcr3";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "hsexif";
-       version = "0.6.1.2";
-       sha256 = "1i6h4gpjlrb9jadm52ygs9i1430lik2kljv86bpq6wz9zmq25d0s";
-       libraryHaskellDepends = [
-         base binary bytestring containers iconv text time
-       ];
-       testHaskellDepends = [
-         base binary bytestring containers hspec HUnit iconv text time
-       ];
-       homepage = "https://github.com/emmanueltouzery/hsexif";
-       description = "EXIF handling library in pure Haskell";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hsexif_0_6_1_3" = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers, hspec, HUnit
-     , iconv, text, time
-     }:
-     mkDerivation {
-       pname = "hsexif";
        version = "0.6.1.3";
        sha256 = "09d8679m6xgbka36rwjvhr7w355dn6arp7cxkdjgbzm7x9zhi5w8";
        libraryHaskellDepends = [
···
        homepage = "https://github.com/emmanueltouzery/hsexif";
        description = "EXIF handling library in pure Haskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hsfacter" = callPackage
···
      }:
      mkDerivation {
        pname = "hsini";
-       version = "0.5.1";
-       sha256 = "0kh96xnpsz1ryrn1f8sajxzjlvqwg8dbhpz6409qdxl57vppcjfq";
+       version = "0.5.1.1";
+       sha256 = "0yfmra5z9fjms5ighlmi6zd092c4kpwnmsrcp2p8gqwdz7k1in51";
        libraryHaskellDepends = [ base bytestring containers mtl parsec ];
        testHaskellDepends = [
          base bytestring containers HUnit mtl parsec QuickCheck tasty
···
      }) {inherit (pkgs) sqlite;};
 
   "hsqml" = callPackage
-    ({ mkDerivation, base, c2hs, containers, directory, filepath, qt5
-     , QuickCheck, tagged, text, transformers
+    ({ mkDerivation, base, c2hs, Cabal, containers, directory, filepath
+     , qt5, QuickCheck, tagged, template-haskell, text, transformers
      }:
      mkDerivation {
        pname = "hsqml";
-       version = "0.3.4.1";
-       sha256 = "0qzg72pdz05rnzz9m6qycbrxm9jnh3qfvsbs0lqn18b1fn4i4qbi";
+       version = "0.3.5.0";
+       sha256 = "1im7jm144vvyvrmkvblxwhbya55xsyxl8z10bs4anwxxjlf9sggc";
+       setupHaskellDepends = [ base Cabal filepath template-haskell ];
        libraryHaskellDepends = [
          base containers filepath tagged text transformers
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "http-client-openssl_0_2_1_0" = callPackage
+    ({ mkDerivation, base, HsOpenSSL, hspec, http-client, http-types
+     , network
+     }:
+     mkDerivation {
+       pname = "http-client-openssl";
+       version = "0.2.1.0";
+       sha256 = "1k80gljqah2dqiardnzdkgrf5p3wvzrxqgc0gqg2vnnjxxj8paf7";
+       libraryHaskellDepends = [ base HsOpenSSL http-client network ];
+       testHaskellDepends = [
+         base HsOpenSSL hspec http-client http-types
+       ];
+       doCheck = false;
+       homepage = "https://github.com/snoyberg/http-client";
+       description = "http-client backend using the OpenSSL library";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "http-client-request-modifiers" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, http-client
      , http-media, http-types, network, network-uri
···
      }:
      mkDerivation {
        pname = "http2-client";
-       version = "0.3.0.1";
-       sha256 = "0py51s0dfw7gz7kz8l6p344aas7ifa8hxx4ybrmbs0936mpmmqbh";
+       version = "0.3.0.2";
+       sha256 = "06iw2mi176rwjmmynhjhyl06f3jq832viyl7adbxgdyws36b64jl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "hw-prim-bits" = callPackage
-    ({ mkDerivation, base, criterion, vector }:
+    ({ mkDerivation, base, criterion, hedgehog, hspec, hw-hedgehog
+     , hw-hspec-hedgehog, QuickCheck, vector
+     }:
      mkDerivation {
        pname = "hw-prim-bits";
-       version = "0.1.0.1";
-       sha256 = "1fvmmp8l93j4wqcszk8lq4isl1xjyqnjzlaghs1wh9m6vywv5ncy";
+       version = "0.1.0.4";
+       sha256 = "1k2fqsa4msd156ar5cx57r0gj5ppwp1929yv56spv6n7xar1ich4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base hedgehog hspec hw-hedgehog hw-hspec-hedgehog QuickCheck
+       ];
        benchmarkHaskellDepends = [ base criterion vector ];
        homepage = "https://github.com/githubuser/hw-prim-bits#readme";
        description = "Primitive support for bit manipulation";
···
      }:
      mkDerivation {
        pname = "hworker-ses";
-       version = "0.1.1.0";
-       sha256 = "1iw16mm7iwjm50y4k878p885d6hjsbnvg3msvpq9zcw52mlk0lyx";
-       revision = "1";
-       editedCabalFile = "0vbzj885q7hrlsv2ds0izsjciishcfnh1m8nw98szzis4byhck48";
+       version = "0.1.1.1";
+       sha256 = "1rvf9fbmdf1xfpwlcxcrbjp0a3h5gmhb91897g6dp343wrq41amv";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-ses base hworker lens text
          time unordered-containers
        ];
-       homepage = "http://github.com/dbp/hworker-ses";
+       homepage = "http://github.com/position/hworker-ses";
        description = "Library for sending email with Amazon's SES and hworker";
        license = stdenv.lib.licenses.isc;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "ige" = callPackage
+    ({ mkDerivation, aeson, array, base, bytestring, cairo, conduit
+     , conduit-combinators, containers, directory, fgl, gtk, linear
+     , megaparsec, microlens-platform, mtl, mwc-random, protolude, stm
+     , stm-chans, stm-conduit, text, transformers, wl-pprint-text
+     }:
+     mkDerivation {
+       pname = "ige";
+       version = "0.1.0.0";
+       sha256 = "14cbmb69h8fxabcqi2ncs48xsnflcq5g8gl8s6hvc4x80wb79f5s";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson array base bytestring cairo conduit conduit-combinators
+         containers directory fgl gtk linear megaparsec microlens-platform
+         mtl mwc-random protolude stm stm-chans stm-conduit text
+         transformers wl-pprint-text
+       ];
+       homepage = "https://github.com/olynch/ige";
+       description = "An keyboard-driven interactive graph editor";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "ige-mac-integration" = callPackage
     ({ mkDerivation, array, base, containers, glib, gtk
      , gtk2hs-buildtools, haskell98, ige-mac-integration, mtl
···
      }:
      mkDerivation {
        pname = "imap";
-       version = "0.3.0.2";
-       sha256 = "1mcfmzqiwiasbaakz8w1cq4zj04jh61sppn1c88cvvkmi28qpwqa";
+       version = "0.3.0.4";
+       sha256 = "021ya9pkf8q1nk805ck5hhm06q9lnp22d78hr0nz112xbxm5rqkw";
        libraryHaskellDepends = [
          attoparsec base bytestring connection containers derive either
          exceptions hslogger list-t network pipes random rolling-queue stm
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "imm_1_2_1_0" = callPackage
+    ({ mkDerivation, aeson, ansi-wl-pprint, atom-conduit, base
+     , blaze-html, blaze-markup, bytestring, case-insensitive
+     , chunked-data, comonad, conduit, conduit-combinators, connection
+     , containers, directory, dyre, fast-logger, filepath, free
+     , hashable, HaskellNet, HaskellNet-SSL, http-client
+     , http-client-tls, http-types, microlens, mime-mail
+     , mono-traversable, monoid-subclasses, network, opml-conduit
+     , optparse-applicative, rainbow, rainbox, rss-conduit
+     , safe-exceptions, tagged, text, time, timerep, tls, transformers
+     , uri-bytestring, xml, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "imm";
+       version = "1.2.1.0";
+       sha256 = "0m869l6z50zf57hfy28ad70id3phfqjwkna64m59yycvcqlkj064";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-wl-pprint atom-conduit base blaze-html blaze-markup
+         bytestring case-insensitive chunked-data comonad conduit
+         conduit-combinators connection containers directory dyre
+         fast-logger filepath free hashable HaskellNet HaskellNet-SSL
+         http-client http-client-tls http-types microlens mime-mail
+         mono-traversable monoid-subclasses network opml-conduit
+         optparse-applicative rainbow rainbox rss-conduit safe-exceptions
+         tagged text time timerep tls transformers uri-bytestring xml
+         xml-conduit xml-types
+       ];
+       executableHaskellDepends = [ base free ];
+       homepage = "https://github.com/k0ral/imm";
+       description = "Execute arbitrary actions for each unread element of RSS/Atom feeds";
+       license = stdenv.lib.licenses.publicDomain;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "immortal" = callPackage
     ({ mkDerivation, base, lifted-base, monad-control, stm, tasty
      , tasty-hunit, transformers, transformers-base
···
        homepage = "https://github.com/feuerbach/immortal";
        description = "Spawn threads that never die (unless told to do so)";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "immortal_0_2_2_1" = callPackage
+    ({ mkDerivation, base, lifted-base, monad-control, stm, tasty
+     , tasty-hunit, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "immortal";
+       version = "0.2.2.1";
+       sha256 = "13lddk62byx8w41k80d24q31mmijacnqqz64zrrkls9si2ia2jpd";
+       libraryHaskellDepends = [
+         base lifted-base monad-control stm transformers-base
+       ];
+       testHaskellDepends = [
+         base lifted-base stm tasty tasty-hunit transformers
+       ];
+       homepage = "https://github.com/feuerbach/immortal";
+       description = "Spawn threads that never die (unless told to do so)";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "imparse" = callPackage
···
      }:
      mkDerivation {
        pname = "intero";
-       version = "0.1.21";
-       sha256 = "1fr855gbz0ypxa73d5f74wp2sr3q67wdv6g4bpckj682c1x7dr73";
+       version = "0.1.23";
+       sha256 = "17247yscz7z1axhml2f5m4i4sxgyydpvcidk75ng350dk6z1wd4x";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          ghc-paths ghci haskeline process syb time transformers unix
        ];
        testHaskellDepends = [
-         base directory hspec process regex-compat temporary transformers
+         base directory filepath hspec process regex-compat temporary
+         transformers
        ];
        homepage = "https://github.com/commercialhaskell/intero";
        description = "Complete interactive development program for Haskell";
···
      }:
      mkDerivation {
        pname = "io-streams-haproxy";
-       version = "1.0.0.1";
-       sha256 = "0zwjdsg1pcxzd8s0d308q4jhx0pfrk2aq8q039gs8k9y8h9cbh64";
-       revision = "2";
-       editedCabalFile = "1zm580jcncmh667k51k47xwwhd171r3f0h00d25hi6isq812ia40";
-       libraryHaskellDepends = [
-         attoparsec base bytestring io-streams network transformers
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring HUnit io-streams network test-framework
-         test-framework-hunit transformers
-       ];
-       homepage = "http://snapframework.com/";
-       description = "HAProxy protocol 1.5 support for io-streams";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "io-streams-haproxy_1_0_0_2" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, HUnit, io-streams
-     , network, test-framework, test-framework-hunit, transformers
-     }:
-     mkDerivation {
-       pname = "io-streams-haproxy";
        version = "1.0.0.2";
        sha256 = "11nh9q158mgnvvb23s5ffg87lkhl5smk039yl43jghxmb214z0bp";
        libraryHaskellDepends = [
···
        homepage = "http://snapframework.com/";
        description = "HAProxy protocol 1.5 support for io-streams";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "io-streams-http" = callPackage
···
        pname = "ip";
        version = "0.9.2";
        sha256 = "0r15mdknz1j85hws9bqfil6l39q88pbbjz0kbky9kl7y675hkzdj";
+       revision = "2";
+       editedCabalFile = "1l6gj2678rbaryby9gzsqvyjyknyfc2r6xj27kbcb02cz4igga7m";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring hashable primitive text vector
        ];
···
      }:
      mkDerivation {
        pname = "jammittools";
-       version = "0.5.3";
-       sha256 = "1lb4ayalkplfd9gpsl4rhi6svj4y3yr5v25br4g19cjh5iiv4sif";
+       version = "0.5.3.2";
+       sha256 = "0wym2mz4bvcmwg10v90dx14n41qhmn58bgccnxy7li9ahqwvj0f0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "json-stream";
-       version = "0.4.1.4";
-       sha256 = "0mg1pv1gp2zd7zpl2n5k8kv73br8ji91mwszfhn1bw119m29v1rs";
-       libraryHaskellDepends = [
-         aeson base bytestring scientific text unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring directory doctest hspec QuickCheck
-         quickcheck-unicode scientific text unordered-containers vector
-       ];
-       homepage = "https://github.com/ondrap/json-stream";
-       description = "Incremental applicative JSON parser";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "json-stream_0_4_1_5" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, directory, doctest, hspec
-     , QuickCheck, quickcheck-unicode, scientific, text
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "json-stream";
        version = "0.4.1.5";
        sha256 = "0h5g76grhi60idvmxdhydpz5f3198bydwywfyv9pghlmbrzjnkih";
        libraryHaskellDepends = [
···
        homepage = "https://github.com/ondrap/json-stream";
        description = "Incremental applicative JSON parser";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "json-togo" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "language-c_0_7_0" = callPackage
+    ({ mkDerivation, alex, array, base, bytestring, containers
+     , directory, filepath, happy, pretty, process, syb
+     }:
+     mkDerivation {
+       pname = "language-c";
+       version = "0.7.0";
+       sha256 = "1j4slggwj5g0rnrdxafgn2savv14sl2nqk7lfy3qj73vmpn1d86d";
+       libraryHaskellDepends = [
+         array base bytestring containers directory filepath pretty process
+         syb
+       ];
+       libraryToolDepends = [ alex happy ];
+       testHaskellDepends = [ base directory filepath process ];
+       homepage = "http://visq.github.io/language-c/";
+       description = "Analysis and generation of C code";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "language-c-comments" = callPackage
     ({ mkDerivation, alex, array, base, language-c }:
      mkDerivation {
···
      }) {};
 
   "language-elm" = callPackage
-    ({ mkDerivation, base, HUnit, MissingH, pretty }:
+    ({ mkDerivation, base, hspec, MissingH, mtl, pretty, protolude }:
      mkDerivation {
        pname = "language-elm";
-       version = "0.0.10.1";
-       sha256 = "1kp2mwl1hngpvl2hfzlf7dghcvcr407f7qc86b3zz2vgxfac0n07";
-       libraryHaskellDepends = [ base MissingH pretty ];
-       testHaskellDepends = [ base HUnit pretty ];
+       version = "0.1.0.3";
+       sha256 = "07pyj3ibrpa3mrqn6skjpk0w44hi32mm0c08yqpnql3qv2xy4wcz";
+       libraryHaskellDepends = [ base MissingH mtl pretty protolude ];
+       testHaskellDepends = [ base hspec mtl pretty protolude ];
        homepage = "https://github.com/eliaslfox/language-elm#readme";
        description = "Generate elm code";
        license = stdenv.lib.licenses.bsd3;
···
      , network-ip, parsers, pathtype, protolude, QuickCheck, random
      , semigroups, stm, stm-chans, stm-containers, temporary
      , test-framework, test-framework-quickcheck2, test-framework-th
-     , text, text-icu, text-icu-normalized, text-printer, time
-     , transformers, transformers-base, zippers
+     , text, text-printer, time, transformers, transformers-base
+     , zippers
      }:
      mkDerivation {
        pname = "liblawless";
-       version = "0.24.0";
-       sha256 = "1dqz2d8zgwb8i176fhga5637y8mfxiq0vq1ws0lsy9ijlpyiikmp";
+       version = "0.25.2";
+       sha256 = "0s1qahk7yabggjv4zkqxiy4yygzbq8zwbh5nvh46zm0r09q802s1";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base base-unicode-symbols binary boomerang bytestring
···
          contravariant data-textual dns exceptions hjsonschema lens
          lifted-async lifted-base machines managed monad-control mtl network
          network-ip parsers pathtype protolude QuickCheck random semigroups
-         stm stm-chans stm-containers temporary text text-icu
-         text-icu-normalized text-printer time transformers
-         transformers-base zippers
+         stm stm-chans stm-containers temporary text text-printer time
+         transformers transformers-base zippers
        ];
        testHaskellDepends = [
          aeson base binary bytestring exceptions filepath QuickCheck
···
      }:
      mkDerivation {
        sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       version = "1.2.0";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       libraryHaskellDepends = [
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       ];
-       benchmarkHaskellDepends = [
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       ];
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-     }:
-     mkDerivation {
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
        version = "1.2.1";
        sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
        libraryHaskellDepends = [
···
        sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
        sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
        sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
···
      }:
      mkDerivation {
        pname = "mackerel-client";
-       version = "0.0.4";
-       sha256 = "1l14jw7awi6vrnlw4g5x4fa4a26j9b7k3mgvr651lxrxz5vc6qrg";
+       version = "0.0.5";
+       sha256 = "17ppg6nzm8q6fz1y630vzda1rgc8fkhxhjabmvis79h2k3q994s5";
        libraryHaskellDepends = [
          aeson base bytestring data-default directory filepath htoml
          http-client http-client-tls http-types parsec split text
···
      }:
      mkDerivation {
        pname = "matterhorn";
-       version = "40000.0.2";
-       sha256 = "1lsxadkhvk8bylpc0sh1pmkldv8m17fpi96zkihdpchpwhw1i8jn";
+       version = "40000.1.0";
+       sha256 = "0zqbaqdvcq45sgkiii7w2y8b3m8fv8zqj1y85rdkycjfy7h8lkjd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "mattermost-api";
-       version = "40000.0.1";
-       sha256 = "0phykn8h08yprmpds92cp6snraxg66hbh553b8da5v47dn06y8mv";
+       version = "40000.1.0";
+       sha256 = "076b5l2hqjbspdm6j321inf141jsr07c9dsckqvq02wxjaz8ws80";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "mattermost-api-qc";
-       version = "40000.0.1";
-       sha256 = "0444m1349gpyffpjlvf9faz4sia5kfsry9q174n6b60ch85w1ilg";
+       version = "40000.1.0";
+       sha256 = "11yxkq19f0iczh69hglv7plv466wfzdskkygp9vh6a7bjwwr8hzk";
        libraryHaskellDepends = [
          base containers mattermost-api QuickCheck text time
        ];
···
      }:
      mkDerivation {
        pname = "memory";
-       version = "0.14.6";
-       sha256 = "0q61zxdlgcw7wg244hb3c11qm5agrmnmln0h61sz2mj72xqc1pn7";
+       version = "0.14.7";
+       sha256 = "0snm3kphsrjixg1hpas1rfxaq7id7i5siprqf1p9lz7x1l4vznyj";
        libraryHaskellDepends = [
          base bytestring deepseq foundation ghc-prim
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "memory_0_14_7" = callPackage
+  "memory_0_14_8" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, foundation, ghc-prim
      , tasty, tasty-hunit, tasty-quickcheck
      }:
      mkDerivation {
        pname = "memory";
-       version = "0.14.7";
-       sha256 = "0snm3kphsrjixg1hpas1rfxaq7id7i5siprqf1p9lz7x1l4vznyj";
+       version = "0.14.8";
+       sha256 = "093jin2yckha0wccswwxqaak2di7fz2v2rid03h1q0pjm4q9vmyk";
        libraryHaskellDepends = [
          base bytestring deepseq foundation ghc-prim
        ];
···
      }:
      mkDerivation {
        pname = "monad-logger";
-       version = "0.3.25";
-       sha256 = "1ai55mk3n72qcdh7b6n4sv8bh5wqf2nznpzldimrwxg3m2b6g88g";
-       libraryHaskellDepends = [
-         base blaze-builder bytestring conduit conduit-extra exceptions
-         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
-         stm-chans template-haskell text transformers transformers-base
-         transformers-compat
-       ];
-       homepage = "https://github.com/kazu-yamamoto/logger";
-       description = "A class of monads which can log messages";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "monad-logger_0_3_25_1" = callPackage
-    ({ mkDerivation, base, blaze-builder, bytestring, conduit
-     , conduit-extra, exceptions, fast-logger, lifted-base
-     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
-     , template-haskell, text, transformers, transformers-base
-     , transformers-compat
-     }:
-     mkDerivation {
-       pname = "monad-logger";
        version = "0.3.25.1";
        sha256 = "0yv4fsi566zrn30j2g5l901lyqgmflhvzy4hji7ikcbh5d45m920";
        libraryHaskellDepends = [
···
        homepage = "https://github.com/kazu-yamamoto/logger";
        description = "A class of monads which can log messages";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "monad-logger-json" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "mysql-simple_0_4_2_0" = callPackage
+    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
+     , blaze-textual, bytestring, hspec, mysql, old-locale, pcre-light
+     , text, time
+     }:
+     mkDerivation {
+       pname = "mysql-simple";
+       version = "0.4.2.0";
+       sha256 = "0050z2hhdg9zmqczghjc609aaaqjzrxrfly68d4m5046wz4lnkx8";
+       libraryHaskellDepends = [
+         attoparsec base base16-bytestring blaze-builder blaze-textual
+         bytestring mysql old-locale pcre-light text time
+       ];
+       testHaskellDepends = [ base hspec ];
+       homepage = "https://github.com/paul-rouse/mysql-simple";
+       description = "A mid-level MySQL client library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mysql-simple-quasi" = callPackage
     ({ mkDerivation, base, haskell-src-meta, mysql-simple
      , template-haskell
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "numhask-array" = callPackage
+    ({ mkDerivation, adjunctions, base, distributive, doctest
+     , ghc-typelits-natnormalise, numhask, protolude, singletons
+     , typelits-witnesses, vector
+     }:
+     mkDerivation {
+       pname = "numhask-array";
+       version = "0.0.1";
+       sha256 = "0drxxbzzflgc7z5pjwy6pkrxkzckkj7xqp2icsn8762nwc9iqsp4";
+       libraryHaskellDepends = [
+         adjunctions base distributive ghc-typelits-natnormalise numhask
+         protolude singletons typelits-witnesses vector
+       ];
+       testHaskellDepends = [ base doctest numhask ];
+       homepage = "https://github.com/tonyday567/numhask-array";
+       description = "See readme.md";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "numhask-range" = callPackage
     ({ mkDerivation, base, containers, foldl, formatting, lens, linear
      , numhask, protolude, QuickCheck, tasty, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "opaleye-trans";
-       version = "0.3.5";
-       sha256 = "1za8xhi20905x8zgnbr821fkdx5w32smmxmz72vx6jga44vxsq4k";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base mtl opaleye postgresql-simple product-profunctors transformers
-         transformers-base
-       ];
-       executableHaskellDepends = [
-         base opaleye postgresql-simple product-profunctors
-       ];
-       homepage = "https://github.com/WraithM/opaleye-trans";
-       description = "A monad transformer for Opaleye";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "opaleye-trans_0_3_6" = callPackage
-    ({ mkDerivation, base, mtl, opaleye, postgresql-simple
-     , product-profunctors, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "opaleye-trans";
        version = "0.3.6";
        sha256 = "03pg31rxnfw22zqpk3l098z32gl2r4dk9pma8z4f8ssp7crz7z8p";
        isLibrary = true;
···
        homepage = "https://github.com/WraithM/opaleye-trans";
        description = "A monad transformer for Opaleye";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "open-browser" = callPackage
···
      }:
      mkDerivation {
        pname = "openssl-streams";
-       version = "1.2.1.1";
-       sha256 = "1annfc0nmkj0hl62x4w39phai54qd8ibislwhbw66k0df3bc8kyz";
-       libraryHaskellDepends = [
-         base bytestring HsOpenSSL io-streams network
-       ];
-       testHaskellDepends = [
-         base bytestring HsOpenSSL HUnit io-streams network test-framework
-         test-framework-hunit
-       ];
-       description = "OpenSSL network support for io-streams";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "openssl-streams_1_2_1_3" = callPackage
-    ({ mkDerivation, base, bytestring, HsOpenSSL, HUnit, io-streams
-     , network, test-framework, test-framework-hunit
-     }:
-     mkDerivation {
-       pname = "openssl-streams";
        version = "1.2.1.3";
        sha256 = "0pwghr7ygv59k572xsj1j97rilkbjz66qaiyj0ra2wfg6pl70wfw";
        libraryHaskellDepends = [
···
        ];
        description = "OpenSSL network support for io-streams";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "opentheory" = callPackage
···
   "pandoc" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base
      , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
-     , cmark, containers, criterion, data-default, deepseq, Diff
+     , Cabal, cmark, containers, criterion, data-default, deepseq, Diff
      , directory, doctemplates, executable-path, extensible-exceptions
      , filemanip, filepath, ghc-prim, haddock-library, hslua, HTTP
      , http-client, http-client-tls, http-types, HUnit, JuicyPixels, mtl
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "1.19.2.1";
-       sha256 = "00bq5h70byfs1fnszkggwws33hp7dpr7lzs0lfdvp5dzfwyjys88";
-       revision = "5";
-       editedCabalFile = "0rp81lr8ys7bcnjx5hm9fn704zhph313whjc51ns8sbpzlpwvx1f";
+       version = "1.19.2.4";
+       sha256 = "0mim429mpakrcnm50csxyqk3ljcx2l26r5grk6w9isnggwgqrq5v";
        configureFlags = [ "-fhttps" "-f-trypandoc" ];
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          aeson array base base64-bytestring binary blaze-html blaze-markup
          bytestring cmark containers data-default deepseq directory
···
        ];
        executableHaskellDepends = [
          aeson base bytestring containers directory extensible-exceptions
-         filepath HTTP network network-uri pandoc-types skylighting text
-         unix yaml
+         filepath HTTP network network-uri pandoc-types skylighting texmath
+         text unix yaml
        ];
        testHaskellDepends = [
          ansi-terminal base bytestring containers Diff directory
···
     ({ mkDerivation, base, exceptions, path }:
      mkDerivation {
        pname = "path-extra";
-       version = "0.0.3";
-       sha256 = "0ncbcc16b1xg5hc8mm3czabn7crz7d41jv1k5lbcvbisgarkn12m";
-       libraryHaskellDepends = [ base exceptions path ];
-       description = "Chris Done's path library, enriched with URL-related goodies";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "path-extra_0_0_5" = callPackage
-    ({ mkDerivation, base, exceptions, path }:
-     mkDerivation {
-       pname = "path-extra";
        version = "0.0.5";
        sha256 = "0ks2h5w4zmgimhcxj6vxv3xrrkpjlfc21pdd8w4gbxci1gsd2jyh";
        libraryHaskellDepends = [ base exceptions path ];
        description = "Chris Done's path library, enriched with URL-related goodies";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "path-io" = callPackage
···
        description = "A one file compiler for PCF";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "pcf-font" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, vector }:
+     mkDerivation {
+       pname = "pcf-font";
+       version = "0.1.0.0";
+       sha256 = "14ix40vsvax0wklb3bffg99rvhfq1w6w937r4n73kknhjszdhf6g";
+       libraryHaskellDepends = [
+         base binary bytestring containers vector
+       ];
+       homepage = "https://github.com/michael-swan/pcf-font";
+       description = "PCF font parsing and rendering library";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "pcg-random" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "perf_0_2_0" = callPackage
+    ({ mkDerivation, base, containers, doctest, foldl, formatting
+     , numhask, optparse-generic, protolude, rdtsc, tdigest, text, time
+     , vector
+     }:
+     mkDerivation {
+       pname = "perf";
+       version = "0.2.0";
+       sha256 = "1db6acsszdwdlkz2cp5r0wwrmgam4jl6n91d02b3zdn0jfazp7nn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers foldl numhask protolude rdtsc tdigest time
+       ];
+       executableHaskellDepends = [
+         base containers formatting numhask optparse-generic protolude text
+         vector
+       ];
+       testHaskellDepends = [ base doctest protolude ];
+       homepage = "https://github.com/tonyday567/perf";
+       description = "low-level performance statistics";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "perfecthash" = callPackage
     ({ mkDerivation, array, base, bytestring, cmph, containers
      , criterion, deepseq, hspec, QuickCheck, random, time
···
      }:
      mkDerivation {
        pname = "phoityne-vscode";
-       version = "0.0.15.0";
-       sha256 = "1r4wbf6x19gzmz88f770si5mvrya9adgilgs76kc36ynlsz5jyrp";
+       version = "0.0.16.0";
+       sha256 = "02ma54ffjijazyfnag2z9gq2l86yiqzvlrdc1y3mw8b8yjgzvidd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, async, base, contravariant, pipes, stm, void }:
      mkDerivation {
        pname = "pipes-concurrency";
-       version = "2.0.7";
-       sha256 = "0nbmyhnkcw0frdbjzyhgal3zadzf6hsrqj5l619lj6rnjq07z90l";
-       libraryHaskellDepends = [ base contravariant pipes stm void ];
-       testHaskellDepends = [ async base pipes stm ];
-       description = "Concurrency for the pipes ecosystem";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "pipes-concurrency_2_0_8" = callPackage
-    ({ mkDerivation, async, base, contravariant, pipes, stm, void }:
-     mkDerivation {
-       pname = "pipes-concurrency";
        version = "2.0.8";
        sha256 = "0ak6vnjl12q4615waifbpdxbm96yz5yzqzwjj1zwvvb2jfk5snwz";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ async base pipes stm ];
        description = "Concurrency for the pipes ecosystem";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "pipes-conduit" = callPackage
···
      }:
      mkDerivation {
        pname = "pipes-group";
-       version = "1.0.7";
-       sha256 = "0p0bfc91ij481bybk99jpfczkkcz3v7mcr0y03kvhxddf575jhw6";
-       libraryHaskellDepends = [
-         base free pipes pipes-parse transformers
-       ];
-       testHaskellDepends = [ base doctest lens-family-core ];
-       description = "Group streams into substreams";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "pipes-group_1_0_8" = callPackage
-    ({ mkDerivation, base, doctest, free, lens-family-core, pipes
-     , pipes-parse, transformers
-     }:
-     mkDerivation {
-       pname = "pipes-group";
        version = "1.0.8";
        sha256 = "0zcmhq46972zxjj5nmr46fdvvwb3q0i42q9m70i758a3iwkmnr3a";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base doctest lens-family-core ];
        description = "Group streams into substreams";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "pipes-http" = callPackage
···
        description = "Stateful IO streams based on pipes";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "pipes-kafka" = callPackage
+    ({ mkDerivation, base, bytestring, exceptions, hw-kafka-client
+     , monad-logger, pipes, pipes-safe, text, transformers
+     , transformers-base
+     }:
+     mkDerivation {
+       pname = "pipes-kafka";
+       version = "0.2.0.0";
+       sha256 = "1ca0pdig35waqr499i4m92w34sywc8nc0gdfszqjcmpsjmba93hv";
+       libraryHaskellDepends = [
+         base bytestring exceptions hw-kafka-client monad-logger pipes
+         pipes-safe text transformers transformers-base
+       ];
+       homepage = "https://github.com/boothead/pipes-kafka";
+       description = "Kafka in the Pipes ecosystem";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "pipes-key-value-csv" = callPackage
···
      }:
      mkDerivation {
        pname = "plot";
-       version = "0.2.3.7";
-       sha256 = "192pjxpdnfrzjb6n8swkcd5f5nv3vvj7kc110v002akcgkii31li";
-       libraryHaskellDepends = [
-         array base cairo colour hmatrix mtl pango transformers
-       ];
-       homepage = "http://github.com/amcphail/plot";
-       description = "A plotting library, exportable as eps/pdf/svg/png or renderable with gtk";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "plot_0_2_3_8" = callPackage
-    ({ mkDerivation, array, base, cairo, colour, hmatrix, mtl, pango
-     , transformers
-     }:
-     mkDerivation {
-       pname = "plot";
        version = "0.2.3.8";
        sha256 = "1in77bvn77wyg9b8vixxd2m5vfnz90in89j3f31v9zbz7fxh2l4m";
        libraryHaskellDepends = [
···
        homepage = "http://github.com/amcphail/plot";
        description = "A plotting library, exportable as eps/pdf/svg/png or renderable with gtk";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "plot-gtk" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "primesieve" = callPackage
+    ({ mkDerivation, base, foundation, primesieve }:
+     mkDerivation {
+       pname = "primesieve";
+       version = "0.1.0.1";
+       sha256 = "17fmja87sr6lpq6qjmn31zx6y1cxhc65amfza22w07480wk7lhp2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base foundation ];
+       executableHaskellDepends = [ base foundation ];
+       executableSystemDepends = [ primesieve ];
+       homepage = "https://github.com/sighingnow/computations/tree/master/primesieve#readme";
+       description = "FFI bindings for the primesieve library";
+       license = stdenv.lib.licenses.mit;
+     }) {primesieve = null;};
+
   "primitive_0_5_1_0" = callPackage
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "push-notify-apn";
-       version = "0.1.0.2";
-       sha256 = "0cziiry6zlaaap6njrqbhpd20ycp97ychk2cy3xkf5c36lzl7kv3";
+       version = "0.1.0.4";
+       sha256 = "1mrlr7x6njb1n21185wn81fybyg89c4jyph8sabf20gg7qng893s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "recursion-schemes-ext";
-       version = "0.2.0.0";
-       sha256 = "0h74109rwybpg6wardmrzh3163868mi025a8wq5dbpcx284zv1w1";
+       version = "0.2.0.1";
+       sha256 = "0lnqc4w4lpavs4d6jzdszl35g4qjksgfrqfqsyhv4a8w3w79xnz9";
        libraryHaskellDepends = [
          base composition-prelude deepseq recursion-schemes template-haskell
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "restless-git" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HSH, tasty
+     , tasty-hunit, temporary, text, time
+     }:
+     mkDerivation {
+       pname = "restless-git";
+       version = "0.5.0";
+       sha256 = "0rz3aqrlsyld6slxq9lbpf3ydngpkka6ksr4qbl9qq6f42hb0pwi";
+       libraryHaskellDepends = [
+         base bytestring containers HSH text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers tasty tasty-hunit temporary text
+       ];
+       homepage = "https://github.com/lessrest/restless-git";
+       description = "Easy Git repository serialization";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "restricted-workers" = callPackage
     ({ mkDerivation, async, base, bytestring, cereal, data-default
      , directory, either, filepath, monad-control, mtl, network, selinux
···
     ({ mkDerivation, base, mtl, transformers }:
      mkDerivation {
        pname = "safe-access";
-       version = "0.3.2.1";
-       sha256 = "1xfivmd1ski2lbjkp5mxd5qjscjjw1bzxwd5s9hwvqlqsgdhya9b";
+       version = "0.3.3.0";
+       sha256 = "0j3k6nlp3qch9kxv2zh5lfx1cfqy4w0xc7pbivqkn38drdjd920z";
        libraryHaskellDepends = [ base mtl transformers ];
        homepage = "http://darcs.redspline.com/safe-access";
        description = "A simple environment to control access to data";
···
      }:
      mkDerivation {
        pname = "safeio";
-       version = "0.0.3.0";
-       sha256 = "0rknn8rlxyj32a0vrx0wjfma9w0zhs3vg1jyksn71drxch7jvwqs";
-       libraryHaskellDepends = [
-         base bytestring conduit conduit-combinators directory filepath
-         resourcet unix
-       ];
-       testHaskellDepends = [
-         base bytestring conduit conduit-combinators directory filepath
-         HUnit resourcet test-framework test-framework-hunit
-         test-framework-th unix
-       ];
-       description = "Write output to disk atomically";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "safeio_0_0_4_0" = callPackage
-    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
-     , directory, filepath, HUnit, resourcet, test-framework
-     , test-framework-hunit, test-framework-th, unix
-     }:
-     mkDerivation {
-       pname = "safeio";
        version = "0.0.4.0";
        sha256 = "1abbg6nxpz4va54r2005swlyw8k4y61xjhcz4s3rshc09cmrrn6l";
        libraryHaskellDepends = [
···
        ];
        description = "Write output to disk atomically";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "safepath" = callPackage
···
      }:
      mkDerivation {
        pname = "salve";
-       version = "0.0.6";
-       sha256 = "1269qhsck9mx5adhzbvyznbfmi2lwrafmf8b750y31cpiziw4mfb";
+       version = "0.0.7";
+       sha256 = "13qrxn5h0pind32wc7sw9i026g8lw91k71i8prrdzdzc656nhiq5";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest microlens ];
        benchmarkHaskellDepends = [
···
        pname = "scalendar";
        version = "1.1.0";
        sha256 = "077v0k745z1hs8k8yb5s6ln1ing8b5fllp7gw2kcrlrw108ijvwb";
+       revision = "5";
+       editedCabalFile = "02p4iy6vypz6q0zh5wmy3lp1s9zrcvqn9xx8vczl8000wa0asn7p";
        libraryHaskellDepends = [ base containers text time ];
        testHaskellDepends = [
          base containers hspec QuickCheck text time
        ];
-       homepage = "https://github.com/stackbuilders/scalendar";
+       homepage = "https://www.researchgate.net/publication/311582722_Method_of_Managing_Resources_in_a_Telecommunication_Network_or_a_Computing_System";
        description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations";
        license = stdenv.lib.licenses.mit;
      }) {};
···
      }) {};
 
   "scotty-rest" = callPackage
-    ({ mkDerivation, base, base-prelude, bytestring, convertible
-     , data-default-class, hspec, hspec-wai, http-date, http-media
-     , http-types, mtl, QuickCheck, scotty, string-conversions, text
-     , time, transformers, wai, wai-extra
+    ({ mkDerivation, aeson, base, base-prelude, bytestring, convertible
+     , hspec, hspec-wai, http-date, http-media, http-types, mtl
+     , QuickCheck, scotty, sqlite-simple, string-conversions, text, time
+     , transformers, wai, wai-extra
      }:
      mkDerivation {
        pname = "scotty-rest";
-       version = "0.1.0.0";
-       sha256 = "1z0x7fvs1933cnxj8kr91xqvf5zqil3d0zq2adq2wlf1a2zwa4j0";
+       version = "0.2.0.0";
+       sha256 = "1pj9xwbppax4s5rhm3kvmmxs41qslm82xz98npj3nb3zb0gbykzc";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-         base base-prelude bytestring convertible data-default-class
-         http-date http-media http-types mtl scotty string-conversions text
-         time transformers wai wai-extra
+         base base-prelude bytestring convertible http-date http-media
+         http-types mtl scotty string-conversions text time transformers wai
+         wai-extra
+       ];
+       executableHaskellDepends = [
+         aeson base mtl scotty sqlite-simple text wai-extra
        ];
        testHaskellDepends = [
          base bytestring hspec hspec-wai mtl QuickCheck scotty
···
      }:
      mkDerivation {
        pname = "selda";
-       version = "0.1.10.1";
-       sha256 = "1yx8gxi9bha95ss2i1hvbv8vlywxgi3a6rxjig44jz5w2s0zlp5h";
+       version = "0.1.11.0";
+       sha256 = "1jdy7rf98ycqvrw73f70xnyidq5gjhzbavd2h64ib6v0mpcskdhy";
        libraryHaskellDepends = [
          base bytestring exceptions hashable mtl psqueues text time
          unordered-containers
···
      }:
      mkDerivation {
        pname = "selda-postgresql";
-       version = "0.1.6.0";
-       sha256 = "0zf77mavhxn64mag6cgf6xch54qknl1yhack5nylf5xlwhpmrgsx";
+       version = "0.1.7.0";
+       sha256 = "0smx2hvpdxjcw58zchwmzcqz4xr5m1idv5y5rrj20df190r4l3l2";
        libraryHaskellDepends = [
          base bytestring exceptions postgresql-libpq selda text
        ];
···
        pname = "semigroupoids";
        version = "5.2.1";
        sha256 = "006jys6kvckkmbnhf4jc51sh64hamkz464mr8ciiakybrfvixr3r";
-       revision = "1";
-       editedCabalFile = "1lb59k2hdz9kbhmpw7bzc0n9pb5x3b9ysglp69dn4yf5xxjw03wx";
+       revision = "2";
+       editedCabalFile = "049j2jl6f5mxqnavi1aadx37j4bk5xksvkxsl43hp4rg7n53p11z";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base base-orphans bifunctors comonad containers contravariant
···
      }) {};
 
   "separated" = callPackage
-    ({ mkDerivation, base, bifunctors, directory, doctest, filepath
-     , lens, parsec, QuickCheck, semigroupoids, semigroups
-     , template-haskell
+    ({ mkDerivation, base, bifunctors, deriving-compat, directory
+     , doctest, filepath, lens, parsec, QuickCheck, semigroupoids
+     , semigroups, template-haskell
      }:
      mkDerivation {
        pname = "separated";
-       version = "0.2.3";
-       sha256 = "0lxl7i0j27nn43a6p7ayxd1rr48h31zj0bviw0nd49fsd9l5c0iq";
-       revision = "1";
-       editedCabalFile = "0k1z3a9yr9aq7cnm7kfk5yiclhq95nqlgnzzz5ksj010qmnsb6zj";
+       version = "0.3.0";
+       sha256 = "1ivgx1iaqs4k4zj4n0l92090zvx9x46j6kp56zf60b1bn9s3fcs0";
        libraryHaskellDepends = [
-         base bifunctors lens semigroupoids semigroups
+         base bifunctors deriving-compat lens semigroupoids semigroups
        ];
        testHaskellDepends = [
          base directory doctest filepath parsec QuickCheck template-haskell
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "skylighting_0_3_3_1" = callPackage
+  "skylighting_0_3_4_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, binary, blaze-html
      , bytestring, case-insensitive, containers, criterion, Diff
      , directory, filepath, HUnit, hxt, mtl, pretty-show, random
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.3.3.1";
-       sha256 = "0msx7hwnfcqmq0rkn27lr3y6iybghfnm9p5bybzkmqfhlh8gkqgk";
+       version = "0.3.4.1";
+       sha256 = "09hw6dqsk859gwkn4p5gh3n75lxix76a6kwyzzdml9yqr973jgbz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "snap-core";
-       version = "1.0.3.0";
-       sha256 = "0vkla7rfrwyhk31nign8ccjfhp7f0nqjhmg6hb7rq7ggblgwgnr4";
-       libraryHaskellDepends = [
-         attoparsec base bytestring bytestring-builder case-insensitive
-         containers directory filepath hashable HUnit io-streams lifted-base
-         monad-control mtl network network-uri old-locale random readable
-         regex-posix text time transformers transformers-base unix-compat
-         unordered-containers vector
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring bytestring-builder case-insensitive
-         containers deepseq directory filepath hashable HUnit io-streams
-         lifted-base monad-control mtl network network-uri old-locale
-         parallel QuickCheck random readable regex-posix test-framework
-         test-framework-hunit test-framework-quickcheck2 text time
-         transformers transformers-base unix-compat unordered-containers
-         vector zlib
-       ];
-       homepage = "http://snapframework.com/";
-       description = "Snap: A Haskell Web Framework (core interfaces and types)";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "snap-core_1_0_3_1" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
-     , case-insensitive, containers, deepseq, directory, filepath
-     , hashable, HUnit, io-streams, lifted-base, monad-control, mtl
-     , network, network-uri, old-locale, parallel, QuickCheck, random
-     , readable, regex-posix, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, text, time, transformers
-     , transformers-base, unix-compat, unordered-containers, vector
-     , zlib
-     }:
-     mkDerivation {
-       pname = "snap-core";
        version = "1.0.3.1";
        sha256 = "0m2pbz7r5dllk859r8bs3yjkmdh4xrw0vafz390jfmj15vaz0j87";
        libraryHaskellDepends = [
···
        homepage = "http://snapframework.com/";
        description = "Snap: A Haskell Web Framework (core interfaces and types)";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "snap-cors" = callPackage
···
      }:
      mkDerivation {
        pname = "snap-server";
-       version = "1.0.3.0";
-       sha256 = "1lvwfrirf6gq6nr6ias0i0xynq62s9myrj4203wdwq0y4c40nhqc";
-       configureFlags = [ "-fopenssl" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base blaze-builder bytestring bytestring-builder
-         case-insensitive clock containers filepath HsOpenSSL io-streams
-         io-streams-haproxy lifted-base mtl network old-locale
-         openssl-streams snap-core text time unix unix-compat vector
-       ];
-       executableHaskellDepends = [
-         attoparsec base blaze-builder bytestring bytestring-builder
-         case-insensitive clock containers directory HsOpenSSL io-streams
-         io-streams-haproxy lifted-base mtl network old-locale
-         openssl-streams snap-core text time transformers unix unix-compat
-         vector
-       ];
-       testHaskellDepends = [
-         attoparsec base base16-bytestring blaze-builder bytestring
-         bytestring-builder case-insensitive clock containers deepseq
-         directory filepath HsOpenSSL http-common http-streams HUnit
-         io-streams io-streams-haproxy lifted-base monad-control mtl network
-         old-locale openssl-streams parallel QuickCheck random snap-core
-         test-framework test-framework-hunit test-framework-quickcheck2 text
-         threads time transformers unix unix-compat vector
-       ];
-       benchmarkHaskellDepends = [
-         attoparsec base blaze-builder bytestring bytestring-builder
-         criterion io-streams io-streams-haproxy snap-core vector
-       ];
-       homepage = "http://snapframework.com/";
-       description = "A web server for the Snap Framework";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "snap-server_1_0_3_1" = callPackage
-    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
-     , bytestring, bytestring-builder, case-insensitive, clock
-     , containers, criterion, deepseq, directory, filepath, HsOpenSSL
-     , http-common, http-streams, HUnit, io-streams, io-streams-haproxy
-     , lifted-base, monad-control, mtl, network, old-locale
-     , openssl-streams, parallel, QuickCheck, random, snap-core
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
-     , text, threads, time, transformers, unix, unix-compat, vector
-     }:
-     mkDerivation {
-       pname = "snap-server";
        version = "1.0.3.1";
        sha256 = "0zawrbjncb5nbnahx70078sb9ai0dyqzghcn06qgy3vzk195gwfi";
        configureFlags = [ "-fopenssl" ];
···
        homepage = "http://snapframework.com/";
        description = "A web server for the Snap Framework";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "snap-templates" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stackage-curator_0_15_0_0" = callPackage
+  "stackage-curator_0_15_1_0" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3, async
-     , base, base16-bytestring, blaze-html, byteable, bytestring, Cabal
-     , classy-prelude-conduit, conduit, conduit-extra, containers
-     , cryptohash, cryptohash-conduit, data-default-class, directory
-     , exceptions, filepath, hashable, hspec, html-conduit, http-client
-     , http-client-tls, http-conduit, lucid, mime-types, monad-unlift
-     , monad-unlift-ref, mono-traversable, mtl, old-locale
+     , base, blaze-html, bytestring, Cabal, classy-prelude-conduit
+     , conduit, conduit-extra, containers, cryptonite
+     , cryptonite-conduit, data-default-class, directory, exceptions
+     , filepath, hashable, hspec, html-conduit, http-client
+     , http-client-tls, http-conduit, lucid, memory, mime-types
+     , monad-unlift, monad-unlift-ref, mono-traversable, mtl, old-locale
      , optparse-applicative, optparse-simple, process, QuickCheck
      , resourcet, safe, semigroups, stm, store, streaming-commons, syb
      , system-fileio, system-filepath, tar, temporary, text, time
···
      }:
      mkDerivation {
        pname = "stackage-curator";
-       version = "0.15.0.0";
-       sha256 = "0z84ywxh4zb996b0ir8hjl9pwdcb0ds0pgq6i8sfxmj5nrw5yjn5";
+       version = "0.15.1.0";
+       sha256 = "158bxk5g1bc139nmdqvr4fid5igmsgqa1d4nxy0dpl8xb68l69jp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson amazonka amazonka-core amazonka-s3 async base
-         base16-bytestring blaze-html byteable bytestring Cabal
-         classy-prelude-conduit conduit conduit-extra containers cryptohash
-         cryptohash-conduit data-default-class directory exceptions filepath
-         hashable html-conduit http-client http-client-tls http-conduit
-         lucid mime-types monad-unlift monad-unlift-ref mono-traversable mtl
-         old-locale process resourcet safe semigroups stm store
-         streaming-commons syb system-fileio system-filepath tar temporary
-         text time transformers unix-compat unordered-containers utf8-string
-         vector xml-conduit xml-types yaml zlib
+         aeson amazonka amazonka-core amazonka-s3 async base blaze-html
+         bytestring Cabal classy-prelude-conduit conduit conduit-extra
+         containers cryptonite cryptonite-conduit data-default-class
+         directory exceptions filepath hashable html-conduit http-client
+         http-client-tls http-conduit lucid memory mime-types monad-unlift
+         monad-unlift-ref mono-traversable mtl old-locale process resourcet
+         safe semigroups stm store streaming-commons syb system-fileio
+         system-filepath tar temporary text time transformers unix-compat
+         unordered-containers utf8-string vector xml-conduit xml-types yaml
+         zlib
        ];
        executableHaskellDepends = [
          aeson base http-client http-client-tls optparse-applicative
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "string-transform" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-hunit
+     , tasty-smallcheck, text, utf8-string
+     }:
+     mkDerivation {
+       pname = "string-transform";
+       version = "0.0.1";
+       sha256 = "1hm360yyh700wwjaf5xlmnla8i8vcm3vk4isgs29yavkq81pwm7x";
+       libraryHaskellDepends = [ base bytestring text utf8-string ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-hunit tasty-smallcheck text utf8-string
+       ];
+       homepage = "https://github.com/ncaq/string-transform#readme";
+       description = "simple and easy haskell string transform";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "string-typelits" = callPackage
     ({ mkDerivation, base, template-haskell, type-combinators
      , type-combinators-quote
···
   "swagger-petstore" = callPackage
     ({ mkDerivation, aeson, base, bytestring, case-insensitive
      , containers, exceptions, hspec, http-api-data, http-client
-     , http-client-tls, http-media, http-types, iso8601-time
+     , http-client-tls, http-media, http-types, iso8601-time, microlens
      , monad-logger, mtl, network, QuickCheck, random, safe-exceptions
      , semigroups, text, time, transformers, unordered-containers
      , vector
      }:
      mkDerivation {
        pname = "swagger-petstore";
-       version = "0.0.1.0";
-       sha256 = "1jpd0mxvdqw52dfk2nxvkhzn0ymdlbk99n2pgby7x66nv8vgs4n7";
+       version = "0.0.1.1";
+       sha256 = "1zpxs97lrpv4ailn6mqdx6ihbzilcsjcycrc8qj1v1f1lg00m9k6";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive containers exceptions
          http-api-data http-client http-client-tls http-media http-types
-         iso8601-time monad-logger mtl network random safe-exceptions text
-         time transformers unordered-containers vector
+         iso8601-time microlens monad-logger mtl network random
+         safe-exceptions text time transformers unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base bytestring containers hspec iso8601-time mtl QuickCheck
···
      , bytestring, case-insensitive, containers, directory, filepath
      , http-client, http-client-tls, http-media, http-types
      , insert-ordered-containers, lens, optparse-applicative, QuickCheck
-     , random, scientific, swagger2, syb, text, unordered-containers
-     , vector
+     , random, scientific, swagger2, syb, text, time
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "swagger-test";
-       version = "0.2.4";
-       sha256 = "1rm001vwhl648xhb02jr6c72q8klx4wigk9kz2lw9ipkz2pra15a";
+       version = "0.2.7";
+       sha256 = "04rhgkdg8c4cy6mj5jxykirp4m1f5n3nik4pdmvyjv71q3gdwkjp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async attoparsec base binary blaze-html bytestring
          case-insensitive containers filepath http-client http-client-tls
          http-media http-types insert-ordered-containers lens QuickCheck
-         random scientific swagger2 syb text unordered-containers vector
+         random scientific swagger2 syb text time unordered-containers
+         vector
        ];
        executableHaskellDepends = [
          aeson async base bytestring directory filepath lens
···
      }:
      mkDerivation {
        pname = "swagger2";
-       version = "2.1.4.1";
-       sha256 = "0b4c9m6yvhj2z7krf7r3a4xmbnyiifhcc4ahl5xfkb2wh6g6nfi3";
+       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
+       sha256 = "1sxv03fgafr21824wcz68l4nvazk6j31z74xa7njg7d3mc5w66pw";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson base base-compat bytestring containers generics-sop hashable
···
      }) {};
 
   "sws" = callPackage
-    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
-     , crypto-pubkey, crypto-random, directory, filepath, hourglass
-     , http-types, network, pem, resourcet, transformers, wai, wai-extra
-     , wai-middleware-static, warp, warp-tls, x509
+    ({ mkDerivation, base, bytestring, cryptonite, directory, filepath
+     , hourglass, http-types, network, resourcet, transformers, wai
+     , wai-extra, wai-middleware-static, warp, warp-tls
      }:
      mkDerivation {
        pname = "sws";
-       version = "0.3.1.2";
-       sha256 = "031495207zswwqg23p8kkv7gnm9lhkipm5b9mdp7ypsh9zgy8sz8";
+       version = "0.4.0.0";
+       sha256 = "02x2dh8nc1ci9n4mzhvq3wxvq5802mghs3kpqi6vhbglai60cj6g";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         asn1-encoding asn1-types base bytestring crypto-pubkey
-         crypto-random directory filepath hourglass http-types network pem
-         resourcet transformers wai wai-extra wai-middleware-static warp
-         warp-tls x509
+         base bytestring cryptonite directory filepath hourglass http-types
+         network resourcet transformers wai wai-extra wai-middleware-static
+         warp warp-tls
        ];
        description = "A simple web server for serving directories, similar to weborf";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "test-framework-th-prime";
-       version = "0.0.9";
-       sha256 = "1gcrhfazxj75msjdf3zj3cz81ikakpd1xfy0lflnpp0788zf7r3p";
+       version = "0.0.10";
+       sha256 = "1x3iq4dqbnhb96rfzs7awdk5v2arr3fi3jgkkhnn4vjz43ixygg8";
        libraryHaskellDepends = [
          base cpphs haskell-src-exts template-haskell test-framework
        ];
···
        homepage = "http://github.com/jgm/texmath";
        description = "Conversion between formats used to represent mathematics";
        license = "GPL";
+     }) {};
+
+  "texmath_0_9_4_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, network-uri, pandoc-types, parsec, process, split, syb
+     , temporary, text, utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.9.4.2";
+       sha256 = "1xx3yp5m0rjs8bi1gb4r0xk0mjh5gm4x2pdsgfmbrisw0pl5x0mv";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec syb xml
+       ];
+       executableHaskellDepends = [ network-uri ];
+       testHaskellDepends = [
+         base bytestring directory filepath process split temporary text
+         utf8-string xml
+       ];
+       homepage = "http://github.com/jgm/texmath";
+       description = "Conversion between formats used to represent mathematics";
+       license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "texrunner" = callPackage
···
     ({ mkDerivation, base, deepseq, hspec, QuickCheck, text, vector }:
      mkDerivation {
        pname = "text-zipper";
-       version = "0.10";
-       sha256 = "0vhp707irmyqdix4clnjphnly8zyph4brpjb41n05rxlaybn96n5";
+       version = "0.10.1";
+       sha256 = "0jxicjp0ak1fyl1n3yspxq6hv9l90zzy75glsv8bc2svsn9ypyls";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base deepseq text vector ];
        testHaskellDepends = [ base hspec QuickCheck text ];
···
     ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
      mkDerivation {
        pname = "th-abstraction";
-       version = "0.2.5.0";
-       sha256 = "1fxapnbny5gyys24q8v93i6ipcrmsrs2b95i8kz2dpgg8cc95skp";
-       libraryHaskellDepends = [
-         base containers ghc-prim template-haskell
-       ];
-       testHaskellDepends = [ base containers template-haskell ];
-       homepage = "https://github.com/glguy/th-abstraction";
-       description = "Nicer interface for reified information about data types";
-       license = stdenv.lib.licenses.isc;
-     }) {};
-
-  "th-abstraction_0_2_6_0" = callPackage
-    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
-     mkDerivation {
-       pname = "th-abstraction";
        version = "0.2.6.0";
        sha256 = "0g42h6wnj2awc5ryhbvx009wd8w75pn66bjzsq1z4s3xajd2hbp5";
        libraryHaskellDepends = [
···
        homepage = "https://github.com/glguy/th-abstraction";
        description = "Nicer interface for reified information about data types";
        license = stdenv.lib.licenses.isc;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "th-alpha" = callPackage
···
        homepage = "https://github.com/fpco/th-utilities#readme";
        description = "Collection of useful functions for use with Template Haskell";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "thank-you-stars" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
+     , directory, filepath, hackage-db, hspec, req, split, text
+     }:
+     mkDerivation {
+       pname = "thank-you-stars";
+       version = "0.1.0";
+       sha256 = "1qxi26g81ndrx8vxckb8hkpaqqpbd60r2ck705mhafrv0yd3kry7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring Cabal containers directory filepath
+         hackage-db req split text
+       ];
+       executableHaskellDepends = [ base containers directory filepath ];
+       testHaskellDepends = [ base Cabal containers hackage-db hspec ];
+       homepage = "https://github.com/y-taka-23/thank-you-stars#readme";
+       description = "Give your dependencies stars on GitHub!";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "themoviedb" = callPackage
···
        homepage = "https://github.com/aiya000/hs-throwable-exceptions#README.md";
        description = "throwable-exceptions gives the easy way to throw exceptions";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "throwable-exceptions_0_1_0_9" = callPackage
+    ({ mkDerivation, base, doctest, either, safe-exceptions, silently
+     , tasty, tasty-discover, tasty-hunit, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "throwable-exceptions";
+       version = "0.1.0.9";
+       sha256 = "1ab9qx87r0wxrvx9fk77cpimj0pm1qa2pvcv4b8sadj0s8fkrcis";
+       libraryHaskellDepends = [ base safe-exceptions template-haskell ];
+       testHaskellDepends = [
+         base doctest either safe-exceptions silently tasty tasty-discover
+         tasty-hunit text
+       ];
+       homepage = "https://github.com/aiya000/hs-throwable-exceptions#README.md";
+       description = "throwable-exceptions gives the easy way to throw exceptions";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "thumbnail" = callPackage
···
      }:
      mkDerivation {
        pname = "tweet-hs";
-       version = "1.0.1.3";
-       sha256 = "0xxyb2czffd46hwiv1wqqhhh5km8z9k0jqv5j64f68zmxfra5x04";
+       version = "1.0.1.7";
+       sha256 = "026hmzrc80mc2jpvd0cnxa6kj4lfirh7ygdh1xaw51svrql8320j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "type-of-html" = callPackage
-    ({ mkDerivation, base, blaze-html, bytestring, criterion, hspec
-     , QuickCheck, text
+    ({ mkDerivation, base, blaze-html, bytestring, criterion, ghc-prim
+     , hspec, QuickCheck, text
      }:
      mkDerivation {
        pname = "type-of-html";
-       version = "0.3.0.0";
-       sha256 = "1cj0q9h7dda8zmn8lnvm0scn97cfwxihvj31x28nzfywgbhimhv6";
-       libraryHaskellDepends = [ base bytestring text ];
+       version = "0.5.1.0";
+       sha256 = "01j4kk5c8qiqcgnymx26csj38aa76zg3vl8nwiwxcjbfng87xvmk";
+       libraryHaskellDepends = [ base bytestring ghc-prim text ];
        testHaskellDepends = [ base hspec QuickCheck text ];
        benchmarkHaskellDepends = [
          base blaze-html bytestring criterion text
···
      }:
      mkDerivation {
        pname = "typed-process";
-       version = "0.1.0.1";
-       sha256 = "05pwpis2vm63qxg8kkqd52whbgkgf5k5sy0w1z1am7jsm6fiychc";
-       libraryHaskellDepends = [
-         async base bytestring conduit conduit-extra exceptions process stm
-         transformers
-       ];
-       testHaskellDepends = [
-         async base base64-bytestring bytestring conduit conduit-extra hspec
-         http-conduit temporary
-       ];
-       homepage = "https://haskell-lang.org/library/typed-process";
-       description = "Run external processes, with strong typing of streams";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "typed-process_0_1_1" = callPackage
-    ({ mkDerivation, async, base, base64-bytestring, bytestring
-     , conduit, conduit-extra, exceptions, hspec, http-conduit, process
-     , stm, temporary, transformers
-     }:
-     mkDerivation {
-       pname = "typed-process";
        version = "0.1.1";
        sha256 = "1n93jy1z2xyin8j5dy972hdv2ydwfdbf5x1bygvn8cc6llb4wsml";
        libraryHaskellDepends = [
···
        homepage = "https://haskell-lang.org/library/typed-process";
        description = "Run external processes, with strong typing of streams";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "typed-spreadsheet" = callPackage
···
      }:
      mkDerivation {
        pname = "uuid-orphans";
-       version = "1.4.1";
-       sha256 = "19hxgi6rn5pg51jd8v64b96a2j0vh016xcbja8vdhkbdpiizyq9j";
+       version = "1.4.2";
+       sha256 = "1rsaskv8xhj773abijsq3xi3maa0ixw1k2qywcmw4bdm25pyxsr2";
        libraryHaskellDepends = [
          base safecopy text th-lift uuid-types web-routes
        ];
···
      }:
      mkDerivation {
        pname = "validation";
-       version = "0.5.4";
-       sha256 = "18vliywmqj3kwlrc4dcp2z3skwqb86crf0rmphpmna1mkrfmyy4b";
-       libraryHaskellDepends = [
-         base bifunctors lens mtl semigroupoids semigroups transformers
-       ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck template-haskell
-       ];
-       homepage = "https://github.com/NICTA/validation";
-       description = "A data-type like Either but with an accumulating Applicative";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "validation_0_5_5" = callPackage
-    ({ mkDerivation, base, bifunctors, directory, doctest, filepath
-     , lens, mtl, QuickCheck, semigroupoids, semigroups
-     , template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "validation";
        version = "0.5.5";
        sha256 = "0fgwgpwcisbabzyq11pkj57gp0kydi4px9gmgzqcq2hn6xb43qkd";
        libraryHaskellDepends = [
···
        homepage = "https://github.com/qfpl/validation";
        description = "A data-type like Either but with an accumulating Applicative";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "validations" = callPackage
···
      }) {};
 
   "vivid" = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers, filepath
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
      , hashable, MonadRandom, mtl, network, process, random
-     , random-shuffle, split, stm, time, transformers
+     , random-shuffle, split, stm, time, transformers, utf8-string
+     , vivid-osc, vivid-supercollider
      }:
      mkDerivation {
        pname = "vivid";
-       version = "0.2.0.5";
-       sha256 = "0wxkv8vygxd8waab0f87p2q8ya20lnjh7b77yih4r3znf092fmpx";
+       version = "0.3.0.2";
+       sha256 = "16dvg5yq26fkrq01mn3c4byz32xld3alxa8h9m16gi4g04f99q00";
        libraryHaskellDepends = [
-         base binary bytestring containers filepath hashable MonadRandom mtl
-         network process random random-shuffle split stm time transformers
+         base bytestring containers directory filepath hashable MonadRandom
+         mtl network process random random-shuffle split stm time
+         transformers utf8-string vivid-osc vivid-supercollider
        ];
-       homepage = "http://vivid-synth.com";
        description = "Sound synthesis with SuperCollider";
        license = "GPL";
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "wai-handler-launch";
-       version = "3.0.2.2";
-       sha256 = "021923x32sgig40sng5mffzkv5ay9asbxpzkik9bpg1yagdc954w";
-       libraryHaskellDepends = [
-         async base blaze-builder bytestring http-types process
-         streaming-commons transformers wai warp
-       ];
-       description = "Launch a web app in the default browser";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "wai-handler-launch_3_0_2_3" = callPackage
-    ({ mkDerivation, async, base, blaze-builder, bytestring, http-types
-     , process, streaming-commons, transformers, wai, warp
-     }:
-     mkDerivation {
-       pname = "wai-handler-launch";
        version = "3.0.2.3";
        sha256 = "1lv1xybpx7zzyz89nb94sw3326pnmyfz6h4sqs00ib9zf05hxl3d";
        libraryHaskellDepends = [
···
        ];
        description = "Launch a web app in the default browser";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "wai-handler-scgi" = callPackage
···
      }:
      mkDerivation {
        pname = "wrecker";
-       version = "1.0.0.2";
-       sha256 = "0ydmwxixgxryiq4nf4lxds30zmx4hhhm1w6fyk4h1hva01vrybr8";
+       version = "1.2.2.0";
+       sha256 = "03iw04jg3lmar97l9mhgd5kabfjps1dh84s7r5p9cbc6rsy5knsh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          unordered-containers vector vty wreq
        ];
        executableHaskellDepends = [
-         aeson aeson-qq base bytestring connection http-client
-         http-client-tls immortal lens markdown-unlit network next-ref
-         optparse-applicative scotty text transformers wai warp wreq
+         base http-client http-client-tls lens markdown-unlit
+         optparse-applicative wreq
        ];
        testHaskellDepends = [
          aeson aeson-qq base bytestring connection hspec hspec-discover
···
        description = "An HTTP Performance Benchmarker";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "wrecker-ui" = callPackage
+       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
+     , directory, distributed-process, distributed-process-async
+     , distributed-process-simplelocalnet, distributed-static, esqueleto
+     , HostAndPort, http-types, iso8601-time, monad-control
+     , monad-logger, mtl, network-transport, network-transport-tcp
+     , persistent, persistent-postgresql, persistent-sqlite
+     , persistent-template, postgresql-simple, postgresql-simple-url
+     , process, resource-pool, resourcet, scotty, stm, temporary, text
+     , time, transformers, wai-cors
+     }:
+     mkDerivation {
+       pname = "wrecker-ui";
+       version = "2.3.0.2";
+       sha256 = "0bfpcc464fgcgzp5h20d2q7p79z3mkxi6c0i3cc4mmzspgvnsjk3";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [
+         aeson async base binary bytestring containers directory
+         distributed-process distributed-process-async
+         distributed-process-simplelocalnet distributed-static esqueleto
+         HostAndPort http-types iso8601-time monad-control monad-logger mtl
+         network-transport network-transport-tcp persistent
+         persistent-postgresql persistent-sqlite persistent-template
+         postgresql-simple postgresql-simple-url process resource-pool
+         resourcet scotty stm temporary text time transformers wai-cors
+       ];
+       description = "A web interface for Wrecker, the HTTP Performance Benchmarker";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "wreq" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "xml-conduit_1_6_0" = callPackage
+  "xml-conduit_1_7_0" = callPackage
     ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
      , blaze-markup, bytestring, conduit, conduit-extra, containers
      , data-default-class, deepseq, hspec, HUnit, monad-control
···
      }:
      mkDerivation {
        pname = "xml-conduit";
-       version = "1.6.0";
-       sha256 = "042cq7i988jxfwayndzpk2mygfs73709xmzi875imhmar10nv914";
+       version = "1.7.0";
+       sha256 = "0g0a6h52n6q3w09350d6vgjpvb6xj224isp4lphgwbmd2xr12i76";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-html blaze-markup bytestring
          conduit conduit-extra containers data-default-class deepseq
···
      }) {};
 
   "xmonad-extras" = callPackage
-    ({ mkDerivation, alsa-mixer, base, bytestring, containers
-     , directory, hint, libmpd, mtl, network, old-locale, old-time
-     , process, random, regex-posix, unix, X11, xmonad, xmonad-contrib
-     }:
-     mkDerivation {
-       pname = "xmonad-extras";
-       version = "0.13.0";
-       sha256 = "11clsfa5i174i6bfp6mdy06w11jyx2sydrbbczf2s9kg92ysbnqb";
-       configureFlags = [
-         "-f-with_hlist" "-fwith_parsec" "-fwith_split"
-       ];
-       libraryHaskellDepends = [
-         alsa-mixer base bytestring containers directory hint libmpd mtl
-         network old-locale old-time process random regex-posix unix X11
-         xmonad xmonad-contrib
-       ];
-       homepage = "https://github.com/xmonad/xmonad-extras";
-       description = "Third party extensions for xmonad with wacky dependencies";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "xmonad-extras_0_13_1" = callPackage
     ({ mkDerivation, alsa-mixer, base, bytestring, containers, hint
      , libmpd, mtl, network, regex-posix, X11, xmonad, xmonad-contrib
      }:
···
        homepage = "https://github.com/xmonad/xmonad-extras";
        description = "Third party extensions for xmonad with wacky dependencies";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "xmonad-screenshot" = callPackage
···
      }:
      mkDerivation {
        pname = "yeshql";
-       version = "3.0.1.1";
-       sha256 = "07swxkxjdvsgsfz9qanygv1fmp3vzcd18hffyp0m6c7qv4av7zps";
+       version = "3.0.1.3";
+       sha256 = "04svfqlmhm94ljyhirihhsdqpskvq989y3wwznclbn0isspjcq9p";
        libraryHaskellDepends = [
          base containers convertible filepath HDBC parsec template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "yesod-auth";
-       version = "1.4.18";
-       sha256 = "1cg3wb5d8cy65rmrc0dq086mmfhvvwdyig926pb0nhn2zj2kbzav";
-       libraryHaskellDepends = [
-         aeson authenticate base base16-bytestring base64-bytestring binary
-         blaze-builder blaze-html blaze-markup byteable bytestring conduit
-         conduit-extra containers cryptonite data-default email-validate
-         file-embed http-client http-conduit http-types lifted-base memory
-         mime-mail network-uri nonce persistent persistent-template random
-         resourcet safe shakespeare template-haskell text time transformers
-         unordered-containers wai yesod-core yesod-form yesod-persistent
-       ];
-       homepage = "http://www.yesodweb.com/";
-       description = "Authentication for Yesod";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "yesod-auth_1_4_19" = callPackage
-    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
-     , base64-bytestring, binary, blaze-builder, blaze-html
-     , blaze-markup, byteable, bytestring, conduit, conduit-extra
-     , containers, cryptonite, data-default, email-validate, file-embed
-     , http-client, http-conduit, http-types, lifted-base, memory
-     , mime-mail, network-uri, nonce, persistent, persistent-template
-     , random, resourcet, safe, shakespeare, template-haskell, text
-     , time, transformers, unordered-containers, wai, yesod-core
-     , yesod-form, yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod-auth";
        version = "1.4.19";
        sha256 = "1r6ykh9q9080wrshicmgxkjjlxb1rxv56kabqnyx44xihhcr19jp";
        libraryHaskellDepends = [
···
        homepage = "http://www.yesodweb.com/";
        description = "Authentication for Yesod";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-auth-account" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-core_1_4_37" = callPackage
+    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
+     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
+     , cereal, clientsession, conduit, conduit-extra, containers, cookie
+     , criterion, data-default, deepseq, deepseq-generics, directory
+     , exceptions, fast-logger, hspec, hspec-expectations, http-types
+     , HUnit, lifted-base, monad-control, monad-logger, mtl, mwc-random
+     , network, old-locale, parsec, path-pieces, primitive, QuickCheck
+     , random, resourcet, safe, semigroups, shakespeare
+     , streaming-commons, template-haskell, text, time, transformers
+     , transformers-base, unix-compat, unordered-containers, vector, wai
+     , wai-extra, wai-logger, warp, word8
+     }:
+     mkDerivation {
+       pname = "yesod-core";
+       version = "1.4.37";
+       sha256 = "0ww8hl0cx2g58zrdx3j6d5m2xwhssbajdqws1xk6rzl7rpfm1b9j";
+       libraryHaskellDepends = [
+         aeson auto-update base blaze-builder blaze-html blaze-markup
+         byteable bytestring case-insensitive cereal clientsession conduit
+         conduit-extra containers cookie data-default deepseq
+         deepseq-generics directory exceptions fast-logger http-types
+         lifted-base monad-control monad-logger mtl mwc-random old-locale
+         parsec path-pieces primitive random resourcet safe semigroups
+         shakespeare template-haskell text time transformers
+         transformers-base unix-compat unordered-containers vector wai
+         wai-extra wai-logger warp word8
+       ];
+       testHaskellDepends = [
+         async base blaze-builder bytestring clientsession conduit
+         conduit-extra containers cookie hspec hspec-expectations http-types
+         HUnit lifted-base mwc-random network path-pieces QuickCheck random
+         resourcet shakespeare streaming-commons template-haskell text
+         transformers wai wai-extra
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-html bytestring criterion shakespeare text transformers
+       ];
+       homepage = "http://www.yesodweb.com/";
+       description = "Creation of type-safe, RESTful web applications";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-crud" = callPackage
     ({ mkDerivation, base, classy-prelude, containers, MissingH
      , monad-control, persistent, random, safe, stm, uuid, yesod-core
···
      }:
      mkDerivation {
        pname = "yesod-form";
-       version = "1.4.15";
-       sha256 = "107ddpngzwzmslrv1cc82fx775icvjpbsgjhinj7cnmpi3paq3w3";
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-builder blaze-html blaze-markup
-         byteable bytestring containers data-default email-validate
-         network-uri persistent resourcet semigroups shakespeare
-         template-haskell text time transformers wai xss-sanitize yesod-core
-       sha256 = "075y56pbi02ssyb965di1b6d2047jdjwq2wp2maraqjm6gdk824y";
-       ];
-       testHaskellDepends = [ base hspec text time ];
-       homepage = "http://www.yesodweb.com/";
-       description = "Form handling support for Yesod Web Framework";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "yesod-form_1_4_16" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
-     , blaze-markup, byteable, bytestring, containers, data-default
-     , email-validate, hspec, network-uri, persistent, resourcet
-     , semigroups, shakespeare, template-haskell, text, time
-     , transformers, wai, xss-sanitize, yesod-core, yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod-form";
        version = "1.4.16";
        sha256 = "0lij3m5vn8nvh6y88r1dhk03xmmjwmjzazm307nc2wvc5fmx9p2j";
        libraryHaskellDepends = [
···
        homepage = "http://www.yesodweb.com/";
        description = "Form handling support for Yesod Web Framework";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-form-bootstrap4" = callPackage
···
        homepage = "https://github.com/ncaq/yesod-form-bootstrap4.git#readme";
        description = "renderBootstrap4";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "yesod-form-bootstrap4_0_1_0_2" = callPackage
+    ({ mkDerivation, base, classy-prelude-yesod, yesod-form }:
+     mkDerivation {
+       pname = "yesod-form-bootstrap4";
+       version = "0.1.0.2";
+       sha256 = "0lsdvs33xsy7ipr44calfhyf375mkq7h3axi39q91f28r76iy6cf";
+       libraryHaskellDepends = [ base classy-prelude-yesod yesod-form ];
+       homepage = "https://github.com/ncaq/yesod-form-bootstrap4#readme";
+       description = "renderBootstrap4";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-form-json" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-recaptcha2_0_1_0_1" = callPackage
+    ({ mkDerivation, base, classy-prelude-yesod, http-conduit
+     , yesod-auth
+     }:
+     mkDerivation {
+       pname = "yesod-recaptcha2";
+       version = "0.1.0.1";
+       sha256 = "0avlm1jchp0j65c3f6bj9gv9kba0cvvk77sq918dzjvx54hnygf3";
+       libraryHaskellDepends = [
+         base classy-prelude-yesod http-conduit yesod-auth
+       ];
+       homepage = "https://github.com/ncaq/yesod-recaptcha2#readme";
+       description = "yesod recaptcha2";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-routes" = callPackage
     ({ mkDerivation, base, bytestring, containers, hspec, HUnit
      , path-pieces, template-haskell, text, vector
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-core_0_15_0" = callPackage
+  "yi-core_0_16_0" = callPackage
     ({ mkDerivation, array, attoparsec, base, binary, bytestring
      , containers, criterion, data-default, deepseq, directory, dlist
      , dynamic-state, filepath, hashable, ListLike, microlens-platform
      , mtl, old-locale, oo-prototypes, parsec, pointedlist, process
      , process-extras, quickcheck-text, split, tasty, tasty-hunit
-     , tasty-quickcheck, text, text-icu, time, transformers-base, unix
+     , tasty-quickcheck, text, time, transformers-base, unix
      , unix-compat, unordered-containers, xdg-basedir, yi-language
      , yi-rope
      }:
      mkDerivation {
        pname = "yi-core";
-       version = "0.15.0";
-       sha256 = "1lfxqi7z2jhvg6mzh31nighgcq1zp4w2ibggqlq02wbliwvbvbsf";
+       version = "0.16.0";
+       sha256 = "0r7hbwlc0l45mb5qd949vn0h34kg5aqj7ic9shifz23cxlapkssj";
        libraryHaskellDepends = [
          array attoparsec base binary bytestring containers data-default
          directory dlist dynamic-state filepath hashable ListLike
          microlens-platform mtl old-locale oo-prototypes parsec pointedlist
-         process process-extras split text text-icu time transformers-base
-         unix unix-compat unordered-containers xdg-basedir yi-language
-         yi-rope
+         process process-extras split text time transformers-base unix
+         unix-compat unordered-containers xdg-basedir yi-language yi-rope
        ];
        testHaskellDepends = [
          array attoparsec base binary bytestring containers data-default
          directory dlist dynamic-state filepath hashable ListLike
          microlens-platform mtl old-locale oo-prototypes parsec pointedlist
          process process-extras quickcheck-text split tasty tasty-hunit
-         tasty-quickcheck text text-icu time transformers-base unix
-         unix-compat unordered-containers xdg-basedir yi-language yi-rope
+         tasty-quickcheck text time transformers-base unix unix-compat
+         unordered-containers xdg-basedir yi-language yi-rope
        ];
        benchmarkHaskellDepends = [
          array attoparsec base binary bytestring containers criterion
          data-default deepseq directory dlist dynamic-state filepath
          hashable ListLike microlens-platform mtl old-locale oo-prototypes
-         parsec pointedlist process process-extras split text text-icu time
+         parsec pointedlist process process-extras split text time
          transformers-base unix unix-compat unordered-containers xdg-basedir
          yi-language yi-rope
        ];
···
      }) {};
 
   "yi-dynamic-configuration" = callPackage
-    ({ mkDerivation, base, dyre, microlens-platform, mtl, text
-     , transformers-base, yi-core, yi-rope
+    ({ mkDerivation, base, data-default, dyre, microlens-platform, mtl
+     , text, transformers-base, yi-core, yi-rope
      }:
      mkDerivation {
        pname = "yi-dynamic-configuration";
-       version = "0.15.0";
-       sha256 = "0dh8vvmczdlcby9ybp89r59mhi1p7ywrvrh36y0nz6zmfckx3ylh";
+       version = "0.16.0";
+       sha256 = "1y439lsrf6akq1db6gkxm44pq83672jbnyg2hcw2s8b0rlr873vz";
        libraryHaskellDepends = [
-         base dyre microlens-platform mtl text transformers-base yi-core
-         yi-rope
+         base data-default dyre microlens-platform mtl text
+         transformers-base yi-core yi-rope
        ];
        homepage = "https://github.com/yi-editor/yi#readme";
        description = "Dynamic configuration support for Yi";
···
      }:
      mkDerivation {
        pname = "yi-frontend-pango";
-       version = "0.15.0";
-       sha256 = "02wfcpsamqq5qxdzmbg98h4qji9dfsvk3v4rq1r9lxw6v3rcnd8h";
+       version = "0.16.0";
+       sha256 = "0dbmkh72rrnmcxs8ixgpzvj6bra0nzrgiwnjz19rlpsgzvw5vfhh";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers filepath glib gtk microlens-platform mtl
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-frontend-vty_0_15_0" = callPackage
+  "yi-frontend-vty_0_16_0" = callPackage
     ({ mkDerivation, base, containers, data-default, dlist
      , microlens-platform, pointedlist, stm, text, vty, yi-core
      , yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-frontend-vty";
-       version = "0.15.0";
-       sha256 = "0c8qvhn22r1bk9p5c65z8dq73hn84ylpxczqyjb1j8i76wycaccc";
+       version = "0.16.0";
+       sha256 = "00rmwcm1431rffhq1rif0k0g43wnzdfhw1zhacl4f2n5v2gxkjsq";
        libraryHaskellDepends = [
          base containers data-default dlist microlens-platform pointedlist
          stm text vty yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-fuzzy-open_0_15_0" = callPackage
+  "yi-fuzzy-open_0_16_0" = callPackage
     ({ mkDerivation, base, binary, containers, data-default, directory
      , filepath, mtl, text, transformers-base, vector, yi-core
      , yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-fuzzy-open";
-       version = "0.15.0";
-       sha256 = "0zlscdkxahcdh46pgnlv2v55s5c7271zc43fi37ff305a9d57axq";
+       version = "0.16.0";
+       sha256 = "0z59g33rgdpg090sj6ilkwxvcg9r3my0v8wd49vvn72livf3v88k";
        libraryHaskellDepends = [
          base binary containers data-default directory filepath mtl text
          transformers-base vector yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-ireader_0_15_0" = callPackage
+  "yi-ireader_0_16_0" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, data-default
      , microlens-platform, text, yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-ireader";
-       version = "0.15.0";
-       sha256 = "05jmsdr4bv14mpjzsb2ib20jvmswgm0666d8vz0h2gp2gvda7skd";
+       version = "0.16.0";
+       sha256 = "1wmkji3sz7hnik7cy25r8wbc7y2x938gy8fyy4cadgrpbpndb58a";
        libraryHaskellDepends = [
          base binary bytestring containers data-default microlens-platform
          text yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-keymap-cua_0_15_0" = callPackage
+  "yi-keymap-cua_0_16_0" = callPackage
     ({ mkDerivation, base, microlens-platform, text, yi-core
      , yi-keymap-emacs, yi-rope
      }:
      mkDerivation {
        pname = "yi-keymap-cua";
-       version = "0.15.0";
-       sha256 = "0wxblxk9pf3i7dc3hl64lwicj1njwvl8qkimkqw20k3si7hls2vz";
+       version = "0.16.0";
+       sha256 = "082f3jhbas2ww4jmq53gqr7ssl8c0cd5gz2avvhqzvfsfxk1qiay";
        libraryHaskellDepends = [
          base microlens-platform text yi-core yi-keymap-emacs yi-rope
        ];
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-keymap-emacs_0_15_0" = callPackage
+  "yi-keymap-emacs_0_16_0" = callPackage
     ({ mkDerivation, base, containers, filepath, Hclip
      , microlens-platform, mtl, oo-prototypes, text, transformers-base
      , yi-core, yi-language, yi-misc-modes, yi-rope
      }:
      mkDerivation {
        pname = "yi-keymap-emacs";
-       version = "0.15.0";
-       sha256 = "1sfyddp123zi3inwnilnckf9gair13kn1qjj6k117g1900fh4ha5";
+       version = "0.16.0";
+       sha256 = "0l0xvkb0y3kp0bkvarl6kdvvj4rn5pm70z1g1yavk1krs41xxz6j";
        libraryHaskellDepends = [
          base containers filepath Hclip microlens-platform mtl oo-prototypes
          text transformers-base yi-core yi-language yi-misc-modes yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-keymap-vim_0_15_0" = callPackage
+  "yi-keymap-vim_0_16_0" = callPackage
     ({ mkDerivation, attoparsec, base, binary, containers, data-default
      , directory, filepath, Hclip, microlens-platform, mtl
      , oo-prototypes, pointedlist, QuickCheck, safe, tasty, tasty-hunit
···
      }:
      mkDerivation {
        pname = "yi-keymap-vim";
-       version = "0.15.0";
-       sha256 = "0jd4ssf97zq6rzsdlxj0framwzdkf5ggnzkafk7wvd9abikihmld";
+       version = "0.16.0";
+       sha256 = "1fvl4frjikkdp561zai6z35r8r7f4fq2izlcxl1k1rvsvxz3cbi2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          attoparsec base binary containers data-default directory filepath
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-language_0_15_0" = callPackage
+  "yi-language_0_16_0" = callPackage
     ({ mkDerivation, alex, array, base, binary, containers
      , data-default, hashable, microlens-platform, oo-prototypes
      , pointedlist, regex-base, regex-tdfa, tasty, tasty-hspec
···
      }:
      mkDerivation {
        pname = "yi-language";
-       version = "0.15.0";
-       sha256 = "0skp7n9l4qg665krs6fv7kxmrq7jrbrqv1lppcqff5bak1dk5vxb";
+       version = "0.16.0";
+       sha256 = "0wq4m665xcy7256iapjwggc3ylrg9y1k1vhvjn5a8716nn23mnr5";
        libraryHaskellDepends = [
          array base binary containers data-default hashable
          microlens-platform oo-prototypes pointedlist regex-base regex-tdfa
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-misc-modes_0_15_0" = callPackage
+  "yi-misc-modes_0_16_0" = callPackage
     ({ mkDerivation, alex, array, base, binary, data-default, filepath
      , microlens-platform, text, yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-misc-modes";
-       version = "0.15.0";
-       sha256 = "0rjk5j3jrqvbznh5azc49wgx6i21q30qn0jz1rvhqqxsakqyaqbx";
+       version = "0.16.0";
+       sha256 = "1vsdfwpqmpmdiaxh30hshxwlpqmkxzih13ic0hnbsx27amd3mv59";
        libraryHaskellDepends = [
          array base binary data-default filepath microlens-platform text
          yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-mode-haskell_0_15_0" = callPackage
+  "yi-mode-haskell_0_16_0" = callPackage
     ({ mkDerivation, alex, array, base, binary, data-default, filepath
      , microlens-platform, text, yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-mode-haskell";
-       version = "0.15.0";
-       sha256 = "12h3ij0a887jfz9kcmmsl0i82jimf11pcvshimdk7d3c9gqf8ygn";
+       version = "0.16.0";
+       sha256 = "0h4796zdcwrj6zkmxcvdjpmwb1rw0zgwzzgsdsch455j770y4dyy";
        libraryHaskellDepends = [
          array base binary data-default filepath microlens-platform text
          yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-mode-javascript_0_15_0" = callPackage
+  "yi-mode-javascript_0_16_0" = callPackage
     ({ mkDerivation, alex, array, base, binary, data-default, dlist
      , filepath, microlens-platform, mtl, text, yi-core, yi-language
      , yi-rope
      }:
      mkDerivation {
        pname = "yi-mode-javascript";
-       version = "0.15.0";
-       sha256 = "0ir6m97v3d42j6my5pg52vnbwlr55sgzidajx23mlafnccl9j6js";
+       version = "0.16.0";
+       sha256 = "09xp4a1w4m6spnzm943zkivaxicipmzs07qn9xqrfvcwavy56kha";
        libraryHaskellDepends = [
          array base binary data-default dlist filepath microlens-platform
          mtl text yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
+  "yi-rope_0_10" = callPackage
+    ({ mkDerivation, base, binary, bytestring, criterion, deepseq
+     , fingertree, hspec, QuickCheck, quickcheck-instances, text
+     }:
+     mkDerivation {
+       pname = "yi-rope";
+       version = "0.10";
+       sha256 = "0lkaca2nnivzd6dbrawdkfydm9rd06bm0j0kbl1nhh53ghdp4cs9";
+       libraryHaskellDepends = [
+         base binary bytestring deepseq fingertree text
+       ];
+       testHaskellDepends = [
+         base hspec QuickCheck quickcheck-instances text
+       ];
+       benchmarkHaskellDepends = [ base criterion deepseq text ];
+       description = "A rope data structure used by Yi";
+       license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yi-snippet" = callPackage
     ({ mkDerivation, base, binary, containers, data-default, free
      , microlens-platform, mtl, tasty-hunit, tasty-th, text, vector
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-snippet_0_15_0" = callPackage
+  "yi-snippet_0_16_0" = callPackage
     ({ mkDerivation, base, binary, containers, data-default, free
      , microlens-platform, mtl, tasty-hunit, tasty-th, text, vector
      , yi-core, yi-rope
      }:
      mkDerivation {
        pname = "yi-snippet";
-       version = "0.15.0";
-       sha256 = "06cnnjbqkd03d5hzs80gm2bp0nzqnfd74ypzc35a8ad6wjdwsvnw";
+       version = "0.16.0";
+       sha256 = "0n9m2n8k4k79hi661gpjdz0yca1jhxmbjdkxgzg7gnvwiikmfawh";
        libraryHaskellDepends = [
          base binary containers data-default free microlens-platform mtl
          text vector yi-core yi-rope

pkgs/development/idris-modules/default.nix

···
     };
 
     files = builtins.filter (n: n != "default") (pkgs.lib.mapAttrsToList (name: type: let
-      m = builtins.match "(.*)\.nix" name;
+      m = builtins.match "(.*)\\.nix" name;
     in if m == null then "default" else builtins.head m) (builtins.readDir ./.));
   in (builtins.listToAttrs (map (name: {
     inherit name;

pkgs/development/interpreters/python/cpython/2.7/default.nix

···
     "--enable-shared"
     "--with-threads"
     "--enable-unicode=ucs4"
+  ] ++ optionals (hostPlatform.isCygwin || hostPlatform.isAarch64) [
+    "--with-system-ffi"
   ] ++ optionals hostPlatform.isCygwin [
-    "--with-system-ffi"
     "--with-system-expat"
     "ac_cv_func_bind_textdomain_codeset=yes"
   ] ++ optionals stdenv.isDarwin [
···
   buildInputs =
     optional (stdenv ? cc && stdenv.cc.libc != null) stdenv.cc.libc ++
     [ bzip2 openssl zlib ]
-    ++ optionals hostPlatform.isCygwin [ expat libffi ]
+    ++ optional (hostPlatform.isCygwin || hostPlatform.isAarch64) libffi
+    ++ optional hostPlatform.isCygwin expat
     ++ [ db gdbm ncurses sqlite readline ]
     ++ optionals x11Support [ tcl tk xlibsWrapper libX11 ]
     ++ optionals stdenv.isDarwin [ CF configd ];

pkgs/development/interpreters/python/cpython/3.4/default.nix

···
 
   patches = [
     ./no-ldconfig.patch
+    ./ld_library_path.patch
   ];
 
   postPatch = ''

pkgs/development/interpreters/python/cpython/3.4/ld_library_path.patch

···
+From 85991e0d7f0e631240f3f6233bd65d1128a66dec Mon Sep 17 00:00:00 2001
+From: Frederik Rietdijk <[e-mail]>
+Date: Thu, 14 Sep 2017 10:00:31 +0200
+Subject: [PATCH] ctypes.util: support LD_LIBRARY_PATH
+
+Backports support for LD_LIBRARY_PATH from 3.6
+---
+ Lib/ctypes/util.py | 26 +++++++++++++++++++++++++-
+ 1 file changed, 25 insertions(+), 1 deletion(-)
+
+diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py
+index 780cd5d21b..d7ac15070f 100644
+--- a/Lib/ctypes/util.py
++++ b/Lib/ctypes/util.py
+@@ -181,8 +181,32 @@ elif os.name == "posix":
+         def _findSoname_ldconfig(name):
+             return None
+ 
++        def _findLib_ld(name):
++            # See issue #9998 for why this is needed
++            expr = r'[^\(\)\s]*lib%s\.[^\(\)\s]*' % re.escape(name)
++            cmd = ['ld', '-t']
++            libpath = os.environ.get('LD_LIBRARY_PATH')
++            if libpath:
++                for d in libpath.split(':'):
++                    cmd.extend(['-L', d])
++            cmd.extend(['-o', os.devnull, '-l%s' % name])
++            result = None
++            try:
++                p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
++                                     stderr=subprocess.PIPE,
++                                     universal_newlines=True)
++                out, _ = p.communicate()
++                res = re.search(expr, os.fsdecode(out))
++                if res:
++                    result = res.group(0)
++            except Exception as e:
++                pass  # result will be None
++            return result
++
+         def find_library(name):
+-            return _findSoname_ldconfig(name) or _get_soname(_findLib_gcc(name))
++            # See issue #9998
++            return _findSoname_ldconfig(name) or \
++                   _get_soname(_findLib_gcc(name) or _findLib_ld(name))
+ 
+ ################################################################
+ # test code
+-- 
+2.14.1
+

pkgs/development/interpreters/python/cpython/3.5/default.nix

···
 
   patches = [
     ./no-ldconfig.patch
+    ./ld_library_path.patch
   ];
 
   postPatch = ''

pkgs/development/interpreters/python/cpython/3.5/ld_library_path.patch

···
+From 918201682127ed8a270a4bd1a448b490019e4ada Mon Sep 17 00:00:00 2001
+From: Frederik Rietdijk <[e-mail]>
+Date: Thu, 14 Sep 2017 10:00:31 +0200
+Subject: [PATCH] ctypes.util: support LD_LIBRARY_PATH
+
+Backports support for LD_LIBRARY_PATH from 3.6
+---
+ Lib/ctypes/util.py | 26 +++++++++++++++++++++++++-
+ 1 file changed, 25 insertions(+), 1 deletion(-)
+
+diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py
+index e9957d7951..9926f6c881 100644
+--- a/Lib/ctypes/util.py
++++ b/Lib/ctypes/util.py
+@@ -219,8 +219,32 @@ elif os.name == "posix":
+         def _findSoname_ldconfig(name):
+             return None
+ 
++        def _findLib_ld(name):
++            # See issue #9998 for why this is needed
++            expr = r'[^\(\)\s]*lib%s\.[^\(\)\s]*' % re.escape(name)
++            cmd = ['ld', '-t']
++            libpath = os.environ.get('LD_LIBRARY_PATH')
++            if libpath:
++                for d in libpath.split(':'):
++                    cmd.extend(['-L', d])
++            cmd.extend(['-o', os.devnull, '-l%s' % name])
++            result = None
++            try:
++                p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
++                                     stderr=subprocess.PIPE,
++                                     universal_newlines=True)
++                out, _ = p.communicate()
++                res = re.search(expr, os.fsdecode(out))
++                if res:
++                    result = res.group(0)
++            except Exception as e:
++                pass  # result will be None
++            return result
++
+         def find_library(name):
+-            return _findSoname_ldconfig(name) or _get_soname(_findLib_gcc(name))
++            # See issue #9998
++            return _findSoname_ldconfig(name) or \
++                   _get_soname(_findLib_gcc(name) or _findLib_ld(name))
+ 
+ ################################################################
+ # test code
+-- 
+2.14.1
+

pkgs/development/interpreters/racket/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "racket-${version}";
-  version = "6.10";
+  version = "6.10.1";
 
   src = fetchurl {
     url = "http://mirror.racket-lang.org/installers/${version}/${name}-src.tgz";
-    sha256 = "1mqnyj3bawad12dygsb11f2dbnkjp7q6d7ra714rqyw8mxix5ws0";
+    sha256 = "0v3z6x277lq1y7wkqdf6mj3826z5vq0yadygspx9h4r0f1dnmafc";
   };
 
   FONTCONFIG_FILE = fontsConf;

pkgs/development/interpreters/ruby/default.nix

···
     };
   };
 
-  ruby_2_4_1 = generic {
-    version = rubyVersion "2" "4" "1" "";
+  ruby_2_4_2 = generic {
+    version = rubyVersion "2" "4" "2" "";
     sha256 = {
-      src = "0l0201fqwzwygnrgxay469gbb2w865bnqckq00x3prdmbh6y2c53";
-      git = "1gjn31ymypzzcwkrjx62hqw59fywz1x3cyvmi1f2yb9bwb3659ss";
+      src = "174cdiz3am1f76vsnm3iqi9c5vqphypbf9kbxx6vqqmj01gfgfck";
+      git = "1w83kzak3m6vv3k09ynfw9vpgc7vpmij3x3zmgrhwm4ds1sp5irl";
     };
   };
 }

pkgs/development/interpreters/ruby/patchsets.nix

···
     "${patchSet}/patches/ruby/2.3/head/railsexpress/02-improve-gc-stats.patch"
     "${patchSet}/patches/ruby/2.3/head/railsexpress/03-display-more-detailed-stack-trace.patch"
   ];
-  "2.4.1" = ops useRailsExpress [
+  "2.4.2" = ops useRailsExpress [
     "${patchSet}/patches/ruby/2.4/head/railsexpress/01-skip-broken-tests.patch"
     "${patchSet}/patches/ruby/2.4/head/railsexpress/02-improve-gc-stats.patch"
     "${patchSet}/patches/ruby/2.4/head/railsexpress/03-display-more-detailed-stack-trace.patch"

pkgs/development/libraries/appstream-glib/default.nix

···
   propagatedBuildInputs = [ gtk3 ];
   mesonFlags = [ "-Denable-rpm=false" "-Denable-stemmer=false" "-Denable-dep11=false" ];
 
-  postFixup = "patchelf --set-rpath ${rpath} $out/lib/libappstream-glib.so";
+  postFixup = ''
+    for elf in "$out"/bin/* "$out"/lib/*.so; do
+      patchelf --set-rpath '${rpath}':"$out/lib" "$elf"
+    done
+  '';
 
   meta = with stdenv.lib; {
     description = "Objects and helper methods to read and write AppStream metadata";

pkgs/development/libraries/ffmpeg-full/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "ffmpeg-full-${version}";
-  version = "3.3.3";
+  version = "3.3.4";
 
   src = fetchurl {
     url = "https://www.ffmpeg.org/releases/ffmpeg-${version}.tar.xz";
-    sha256 = "07is8msrhxr1dk6vgwa192k2pl2a0in1h9w8f9cknlvbvhn01afj";
+    sha256 = "0mx9dvad3lkyhvsrblf280x2bz6dxajya1ylnspbdzldj0dpxfcq";
   };
 
   patchPhase = ''patchShebangs .

pkgs/development/libraries/ffmpeg/3.3.nix

···
 
 callPackage ./generic.nix (args // rec {
   version = "${branch}";
-  branch = "3.3.3";
-  sha256 = "0wx421d7vp4nz8kgp0kg16sswikj8ff1pd18x9mmcbpmqy7sqs8h";
+  branch = "3.3.4";
+  sha256 = "0zmczggi95fbsq9nz33mpln1y3p1gqniqc4x5smp871idhkykxay";
   darwinFrameworks = [ Cocoa CoreMedia ];
 })

pkgs/development/libraries/gmime/3.nix

···
+{ stdenv, fetchurl, pkgconfig, glib, zlib, gpgme, libidn, gobjectIntrospection }:
+
+stdenv.mkDerivation rec {
+  version = "3.0.1";
+  name = "gmime-${version}";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gmime/3.0/${name}.tar.xz";
+    sha256 = "001y93b8mq9alzkvli6vfh3pzdcn5c5iy206ml23lzhhhvm5k162";
+  };
+
+  outputs = [ "out" "dev" ];
+
+  nativeBuildInputs = [ pkgconfig gobjectIntrospection ];
+  propagatedBuildInputs = [ glib zlib gpgme libidn ];
+  configureFlags = [ "--enable-introspection=yes" ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/jstedfast/gmime/;
+    description = "A C/C++ library for creating, editing and parsing MIME messages and structures";
+    license = licenses.lgpl21Plus;
+    maintainers = with maintainers; [ chaoflow ];
+    platforms = platforms.unix;
+  };
+}

pkgs/development/libraries/gmime/default.nix pkgs/development/libraries/gmime/2.nix

···
 { stdenv, fetchurl, pkgconfig, glib, zlib, libgpgerror, gobjectIntrospection }:
 
 stdenv.mkDerivation rec {
-  name = "gmime-2.6.23";
+  version = "2.6.23";
+  name = "gmime-${version}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/gmime/2.6/${name}.tar.xz";
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = https://github.com/jstedfast/gmime/;
     description = "A C/C++ library for creating, editing and parsing MIME messages and structures";
-    maintainers = [ stdenv.lib.maintainers.chaoflow ];
-    platforms = stdenv.lib.platforms.unix;
+    license = licenses.lgpl21Plus;
+    maintainers = with maintainers; [ chaoflow ];
+    platforms = platforms.unix;
   };
 }

pkgs/development/libraries/gtk+/3.x.nix

···
 
 let
   ver_maj = "3.22";
-  ver_min = "19";
+  ver_min = "21";
   version = "${ver_maj}.${ver_min}";
 in
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "mirror://gnome/sources/gtk+/${ver_maj}/gtk+-${version}.tar.xz";
-    sha256 = "9883d3ca5244f9b3168ce660e87d52900e141d0f7147dea0640bdd6fe8e5166c";
+    sha256 = "1bd3c1a85cfb4db112cabb5379abb05a1a94fe43052d309d573493fca00e6b87";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/kde-frameworks/fetch.sh

···
-WGET_ARGS=( https://download.kde.org/stable/frameworks/5.37/ -A '*.tar.xz' )
+WGET_ARGS=( https://download.kde.org/stable/frameworks/5.38/ -A '*.tar.xz' )

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

···
   mkDerivation, lib, copyPathsToStore,
   extra-cmake-modules, perl,
   karchive, kconfig, kguiaddons, ki18n, kiconthemes, kio, kparts, libgit2,
-  qtscript, qtxmlpatterns, sonnet, syntax-highlighting
+  qtscript, qtxmlpatterns, sonnet, syntax-highlighting, qtquickcontrols
 }:
 
 mkDerivation {
···
   nativeBuildInputs = [ extra-cmake-modules perl ];
   buildInputs = [
     karchive kconfig kguiaddons ki18n kiconthemes kio libgit2 qtscript
-    qtxmlpatterns sonnet syntax-highlighting
+    qtxmlpatterns sonnet syntax-highlighting qtquickcontrols
   ];
   propagatedBuildInputs = [ kparts ];
 }

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

···
 
 {
   attica = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/attica-5.37.0.tar.xz";
-      sha256 = "13jqk4w9crh8pca6n9334l1gb8bmwf86pa36k0mfh5j19dq72g2p";
-      name = "attica-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/attica-5.38.0.tar.xz";
+      sha256 = "12smdcd7lcyjqiw0bsk3lwivrl6cvmiqv5cqaw0gz8flhvk29w96";
+      name = "attica-5.38.0.tar.xz";
     };
   };
   baloo = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/baloo-5.37.0.tar.xz";
-      sha256 = "19sl07lhjrri40vfi8wl6azgmg08lgfb98xx110j6spjbbbnww79";
-      name = "baloo-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/baloo-5.38.0.tar.xz";
+      sha256 = "14522akyxg36lclfblp65xai95i9hiydqjhkmfkadjbq82wm9s9i";
+      name = "baloo-5.38.0.tar.xz";
     };
   };
   bluez-qt = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/bluez-qt-5.37.0.tar.xz";
-      sha256 = "1x6nj7vsn0sp9rckzkcbl6fwm7qzj5w98w2qys1fndb1spl7av8s";
-      name = "bluez-qt-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/bluez-qt-5.38.0.tar.xz";
+      sha256 = "0hanmygp4smbvczxn4dj997z3bln32p017z0r26z89m2p0b2ylwv";
+      name = "bluez-qt-5.38.0.tar.xz";
     };
   };
   breeze-icons = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/breeze-icons-5.37.0.tar.xz";
-      sha256 = "17nr2phd0nxyx49igvl170ksikapgc4365z26pw0dmmw41llcbxw";
-      name = "breeze-icons-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/breeze-icons-5.38.0.tar.xz";
+      sha256 = "09afi6c4h31ycs6aa85lqbmn392zi532zf8fp7ll43xxjv9isac9";
+      name = "breeze-icons-5.38.0.tar.xz";
     };
   };
   extra-cmake-modules = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/extra-cmake-modules-5.37.0.tar.xz";
-      sha256 = "1jr7nmhh4kyz1g454qkldfhimfjvvylqa19zna5iak08bkq8q696";
-      name = "extra-cmake-modules-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/extra-cmake-modules-5.38.0.tar.xz";
+      sha256 = "0ci3vdzdbcrbnxpqvf4hcwcrzz1ijhifp8b99wh3k53rinnai231";
+      name = "extra-cmake-modules-5.38.0.tar.xz";
     };
   };
   frameworkintegration = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/frameworkintegration-5.37.0.tar.xz";
-      sha256 = "0pcy3hjqbahbx65yxz5bl0h2ah4y3fb7mq3pj1rrp2cpp92s135a";
-      name = "frameworkintegration-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/frameworkintegration-5.38.0.tar.xz";
+      sha256 = "0w1n3czgsnnmaqwypy3mpci8s4ppv9030zxw7ka7rsvwgkpqijq8";
+      name = "frameworkintegration-5.38.0.tar.xz";
     };
   };
   kactivities = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kactivities-5.37.0.tar.xz";
-      sha256 = "005xvzp10kvwcsl2w6ghcqgqnr2rdvv9w61i4y44y25vcb85g26v";
-      name = "kactivities-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kactivities-5.38.0.tar.xz";
+      sha256 = "0grm0cilc80g5ih2hqhwgwm35mlfnrs343j6ixkd9s0mflv2b798";
+      name = "kactivities-5.38.0.tar.xz";
     };
   };
   kactivities-stats = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kactivities-stats-5.37.0.tar.xz";
-      sha256 = "09zsdzf77palmww7x3dzinl0hxrm4z0q0yc2fmf0d7z6cfl695y2";
-      name = "kactivities-stats-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kactivities-stats-5.38.0.tar.xz";
+      sha256 = "0s57iz04n3m4fpqrqflda6vpk4l1mnf0nyz1iyza382fb375afd2";
+      name = "kactivities-stats-5.38.0.tar.xz";
     };
   };
   kapidox = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kapidox-5.37.0.tar.xz";
-      sha256 = "1xwkaamifxjghv158rwslndfd9z70rm9ixnp1mmkgw8radwsqg5v";
-      name = "kapidox-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kapidox-5.38.0.tar.xz";
+      sha256 = "1j4k75lhqdnsxmgyvblla0627qvgabxivw6limfdb3rdpmqdxj76";
+      name = "kapidox-5.38.0.tar.xz";
     };
   };
   karchive = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/karchive-5.37.0.tar.xz";
-      sha256 = "1599lql0kcx705313bfvbazr7rayr6vsiwrpiq6iwljzc7lli1im";
-      name = "karchive-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/karchive-5.38.0.tar.xz";
+      sha256 = "0n5nxd3v9ljjff0r6k4xrvy5hj057b7c7jzcq258harl359d8m4k";
+      name = "karchive-5.38.0.tar.xz";
     };
   };
   kauth = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kauth-5.37.0.tar.xz";
-      sha256 = "0ciz28bvbvxlv0iz0cgs31x2m1czkki21ypzqj8rg2ix8jw2p65w";
-      name = "kauth-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kauth-5.38.0.tar.xz";
+      sha256 = "12nyfbilz4v4b2i5x191iph3jj4lcpw7z1rh0xrv5y1v7dczk6i7";
+      name = "kauth-5.38.0.tar.xz";
     };
   };
   kbookmarks = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kbookmarks-5.37.0.tar.xz";
-      sha256 = "0l6rkj0b7hk2wg6dypj1dkl8pcd1vx89gaiixbhkd3vf7jp46n41";
-      name = "kbookmarks-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kbookmarks-5.38.0.tar.xz";
+      sha256 = "0s230mcwmrg0qpz42sg804m96j2xpnwj4bdp0mfv08x3jasqpbrq";
+      name = "kbookmarks-5.38.0.tar.xz";
     };
   };
   kcmutils = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kcmutils-5.37.0.tar.xz";
-      sha256 = "1ik1505f16swsmvrv62dacis33f1ccnmkw3zbhb84vbrbqyskvzx";
-      name = "kcmutils-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kcmutils-5.38.0.tar.xz";
+      sha256 = "0n6f2xvl5v8fwfxpdl6la1hb01dh4h1pcdrf05nn60v0rqg9f58b";
+      name = "kcmutils-5.38.0.tar.xz";
     };
   };
   kcodecs = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kcodecs-5.37.0.tar.xz";
-      sha256 = "0kmk97b5vbnyb3xjxwmg3l47aka8mkf50g4p7wvr096qwplffbva";
-      name = "kcodecs-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kcodecs-5.38.0.tar.xz";
+      sha256 = "0cnxhaj5jk7f3j9q4hzphc3nm3vdaqwy9xab5d4nvn1kv8vjv8ii";
+      name = "kcodecs-5.38.0.tar.xz";
     };
   };
   kcompletion = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kcompletion-5.37.0.tar.xz";
-      sha256 = "0qhjkqmd1jjy50hlzsdxwgnjwpfdrz3njl5n88h3nzp83yjv1ljz";
-      name = "kcompletion-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kcompletion-5.38.0.tar.xz";
+      sha256 = "0f955w67wrk15rdmglrk7k0xc5i6kah12bpb078xhzlyfackg52w";
+      name = "kcompletion-5.38.0.tar.xz";
     };
   };
   kconfig = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kconfig-5.37.0.tar.xz";
-      sha256 = "1f0y2gmwy05b17clr7vg1zp18l1z0fd757v02ha7cwd64yznyr5d";
-      name = "kconfig-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kconfig-5.38.0.tar.xz";
+      sha256 = "0fi428dsr6qpa9336wcfic6hyix6l2p9s135w00qzdwhdkr4lx3r";
+      name = "kconfig-5.38.0.tar.xz";
     };
   };
   kconfigwidgets = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kconfigwidgets-5.37.0.tar.xz";
-      sha256 = "001d1nj8q6xpl71rwm15rnvy5ajyxpvknvf4ic7p5pbik3021bs6";
-      name = "kconfigwidgets-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kconfigwidgets-5.38.0.tar.xz";
+      sha256 = "0w319d94wxn90dbbdfw5zrn2ddnv9vb7wldkpvvycq7yxrhsfw0x";
+      name = "kconfigwidgets-5.38.0.tar.xz";
     };
   };
   kcoreaddons = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kcoreaddons-5.37.0.tar.xz";
-      sha256 = "0a45sz11d7b2d8sbr9z57mv337nbhd94fiqk3issw470n0y46g3y";
-      name = "kcoreaddons-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kcoreaddons-5.38.0.tar.xz";
+      sha256 = "1m3mn9fhllwcidzji2l26k5yxzrqkbyjdly04nh3s5rf823dvqwv";
+      name = "kcoreaddons-5.38.0.tar.xz";
     };
   };
   kcrash = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kcrash-5.37.0.tar.xz";
-      sha256 = "16k2pwf3s3adgayd9vq7kk8c5gnq9g6wra4psrvs3a3c5k5am5y0";
-      name = "kcrash-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kcrash-5.38.0.tar.xz";
+      sha256 = "1a8hvyhwa112wx4ldadlrxpyda6qpial387j07dr1jq1cnzr0p11";
+      name = "kcrash-5.38.0.tar.xz";
     };
   };
   kdbusaddons = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdbusaddons-5.37.0.tar.xz";
-      sha256 = "0745arkp4wnpwyhjq02h7lfac049cmlg5qwhf96i7ss0w54vch4i";
-      name = "kdbusaddons-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdbusaddons-5.38.0.tar.xz";
+      sha256 = "1mw9sl82y2aj7l2xj1skrbxbyv55br60h6f61r4f1mqcaxaqj7qw";
+      name = "kdbusaddons-5.38.0.tar.xz";
     };
   };
   kdeclarative = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdeclarative-5.37.0.tar.xz";
-      sha256 = "1ish46m2dpnpqjnf8g660clcg7ky65w11cbk2m79pwyhqvhxgggj";
-      name = "kdeclarative-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdeclarative-5.38.0.tar.xz";
+      sha256 = "1966sxzhdkzi2lwg5ixhrx0yg10plbvn9lsjgnj9crghaajsnf4b";
+      name = "kdeclarative-5.38.0.tar.xz";
     };
   };
   kded = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kded-5.37.0.tar.xz";
-      sha256 = "162s5qx2qb0bi889f8jjvd3ci31azd8iwp25i04vwi0lzglwb8gy";
-      name = "kded-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kded-5.38.0.tar.xz";
+      sha256 = "0xsjzj5jx4wsrq5fnbv6raqlr11shz20p2mvypf5wfvq2c1vb5lb";
+      name = "kded-5.38.0.tar.xz";
     };
   };
   kdelibs4support = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/portingAids/kdelibs4support-5.37.0.tar.xz";
-      sha256 = "1zz100m1sqfmg3ni7023b99qn79jhdd2ryw6534axl5zgn0sglh9";
-      name = "kdelibs4support-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/portingAids/kdelibs4support-5.38.0.tar.xz";
+      sha256 = "06vlgziy212pwm4z9r8rbfa9ziwx3nkihy9b25m13gbh60baqapp";
+      name = "kdelibs4support-5.38.0.tar.xz";
     };
   };
   kdesignerplugin = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdesignerplugin-5.37.0.tar.xz";
-      sha256 = "1197003bqcdpsyn6faasr2nhaadh7ryg92vjpqim78af3vwinsdw";
-      name = "kdesignerplugin-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdesignerplugin-5.38.0.tar.xz";
+      sha256 = "0rivjxgsxvsgk24lnzsqpzqr7m1i1faqnbby3rnkw2059z28l0y6";
+      name = "kdesignerplugin-5.38.0.tar.xz";
     };
   };
   kdesu = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdesu-5.37.0.tar.xz";
-      sha256 = "1qfhkzk6l9rfdyiad8y6k30zlhziz3q2dxvxkmnghxmkg98yhdza";
-      name = "kdesu-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdesu-5.38.0.tar.xz";
+      sha256 = "1c9j2zih7r0jph41kzxnxpri9snphm1k4w4rs1q6zawwz8a5kcr5";
+      name = "kdesu-5.38.0.tar.xz";
     };
   };
   kdewebkit = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdewebkit-5.37.0.tar.xz";
-      sha256 = "1ph3a50wix42hmsbc9jbfxla172aihjx9yzp9rza09j1a7va3hg1";
-      name = "kdewebkit-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdewebkit-5.38.0.tar.xz";
+      sha256 = "1cncbjkgrbrnvwx3izjqh9hqiw9bg6aqaq09f8bdryvr8537b0zf";
+      name = "kdewebkit-5.38.0.tar.xz";
     };
   };
   kdnssd = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdnssd-5.37.0.tar.xz";
-      sha256 = "03rd6znn2qwndn4m3bb03slwyic06ry535rawgyh06lfps0fcc5z";
-      name = "kdnssd-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdnssd-5.38.0.tar.xz";
+      sha256 = "101gygxrq2m3yfz6j0ldspib3pm3jjvqz505j3h15zj59qcwqw0x";
+      name = "kdnssd-5.38.0.tar.xz";
     };
   };
   kdoctools = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kdoctools-5.37.0.tar.xz";
-      sha256 = "0gbc5qqim6262hvkl9pf6rynnblxb3hsw3c4ars03ip7n761y0zl";
-      name = "kdoctools-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kdoctools-5.38.0.tar.xz";
+      sha256 = "0fbv7i1930rl496psny7nfiixvsnaq535h1zggwkwv6i9dh7wpy9";
+      name = "kdoctools-5.38.0.tar.xz";
     };
   };
   kemoticons = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kemoticons-5.37.0.tar.xz";
-      sha256 = "1cx978s1dm3v1jh4aymncxs44iizdqp174dqg9m5mf043fcvvinq";
-      name = "kemoticons-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kemoticons-5.38.0.tar.xz";
+      sha256 = "1c0991yd8jx2diy5ynl11h5qqyapn1dsir2gy04y8m90h944vdd5";
+      name = "kemoticons-5.38.0.tar.xz";
     };
   };
   kfilemetadata = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kfilemetadata-5.37.0.tar.xz";
-      sha256 = "17mbm6pdi6ac61kj2qzxf7y3rbxhxg9rwqr7qy766gh3img2vq8p";
-      name = "kfilemetadata-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kfilemetadata-5.38.0.tar.xz";
+      sha256 = "1815r9lx99h9kzbk67bfk41jya3y2hsi112fsgpv3m4mg028pklm";
+      name = "kfilemetadata-5.38.0.tar.xz";
     };
   };
   kglobalaccel = {
-    version = "5.37.0";
+    version = "5.38.1";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kglobalaccel-5.37.0.tar.xz";
-      sha256 = "1d84q3r6q5n2lclym9a9m1brfqnq3p3dykfpzvhcba3bjxh3cdsb";
-      name = "kglobalaccel-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kglobalaccel-5.38.1.tar.xz";
+      sha256 = "0si3bxxa6wj008j6rr6a1ljnsbmim4z0pqyx1z48ih4qamcfpkin";
+      name = "kglobalaccel-5.38.1.tar.xz";
     };
   };
   kguiaddons = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kguiaddons-5.37.0.tar.xz";
-      sha256 = "13g6nlw8fk135i6z3f8ichy8whxd6v4rycg80dlvm25h66rg6vn5";
-      name = "kguiaddons-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kguiaddons-5.38.0.tar.xz";
+      sha256 = "1jks0hwn665hlypl0qfhi5r0prqzrg1gv4skc88zp1kgx05kb9h1";
+      name = "kguiaddons-5.38.0.tar.xz";
     };
   };
   khtml = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/portingAids/khtml-5.37.0.tar.xz";
-      sha256 = "1n0mx2xy9n5ffhvh58z3kn61aa7dhppsrwgxk697pybqy1h45ah2";
-      name = "khtml-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/portingAids/khtml-5.38.0.tar.xz";
+      sha256 = "0fa61va3dbwml40y4scxks223swlb8vf5730wr7rijl91lz1adgy";
+      name = "khtml-5.38.0.tar.xz";
     };
   };
   ki18n = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/ki18n-5.37.0.tar.xz";
-      sha256 = "1c1sy4pbhlwsajs2972brdmma5val72gkil6k0a0f58nfvvg952d";
-      name = "ki18n-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/ki18n-5.38.0.tar.xz";
+      sha256 = "0z9arj2s4fn04vavl6ad3avl1p5yr3mgr2n802lmvy2wlqicy314";
+      name = "ki18n-5.38.0.tar.xz";
     };
   };
   kiconthemes = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kiconthemes-5.37.0.tar.xz";
-      sha256 = "1j7mgfsvxa24nf1d9xyn2jv9y9j523vghsvsm73x8d3ijibchfxq";
-      name = "kiconthemes-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kiconthemes-5.38.0.tar.xz";
+      sha256 = "01xa30r2cx312vbmz2c3x8vvna1cqb6fx91cjp4aivp9q4jwaz9a";
+      name = "kiconthemes-5.38.0.tar.xz";
     };
   };
   kidletime = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kidletime-5.37.0.tar.xz";
-      sha256 = "01m4q3l2yq83f2dpbv6jry7cjkj6bqdgfpy5b8byaf1gf9w2firs";
-      name = "kidletime-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kidletime-5.38.0.tar.xz";
+      sha256 = "1i91w9hcb2k5n9qz8q7k2z44z9ss7r9i2zsg9vnl8am7dqqhmlsv";
+      name = "kidletime-5.38.0.tar.xz";
     };
   };
   kimageformats = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kimageformats-5.37.0.tar.xz";
-      sha256 = "1knha6wjzjs0vnkljwpfinzg3hg2jyh9c07ifqvd47cprl96ickg";
-      name = "kimageformats-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kimageformats-5.38.0.tar.xz";
+      sha256 = "0q78shcwgczdm5ylhbp9fnq70w3hqzkbynp2vpyyg5pjaam8xjlp";
+      name = "kimageformats-5.38.0.tar.xz";
     };
   };
   kinit = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kinit-5.37.0.tar.xz";
-      sha256 = "0b7dyy4hqyf6wk7gg2l23ldnji2zl8vzyj5wd5qh4yi7rdl6js5r";
-      name = "kinit-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kinit-5.38.0.tar.xz";
+      sha256 = "0k4i0zrwkz088vjkk7d7whwhkrjvqqhdigspzf58d1laryiy0jdf";
+      name = "kinit-5.38.0.tar.xz";
     };
   };
   kio = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kio-5.37.0.tar.xz";
-      sha256 = "0nxchbhs8p2d4243dyp7qa65g1p6r3ic2h6dz7w0aa0qzsy8wi29";
-      name = "kio-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kio-5.38.0.tar.xz";
+      sha256 = "15qmr2ghrj7pgqxrgpvhdp9g5vaap9mzlmry6ayph75m1afb4fpl";
+      name = "kio-5.38.0.tar.xz";
     };
   };
   kirigami2 = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kirigami2-5.37.0.tar.xz";
-      sha256 = "1z42rsi8nzshrbv8m8vxkay4dq46kggglhgxbbgg2q00y8gjq9dd";
-      name = "kirigami2-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kirigami2-5.38.0.tar.xz";
+      sha256 = "18k41j5ijmgmzgl2rv4ac0bnxlax3505zi1nmqm8bkdpznhfr13c";
+      name = "kirigami2-5.38.0.tar.xz";
     };
   };
   kitemmodels = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kitemmodels-5.37.0.tar.xz";
-      sha256 = "1nlpzzp4m0ghfz1p2hrwn4lbhjhxc8b8q8kbzqbh9hmwmimbzzrr";
-      name = "kitemmodels-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kitemmodels-5.38.0.tar.xz";
+      sha256 = "0s20in4jjd2pvv9bn79lvgqqlf806hw014icp51f5hfknrhpdyjc";
+      name = "kitemmodels-5.38.0.tar.xz";
     };
   };
   kitemviews = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kitemviews-5.37.0.tar.xz";
-      sha256 = "17r7vnlyiiifhrz4gb4fifshn1jb4c67lhadczi8d301rzk7wwsm";
-      name = "kitemviews-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kitemviews-5.38.0.tar.xz";
+      sha256 = "0ldi8qzs2sbhz8l57nshjrnwhjl9mhw90kcqw71cldp41wm0pps6";
+      name = "kitemviews-5.38.0.tar.xz";
     };
   };
   kjobwidgets = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kjobwidgets-5.37.0.tar.xz";
-      sha256 = "1162dxhpspd7p1735npp0amrxr5b0j467f5651k2rv6mvqfmqr4b";
-      name = "kjobwidgets-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kjobwidgets-5.38.0.tar.xz";
+      sha256 = "0vp6nc73c9788nrib742k9nzqbx4m8m77ipqh9dnnkx4ggrhsd55";
+      name = "kjobwidgets-5.38.0.tar.xz";
     };
   };
   kjs = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/portingAids/kjs-5.37.0.tar.xz";
-      sha256 = "046hy8ji4i6p2xp5gnqa8dk82sv6sbh4xg67y79i82bbi97dvq9b";
-      name = "kjs-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/portingAids/kjs-5.38.0.tar.xz";
+      sha256 = "0diw580k5kyv60bqhnxhqinlrn0b3p3n89iy0kdgjgnr6197fwy1";
+      name = "kjs-5.38.0.tar.xz";
     };
   };
   kjsembed = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/portingAids/kjsembed-5.37.0.tar.xz";
-      sha256 = "0w2wk5azf1b45db58qj0cdc1l056x9s1xcd09ibavx5xmdvq6br0";
-      name = "kjsembed-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/portingAids/kjsembed-5.38.0.tar.xz";
+      sha256 = "0nb07n54208gnmag7h3dhc8hri2s83ln1c9wq6c0xw7jchaz9z8a";
+      name = "kjsembed-5.38.0.tar.xz";
     };
   };
   kmediaplayer = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/portingAids/kmediaplayer-5.37.0.tar.xz";
-      sha256 = "0fqxrkcwwzg11zsax9q169lisnfp9jsqg4ccd6xvv8kpkz3g04jp";
-      name = "kmediaplayer-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/portingAids/kmediaplayer-5.38.0.tar.xz";
+      sha256 = "1qb2g8j871gf38i2dk2j9ags848fa3kqdjl3l4924hf28az0g736";
+      name = "kmediaplayer-5.38.0.tar.xz";
     };
   };
   knewstuff = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/knewstuff-5.37.0.tar.xz";
-      sha256 = "1scnxhxx4g8j4wml6x8i5v00rpaxyzzcm7vqbra2axbql5d8g8ny";
-      name = "knewstuff-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/knewstuff-5.38.0.tar.xz";
+      sha256 = "1l4cmfcsljg7v5l6341fxcp7c7i615l8351l941dwcmw4yng0lj0";
+      name = "knewstuff-5.38.0.tar.xz";
     };
   };
   knotifications = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/knotifications-5.37.0.tar.xz";
-      sha256 = "0gvv6jal7n4m3y30ragjlyhghq3y2782d422im9klxqzlgdgvkb6";
-      name = "knotifications-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/knotifications-5.38.0.tar.xz";
+      sha256 = "1jvmv2hi3dbf0bd2b61l9s5lb1dx2rjl9z7pw1fb5j20910k6zgd";
+      name = "knotifications-5.38.0.tar.xz";
     };
   };
   knotifyconfig = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/knotifyconfig-5.37.0.tar.xz";
-      sha256 = "14kjckynszv8015p17j578l3knmkmw25d8r8ks4wavgj3db9bik5";
-      name = "knotifyconfig-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/knotifyconfig-5.38.0.tar.xz";
+      sha256 = "05hgglm6ypbaplxr43632zh5fmgsz6543110169k9fbjnczyhcyk";
+      name = "knotifyconfig-5.38.0.tar.xz";
     };
   };
   kpackage = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kpackage-5.37.0.tar.xz";
-      sha256 = "1ikf55q2pk8vm70pqm7rmakja309zjh9z1lg0xqslq1pqd6xki7s";
-      name = "kpackage-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kpackage-5.38.0.tar.xz";
+      sha256 = "0v4j3kqgg52rlmdxmd98aqw0hk7i2xqsw9mhhxfs9c7vm1x05sxn";
+      name = "kpackage-5.38.0.tar.xz";
     };
   };
   kparts = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kparts-5.37.0.tar.xz";
-      sha256 = "0jrd8idkz8nhkda2rwgf8rysqngiv4r5ajmrzp2kfz1pr91a6l5h";
-      name = "kparts-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kparts-5.38.0.tar.xz";
+      sha256 = "19ba749pwnb7xvmr7lryn6z53zb49hqn0xq4j9fmbic95nh039zp";
+      name = "kparts-5.38.0.tar.xz";
     };
   };
   kpeople = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kpeople-5.37.0.tar.xz";
-      sha256 = "1qgp4wqp985ac1m9wakpsvk3c2driwkwrjkc3aic7dyr1p456qsf";
-      name = "kpeople-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kpeople-5.38.0.tar.xz";
+      sha256 = "0yd29436bgfw6jjjr9n38hx8561mrlgl5vynci6ng9bx1jflay0x";
+      name = "kpeople-5.38.0.tar.xz";
     };
   };
   kplotting = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kplotting-5.37.0.tar.xz";
-      sha256 = "0k4s0qvhjm9h1bmg16l32g4bsdrp2jrcila4dgzvrb56447px0zw";
-      name = "kplotting-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kplotting-5.38.0.tar.xz";
+      sha256 = "1hvfqm6i5fsyssb51w3yybsil8h9cbqgd2n8k0wnz99m8xifzn72";
+      name = "kplotting-5.38.0.tar.xz";
     };
   };
   kpty = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kpty-5.37.0.tar.xz";
-      sha256 = "0wb873r1ycgi11s0qx3lhvz54703yz5sax6fb6wdmri5c05gzd5a";
-      name = "kpty-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kpty-5.38.0.tar.xz";
+      sha256 = "0cgh8hixrplgc280652jlvk8ibcddmjvflwb0gjawd9iq7lcb66y";
+      name = "kpty-5.38.0.tar.xz";
     };
   };
   kross = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/portingAids/kross-5.37.0.tar.xz";
-      sha256 = "06pk6f6v82pd7x9rsmkhkp5r9sgcbrc503lqckl8d7argbb7j4k1";
-      name = "kross-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/portingAids/kross-5.38.0.tar.xz";
+      sha256 = "1dccg214cqpyn3nninalpknglfmchz2k1fk4rlgq53wf4n6w23b7";
+      name = "kross-5.38.0.tar.xz";
     };
   };
   krunner = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/krunner-5.37.0.tar.xz";
-      sha256 = "171qbhr1yszl2gcffm47p5wiwj71w9yhvk6srhvfpiwfyh61a4ld";
-      name = "krunner-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/krunner-5.38.0.tar.xz";
+      sha256 = "16fhl5zm8scyxk83mpkavvzkn23qgzcblg315jy6klr5bz9jxgcm";
+      name = "krunner-5.38.0.tar.xz";
     };
   };
   kservice = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kservice-5.37.0.tar.xz";
-      sha256 = "1zxs5yzd3rmy33vsip4c4igk9g38kzaggw8c29sxmgr8vgdrnvhr";
-      name = "kservice-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kservice-5.38.0.tar.xz";
+      sha256 = "0zaamvxhfx4xdy2m8spyhi0hdv6p0fn5hqn9pyi5l8xdixnwjc9d";
+      name = "kservice-5.38.0.tar.xz";
     };
   };
   ktexteditor = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/ktexteditor-5.37.0.tar.xz";
-      sha256 = "0y04s1nwkf0np6iymjxf0jssin28qw2901kpb3iw8gd52ni5rrks";
-      name = "ktexteditor-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/ktexteditor-5.38.0.tar.xz";
+      sha256 = "195ygv1j4wfvly31g22wxz9sshhqyi1yyf2mv1v63d9ci88v7rri";
+      name = "ktexteditor-5.38.0.tar.xz";
     };
   };
   ktextwidgets = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/ktextwidgets-5.37.0.tar.xz";
-      sha256 = "1p8ns75sbnapm6ds16hx36q9vlnz9phgy28rx0gm1ckxqvm4yzr5";
-      name = "ktextwidgets-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/ktextwidgets-5.38.0.tar.xz";
+      sha256 = "120jxab8w1vhqcckda51r0x2pmfb2qd2h6inhivl72c4m5x89w7f";
+      name = "ktextwidgets-5.38.0.tar.xz";
     };
   };
   kunitconversion = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kunitconversion-5.37.0.tar.xz";
-      sha256 = "1qvq61sbv9naj5ndi5xjwx7ami0xa6bqiajr912kbbbp2257cjsi";
-      name = "kunitconversion-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kunitconversion-5.38.0.tar.xz";
+      sha256 = "10k0xfb11r7l1bdnlanqgdwwx8wrs8bmnswb2y85xxr7wwsqnlvc";
+      name = "kunitconversion-5.38.0.tar.xz";
     };
   };
   kwallet = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kwallet-5.37.0.tar.xz";
-      sha256 = "1l7jl3y0rzx2whnbp6w5p6kg71vwyccp2nwxxgcxr6541m0nihsz";
-      name = "kwallet-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kwallet-5.38.0.tar.xz";
+      sha256 = "1qysdj4nmkxywj7bzqdc78ifnqjnkrz9qbp4a49acpng2y4zw1nw";
+      name = "kwallet-5.38.0.tar.xz";
     };
   };
   kwayland = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kwayland-5.37.0.tar.xz";
-      sha256 = "0d4c8l8k38pgj73kzlf1hsq52w31wy9wgpwph1bv0cq5yn2rjiyr";
-      name = "kwayland-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kwayland-5.38.0.tar.xz";
+      sha256 = "0gd58nvyc39waj7vv2c68r59qqpv0jppm95548j2p924w48syjj0";
+      name = "kwayland-5.38.0.tar.xz";
     };
   };
   kwidgetsaddons = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kwidgetsaddons-5.37.0.tar.xz";
-      sha256 = "1jmk377r1h4is2il7chh6bq8wbj21psf4b1yiw84iivg38vlpid4";
-      name = "kwidgetsaddons-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kwidgetsaddons-5.38.0.tar.xz";
+      sha256 = "1yh48qxdqz3rk020wr897vkzsi4nhh37lxbg6211xrlirn0lzvj5";
+      name = "kwidgetsaddons-5.38.0.tar.xz";
     };
   };
   kwindowsystem = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kwindowsystem-5.37.0.tar.xz";
-      sha256 = "0pd2n0j5pdv1x7wf4mwcpimnah73g6l0xidhqbpg37p829jix2k2";
-      name = "kwindowsystem-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kwindowsystem-5.38.0.tar.xz";
+      sha256 = "02xrin8lshvqkw12d0692z40h3g61f4crh28jcmi5zqlaxiyn5ic";
+      name = "kwindowsystem-5.38.0.tar.xz";
     };
   };
   kxmlgui = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kxmlgui-5.37.0.tar.xz";
-      sha256 = "0jrvjlxkg9knj61b2gj2w6l96jlmww9kn4ij808ir35365x3cdg2";
-      name = "kxmlgui-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kxmlgui-5.38.0.tar.xz";
+      sha256 = "12cmyhm05nkr9xj7cpnqihrlndfqn1kjkzhcn1ywj20y1gd3mxv4";
+      name = "kxmlgui-5.38.0.tar.xz";
     };
   };
   kxmlrpcclient = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/kxmlrpcclient-5.37.0.tar.xz";
-      sha256 = "1jn9v86dpfx43qcdcsp6lpnga9q6aa5vxjkkg4wg0wbxmw4w9gvq";
-      name = "kxmlrpcclient-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/kxmlrpcclient-5.38.0.tar.xz";
+      sha256 = "0g9ah59h8vq68yg4pfdbqx44xrs856wrr181rsdbsizj0qj3hyaa";
+      name = "kxmlrpcclient-5.38.0.tar.xz";
     };
   };
   modemmanager-qt = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/modemmanager-qt-5.37.0.tar.xz";
-      sha256 = "1fqf43kvj1v1mcdlbfxbh6sh3ycvg35aml2ywh2a684iz4qzq1aq";
-      name = "modemmanager-qt-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/modemmanager-qt-5.38.0.tar.xz";
+      sha256 = "18ham8lrxblywc634n49237js5y5k6qgjf5zrjc8gzapn934l89w";
+      name = "modemmanager-qt-5.38.0.tar.xz";
     };
   };
   networkmanager-qt = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/networkmanager-qt-5.37.0.tar.xz";
-      sha256 = "01px9n97gyvyyfg3dp1k7dik9fprgx9i28hg8wjr2rb5dlr99jd1";
-      name = "networkmanager-qt-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/networkmanager-qt-5.38.0.tar.xz";
+      sha256 = "10d28nrkppmmfl9pwq2hkrvi461acf29djdzala4l37mp4dwvbf8";
+      name = "networkmanager-qt-5.38.0.tar.xz";
     };
   };
   oxygen-icons5 = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/oxygen-icons5-5.37.0.tar.xz";
-      sha256 = "1rns7n93f83qp5q11a7r5y87y0hvc0q95ar57cqy0fxsqrg4614h";
-      name = "oxygen-icons5-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/oxygen-icons5-5.38.0.tar.xz";
+      sha256 = "0fk97r3br5myqpnfalz67l5hkamxc5vc5swa68wpg1xih6jc3iid";
+      name = "oxygen-icons5-5.38.0.tar.xz";
     };
   };
   plasma-framework = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/plasma-framework-5.37.0.tar.xz";
-      sha256 = "0kamvxfzrbx3msn0cp3k20clqchz9jg5wlazz3h6p6zmrk5v16bh";
-      name = "plasma-framework-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/plasma-framework-5.38.0.tar.xz";
+      sha256 = "1dvhqfi34v44h0wj0m68k477hmx53x9zsf4mh03xq164w1yz68sg";
+      name = "plasma-framework-5.38.0.tar.xz";
     };
   };
   prison = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/prison-5.37.0.tar.xz";
-      sha256 = "1icsirwfh7zscm8x9g2gp7aqzhs81ahhjflwjcwpz9bh0r9f1wb7";
-      name = "prison-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/prison-5.38.0.tar.xz";
+      sha256 = "0prj3z6s3aighmk4qarfljca7j9cy7ypvgh8rv5di3jb2v4nbg4m";
+      name = "prison-5.38.0.tar.xz";
     };
   };
   solid = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/solid-5.37.0.tar.xz";
-      sha256 = "1gb9gnp1a11q5abl97b7sq1if2rqcrcs0f33sakpxf1z9y0ppg8l";
-      name = "solid-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/solid-5.38.0.tar.xz";
+      sha256 = "1b3c5drx4m1x4ai0ziz0yan16a5s3ghf0py37mb92qyimq586lhh";
+      name = "solid-5.38.0.tar.xz";
     };
   };
   sonnet = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/sonnet-5.37.0.tar.xz";
-      sha256 = "0sb6i464riadgb2q73nj0vy6xavr2m1sszrvghr20nj7i64f3kk0";
-      name = "sonnet-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/sonnet-5.38.0.tar.xz";
+      sha256 = "1355p88swnk828gsbnm3v4gryffnwbzjcdq49k8jwywzb65bnwxa";
+      name = "sonnet-5.38.0.tar.xz";
     };
   };
   syntax-highlighting = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/syntax-highlighting-5.37.0.tar.xz";
-      sha256 = "1l56pb84z7sy0qq8xkd5w5v5418bm9n4qds0vd39ch655d47bl72";
-      name = "syntax-highlighting-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/syntax-highlighting-5.38.0.tar.xz";
+      sha256 = "101ng0l3jfg8x9bns9z38jk3iayijwcb299kf860vfy0nki8gf6l";
+      name = "syntax-highlighting-5.38.0.tar.xz";
     };
   };
   threadweaver = {
-    version = "5.37.0";
+    version = "5.38.0";
     src = fetchurl {
-      url = "${mirror}/stable/frameworks/5.37/threadweaver-5.37.0.tar.xz";
-      sha256 = "1hb3721r1zbbyj211886sfkcxk18k0rsdhcg9ssagx10f29rpxx4";
-      name = "threadweaver-5.37.0.tar.xz";
+      url = "${mirror}/stable/frameworks/5.38/threadweaver-5.38.0.tar.xz";
+      sha256 = "1d89l9lknc1q25cz9r8iwc1a102q788mj01ghnl6ydss65rclvfv";
+      name = "threadweaver-5.38.0.tar.xz";
     };
   };
 }

pkgs/development/libraries/libffi/default.nix

···
     sha256 = "0dya49bnhianl0r65m65xndz6ls2jn1xngyn72gd28ls3n7bnvnh";
   };
 
-  patches = stdenv.lib.optional stdenv.isCygwin ./3.2.1-cygwin.patch;
+  patches = stdenv.lib.optional stdenv.isCygwin ./3.2.1-cygwin.patch ++
+    stdenv.lib.optional stdenv.isAarch64 (fetchurl {
+      url = https://src.fedoraproject.org/rpms/libffi/raw/ccffc1700abfadb0969495a6e51b964117fc03f6/f/libffi-aarch64-rhbz1174037.patch;
+      sha256 = "1vpirrgny43hp0885rswgv3xski8hg7791vskpbg3wdjdpb20wbc";
+    });
 
   outputs = [ "out" "dev" "man" "info" ];
 

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 = "http://sourceforge.net/projects/libipfix/files/libipfix/libipfix_110209.tgz";
     sha256 = "0h7v0sxjjdc41hl5vq2x0yhyn04bczl11bqm97825mivrvfymhn6";
   };
   meta = with stdenv.lib; {

pkgs/development/libraries/sqlite-amalgamation/default.nix pkgs/games/zandronum/sqlite.nix

···
 { lib, stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation {
-  name = "sqlite-amalgamation-201505302257";
+  name = "sqlite-zandronum-3.0";
 
   src = fetchurl {
-    url = "https://www.sqlite.org/snapshot/sqlite-amalgamation-201505302257.zip";
-    sha256 = "0488wjrpnxd61g7pcka6fckx0q8yl1k26i6q5hrmkm92qcpml76h";
+    url = "https://www.sqlite.org/2017/sqlite-autoconf-3180000.tar.gz";
+    sha256 = "0p5cx7nbjxk7glcm277ypi5w4gv144qazw79ql47svlpccj62mrp";
   };
 
   phases = [ "unpackPhase" "buildPhase" ];
 
-  buildInputs = [ unzip ];
-
-  unpackPhase = ''
-    unzip $src
-  '';
-
   buildPhase = ''
     mkdir -p $out
     cp sqlite3.c $out/
     cp sqlite3.h $out/
     cp sqlite3ext.h $out/
-    cp shell.c $out/
   '';
 
   meta = {

pkgs/development/pharo/launcher/default.nix

···
      secs=5
      echo -n "Running headless Pharo for $secs seconds to check for a crash... "
      timeout $secs \
-       "${pharo}/bin/pharo" -nodisplay PharoLauncher.image --no-quit eval 'true'
+       "${pharo}/bin/pharo" --nodisplay PharoLauncher.image --no-quit eval 'true'
      test "$?" == 124 && echo "ok")
   '';
 

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

···
   '';
 
   propagatedBuildInputs = [ vega pandas ipython traitlets ];
+  # Disabling checks, MockRequest object has no method send()
+  doCheck = false;
 
   meta = with stdenv.lib; {
     description = "A declarative statistical visualization library for Python.";

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

···
 { gui ? true,
   buildPythonPackage, fetchFromGitHub, lib,
   sphinx_1_2, lxml, isodate, numpy, pytest,
-  tkinter ? null,
+  tkinter ? null, py3to2,
   ... }:
 
 let
···
   buildInputs = [
     sphinx_1_2
     pytest
+    py3to2
   ];
   propagatedBuildInputs = [
     lxml

pkgs/development/python-modules/cachetools/1.nix

···
+{ stdenv, buildPythonPackage, fetchPypi, isPyPy }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "cachetools";
+  version = "1.1.3";
+  disabled = isPyPy;  # a test fails
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0js7qx5pa8ibr8487lcf0x3a7w0xml0wa17snd6hjs0857kqhn20";
+  };
+
+  meta = with stdenv.lib; {
+    homepage = "https://github.com/tkem/cachetools";
+    license = licenses.mit;
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, isPyPy }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "cachetools";
+  version = "2.0.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0pdw2fr29pxlyn1g5fhdrrqbpn0iw062nv716ngdqvdx7hnizq7d";
+  };
+
+  meta = with stdenv.lib; {
+    description = "Extensible memoizing collections and decorators";
+    homepage = "https://github.com/tkem/cachetools";
+    license = licenses.mit;
+  };
+}

pkgs/development/python-modules/cld2-cffi/default.nix

···
+{ stdenv, buildPythonPackage, fetchPypi, six, cffi, nose }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "cld2-cffi";
+  version = "0.1.4";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0rvcdx4fdh5yk4d2nlddq1q1r2r0xqp86hpmbdn447pdcj1r8a9s";
+  };
+
+  propagatedBuildInputs = [ six cffi ];
+  checkInputs = [ nose ];
+
+  # gcc doesn't approve of this code, so disable -Werror
+  NIX_CFLAGS_COMPILE = "-w";
+
+  checkPhase = "nosetests -v";
+
+  meta = with stdenv.lib; {
+    description = "CFFI bindings around Google Chromium's embedded compact language detection library (CLD2)";
+    homepage = "https://github.com/GregBowyer/cld2-cffi";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ rvl ];
+  };
+}

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

···
     #COVERAGE=${coverage}/bin/coverage $out/bin/cram tests
     #${coverage}/bin/coverage report --fail-under=100
     COVERAGE=coverage $out/bin/cram tests
-    coverage report --fail-under=100 --omit="*/_encoding.py"
+    coverage report --fail-under=100 --omit="*/_encoding.py,*/__main__.py"
   '';
 
   meta = {

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

···
+{ stdenv, buildPythonPackage, fetchPypi, cryptography, boto3, pyyaml, docutils }:
+
+buildPythonPackage rec {
+  pname    = "credstash";
+  version = "1.13.3";
+  name = "${pname}-${version}";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1x2dh4rs5sahb8h2xznhq7srcm2zl9ykc72a8iqpq4dz7l9k7x7i";
+  };
+
+  propagatedBuildInputs = [ cryptography boto3 pyyaml docutils ];
+
+  # No tests in archive
+  doCheck = false;
+
+  meta = with stdenv.lib; {
+    description = "A utility for managing secrets in the cloud using AWS KMS and DynamoDB";
+    homepage = https://github.com/LuminalOSS/credstash;
+    license = licenses.asl20;
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, isPyPy, isPy35, ncurses }:
+
+buildPythonPackage rec {
+  pname = "cx_Freeze";
+  version = "5.0.2";
+  name  = "${pname}-${version}";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0zbx9j5z5l06bvwvlqvvn7h9dm7zjcjgxm7agbb625nymkq6cd15";
+  };
+
+  propagatedBuildInputs = [ ncurses ];
+
+  # timestamp need to come after 1980 for zipfiles and nix store is set to epoch
+  prePatch = ''
+    substituteInPlace cx_Freeze/freezer.py --replace "os.stat(module.file).st_mtime" "time.time()"
+  '';
+
+  # fails to find Console even though it exists on python 3.x
+  doCheck = false;
+
+  meta = with stdenv.lib; {
+    description = "A set of scripts and modules for freezing Python scripts into executables";
+    homepage = "http://cx-freeze.sourceforge.net/";
+    license = licenses.psfl;
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "ijson";
+  version = "2.3";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0x7l9k2dvxzd5mjgiq15nl9b0sxcqy1cqaz744bjwkz4z5mrypzg";
+  };
+
+  doCheck = false; # something about yajl
+
+  meta = with stdenv.lib; {
+    description = "Iterative JSON parser with a standard Python iterator interface";
+    homepage = "https://github.com/isagalaev/ijson";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ rvl ];
+  };
+}

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

···
-{ lib
-, buildPythonPackage
-, fetchPypi
-, pytest
-, glibcLocales
-}:
+{ stdenv, buildPythonPackage, fetchPypi, pytest, glibcLocales, tox, pytestcov }:
 
 buildPythonPackage rec {
   pname = "jedi";
···
     sha256 = "7abb618cac6470ebbd142e59c23daec5e6e063bfcecc8a43a037d2ab57276f4e";
   };
 
-  checkInputs = [ pytest glibcLocales ];
+  checkInputs = [ pytest glibcLocales tox pytestcov ];
 
   checkPhase = ''
     LC_ALL="en_US.UTF-8" py.test test
   '';
 
-  # 7 failed
-  #doCheck = false;
+  # tox required for tests: https://github.com/davidhalter/jedi/issues/808
+  doCheck = false;
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = https://github.com/davidhalter/jedi;
     description = "An autocompletion tool for Python that can be used for text editors";
-    license = lib.licenses.lgpl3Plus;
-    maintainers = with lib.maintainers; [ garbas ];
+    license = licenses.lgpl3Plus;
+    maintainers = with maintainers; [ garbas ];
   };
 }

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

···
+{ stdenv, buildPythonPackage, fetchPypi, pytest_29, future, numpy }:
+
+buildPythonPackage rec {
+  pname = "MDP";
+  version = "3.5";
+  name  = "${pname}-${version}";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0aw1zxmyvx6gfmmnixbqmdaah28jl7rmqkzhxv53091asc23iw9k";
+  };
+
+  checkInputs = [ pytest_29 ];
+  propagatedBuildInputs = [ future numpy ];
+
+  # Tests disabled because of missing dependencies not in nix
+  doCheck = false;
+
+  meta = with stdenv.lib; {
+    description = "Library for building complex data processing software by combining widely used machine learning algorithms";
+    homepage = http://mdp-toolkit.sourceforge.net;
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ nico202 ];
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, jinja2, werkzeug, flask, requests, pytz
+, six, boto, httpretty, xmltodict, nose, sure, boto3, freezegun, dateutil }:
+
+buildPythonPackage rec {
+  pname = "moto";
+  version = "0.4.31";
+  name    = "moto-${version}";
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "19s8hfz4mzzzdksa0ddlvrga5mxdaqahk89p5l29a5id8127shr8";
+  };
+
+  propagatedBuildInputs = [
+    boto
+    dateutil
+    flask
+    httpretty
+    jinja2
+    pytz
+    werkzeug
+    requests
+    six
+    xmltodict
+  ];
+
+  checkInputs = [ boto3 nose sure freezegun ];
+
+  checkPhase = "nosetests";
+
+  # TODO: make this true; I think lots of the tests want network access but we can probably run the others
+  doCheck = false;
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, nose, nibabel, numpy, scikitlearn
+, scipy, matplotlib }:
+
+buildPythonPackage rec {
+  pname = "nilearn";
+  version = "0.3.1";
+  name = "nilearn-${version}";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0kkarh5cdcd2czs0bf0s1g51qas84mfxfq0dzd7k5h5l0qr4zy06";
+  };
+
+  checkPhase = "nosetests --exclude with_expand_user nilearn/tests";
+
+  buildInputs = [ nose ];
+
+  propagatedBuildInputs = [
+    matplotlib
+    nibabel
+    numpy
+    scikitlearn
+    scipy
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = http://nilearn.github.io;
+    description = "A module for statistical learning on neuroimaging data";
+    license = licenses.bsd3;
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, wcwidth, six, prompt_toolkit, docopt
+, jedi, pygments }:
+
+buildPythonPackage rec {
+  pname = "ptpython";
+  version = "0.41";
+  name  = "${pname}-${version}";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1hcaaadkp5n37hxggraynifa33wx1akklzvf6y4rvgjxbjl2g2x7";
+  };
+
+  propagatedBuildInputs = [ wcwidth six prompt_toolkit docopt jedi pygments ];
+
+  # no tests to run
+  doCheck = false;
+
+  meta = with stdenv.lib; {
+    description = "An advanced Python REPL";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ mlieberman85 ];
+    platforms = platforms.all;
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, numpy, cython }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "pyemd";
+  version = "0.4.4";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "13y06y7r1697cv4r430g45fxs40i2yk9xn0dk9nqlrpddw3a0mr4";
+  };
+
+  propagatedBuildInputs = [ numpy ];
+  buildInputs = [ cython ];
+
+  meta = with stdenv.lib; {
+    description = "A Python wrapper for Ofir Pele and Michael Werman's implementation of the Earth Mover's Distance";
+    homepage = http://github.com/wmayner/pyemd;
+    license = licenses.mit;
+    maintainers = with maintainers; [ rvl ];
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "Pyphen";
+  version = "0.9.4";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1mqb5jrigxipxzp1d8nbwkq0cfjw77pnn6hc4mp1yd2mn059mymb";
+  };
+
+  meta = with stdenv.lib; {
+    description = "Pure Python module to hyphenate text";
+    homepage = "https://github.com/Kozea/Pyphen";
+    license = with licenses; [gpl2 lgpl21 mpl20];
+    maintainers = with maintainers; [ rvl ];
+  };
+}

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

···
-{ lib, fetchurl, buildPythonPackage, isPy3k }:
+{ stdenv, fetchPypi, buildPythonPackage, isPy3k }:
 
 buildPythonPackage rec {
-  pname = "pywebdav";
-  name = "${pname}-${version}";
+  pname = "PyWebDAV";
   version = "0.9.8";
+  name = "${pname}-${version}";
   disabled = isPy3k;
-  src = fetchurl {
-    url = "mirror://pypi/p/pywebdav/${name}.tar.gz";
+  src = fetchPypi {
+    inherit pname version;
     sha256 = "1v10vg79h85milnq8w7yd75qq5z6297ywkn9b2kxajldzwqxn3ji";
   };
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://code.google.com/p/pywebdav/;
     description = "WebDAV library including a standalone server for python";
-    maintainers = with lib.maintainers; [ johbo ];
-    license = lib.licenses.gpl2Plus;
+    maintainers = with maintainers; [ johbo ];
+    license = licenses.gpl2Plus;
   };
 }

pkgs/development/python-modules/spacy/models.json

···
+[{
+  "pname": "es_core_web_md",
+  "version": "1.0.0",
+  "sha256": "0ikyakdhnj6rrfpr8k83695d1gd3z9n60a245hwwchv94jmr7r6s",
+  "license": "cc-by-sa-40"
+},
+{
+  "pname": "fr_depvec_web_lg",
+  "version": "1.0.0",
+  "sha256": "0nxmdszs1s5by2874cz37azrmwamh1ngdsiylffkfihzq6s8bhka",
+  "license": "cc-by-nc-sa-40"
+},
+{
+  "pname": "en_core_web_md",
+  "version": "1.2.1",
+  "sha256": "12prr4hcbfdaky9rcna1y1ykr417jkhkks2r8l06g8fb7am3pvp3",
+  "license": "cc-by-sa-40"
+},
+{
+  "pname": "en_depent_web_md",
+  "version": "1.2.1",
+  "sha256": "0giyr35q5lpp5drpcamyvb5gsjnhj62mk3ndfr49nm1s6d5f6m52",
+  "license": "cc-by-sa-40"
+},
+{
+  "pname": "en_core_web_sm",
+  "version": "1.2.0",
+  "sha256": "0vc4l77dcwa9lmzyqdci8ikjc0m2rhasl2zvyba547vf76qb0528",
+  "license": "cc-by-sa-40"
+},
+{
+  "pname": "de_core_news_md",
+  "version": "1.0.0",
+  "sha256": "072jz2rdi1nckny7k16avp86vjg4didfdsw816kfl9zwr88iny6g",
+  "license": "cc-by-sa-40"
+},
+{
+  "pname": "en_vectors_glove_md",
+  "version": "1.0.0",
+  "sha256": "1jbr27xnh5fdww8yphpvk2brfnzb174wfnxkzdqwv3iyi02zsin6",
+  "license": "cc-by-sa-40"
+}]

pkgs/development/python-modules/spacy/models.nix

···
+{ stdenv, buildPythonPackage, fetchurl, spacy }:
+let
+  buildModelPackage = { pname, version, sha256, license }: buildPythonPackage {
+    name = "${pname}-${version}";
+    inherit pname version;
+
+    src = fetchurl {
+      url = "https://github.com/explosion/spacy-models/releases/download/${pname}-${version}/${pname}-${version}.tar.gz";
+      inherit sha256;
+    };
+
+    propagatedBuildInputs = [ spacy ];
+
+    meta = with stdenv.lib; {
+      description = "Models for the spaCy NLP library";
+      homepage    = "https://github.com/explosion/spacy-models";
+      license     = licenses."${license}";
+      maintainers = with maintainers; [ rvl ];
+    };
+  };
+
+  makeModelSet = models: with stdenv.lib; listToAttrs (map (m: nameValuePair m.pname (buildModelPackage m)) models);
+
+in makeModelSet (stdenv.lib.importJSON ./models.json)
+
+# cat models.json | jq -r '.[] | @uri "https://github.com/explosion/spacy-models/releases/download/\(.pname)-\(.version)/\(.pname)-\(.version).tar.gz"' | xargs -n1 nix-prefetch-url

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

···
+{ stdenv
+, buildPythonPackage
+, isPy27
+, fetchPypi
+, cachetools
+, cld2-cffi
+, cython
+, cytoolz
+, ftfy
+, ijson
+, matplotlib
+, networkx
+, numpy
+, pyemd
+, pyphen
+, python-Levenshtein
+, requests
+, scikitlearn
+, scipy
+, spacy
+, tqdm
+, unidecode
+}:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "textacy";
+  version = "0.4.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "04wf3a7zgzz83nmgkh488wkl50zm9yfdpv3sl12sm2zj685plqcz";
+  };
+
+  disabled = isPy27; # 2.7 requires backports.csv
+
+  propagatedBuildInputs = [
+    cachetools
+    cld2-cffi
+    cytoolz
+    ftfy
+    ijson
+    matplotlib
+    networkx
+    numpy
+    pyemd
+    pyphen
+    python-Levenshtein
+    requests
+    scikitlearn
+    scipy
+    spacy
+    tqdm
+    unidecode
+  ];
+
+  doCheck = false;  # tests want to download data files
+
+  meta = with stdenv.lib; {
+    description = "Higher-level text processing, built on spaCy";
+    homepage = "http://textacy.readthedocs.io/";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ rvl ];
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, glibcLocales }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "Unidecode";
+  version = "0.04.21";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0lfhp9c5xrbpjvbpr12ji52g1lx04404bzzdg6pvabhzisw6l2i8";
+  };
+
+  LC_ALL="en_US.UTF-8";
+
+  buildInputs = [ glibcLocales ];
+
+  meta = with stdenv.lib; {
+    homepage = http://pypi.python.org/pypi/Unidecode/;
+    description = "ASCII transliterations of Unicode text";
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ domenkozar ];
+  };
+}

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

···
+{ stdenv, buildPythonPackage, fetchPypi, pytest, mock, git, asyncio
+, cherrypy, gevent, tornado }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "ws4py";
+  version = "0.4.2";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0zr3254ky6r7q15l3dhdczfa8i723055zdkqssjifsgcwvirriks";
+  };
+
+  checkInputs = [ pytest mock git ];
+  propagatedBuildInputs = [ asyncio cherrypy gevent tornado ];
+
+  checkPhase = ''
+    pytest test
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://ws4py.readthedocs.org;
+    description = "A WebSocket package for Python";
+    maintainers = with maintainers; [ rickynils ];
+  };
+}

pkgs/development/tools/analysis/include-what-you-use/default.nix

···
 stdenv.mkDerivation rec {
   name = "include-what-you-use-${version}";
   # Also bump llvmPackages in all-packages.nix to the supported version!
-  version = "0.6";
+  version = "0.8";
 
   src = fetchurl {
-    sha256 = "0n3z4pfbby0rl338irbs4yvcmjfnza82xg9a8r9amyl0bkfasbxb";
+    sha256 = "0r6n5gqicl0f9c8jrphq40kc2cis952gmnkm3643m3jwad0mn33d";
     url = "${meta.homepage}/downloads/${name}.src.tar.gz";
   };
 
-  buildInputs = with llvmPackages; [ clang llvm ];
+  buildInputs = with llvmPackages; [ clang-unwrapped llvm ];
   nativeBuildInputs = [ cmake ];
 
   cmakeFlags = [ "-DIWYU_LLVM_ROOT_PATH=${llvmPackages.clang-unwrapped}" ];

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

···
 { lib, python3Packages }:
 python3Packages.buildPythonApplication rec {
-  version = "0.41.2";
+  version = "0.42.1";
   pname = "meson";
   name = "${pname}-${version}";
 
   src = python3Packages.fetchPypi {
     inherit pname version;
-    sha256 = "0p69hir68ar3nzrjn0zjsnyzq181b0kq6arrcmxqpzl7g5qhf5xd";
+    sha256 = "1phf1xpwm8m85qiiirkqhrf5aigx7ajaw0l59d6lzadf1fmgfx5v";
   };
 
   postFixup = ''

pkgs/development/tools/dtools/default.nix

···
 
       substituteInPlace posix.mak \
           --replace gcc $CC
+
+      # To fix rdmd test with newer phobos
+      substituteInPlace rdmd.d \
+          --replace " std.stdiobase," ""
   '';
 
   nativeBuildInputs = [ dmd ];
···
     }
 	'';
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "Ancillary tools for the D programming language compiler";
     homepage = https://github.com/dlang/tools;
     license = lib.licenses.boost;
+    maintainers = with maintainers; [ ThomasMader ];
     platforms = stdenv.lib.platforms.unix;
   };
 }

pkgs/development/tools/irony-server/default.nix

···
   name = "irony-server-${version}";
   inherit (irony) version;
 
-  buildInputs = [ cmake llvmPackages.clang ];
+  nativeBuildInputs = [ cmake ];
 
   dontUseCmakeBuildDir = true;
 

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

···
 
 stdenv.mkDerivation rec {
   name = "strace-${version}";
-  version = "4.18";
+  version = "4.19";
 
   src = fetchurl {
     url = "mirror://sourceforge/strace/${name}.tar.xz";
-    sha256 = "026agy9nq238nx3ynhmi8h3vx96yra4xacfsm2ybs9k23ry8ibc9";
+    sha256 = "10bjh2mrkvx41fk60b2iqv5b5k4r7a3qdsx04iyg904jqb3fp4vw";
   };
 
   nativeBuildInputs = [ perl ];

pkgs/development/tools/rtags/default.nix

···
   name = "rtags-${version}";
   version = "2.12";
 
-  buildInputs = [ cmake llvmPackages.llvm openssl llvmPackages.clang emacs pkgconfig ]
+  nativeBuildInputs = [ cmake pkgconfig ];
+  buildInputs = [ llvmPackages.llvm openssl emacs ]
+    ++ lib.optionals stdenv.cc.isGNU [ llvmPackages.clang-unwrapped ]
     ++ lib.optionals stdenv.isDarwin [ apple_sdk.libs.xpc apple_sdk.frameworks.CoreServices ];
 
 

pkgs/games/steam/chrootenv.nix

···
 , extraPkgs ? pkgs: [ ] # extra packages to add to targetPkgs
 , nativeOnly ? false
 , runtimeOnly ? false
-, newStdcpp ? false
 }:
 
 let
   commonTargetPkgs = pkgs: with pkgs;
     let
-      primus2 = if newStdcpp then primus else primus.override {
-        stdenv = overrideInStdenv stdenv [ useOldCXXAbi ];
-        stdenv_i686 = overrideInStdenv pkgsi686Linux.stdenv [ useOldCXXAbi ];
-      };
       tzdir = "${pkgs.tzdata}/share/zoneinfo";
       # I'm not sure if this is the best way to add things like this
       # to an FHSUserEnv
···
       # Zoneinfo
       etc-zoneinfo
     ] ++ lib.optional withJava jdk
-      ++ lib.optional withPrimus primus2
+      ++ lib.optional withPrimus primus
       ++ extraPkgs pkgs;
 
 in buildFHSUserEnv rec {
···
     xlibs.libpciaccess
 
     (steamPackages.steam-runtime-wrapped.override {
-      inherit nativeOnly runtimeOnly newStdcpp;
+      inherit nativeOnly runtimeOnly;
     })
   ];
 

pkgs/games/steam/runtime-wrapped.nix

···
 { stdenv, lib, perl, pkgs, steam-runtime
 , nativeOnly ? false
 , runtimeOnly ? false
-, newStdcpp ? false
 }:
 
 assert !(nativeOnly && runtimeOnly);
-assert newStdcpp -> !runtimeOnly;
 
 let 
   runtimePkgs = with pkgs; [
···
     SDL2_mixer
     gstreamer
     gst-plugins-base
-  ] ++ lib.optional (!newStdcpp) gcc48.cc;
+  ];
 
   overridePkgs = with pkgs; [
     libgpgerror
···
     openalSoft
     libva
     vulkan-loader
-  ] ++ lib.optional newStdcpp gcc.cc;
+    gcc.cc
+  ];
 
   ourRuntime = if runtimeOnly then []
                else if nativeOnly then runtimePkgs ++ overridePkgs

pkgs/games/zandronum/add_gitinfo.patch

···
+diff -Naur blah/src/gitinfo.h blah2/src/gitinfo.h
+--- blah/src/gitinfo.h	1969-12-31 16:00:00.000000000 -0800
++++ blah2/src/gitinfo.h	2017-09-15 01:44:43.953562714 -0700
+@@ -0,0 +1,11 @@
++// dd3c3b57023f64cda84f09ed13e4c03a4ad2b920
++//
++// This file was automatically generated by the
++// updaterevision tool. Do not edit by hand.
++
++#define GIT_DESCRIPTION "ZA_3.0-0-dd3c3b57023f"
++#define GIT_HASH "dd3c3b57023f64cda84f09ed13e4c03a4ad2b920"
++#define GIT_TIME "2017-09-01 06:40:50 -0500"
++#define HG_REVISION_NUMBER 1504266050
++#define HG_REVISION_HASH_STRING "dd3c3b57023f"
++#define HG_TIME "170901-1140"

pkgs/games/zandronum/bin.nix

···
-{ stdenv
-, atk
-, bzip2
-, cairo
-, fetchurl
-, fluidsynth
-, fontconfig
-, freetype
-, gdk_pixbuf
-, glib
-, gtk2
-, libjpeg_turbo
-, mesa_glu
-, mesa_noglu
-, openssl
-, pango
-, SDL
-, zlib
-, makeWrapper
-}:
-
-stdenv.mkDerivation rec {
-  name = "zandronum-2.1.2";
-
-  src = fetchurl {
-    url = "http://zandronum.com/downloads/zandronum2.1.2-linux-x86_64.tar.bz2";
-    sha256 = "1f5aw2m8c0bl3lrvi2k3rrzq3q9x1ikxnxxjgh3k9qvanfn7ykbk";
-  };
-
-  libPath = stdenv.lib.makeLibraryPath [
-    atk
-    bzip2
-    cairo
-    fluidsynth
-    fontconfig
-    freetype
-    gdk_pixbuf
-    glib
-    gtk2
-    libjpeg_turbo
-    mesa_glu
-    mesa_noglu
-    openssl
-    pango
-    SDL
-    stdenv.cc.cc
-    zlib
-  ];
-
-  nativeBuildInputs = [ makeWrapper ];
-
-  phases = [ "unpackPhase" "installPhase" ];
-
-  sourceRoot = ".";
-
-  installPhase = ''
-    mkdir -p $out/bin
-    mkdir -p $out/share/zandronum
-    cp *.so *.pk3 zandronum zandronum-server $out/share/zandronum
-
-    patchelf \
-      --set-interpreter $(cat ${stdenv.cc}/nix-support/dynamic-linker) \
-      --set-rpath $libPath:$out/share/zandronum \
-      $out/share/zandronum/zandronum
-    patchelf \
-      --set-interpreter $(cat ${stdenv.cc}/nix-support/dynamic-linker) \
-      --set-rpath $libPath \
-      $out/share/zandronum/zandronum-server
-
-    # If we don't set absolute argv0, zandronum.wad file is not found.
-    makeWrapper $out/share/zandronum/zandronum $out/bin/zandronum
-    makeWrapper $out/share/zandronum/zandronum-server $out/bin/zandronum-server
-  '';
-
-  meta = {
-    homepage = http://zandronum.com/;
-    description = "Multiplayer oriented port, based off Skulltag, for Doom and Doom II by id Software. Binary version for online play";
-    maintainers = [ stdenv.lib.maintainers.lassulus ];
-    # Binary version has different version string than source code version.
-    license = stdenv.lib.licenses.unfreeRedistributable;
-    platforms = [ "x86_64-linux" ];
-  };
-}

pkgs/games/zandronum/default.nix

···
 { stdenv, lib, fetchhg, cmake, pkgconfig, makeWrapper, callPackage
-, soundfont-fluid, SDL, mesa, bzip2, zlib, libjpeg, fluidsynth, openssl, sqlite-amalgamation, gtk2
+, soundfont-fluid, SDL, mesa, glew, bzip2, zlib, libjpeg, fluidsynth, openssl, gtk2, python3
 , serverOnly ? false
 }:
 
 let
   suffix = lib.optionalString serverOnly "-server";
   fmod = callPackage ./fmod.nix { };
+  sqlite = callPackage ./sqlite.nix { };
 
-# FIXME: drop binary package when upstream fixes their protocol versioning
 in stdenv.mkDerivation {
-  name = "zandronum${suffix}-2.1.2";
+  name = "zandronum${suffix}-3.0";
 
   src = fetchhg {
     url = "https://bitbucket.org/Torr_Samaho/zandronum-stable";
-    rev = "a3663b0061d5";
-    sha256 = "0qwsnbwhcldwrirfk6hpiklmcj3a7dzh6pn36nizci6pcza07p56";
+    rev = "dd3c3b57023f";
+    sha256 = "1f8pd8d2zjwdp6v9anp9yrkdbfhd2mp7svmnna0jiqgxjw6wkyls";
   };
 
+  # zandronum tries to download sqlite now when running cmake, don't let it
+
+  # it also needs the current mercurial revision info embedded in gitinfo.h
+  # otherwise, the client will fail to connect to servers because the
+  # protocol version doesn't match.
+
+  patches = [ ./zan_configure_impurity.patch ./add_gitinfo.patch ./dont_update_gitinfo.patch ];
+
   # I have no idea why would SDL and libjpeg be needed for the server part!
   # But they are.
-  buildInputs = [ openssl bzip2 zlib SDL libjpeg ]
-             ++ lib.optionals (!serverOnly) [ mesa fmod fluidsynth gtk2 ];
+  buildInputs = [ openssl bzip2 zlib SDL libjpeg sqlite ]
+             ++ lib.optionals (!serverOnly) [ mesa glew fmod fluidsynth gtk2 ];
 
-  nativeBuildInputs = [ cmake pkgconfig makeWrapper ];
+  nativeBuildInputs = [ cmake pkgconfig makeWrapper python3 ];
 
   preConfigure = ''
-    ln -s ${sqlite-amalgamation}/* sqlite/
+    ln -s ${sqlite}/* sqlite/
     sed -ie 's| restrict| _restrict|g' dumb/include/dumb.h \
                                        dumb/src/it/*.c
-  '' + lib.optionalString serverOnly ''
+  '' + lib.optionalString (!serverOnly) ''
     sed -i \
       -e "s@/usr/share/sounds/sf2/@${soundfont-fluid}/share/soundfonts/@g" \
       -e "s@FluidR3_GM.sf2@FluidR3_GM2-2.sf2@g" \
···
        *.pk3 \
        ${lib.optionalString (!serverOnly) "liboutput_sdl.so"} \
        $out/lib/zandronum
-
-    # For some reason, while symlinks work for binary version, they don't for source one.
-    makeWrapper $out/lib/zandronum/zandronum${suffix} $out/bin/zandronum${suffix}
-  '';
+  '' + (if (!serverOnly) then
+          ''makeWrapper $out/lib/zandronum/zandronum $out/bin/zandronum --prefix LD_LIBRARY_PATH : "$LD_LIBRARY_PATH:${fluidsynth}/lib"''
+        else
+          ''makeWrapper $out/lib/zandronum/zandronum${suffix} $out/bin/zandronum${suffix}'');
 
   postFixup = lib.optionalString (!serverOnly) ''
     patchelf --set-rpath $(patchelf --print-rpath $out/lib/zandronum/zandronum):$out/lib/zandronum \
···
   meta = with stdenv.lib; {
     homepage = http://zandronum.com/;
     description = "Multiplayer oriented port, based off Skulltag, for Doom and Doom II by id Software";
-    maintainers = with maintainers; [ lassulus ];
+    maintainers = with maintainers; [ lassulus MP2E ];
     license = licenses.unfreeRedistributable;
     platforms = platforms.linux;
   };

pkgs/games/zandronum/dont_update_gitinfo.patch

···
+diff -r dd3c3b57023f src/CMakeLists.txt
+--- a/src/CMakeLists.txt	Fri Sep 01 06:40:50 2017 -0500
++++ b/src/CMakeLists.txt	Fri Sep 15 01:46:34 2017 -0700
+@@ -636,15 +636,6 @@
+	add_definitions( -DBACKPATCH )
+ endif( BACKPATCH )
+
+-# Update gitinfo.h
+-
+-get_target_property( UPDATEREVISION_EXE updaterevision LOCATION )
+-
+-add_custom_target( revision_check ALL
+-	COMMAND ${UPDATEREVISION_EXE} src/gitinfo.h
+-	WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+-	DEPENDS updaterevision )
+-
+ # Libraries ZDoom needs
+
+ message( STATUS "Fluid synth libs: ${FLUIDSYNTH_LIBRARIES}" )

pkgs/games/zandronum/zan_configure_impurity.patch

···
+diff -r 6d5130e4ae52 sqlite/CMakeLists.txt
+--- a/sqlite/CMakeLists.txt	Sun Sep 10 18:53:00 2017 +0200
++++ b/sqlite/CMakeLists.txt	Fri Sep 15 00:12:11 2017 -0700
+@@ -1,62 +1,5 @@
+ cmake_minimum_required( VERSION 2.4 )
+
+-# [BB/EP] Download SQLite archive and extract the sources if necessary.
+-set( ZAN_SQLITE_VERSION 3180000 ) # SQL version 3.18.0
+-set( ZAN_SQLITE_YEAR 2017 )
+-set( ZAN_SQLITE_SHA1 "74559194e1dd9b9d577cac001c0e9d370856671b" )
+-set( ZAN_SQLITE_DOWNLOAD_NAME "sqlite-autoconf-${ZAN_SQLITE_VERSION}" )
+-set( ZAN_SQLITE_TEMP_ARCHIVE "${CMAKE_CURRENT_SOURCE_DIR}/${ZAN_SQLITE_DOWNLOAD_NAME}.tar.gz" )
+-set( ZAN_SQLITE_HASHED_ARCHIVE "${CMAKE_CURRENT_SOURCE_DIR}/sqlite-${ZAN_SQLITE_SHA1}.tar.gz" )
+-
+-if( IS_DIRECTORY ${ZAN_SQLITE_HASHED_ARCHIVE} OR IS_SYMLINK ${ZAN_SQLITE_HASHED_ARCHIVE} )
+-	message( FATAL_ERROR "SQLite: ${ZAN_SQLITE_HASHED_ARCHIVE} must be a valid file.\n"
+-				"SQLite: Please remove it and try again." )
+-elseif( NOT EXISTS ${ZAN_SQLITE_HASHED_ARCHIVE} )
+-
+-	if( IS_DIRECTORY ${ZAN_SQLITE_TEMP_ARCHIVE} OR IS_SYMLINK ${ZAN_SQLITE_TEMP_ARCHIVE} )
+-		message( FATAL_ERROR "SQLite: ${ZAN_SQLITE_TEMP_ARCHIVE} must be a valid file.\n"
+-					"SQLite: Please remove it and try again." )
+-	endif()
+-	message( STATUS "SQLite: downloading the archive..." )
+-
+-	file( DOWNLOAD https://www.sqlite.org/${ZAN_SQLITE_YEAR}/${ZAN_SQLITE_DOWNLOAD_NAME}.tar.gz ${ZAN_SQLITE_TEMP_ARCHIVE}
+-			SHOW_PROGRESS
+-			STATUS ZAN_SQLITE_DOWNLOAD_STATUS )
+-
+-	# Report any problem if present and abort immediately.
+-	list( GET ZAN_SQLITE_DOWNLOAD_STATUS 0 ZAN_SQLITE_DOWNLOAD_ERROR_CODE )
+-	if( ZAN_SQLITE_DOWNLOAD_ERROR_CODE )
+-		list( GET ZAN_SQLITE_DOWNLOAD_STATUS 1 ZAN_SQLITE_DOWNLOAD_ERROR_MESSAGE )
+-		message( FATAL_ERROR "SQLite: download failed. Reason: ${ZAN_SQLITE_DOWNLOAD_ERROR_MESSAGE}" )
+-	endif()
+-
+-	# Check the hash. Abort immediately if it's not valid (something is wrong with the download)
+-	file( SHA1 ${ZAN_SQLITE_TEMP_ARCHIVE} ZAN_SQLITE_CURRENT_SHA1 )
+-	if( NOT ZAN_SQLITE_CURRENT_SHA1 STREQUAL ZAN_SQLITE_SHA1 )
+-		message( FATAL_ERROR "SQLite: download failed. The downloaded file has a different hash:\n"
+-					"SQLite:    valid:      ${ZAN_SQLITE_SHA1}\n"
+-					"SQLite:    downloaded: ${ZAN_SQLITE_CURRENT_SHA1}" )
+-	endif()
+-
+-	message( STATUS "SQLite: saving the source files into the 'sqlite' directory." )
+-
+-	# Rename the archive.
+-	execute_process( COMMAND ${CMAKE_COMMAND} -E rename ${ZAN_SQLITE_TEMP_ARCHIVE} ${ZAN_SQLITE_HASHED_ARCHIVE} )
+-
+-	# Extract the archive.
+-	execute_process( COMMAND ${CMAKE_COMMAND} -E tar xzf ${ZAN_SQLITE_HASHED_ARCHIVE} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
+-
+-	# Copy the required files.
+-	execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/${ZAN_SQLITE_DOWNLOAD_NAME}/sqlite3.c ${CMAKE_CURRENT_SOURCE_DIR} )
+-	execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/${ZAN_SQLITE_DOWNLOAD_NAME}/sqlite3.h ${CMAKE_CURRENT_SOURCE_DIR} )
+-	execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/${ZAN_SQLITE_DOWNLOAD_NAME}/sqlite3ext.h ${CMAKE_CURRENT_SOURCE_DIR} )
+-
+-	# Remove the extracted folder.
+-	execute_process( COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_CURRENT_SOURCE_DIR}/${ZAN_SQLITE_DOWNLOAD_NAME} )
+-
+-	message( STATUS "SQLite: done." )
+-endif()
+-
+ add_library( sqlite3 sqlite3.c )
+ target_link_libraries( sqlite3 ${CMAKE_DL_LIBS} )

pkgs/misc/drivers/epson-alc1100/cups-data-dir.patch

···
+diff --git a/configure b/configure
+index 0053441..9a6b855 100755
+--- a/configure
++++ b/configure
+@@ -2833,7 +2833,7 @@ if test $have_cups_config = yes; then
+    CUPS_LIBS=`cups-config --libs`
+    CUPS_IMAGE_LIBS=`cups-config --image --libs`
+    CUPS_SERVER_DIR=`cups-config --serverbin`
+-   CUPS_DATA_DIR=`cups-config --datadir`
++   CUPS_DATA_DIR="${prefix}/share/cups"
+ else
+    { { echo "$as_me:$LINENO: error: *** 'cups-config' missing, please install CUPS or fix your \$PATH ***" >&5
+ echo "$as_me: error: *** 'cups-config' missing, please install CUPS or fix your \$PATH ***" >&2;}

pkgs/misc/drivers/epson-alc1100/default.nix

···
+{ stdenv, stdenv_32bit, fetchurl, cups, pkgsi686Linux, dpkg, psutils, makeWrapper, ghostscript, bash }:
+
+let
+  version = "1.2-0";
+
+  libstdcpp5 = fetchurl {
+    url = "http://old-releases.ubuntu.com/ubuntu/pool/universe/g/gcc-3.3/libstdc++5_3.3.6-17ubuntu1_i386.deb";
+    sha256 = "10f8zcmqaa7skvg2bz94mnlgqpan4iscvi8913r6iawjh7hiisjy";
+  };
+in
+  stdenv.mkDerivation {
+    name = "epson-alc1100-${version}";
+
+    src = fetchurl {
+      url = "http://a1227.g.akamai.net/f/1227/40484/7d/download.ebz.epson.net/dsc/f/01/00/01/58/65/cd71929d2bf41ebf7e96f68fa9f1279556545ef1/Epson-ALC1100-filter-1.2.tar.gz";
+      sha256 = "0q0bf4dfm4v69l7xg6sgkh7rwb0h77i8j9kplq1dfkd208g7y81p";
+    };
+
+    patches = [ ./cups-data-dir.patch ./ppd.patch ];
+
+    nativeBuildInputs = [ dpkg makeWrapper ];
+
+    buildInputs = [ cups pkgsi686Linux.glibc psutils ghostscript bash ];
+
+    postUnpack = ''
+      dpkg -x ${libstdcpp5} libstdcpp5_i386;
+
+      mkdir -p $out/lib;
+
+      mv libstdcpp5_i386/usr/lib/* $out/lib;
+    '';
+
+    postFixup = ''
+      patchelf --set-interpreter ${pkgsi686Linux.glibc}/lib/ld-linux.so.2 \
+        --set-rpath "${stdenv.lib.makeLibraryPath [
+          pkgsi686Linux.glibc
+          "$out"
+        ]}" $out/bin/alc1100
+
+      patchelf --set-rpath "${stdenv.lib.makeLibraryPath [
+          pkgsi686Linux.glibc
+        ]}" $out/lib/libstdc++.so.5.0.7
+
+      wrapProgram $out/bin/alc1100_lprwrapper.sh \
+        --suffix PATH : "\$PATH:${psutils}/bin:/var/lib/cups/path/bin"
+
+      wrapProgram $out/bin/pstoalc1100.sh \
+        --suffix PATH : "\$PATH:${psutils}/bin:${ghostscript}/bin:${bash}/bin:/var/lib/cups/path/bin"
+    '';
+
+    meta = with stdenv.lib; {
+      homepage = "http://download.ebz.epson.net/dsc/search/01/search/";
+      description = "Epson AcuLaser C1100 Driver";
+      longDescription = ''
+        This package provides a print filter for printing to EPSON AL-C1100
+        printers on Linux systems.
+
+        To use the driver adjust your configuration.nix file:
+          services.printing = {
+            enable = true;
+            drivers = [ pkgs.epson-alc1100 ];
+          };
+      '';
+
+      license = with licenses; [ mit eapl ];
+      maintainers = [ maintainers.eperuffo ];
+      platforms = platforms.linux;
+    };
+
+  }

pkgs/misc/drivers/epson-alc1100/ppd.patch

···
+diff --git a/ppd/Epson-AL-C1100-fm3.ppd b/ppd/Epson-AL-C1100-fm3.ppd
+index 75c7fff..ecd04c8 100644
+--- a/ppd/Epson-AL-C1100-fm3.ppd
++++ b/ppd/Epson-AL-C1100-fm3.ppd
+@@ -68,7 +68,7 @@
+ *%*********** Foomatic Configulations ************
+ *%pprRIP:        foomatic-rip other
+ *FoomaticIDs: Epson-AL-C1100 alc1100
+-*FoomaticRIPCommandLine: "pstoalc1100.sh %C"
++*FoomaticRIPCommandLine: "/var/lib/cups/path/bin/pstoalc1100.sh %C"
+ 
+ *%**************** Paper Handling ******************
+ 

pkgs/misc/emulators/mgba/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mgba-${version}";
-  version = "0.5.2";
+  version = "0.6.0";
 
   src = fetchFromGitHub {
     owner = "mgba-emu";
     repo = "mgba";
     rev = version;
-    sha256 = "1cpxiwzbywnjs3lrqa3bc9bj68plypx0br3lssd6p68c4wh01fyp";
+    sha256 = "1kzb6zj2lxfaiyfq9h7q26fh7xh1ggybmh5pin5rcgs7jyygrsjb";
   };
 
   nativeBuildInputs = [ pkgconfig cmake ];

pkgs/misc/themes/adapta/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "adapta-gtk-theme-${version}";
-  version = "3.91.2.10";
+  version = "3.91.2.147";
 
   src = fetchFromGitHub {
     owner = "tista500";
     repo = "Adapta";
     rev = version;
-    sha256 = "0bp5fnxgrrrs0ajqw2lbhbarbpvzvajnvcjip6fkl9aa76gz9czy";
+    sha256 = "1sv4s8rcc40v4lanapdqanlqf1l60rbc5wd7h73l5cigbqxxgda9";
   };
 
   preferLocalBuild = true;

pkgs/misc/themes/gtk3/clearlooks-phenix/default.nix pkgs/misc/themes/clearlooks-phenix/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "5.0.7";
+  version = "7.0.1";
   name = "clearlooks-phenix-${version}";
 
   src = fetchurl {
     url = "http://github.com/jpfleury/clearlooks-phenix/archive/${version}.tar.gz";
-    sha256 = "107jx3p3zwzy8xy0m8hwzs1kp8j60xgc3dja27r3vwhb3x3y1i8k";
+    sha256 = "1x2psfbhxc3bk3q795bafxv6p890yfsankfw64p44q4r1x0236ra";
   };
 
   dontBuild = true;

pkgs/misc/themes/numix/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "2017-02-15";
+  version = "2017-07-26";
   name = "numix-gtk-theme-${version}";
 
   src = fetchFromGitHub {
     repo = "numix-gtk-theme";
     owner = "numixproject";
-    rev = "f25d7e04353543e03fd155f4d9dfa80fc6b551f2";
-    sha256 = "0n57airi1kgg754099sdq40bb0mbp4my385fvslnsjv5d4h8jhvq";
+    rev = "858e6292c4336302be4d499c9b085a891b4c3b40";
+    sha256 = "1z9l13px79yk42874dlh8z6p7chlngwarfnki89win3g2xvclz8q";
   };
 
   nativeBuildInputs = [ sass glib libxml2 gdk_pixbuf ];

pkgs/misc/themes/zuki/default.nix

···
-{ stdenv, fetchFromGitHub, gnome3, gdk_pixbuf, gtk_engines, gtk-engine-murrine }:
+{ stdenv, fetchFromGitHub, gdk_pixbuf, gtk_engines, gtk-engine-murrine }:
 
 stdenv.mkDerivation rec {
   name = "zuki-themes-${version}";
-  version = "${gnome3.version}.${date}";
-  date = {
-    "3.20" = "2017-05-03";
-    "3.22" = "2017-04-23";
-    "3.24" = "2017-06-26";
-  }."${gnome3.version}";
+  version = "3.24-2";
 
   src = fetchFromGitHub {
     owner = "lassekongo83";
     repo = "zuki-themes";
-    rev = {
-      "3.20" = "ce7ae498df7d5c81acaf48ed957b9f828356d58c";
-      "3.22" = "e97f2c3cf75b5205bc5ecd6072696327169fde5d";
-      "3.24" = "d25e0a2fb6e08ad107d8bb627451433362f2a830";
-    }."${gnome3.version}";
-    sha256 = {
-      "3.20" = "0na81q9mc8kwn9m04kkcchrdr67087dqf3q155imhjgqrxjhh3w4";
-      "3.22" = "195v0d2sgqh92c104xqm00p68yxp6kzp5mzx8q7s36bdv9p972q4";
-      "3.24" = "0z5swi5aah3s4yinfglh491qydxgjkqwf6zxyz7k9c1d7lrvj3ww";
-    }."${gnome3.version}";
+    rev = "v${version}";
+    sha256 = "1js92qq1zi3iq40nl6n0m52hhhn9ql9i7y8ycg8vw3w0v8xyb4km";
   };
 
   buildInputs = [ gdk_pixbuf gtk_engines gtk-engine-murrine ];

pkgs/misc/vim-plugins/default.nix

···
 
   };
 
+  nvim-completion-manager = buildVimPluginFrom2Nix { # created by nix#NixDerivation
+    name = "nvim-completion-manager-2017-09-05";
+    src = fetchgit {
+      url = "https://github.com/roxma/nvim-completion-manager";
+      rev = "d9db97f7e5a4ab8af905bc00a4501d770368dee4";
+      sha256 = "1aaclyz1ss2iv0lwcxkz8x5x4wivsixmlk5xakwy989q9g9ps2f1";
+    };
+    dependencies = [];
+
+  };
+
   rust-vim = buildVimPluginFrom2Nix { # created by nix#NixDerivation
     name = "rust-vim-2017-07-14";
     src = fetchgit {
       url = "https://github.com/rust-lang/rust.vim";
       rev = "5a6133680ecf9e22eeba35c35e62ea6210225b02";
       sha256 = "0mxzl8lghq7bnwp8qs3haxq83ds5q8s8br0ajn40a3c3ns2hkhla";
+    };
+    dependencies = [];
+
+  };
+
+  vim-devicons = buildVimPluginFrom2Nix { # created by nix#NixDerivation
+    name = "vim-devicons-2017-05-29";
+    src = fetchgit {
+      url = "https://github.com/ryanoasis/vim-devicons";
+      rev = "153266275acc4f4615407a18e90f58780ebaef92";
+      sha256 = "1zjrra0q5c7lmgxzlz7ddd7vi6k2vhz69fdy2s7d873nnmmd7kgn";
     };
     dependencies = [];
 

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

···
 "github:raichoo/purescript-vim"
 "github:rhysd/vim-grammarous"
 "github:rodjek/vim-puppet"
+"github:roxma/nvim-completion-manager"
+"github:ryanoasis/vim-devicons"
 "github:rust-lang/rust.vim"
 "github:sbdchd/neoformat"
 "github:sebastianmarkow/deoplete-rust"

pkgs/os-specific/darwin/apple-sdk/frameworks.nix

···
   ExceptionHandling       = [];
   FWAUserLib              = [];
   ForceFeedback           = [ CF IOKit ];
-  Foundation              = [ CF libobjc Security ApplicationServices SystemConfiguration ];
+  # cf-private was moved first in list because of https://github.com/NixOS/nixpkgs/pull/28635
+  Foundation              = [ cf-private CF libobjc Security ApplicationServices SystemConfiguration ];
   GLKit                   = [ CF ];
   GLUT                    = [ OpenGL ];
   GSS                     = [];

pkgs/os-specific/darwin/duti/default.nix

···
+{stdenv, lib, fetchFromGitHub, autoreconfHook, darwin}:
+
+stdenv.mkDerivation rec {
+  pname = "duti";
+  name = "${pname}-${version}";
+  version = "1.5.4pre";
+  src = fetchFromGitHub {
+    owner = "moretension";
+    repo = pname;
+    rev = "7dbcae86f99fedef5a6c4311f032a0f1ca0539cc";
+    sha256 = "1z9sa0yk87vs57d5338y6lvm1v1vvynxb7dy1x5aqzkcr0imhljl";
+  };
+  nativeBuildInputs = [autoreconfHook];
+  buildInputs = [darwin.apple_sdk.frameworks.ApplicationServices];
+  configureFlags = ["--with-macosx-sdk=/homeless-shelter"];
+  meta = with lib; {
+    description = "A command-line tool to select default applications for document types and URL schemes on Mac OS X";
+    longDescription = ''
+      duti is a command-line utility capable of setting default applications for
+      various document types on Mac OS X, using Apple's Uniform Type Identifiers. A
+      UTI is a unique string describing the format of a file's content. For instance,
+      a Microsoft Word document has a UTI of com.microsoft.word.doc. Using duti, the
+      user can change which application acts as the default handler for a given UTI.
+    '';
+    maintainers = with maintainers; [matthewbauer];
+    platforms = platforms.darwin;
+    licenses = licenses.publicDomain;
+    homepage = "http://duti.org/";
+  };
+}

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

···
     platforms = platforms.linux;
     license = licenses.gpl2;
     homepage = http://www.displaylink.com/;
-    broken = versionOlder kernel.version "4.9";
+    broken = versionOlder kernel.version "4.9" || !stdenv.lib.versionOlder kernel.version "4.13";
   };
 }

pkgs/os-specific/linux/kernel/hardened-config.nix

···
 SCHED_STACK_END_CHECK y
 BUG_ON_DATA_CORRUPTION y
 
+${optionalString (versionAtLeast version "4.13") ''
+  REFCOUNT_FULL y
+''}
+
 # Perform usercopy bounds checking.
 HARDENED_USERCOPY y
 
···
   GCC_PLUGIN_STRUCTLEAK y # A port of the PaX structleak plugin
 ''}
 
+${optionalString (versionAtLeast version "4.13") ''
+  GCC_PLUGIN_RANDSTRUCT y # A port of the PaX randstruct plugin
+  GCC_PLUGIN_RANDSTRUCT_PERFORMANCE y
+''}
+
 # Disable various dangerous settings
 ACPI_CUSTOM_METHOD n # Allows writing directly to physical memory
 PROC_KCORE n # Exposes kernel text image layout
···
 # Use -fstack-protector-strong (gcc 4.9+) for best stack canary coverage.
 CC_STACKPROTECTOR_REGULAR n
 CC_STACKPROTECTOR_STRONG y
+
+# Enable compile/run-time buffer overflow detection ala glibc's _FORTIFY_SOURCE
+${optionalString (versionAtLeast version "4.13") ''
+  FORTIFY_SOURCE y
+''}
 ''

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

···
 { stdenv, hostPlatform, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.12.12";
+  version = "4.12.13";
   extraMeta.branch = "4.12";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1d254yxn46ydp0x3s5cpyg4p74zvdwiqfiaaim1m3g6rwjmlkjpa";
+    sha256 = "18sxw7mw4fya7381mkah70s3di6b8xxfigjhrhb7zcczrffb4vl9";
   };
 
   kernelPatches = args.kernelPatches;

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

···
 { stdenv, hostPlatform, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.13.1";
+  version = "4.13.2";
   extraMeta.branch = "4.13";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1kp1lsf4314af7crpqkd2x1zx407a97r7rz3zhhskbilvsifgkny";
+    sha256 = "1lgwgw9yp5ywbylnmahsmqzs98yfq53mvvqqdgp7ljiqg8bxqjh6";
   };
 
   kernelPatches = args.kernelPatches;

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

···
 { stdenv, hostPlatform, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.9.49";
+  version = "4.9.50";
   extraMeta.branch = "4.9";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1ywiww2h1gf3ps305irzk7n9xkcgg9bclr2jw6r5cqxmh3qxrv2p";
+    sha256 = "0dhm5w7qa1hyqp254r41b4nhf10a8w7sv1mhd16f61inpb41829c";
   };
 
   kernelPatches = args.kernelPatches;

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

···
     license = stdenv.lib.licenses.gpl2;
     platforms = stdenv.lib.platforms.linux;
     maintainers = with stdenv.lib.maintainers; [viric];
+    broken = !stdenv.lib.versionOlder kernel.version "4.13";
   };
 }

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

···
     license = with licenses; [ bsd3 gpl2 ];
     maintainers = with maintainers; [ fpletz ];
     platforms = platforms.linux;
+    broken = !stdenv.lib.versionOlder kernel.version "4.13";
   };
 }

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

···
 let
   buildKernel = any (n: n == configFile) [ "kernel" "all" ];
   buildUser = any (n: n == configFile) [ "user" "all" ];
-in
-  assert any (n: n == configFile) [ "kernel" "user" "all" ];
-  assert buildKernel -> kernel != null;
-stdenv.mkDerivation rec {
-  name = "spl-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
-  version = "0.7.1";
+  common = { version
+    , sha256
+    , rev ? "spl-${version}"
+    } @ args : stdenv.mkDerivation rec {
+      name = "spl-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
 
-  src = fetchFromGitHub {
-    owner = "zfsonlinux";
-    repo = "spl";
-    rev = "spl-${version}";
-    sha256 = "0m8qhbdd8n40lbd91s30q4lrw8g169sha0410c8rwk2d5qfaxv9n";
-  };
+      src = fetchFromGitHub {
+        owner = "zfsonlinux";
+        repo = "spl";
+        inherit rev sha256;
+      };
 
-  patches = [ ./const.patch ./install_prefix.patch ];
+      patches = [ ./const.patch ./install_prefix.patch ];
 
-  nativeBuildInputs = [ autoreconfHook ];
+      nativeBuildInputs = [ autoreconfHook ];
 
-  hardeningDisable = [ "pic" ];
+      hardeningDisable = [ "pic" ];
 
-  preConfigure = ''
-    substituteInPlace ./module/spl/spl-generic.c --replace /usr/bin/hostid hostid
-    substituteInPlace ./module/spl/spl-generic.c --replace "PATH=/sbin:/usr/sbin:/bin:/usr/bin" "PATH=${coreutils}:${gawk}:/bin"
-    substituteInPlace ./module/splat/splat-vnode.c --replace "PATH=/sbin:/usr/sbin:/bin:/usr/bin" "PATH=${coreutils}:/bin"
-    substituteInPlace ./module/splat/splat-linux.c --replace "PATH=/sbin:/usr/sbin:/bin:/usr/bin" "PATH=${coreutils}:/bin"
-  '';
+      preConfigure = ''
+        substituteInPlace ./module/spl/spl-generic.c --replace /usr/bin/hostid hostid
+        substituteInPlace ./module/spl/spl-generic.c --replace "PATH=/sbin:/usr/sbin:/bin:/usr/bin" "PATH=${coreutils}:${gawk}:/bin"
+        substituteInPlace ./module/splat/splat-vnode.c --replace "PATH=/sbin:/usr/sbin:/bin:/usr/bin" "PATH=${coreutils}:/bin"
+        substituteInPlace ./module/splat/splat-linux.c --replace "PATH=/sbin:/usr/sbin:/bin:/usr/bin" "PATH=${coreutils}:/bin"
+      '';
 
-  configureFlags = [
-    "--with-config=${configFile}"
-  ] ++ optionals buildKernel [
-    "--with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source"
-    "--with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
-  ];
+      configureFlags = [
+        "--with-config=${configFile}"
+      ] ++ optionals buildKernel [
+        "--with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source"
+        "--with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
+      ];
 
-  enableParallelBuilding = true;
+      enableParallelBuilding = true;
 
-  meta = {
-    description = "Kernel module driver for solaris porting layer (needed by in-kernel zfs)";
+      meta = {
+        description = "Kernel module driver for solaris porting layer (needed by in-kernel zfs)";
 
-    longDescription = ''
-      This kernel module is a porting layer for ZFS to work inside the linux
-      kernel.
-    '';
+        longDescription = ''
+          This kernel module is a porting layer for ZFS to work inside the linux
+          kernel.
+        '';
 
-    homepage = http://zfsonlinux.org/;
-    platforms = platforms.linux;
-    license = licenses.gpl2Plus;
-    maintainers = with maintainers; [ jcumming wizeman wkennington fpletz globin ];
+        homepage = http://zfsonlinux.org/;
+        platforms = platforms.linux;
+        license = licenses.gpl2Plus;
+        maintainers = with maintainers; [ jcumming wizeman wkennington fpletz globin ];
+      };
   };
+in
+  assert any (n: n == configFile) [ "kernel" "user" "all" ];
+  assert buildKernel -> kernel != null;
+{
+    splStable = common {
+      version = "0.7.1";
+      sha256 = "0m8qhbdd8n40lbd91s30q4lrw8g169sha0410c8rwk2d5qfaxv9n";
+    };
+
+    splUnstable = common {
+      version = "2017-08-11";
+      rev = "9df9692637aeee416f509c7f39655beb2d35b549";
+      sha256 = "1dggf6xqgk2f7vccv6cgvr8krj7h9f921szp1j2qbxnnq41m37mi";
+    };
 }

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

···
   buildKernel = any (n: n == configFile) [ "kernel" "all" ];
   buildUser = any (n: n == configFile) [ "user" "all" ];
 
-in stdenv.mkDerivation rec {
-  name = "zfs-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
-  version = "0.7.1";
+  common = { version
+    , sha256
+    , extraPatches
+    , spl
+    , rev ? "zfs-${version}"
+    , isUnstable ? false
+    , incompatibleKernelVersion ? null } @ args:
+    if buildKernel &&
+      (incompatibleKernelVersion != null) &&
+        versionAtLeast kernel.version incompatibleKernelVersion then
+       throw ''
+         Linux v${kernel.version} is not yet supported by zfsonlinux v${version}.
+         ${stdenv.lib.optional (!isUnstable) "Try zfsUnstable or set the NixOS option boot.zfs.enableUnstable."}
+       ''
+    else stdenv.mkDerivation rec {
+      name = "zfs-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
+
+      src = fetchFromGitHub {
+        owner = "zfsonlinux";
+        repo = "zfs";
+        inherit rev sha256;
+      };
+
+      patches = extraPatches;
+
+      buildInputs = [ autoreconfHook nukeReferences ]
+        ++ optionals buildKernel [ spl ]
+        ++ optionals buildUser [ zlib libuuid python attr ];
+
+      # for zdb to get the rpath to libgcc_s, needed for pthread_cancel to work
+      NIX_CFLAGS_LINK = "-lgcc_s";
+
+      hardeningDisable = [ "pic" ];
+
+      preConfigure = ''
+        substituteInPlace ./module/zfs/zfs_ctldir.c   --replace "umount -t zfs"           "${utillinux}/bin/umount -t zfs"
+        substituteInPlace ./module/zfs/zfs_ctldir.c   --replace "mount -t zfs"            "${utillinux}/bin/mount -t zfs"
+        substituteInPlace ./lib/libzfs/libzfs_mount.c --replace "/bin/umount"             "${utillinux}/bin/umount"
+        substituteInPlace ./lib/libzfs/libzfs_mount.c --replace "/bin/mount"              "${utillinux}/bin/mount"
+        substituteInPlace ./cmd/ztest/ztest.c         --replace "/usr/sbin/ztest"         "$out/sbin/ztest"
+        substituteInPlace ./cmd/ztest/ztest.c         --replace "/usr/sbin/zdb"           "$out/sbin/zdb"
+        substituteInPlace ./config/user-systemd.m4    --replace "/usr/lib/modules-load.d" "$out/etc/modules-load.d"
+        substituteInPlace ./config/zfs-build.m4       --replace "\$sysconfdir/init.d"     "$out/etc/init.d"
+        substituteInPlace ./etc/zfs/Makefile.am       --replace "\$(sysconfdir)"          "$out/etc"
+        substituteInPlace ./cmd/zed/Makefile.am       --replace "\$(sysconfdir)"          "$out/etc"
+        substituteInPlace ./module/Makefile.in        --replace "/bin/cp"                 "cp"
+        substituteInPlace ./etc/systemd/system/zfs-share.service.in \
+          --replace "@bindir@/rm " "${coreutils}/bin/rm "
+
+        for f in ./udev/rules.d/*
+        do
+          substituteInPlace "$f" --replace "/lib/udev/vdev_id" "$out/lib/udev/vdev_id"
+        done
+
+        ./autogen.sh
+      '';
+
+      configureFlags = [
+        "--with-config=${configFile}"
+        ] ++ optionals buildUser [
+        "--with-dracutdir=$(out)/lib/dracut"
+        "--with-udevdir=$(out)/lib/udev"
+        "--with-systemdunitdir=$(out)/etc/systemd/system"
+        "--with-systemdpresetdir=$(out)/etc/systemd/system-preset"
+        "--with-mounthelperdir=$(out)/bin"
+        "--sysconfdir=/etc"
+        "--localstatedir=/var"
+        "--enable-systemd"
+        ] ++ optionals buildKernel [
+        "--with-spl=${spl}/libexec/spl"
+        "--with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source"
+        "--with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
+      ];
 
-  src = fetchFromGitHub {
-    owner = "zfsonlinux";
-    repo = "zfs";
-    rev = "zfs-${version}";
-    sha256 = "0czal6lpl8igrhwmqh5jcgx07rlcgnrfg6ywzf681vsyh3gaxj9n";
-  };
+      enableParallelBuilding = true;
 
-  patches = [
-    (fetchpatch {
-      url = "https://github.com/Mic92/zfs/compare/zfs-0.7.0-rc3...nixos-zfs-0.7.0-rc3.patch";
-      sha256 = "1vlw98v8xvi8qapzl1jwm69qmfslwnbg3ry1lmacndaxnyckkvhh";
-    })
-  ];
+      installFlags = [
+        "sysconfdir=\${out}/etc"
+        "DEFAULT_INITCONF_DIR=\${out}/default"
+      ];
 
-  buildInputs = [ autoreconfHook nukeReferences ]
-  ++ optionals buildKernel [ spl ]
-  ++ optionals buildUser [ zlib libuuid python attr ];
+      postInstall = ''
+        # Prevent kernel modules from depending on the Linux -dev output.
+        nuke-refs $(find $out -name "*.ko")
+      '' + optionalString buildUser ''
+        # Remove provided services as they are buggy
+        rm $out/etc/systemd/system/zfs-import-*.service
 
-  # for zdb to get the rpath to libgcc_s, needed for pthread_cancel to work
-  NIX_CFLAGS_LINK = "-lgcc_s";
+        sed -i '/zfs-import-scan.service/d' $out/etc/systemd/system/*
 
-  hardeningDisable = [ "pic" ];
+        for i in $out/etc/systemd/system/*; do
+        substituteInPlace $i --replace "zfs-import-cache.service" "zfs-import.target"
+        done
 
-  preConfigure = ''
-    substituteInPlace ./module/zfs/zfs_ctldir.c   --replace "umount -t zfs"           "${utillinux}/bin/umount -t zfs"
-    substituteInPlace ./module/zfs/zfs_ctldir.c   --replace "mount -t zfs"            "${utillinux}/bin/mount -t zfs"
-    substituteInPlace ./lib/libzfs/libzfs_mount.c --replace "/bin/umount"             "${utillinux}/bin/umount"
-    substituteInPlace ./lib/libzfs/libzfs_mount.c --replace "/bin/mount"              "${utillinux}/bin/mount"
-    substituteInPlace ./cmd/ztest/ztest.c         --replace "/usr/sbin/ztest"         "$out/sbin/ztest"
-    substituteInPlace ./cmd/ztest/ztest.c         --replace "/usr/sbin/zdb"           "$out/sbin/zdb"
-    substituteInPlace ./config/user-systemd.m4    --replace "/usr/lib/modules-load.d" "$out/etc/modules-load.d"
-    substituteInPlace ./config/zfs-build.m4       --replace "\$sysconfdir/init.d"     "$out/etc/init.d"
-    substituteInPlace ./etc/zfs/Makefile.am       --replace "\$(sysconfdir)"          "$out/etc"
-    substituteInPlace ./cmd/zed/Makefile.am       --replace "\$(sysconfdir)"          "$out/etc"
-    substituteInPlace ./module/Makefile.in        --replace "/bin/cp"                 "cp"
-    substituteInPlace ./etc/systemd/system/zfs-share.service.in \
-      --replace "@bindir@/rm " "${coreutils}/bin/rm "
+        # Fix pkgconfig.
+        ln -s ../share/pkgconfig $out/lib/pkgconfig
 
-    for f in ./udev/rules.d/*
-    do
-      substituteInPlace "$f" --replace "/lib/udev/vdev_id" "$out/lib/udev/vdev_id"
-    done
+        # Remove tests because they add a runtime dependency on gcc
+        rm -rf $out/share/zfs/zfs-tests
+      '';
 
-    ./autogen.sh
-  '';
+      outputs = [ "out" ] ++ optionals buildUser [ "lib" "dev" ];
 
-  configureFlags = [
-    "--with-config=${configFile}"
-    ] ++ optionals buildUser [
-    "--with-dracutdir=$(out)/lib/dracut"
-    "--with-udevdir=$(out)/lib/udev"
-    "--with-systemdunitdir=$(out)/etc/systemd/system"
-    "--with-systemdpresetdir=$(out)/etc/systemd/system-preset"
-    "--with-mounthelperdir=$(out)/bin"
-    "--sysconfdir=/etc"
-    "--localstatedir=/var"
-    "--enable-systemd"
-    ] ++ optionals buildKernel [
-    "--with-spl=${spl}/libexec/spl"
-    "--with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source"
-    "--with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
-  ];
+      meta = {
+        description = "ZFS Filesystem Linux Kernel module";
+        longDescription = ''
+          ZFS is a filesystem that combines a logical volume manager with a
+          Copy-On-Write filesystem with data integrity detection and repair,
+          snapshotting, cloning, block devices, deduplication, and more.
+        '';
+        home = http://zfsonlinux.org/;
+        license = licenses.cddl;
+        platforms = platforms.linux;
+        maintainers = with maintainers; [ jcumming wizeman wkennington fpletz globin ];
+      };
+    };
+in {
+  # also check if kernel version constraints in
+  # ./nixos/modules/tasks/filesystems/zfs.nix needs
+  # to be adapted
+  zfsStable = common {
+    # comment/uncomment if breaking kernel versions are known
+    incompatibleKernelVersion = null;
 
-  enableParallelBuilding = true;
+    # this package should point to the latest release.
+    version = "0.7.1";
 
-  installFlags = [
-    "sysconfdir=\${out}/etc"
-    "DEFAULT_INITCONF_DIR=\${out}/default"
-  ];
+    sha256 = "0czal6lpl8igrhwmqh5jcgx07rlcgnrfg6ywzf681vsyh3gaxj9n";
 
-  postInstall = ''
-    # Prevent kernel modules from depending on the Linux -dev output.
-    nuke-refs $(find $out -name "*.ko")
-  '' + optionalString buildUser ''
-    # Remove provided services as they are buggy
-    rm $out/etc/systemd/system/zfs-import-*.service
+    extraPatches = [
+      (fetchpatch {
+        url = "https://github.com/Mic92/zfs/compare/zfs-0.7.0-rc3...nixos-zfs-0.7.0-rc3.patch";
+        sha256 = "1vlw98v8xvi8qapzl1jwm69qmfslwnbg3ry1lmacndaxnyckkvhh";
+      })
+    ];
 
-    sed -i '/zfs-import-scan.service/d' $out/etc/systemd/system/*
+    inherit spl;
+  };
 
-    for i in $out/etc/systemd/system/*; do
-    substituteInPlace $i --replace "zfs-import-cache.service" "zfs-import.target"
-    done
+  zfsUnstable = common {
+    # comment/uncomment if breaking kernel versions are known
+    incompatibleKernelVersion = null;
 
-    # Fix pkgconfig.
-    ln -s ../share/pkgconfig $out/lib/pkgconfig
+    # this package should point to a version / git revision compatible with the latest kernel release
+    version = "2017-09-12";
 
-    # Remove tests because they add a runtime dependency on gcc
-    rm -rf $out/share/zfs/zfs-tests
-  '';
+    rev = "ded8f06a3cfee60b3a8ea5309e9c4d0e567ed3b5";
+    sha256 = "0yn4fg4a00hpflmmr0jbbhfb921nygpw2xbbjy35abl57k6zk375";
+    isUnstable = true;
 
-  outputs = [ "out" ] ++ optionals buildUser [ "lib" "dev" ];
+    extraPatches = [
+      (fetchpatch {
+        url = "https://github.com/Mic92/zfs/compare/ded8f06a3cfee...nixos-zfs-2017-09-12.patch";
+        sha256 = "033wf4jn0h0kp0h47ai98rywnkv5jwvf3xwym30phnaf8xxdx8aj";
+      })
+    ];
 
-  meta = {
-    description = "ZFS Filesystem Linux Kernel module";
-    longDescription = ''
-      ZFS is a filesystem that combines a logical volume manager with a
-      Copy-On-Write filesystem with data integrity detection and repair,
-      snapshotting, cloning, block devices, deduplication, and more.
-    '';
-    homepage = http://zfsonlinux.org/;
-    license = licenses.cddl;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ jcumming wizeman wkennington fpletz globin ];
+    spl = splUnstable;
   };
 }

pkgs/servers/monitoring/grafana/default.nix

···
 { lib, buildGoPackage, fetchurl, fetchFromGitHub, phantomjs2 }:
 
 buildGoPackage rec {
-  version = "4.4.3";
+  version = "4.5.0";
   name = "grafana-v${version}";
   goPackagePath = "github.com/grafana/grafana";
 
···
     rev = "v${version}";
     owner = "grafana";
     repo = "grafana";
-    sha256 = "04cm8h7if8yvczcwd83drbfzgr1spfspzg5im8lb540ks9x55dz4";
+    sha256 = "00n58v3a5amkj9r2nsbzmifbnch9rq1cpcqc5ws0bz3x004z43cs";
   };
 
   srcStatic = fetchurl {
     url = "https://s3-us-west-2.amazonaws.com/grafana-releases/release/grafana-${version}.linux-x64.tar.gz";
-    sha256 = "1p36hniay2y3mwg300b7n3sl3vv7l5jq5ddcnmpmznwyd8zwbl4h";
+    sha256 = "0fm69r1qb2fn8zwfsiwss8vc7nx0ql98pk0a3d2vjgpdyvk5jmw7";
   };
 
   preBuild = "export GOPATH=$GOPATH:$NIX_BUILD_TOP/go/src/${goPackagePath}/Godeps/_workspace";

pkgs/servers/monitoring/prometheus/node-exporter.nix

···
     sha256 = "0rm43jjqv7crfahl973swi4warqmqnmv740cg800yvzvnlp37kl4";
   };
 
+  preFixup = stdenv.lib.optionalString stdenv.isDarwin ''
+    install_name_tool -delete_rpath $out/lib $bin/bin/node_exporter
+  '';
+
   # FIXME: megacli test fails
   doCheck = false;
 

pkgs/tools/audio/abcmidi/default.nix

···
+{ stdenv, fetchFromGitHub }:
+
+stdenv.mkDerivation rec {
+  name = "abcMIDI-${version}";
+  version = "2017.06.10";
+
+  src = fetchFromGitHub {
+    owner = "leesavide";
+    repo = "abcmidi";
+    rev = name;
+    sha256 = "0y92m3mj63vvy79ksq4z5hgkz6w50drg9a4bmbk6jylny0l0bdpy";
+  };
+
+  # There is also a file called "makefile" which seems to be preferred by the standard build phase
+  makefile = "Makefile";
+
+  meta = with stdenv.lib; {
+    homepage = http://abc.sourceforge.net/abcMIDI/;
+    license = licenses.gpl2Plus;
+    description = "abc <-> MIDI conversion utilities";
+    maintainers = [ maintainers.dotlambda ];
+  };
+}

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

···
   version = "0.4";
 
   src = fetchurl {
-    url = "gregory.kokanosky.free.fr/v4/linux/${name}.tar.gz";
+    url = "http://gregory.kokanosky.free.fr/v4/linux/${name}.tar.gz";
     sha256 = "18sam7yy50rbfhjixwd7wx7kmfn1x1y5j80vwfxi5v408s39s115";
   };
 

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

···
 { fetchurl, stdenv, libcdio, zlib, bzip2, readline, acl, attr }:
 
 stdenv.mkDerivation rec {
-  name = "xorriso-1.4.6";
+  name = "xorriso-1.4.8";
 
   src = fetchurl {
     url = "mirror://gnu/xorriso/${name}.tar.gz";
-    sha256 = "112p0ghwzxrcjbsir1n2jxhq103ckrw93wzvd55qqvzfgs674vsj";
+    sha256 = "10c44yr3dpmwxa7rf23mwfsy1bahny3jpcg9ig0xjv090jg0d0pc";
   };
 
   doCheck = true;

pkgs/tools/filesystems/bcachefs-tools/default.nix

···
   buildInputs = [ pkgconfig attr libuuid libscrypt libsodium keyutils liburcu zlib libaio ];
 
   preConfigure = ''
-    substituteInPlace cmd_migrate.c --replace /usr/include/dirent.h ${stdenv.glibc.dev}/include/dirent.h
+    substituteInPlace cmd_migrate.c --replace /usr/include/dirent.h ${stdenv.lib.getDev stdenv.cc.libc}/include/dirent.h
   '';
 
   installFlags = [ "PREFIX=$(out)" ];

pkgs/tools/filesystems/s3fs/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "s3fs-fuse-${version}";
-  version = "1.80";
+  version = "1.82";
 
   src = fetchFromGitHub {
     owner  = "s3fs-fuse";
     repo   = "s3fs-fuse";
     rev    = "v${version}";
-    sha256 = "0yikqpdyjibbb36rj4118lv9nxgp9f5jhydzxijzxrzw29ypvw76";
+    sha256 = "0bammbb8h10n51qk5141gabsd5p91qbaqq7cwa1q8yf5qglwlp10";
   };
 
   buildInputs = [ curl openssl libxml2 fuse ];

pkgs/tools/misc/cloc/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "cloc-${version}";
-  version = "1.72";
+  version = "1.74";
 
   src = fetchFromGitHub {
     owner = "AlDanial";
     repo = "cloc";
-    rev = "v${version}";
-    sha256 = "192z3fzib71y3sjic03ll67xv51igdlpvfhx12yv9wnzkir7lx02";
+    rev = version;
+    sha256 = "1ihma4f6f92jp1mvzr4rjrgyh9m5wzrlxngaxfn7g0a8r2kyi65b";
   };
 
-  sourceRoot = "cloc-v${version}-src/Unix";
+  sourceRoot = "cloc-${version}-src/Unix";
 
   buildInputs = [ makeWrapper perl AlgorithmDiff RegexpCommon ];
 
···
     homepage = https://github.com/AlDanial/cloc;
     license = stdenv.lib.licenses.gpl2;
     platforms = stdenv.lib.platforms.all;
-    maintainers = with stdenv.lib.maintainers; [ fuuzetsu ];
+    maintainers = with stdenv.lib.maintainers; [ fuuzetsu rycee ];
   };
 }

pkgs/tools/misc/diffoscope/default.nix

···
 { lib, stdenv, fetchgit, python3Packages, docutils
-, acl, binutils, bzip2, cbfstool, cdrkit, colord, colordiff, coreutils, cpio, diffutils, dtc, e2fsprogs
-, file, findutils, fpc, gettext, ghc, gnupg1, gnutar, gzip, imagemagick, jdk, libarchive, libcaca, llvm
-, mono, openssh, pdftk, poppler_utils, sng, sqlite, squashfsTools, tcpdump, unzip, xxd, xz
+, acl, apktool, binutils, bzip2, cbfstool, cdrkit, colord, colordiff, coreutils, cpio, diffutils, dtc
+, e2fsprogs, file, findutils, fontforge-fonttools, fpc, gettext, ghc, ghostscriptX, giflib, gnupg1, gnutar
+, gzip, imagemagick, jdk, libarchive, libcaca, llvm, mono, openssh, pdftk, pgpdump, poppler_utils, sng, sqlite
+, squashfsTools, tcpdump, unoconv, unzip, xxd, xz
 , enableBloat ? false
 }:
 
···
     sed -i setup.py -e "/'rpm-python',/d"
   '';
 
-  # Still missing these tools: apktool docx2txt enjarify gifbuild js-beautify odt2txt oggDump pgpdump ps2ascii Rscript showttf
+  # Still missing these tools: docx2txt enjarify js-beautify oggDump Rscript
   # Also these libraries: python3-guestfs
   pythonPath = with python3Packages; [ debian libarchive-c python_magic tlsh rpm ] ++ [
-      acl binutils bzip2 cbfstool cdrkit colordiff coreutils cpio diffutils dtc e2fsprogs file
-      findutils gettext gnutar gzip libarchive libcaca poppler_utils sng sqlite squashfsTools unzip
-      xxd xz
-    ] ++ lib.optionals enableBloat [ colord fpc ghc gnupg1 imagemagick llvm jdk mono openssh pdftk tcpdump ];
+      acl binutils bzip2 cdrkit colordiff coreutils cpio diffutils dtc e2fsprogs file findutils
+      fontforge-fonttools gettext gnutar gzip libarchive libcaca pgpdump sng sqlite
+      squashfsTools unzip xxd xz
+    ] ++ lib.optionals enableBloat [
+      apktool cbfstool colord fpc ghc ghostscriptX giflib gnupg1 imagemagick
+      llvm jdk mono openssh pdftk poppler_utils tcpdump unoconv
+    ];
 
   doCheck = false; # Calls 'mknod' in squashfs tests, which needs root
 

pkgs/tools/misc/neofetch/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "neofetch-${version}";
-  version = "3.2.0";
+  version = "3.3.0";
   src = fetchFromGitHub {
     owner = "dylanaraps";
     repo = "neofetch";
     rev = version;
-    sha256 = "1skkclvkqayqsbywja2fhv18l4rn9kg2da6bkip82zrwd713akl3";
+    sha256 = "1f1hvd635wv81qg802jdi0yggi4631w9nlznipaxkvk4y1zpdq5j";
   };
-
-  # This patch is only needed so that Neofetch 3.2.0 can look for
-  # configuration file, w3m directory (for fetching images) and ASCII
-  # directory properly. It won't be needed in subsequent releases.
-  patches = [
-    (fetchpatch {
-      name = "nixos.patch";
-      url = "https://github.com/konimex/neofetch/releases/download/3.2.0/nixos.patch";
-      sha256 = "0c6vsa74bxq6qlgbv3rrkhzkpvnq4304s6y2r1bl0sachyakaljy";
-    })
-  ];
-
 
   dontBuild = true;
 

pkgs/tools/networking/mtr/default.nix

···
-{stdenv, fetchurl, autoreconfHook, pkgconfig, ncurses
-, withGtk ? false, gtk2 ? null}:
+{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, ncurses
+, withGtk ? false, gtk2 ? null }:
 
 assert withGtk -> gtk2 != null;
 
-with stdenv.lib;
 stdenv.mkDerivation rec {
-  baseName="mtr";
-  version="0.87";
-  name="${baseName}-${version}";
+  name="mtr-${version}";
+  version="0.92";
 
-  src = fetchurl {
-    url="ftp://ftp.bitwizard.nl/${baseName}/${name}.tar.gz";
-    sha256 = "17zi99n8bdqrwrnbfyjn327jz4gxx287wrq3vk459c933p34ff8r";
+  src = fetchFromGitHub {
+    owner  = "traviscross";
+    repo   = "mtr";
+    rev    = "v${version}";
+    sha256 = "0ca2ml846cv0zzkpd8y7ah6i9b3czrr8wlxja3cray94ybwb294d";
   };
 
-  preConfigure = "substituteInPlace Makefile.in --replace ' install-exec-hook' ''";
+  preConfigure = ''
+    echo ${version} > .tarball-version
 
-  configureFlags = optionalString (!withGtk) "--without-gtk";
+    ./bootstrap.sh
+
+    substituteInPlace Makefile.in --replace ' install-exec-hook' ""
+  '';
+
+  configureFlags = stdenv.lib.optionalString (!withGtk) "--without-gtk";
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
 
-  buildInputs = [ ncurses ] ++ optional withGtk gtk2;
+  buildInputs = [ ncurses ] ++ stdenv.lib.optional withGtk gtk2;
 
   enableParallelBuilding = true;
 
-  meta = {
-    homepage = http://www.bitwizard.nl/mtr/;
+  meta = with stdenv.lib; {
     description = "A network diagnostics tool";
+    homepage    = http://www.bitwizard.nl/mtr/;
+    license     = licenses.gpl2;
     maintainers = with maintainers; [ koral orivej raskin ];
-    platforms = platforms.unix;
-    license = licenses.gpl2;
+    platforms   = platforms.unix;
   };
 }

pkgs/tools/networking/tinc/pre.nix

···
 
 stdenv.mkDerivation rec {
   name = "tinc-${version}";
-  version = "1.1pre14";
+  version = "1.1pre15";
 
   src = fetchgit {
     rev = "refs/tags/release-${version}";
     url = "git://tinc-vpn.org/tinc";
-    sha256 = "05an2vj0a3wjv5w672wgzyixbydin5jpja5zv6x81bc72dms0ymc";
+    sha256 = "1msym63jpipvzb5dn8yn8yycrii43ncfq6xddxh2ifrakr48l6y5";
   };
 
   outputs = [ "out" "man" "info" ];
···
   nativeBuildInputs = [ autoreconfHook texinfo ];
   buildInputs = [ ncurses readline zlib lzo openssl ];
 
+  # needed so the build doesn't need to run git to find out the version.
   prePatch = ''
     substituteInPlace configure.ac --replace UNKNOWN ${version}
+    echo "${version}" > configure-version
+    echo "https://tinc-vpn.org/git/browse?p=tinc;a=log;h=refs/tags/release-${version}" > ChangeLog
+    sed -i '/AC_INIT/s/m4_esyscmd_s.*/${version})/' configure.ac
   '';
 
-  patches = [
-    # Avoid infinite loop with "Error while reading from Linux tun/tap device (tun mode) /dev/net/tun: File descriptor in bad state" on network restart
-    (fetchpatch {
-      url = https://github.com/gsliepen/tinc/compare/acefa66...e4544db.patch;
-      sha256 = "1jz7anqqzk7j96l5ifggc2knp14fmbsjdzfrbncxx0qhb6ihdcvn";
-    })
-  ];
-
   postInstall = ''
     rm $out/bin/tinc-gui
   '';
···
     homepage="http://www.tinc-vpn.org/";
     license = licenses.gpl2Plus;
     platforms = platforms.unix;
-    maintainers = with maintainers; [ wkennington fpletz ];
+    maintainers = with maintainers; [ wkennington fpletz lassulus ];
   };
 }

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

···
 { lib, stdenv, fetchurl, fetchFromGitHub, perl, curl, bzip2, sqlite, openssl ? null, xz
 , pkgconfig, boehmgc, perlPackages, libsodium, aws-sdk-cpp, brotli, readline
 , autoreconfHook, autoconf-archive, bison, flex, libxml2, libxslt, docbook5, docbook5_xsl
-, libseccomp, busybox
+, libseccomp, busybox, nlohmann_json
 , hostPlatform
 , storeDir ? "/nix/store"
 , stateDir ? "/nix/var"
···
 
     buildInputs = [ curl openssl sqlite xz ]
       ++ lib.optional (stdenv.isLinux || stdenv.isDarwin) libsodium
-      ++ lib.optionals fromGit [ brotli readline ] # Since 1.12
+      ++ lib.optionals fromGit [ brotli readline nlohmann_json ] # Since 1.12
       ++ lib.optional stdenv.isLinux libseccomp
       ++ lib.optional ((stdenv.isLinux || stdenv.isDarwin) && is112)
           (aws-sdk-cpp.override {
···
   nix = nixStable;
 
   nixStable = (common rec {
-    name = "nix-1.11.14";
+    name = "nix-1.11.15";
     src = fetchurl {
       url = "http://nixos.org/releases/nix/${name}/${name}.tar.xz";
-      sha256 = "26593c831addf1d40f6b7d131f394cb0f9fbec9e46471369faed16eaa2c4b7e4";
+      sha256 = "d20f20e45d519f54fae5c61d55eadcf53e6d7cdbde9870eeec80d499f9805165";
     };
   }) // { perl-bindings = nixStable; };
 
   nixUnstable = (lib.lowPrio (common rec {
     name = "nix-1.12${suffix}";
-    suffix = "pre5511_c94f3d55";
+    suffix = "pre5619_346aeee1";
     src = fetchFromGitHub {
       owner = "NixOS";
       repo = "nix";
-      rev = "c94f3d5575d7af5403274d1e9e2f3c9d72989751";
-      sha256 = "1akfzzm4f07wj6l7za916xv5rnh71pk3vl8dphgradjfqb37bv18";
+      rev = "346aeee1cb21b5cab5ddc3e8658c88321f513761";
+      sha256 = "0lyrs0mqnh89w1nzrqpxvnh7bdjpg8j22xaidql47f1nwbblmn3f";
     };
     fromGit = true;
   })) // { perl-bindings = perl-bindings { nix = nixUnstable; }; };

pkgs/tools/typesetting/pdf2odt/default.nix

···
 { stdenv, lib, makeWrapper, fetchFromGitHub
 , bc, coreutils, file, gawk, ghostscript, gnused, imagemagick, zip }:
 
-stdenv.mkDerivation rec {
-  version = "2014-12-17";
-  name = "pdf2odt-${version}";
-
-  src = fetchFromGitHub {
-    owner = "gutschke";
-    repo = "pdf2odt";
-    rev = "master";
-    sha256 = "14f9r5f0g6jzanl54jv86ls0frvspka1p9c8dy3fnriqpm584j0r";
-  };
-
-  dontStrip = true;
-
-  nativeBuildInputs = [ makeWrapper ];
-
+let
   path = lib.makeBinPath [
     bc
     coreutils
···
     zip
   ];
 
+in stdenv.mkDerivation rec {
+  name = "pdf2odt-${version}";
+  version = "20170207";
+
+  src = fetchFromGitHub {
+    owner  = "gutschke";
+    repo   = "pdf2odt";
+    rev    = "4533bd14306c30c085001db59dbb8114ea09c360";
+    sha256 = "14f9r5f0g6jzanl54jv86ls0frvspka1p9c8dy3fnriqpm584j0r";
+  };
+
+  nativeBuildInputs = [ makeWrapper ];
+
   patches = [ ./use_mktemp.patch ];
 
   installPhase = ''
-    mkdir -p $out/bin $out/share/doc
+    install -Dm0755 pdf2odt           -t $out/bin
+    install -Dm0644 README.md LICENSE -t $out/share/doc/pdf2odt
 
-    install -m0755 pdf2odt $out/bin/pdf2odt
     ln -rs $out/bin/pdf2odt $out/bin/pdf2ods
 
-    install -m0644 README.md LICENSE -t $out/share/doc
-
-    wrapProgram $out/bin/pdf2odt --prefix PATH : ${path}
+    wrapProgram $out/bin/pdf2odt \
+      --prefix PATH : ${path}
   '';
 
   meta = with stdenv.lib; {
     description = "PDF to ODT format converter";
-    homepage = http://github.com/gutschke/pdf2odt;
-    license = licenses.mit;
-    platforms = platforms.all;
+    homepage    = http://github.com/gutschke/pdf2odt;
+    license     = licenses.mit;
+    platforms   = platforms.all;
     maintainers = with maintainers; [ peterhoeg ];
     inherit version;
   };

pkgs/tools/video/swfmill/default.nix

···
     sha256 = "15mcpql448vvgsbxs7wd0vdk1ln6rdcpnif6i2zjm5l4xng55s7r";
   };
 
+  # Fixes build with GCC 6
+  NIX_CFLAGS_COMPILE = "-std=c++03";
+
   buildInputs = [ pkgconfig libxslt freetype libpng libxml2 ];
 
   meta = {

pkgs/top-level/all-packages.nix

···
 
   a2ps = callPackage ../tools/text/a2ps { };
 
+  abcmidi = callPackage ../tools/audio/abcmidi { };
+
   abduco = callPackage ../tools/misc/abduco { };
 
   acbuild = callPackage ../applications/misc/acbuild { };
···
 
   disper = callPackage ../tools/misc/disper { };
 
-  dmd_2_067_1 = callPackage ../development/compilers/dmd/2.067.1.nix { };
+  dmd_2_067_1 = callPackage ../development/compilers/dmd/2.067.1.nix {
+    stdenv = if stdenv.hostPlatform.isDarwin then
+               stdenv
+             else
+               # Doesn't build with gcc6 on linux
+               overrideCC stdenv gcc5;
+  };
+
   dmd = callPackage ../development/compilers/dmd {
     bootstrapDmd = dmd_2_067_1;
   };
···
 
   emscripten = callPackage ../development/compilers/emscripten { };
 
-  emscriptenfastcomp-unwrapped = callPackage ../development/compilers/emscripten-fastcomp { };
-  emscriptenfastcomp-wrapped = wrapCCWith stdenv.cc.libc ''
-    # hardening flags break WASM support
-    cat > $out/nix-support/add-hardening.sh
-  '' emscriptenfastcomp-unwrapped;
-  emscriptenfastcomp = symlinkJoin {
-    name = "emscriptenfastcomp";
-    paths = [ emscriptenfastcomp-wrapped emscriptenfastcomp-unwrapped ];
-    preferLocalBuild = false;
-    allowSubstitutes = true;
-    postBuild = ''
-      # replace unwrapped clang-3.9 binary by wrapper
-      ln -sf $out/bin/clang $out/bin/clang-[0-9]*
-    '';
-  };
+  emscriptenfastcompPackages = callPackage ../development/compilers/emscripten-fastcomp { };
+
+  emscriptenfastcomp = emscriptenfastcompPackages.emscriptenfastcomp;
 
   emscriptenPackages = recurseIntoAttrs (callPackage ./emscripten-packages.nix { });
 
···
 
   kytea = callPackage ../tools/text/kytea { };
 
+  ldc = callPackage ../development/compilers/ldc { };
+
   lbreakout2 = callPackage ../games/lbreakout2 { };
 
   leocad = callPackage ../applications/graphics/leocad { };
···
 
   pdf2svg = callPackage ../tools/graphics/pdf2svg { };
 
+  fmodex = callPackage ../games/zandronum/fmod.nix { };
+
   pdfmod = callPackage ../applications/misc/pdfmod { };
 
   jbig2enc = callPackage ../tools/graphics/jbig2enc { };
···
 
   tldr = callPackage ../tools/misc/tldr { };
 
+  tldr-hs = haskellPackages.tldr;
+
   tlspool = callPackage ../tools/networking/tlspool { };
 
   tmate = callPackage ../tools/misc/tmate { };
···
   ttylog = callPackage ../tools/misc/ttylog { };
 
   turses = callPackage ../applications/networking/instant-messengers/turses { };
+
+  oysttyer = callPackage ../applications/networking/instant-messengers/oysttyer { };
 
   twitterBootstrap = callPackage ../development/web/twitter-bootstrap {};
   twitterBootstrap3 = callPackage ../development/web/twitter-bootstrap/v3.nix {};
···
   #Use this instead of stdenv to build with clang
   clangStdenv = if stdenv.isDarwin then stdenv else lowPrio llvmPackages.stdenv;
   clang-sierraHack-stdenv = overrideCC stdenv clang-sierraHack;
-  libcxxStdenv = lowPrio llvmPackages.libcxxStdenv;
+  libcxxStdenv = if stdenv.isDarwin then stdenv else lowPrio llvmPackages.libcxxStdenv;
 
   clean = callPackage ../development/compilers/clean { };
 
···
     ruby_2_1_10
     ruby_2_2_7
     ruby_2_3_4
-    ruby_2_4_1;
+    ruby_2_4_2;
 
   # Ruby aliases
   ruby = ruby_2_3;
···
   ruby_2_1 = ruby_2_1_10;
   ruby_2_2 = ruby_2_2_7;
   ruby_2_3 = ruby_2_3_4;
-  ruby_2_4 = ruby_2_4_1;
+  ruby_2_4 = ruby_2_4_2;
 
   scsh = callPackage ../development/interpreters/scsh { };
 
···
   };
 
   include-what-you-use = callPackage ../development/tools/analysis/include-what-you-use {
-    llvmPackages = llvmPackages_38;
+    llvmPackages = llvmPackages_4;
   };
 
   indent = callPackage ../development/tools/misc/indent { };
···
 
   glui = callPackage ../development/libraries/glui {};
 
-  gmime = callPackage ../development/libraries/gmime { };
+  gmime2 = callPackage ../development/libraries/gmime/2.nix { };
+  gmime3 = callPackage ../development/libraries/gmime/3.nix { };
+  gmime = gmime2;
 
   gmm = callPackage ../development/libraries/gmm { };
 
···
 
   sqlite3_analyzer = lowPrio (callPackage ../development/libraries/sqlite/sqlite3_analyzer.nix { });
 
-  sqlite-amalgamation = callPackage ../development/libraries/sqlite-amalgamation { };
-
   sqlite-interactive = appendToName "interactive" (sqlite.override { interactive = true; }).bin;
 
   sqlcipher = lowPrio (callPackage ../development/libraries/sqlcipher {
···
 
     sch_cake = callPackage ../os-specific/linux/sch_cake { };
 
-    spl = callPackage ../os-specific/linux/spl {
+    inherit (callPackage ../os-specific/linux/spl {
       configFile = "kernel";
       inherit kernel;
-    };
+    }) splStable splUnstable;
+
+    spl = splStable;
 
     sysdig = callPackage ../os-specific/linux/sysdig {};
 
···
 
     x86_energy_perf_policy = callPackage ../os-specific/linux/x86_energy_perf_policy { };
 
-    zfs = callPackage ../os-specific/linux/zfs {
+    inherit (callPackage ../os-specific/linux/zfs {
       configFile = "kernel";
       inherit kernel spl;
-    };
+     }) zfsStable zfsUnstable;
+
+     zfs = zfsStable;
   });
 
   # The current default kernel / kernel modules.
···
 
   statifier = callPackage ../os-specific/linux/statifier { };
 
-  spl = callPackage ../os-specific/linux/spl {
+  inherit (callPackage ../os-specific/linux/spl {
     configFile = "user";
-  };
+  }) splStable splUnstable;
 
   sysdig = callPackage ../os-specific/linux/sysdig {
     kernel = null;
···
 
   zd1211fw = callPackage ../os-specific/linux/firmware/zd1211 { };
 
-  zfs = callPackage ../os-specific/linux/zfs {
+  inherit (callPackage ../os-specific/linux/zfs {
     configFile = "user";
-  };
+  }) zfsStable zfsUnstable;
+
+  zfs = zfsStable;
 
   ### DATA
 
···
   kadu = kde4.callPackage ../applications/networking/instant-messengers/kadu { };
 
   kanboard = callPackage ../applications/misc/kanboard { };
-
-  kde-telepathy = kde4.callPackage ../applications/networking/instant-messengers/telepathy/kde {};
 
   kdeApplications =
     let
···
 
   notepadqq = libsForQt56.callPackage ../applications/editors/notepadqq { };
 
-  notmuch = callPackage ../applications/networking/mailreaders/notmuch { };
+  notmuch = callPackage ../applications/networking/mailreaders/notmuch {
+    gmime = gmime3;
+  };
 
   notmuch-mutt = callPackage ../applications/networking/mailreaders/notmuch/mutt.nix { };
 
···
 
   xsokoban = callPackage ../games/xsokoban { };
 
-  zandronum = callPackage ../games/zandronum {
-    cmake = cmake_2_8;
-  };
+  zandronum = callPackage ../games/zandronum { };
 
   zandronum-server = zandronum.override {
     serverOnly = true;
   };
-
-  zandronum-bin = hiPrio (callPackage ../games/zandronum/bin.nix { });
 
   zangband = callPackage ../games/zangband { };
 
···
 
   ### DESKTOP ENVIRONMENTS
 
-  clearlooks-phenix = callPackage ../misc/themes/gtk3/clearlooks-phenix { };
+  clearlooks-phenix = callPackage ../misc/themes/clearlooks-phenix { };
 
   enlightenment = recurseIntoAttrs (callPackage ../desktops/enlightenment {
     callPackage = newScope pkgs.enlightenment;
···
     ecl = ecl_16_1_2;
     sbcl = null;
   };
+
+  mxnet = callPackage ../applications/science/math/mxnet { };
 
   wxmaxima = callPackage ../applications/science/math/wxmaxima { wxGTK = wxGTK30; };
 
···
 
   e17gtk = callPackage ../misc/themes/e17gtk { };
 
+  epson-alc1100 = callPackage ../misc/drivers/epson-alc1100 { };
+
   epson-escpr = callPackage ../misc/drivers/epson-escpr { };
 
   epson_201207w = callPackage ../misc/drivers/epson_201207w { };
···
   # `recurseIntoAttrs` for sake of hydra, not nix-env
   tests = recurseIntoAttrs {
     cc-wrapper = callPackage ../test/cc-wrapper { };
-    cc-wrapper-clang = callPackage ../test/cc-wrapper { stdenv = clangStdenv; };
-    cc-wrapper-libcxx = callPackage ../test/cc-wrapper { stdenv = libcxxStdenv; };
+    cc-wrapper-clang = callPackage ../test/cc-wrapper { stdenv = llvmPackages.stdenv; };
+    cc-wrapper-libcxx = callPackage ../test/cc-wrapper { stdenv = llvmPackages.libcxxStdenv; };
+    cc-wrapper-clang-39 = callPackage ../test/cc-wrapper { stdenv = llvmPackages_39.stdenv; };
+    cc-wrapper-libcxx-39 = callPackage ../test/cc-wrapper { stdenv = llvmPackages_39.libcxxStdenv; };
     stdenv-inputs = callPackage ../test/stdenv-inputs { };
 
     macOSSierraShared = callPackage ../test/macos-sierra-shared {};
   };
+
+  duti = callPackage ../os-specific/darwin/duti {};
 }

pkgs/top-level/impure.nix

···
           # it's a directory, so the set of overlays from the directory, ordered lexicographically
           let content = readDir path; in
           map (n: import (path + ("/" + n)))
-            (builtins.filter (n: builtins.match ".*\.nix" n != null || pathExists (path + ("/" + n + "/default.nix")))
+            (builtins.filter (n: builtins.match ".*\\.nix" n != null || pathExists (path + ("/" + n + "/default.nix")))
               (attrNames content))
         else 
           # it's a file, so the result is the contents of the file itself

pkgs/top-level/perl-packages.nix

···
     };
   };
 
+  HTTPDAV = buildPerlPackage rec {
+    name = "HTTP-DAV-0.44";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/O/OP/OPERA/${name}.tar.gz";
+      sha256 = "1pp7xbfn6yr87cqy2m2kl2v5zgvmmikhl7wmaw6c5nksj4wi9xq1";
+    };
+    buildInputs = [ LWP XMLDOM ];
+    meta = {
+      description = "WebDAV client library.";
+    };
+  };
+
   HTTPHeaderParserXS = buildPerlPackage rec {
     name = "HTTP-HeaderParser-XS-0.20";
     src = fetchurl {
···
     propagatedBuildInputs = [ IPCSignal ];
   };
 
+  ProtocolWebSocket = buildPerlModule rec {
+    name = "Protocol-WebSocket-0.20";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/V/VT/VTI/${name}.tar.gz";
+      sha256 = "00ga7sjrqcbr46kwfbaa37lxqqbp9z5gymjckzps6ll2jf7k58mx";
+    };
+    buildInputs = [ ModuleBuildTiny ];
+  };
+
+  ProtocolHTTP2 = buildPerlModule rec {
+    name = "Protocol-HTTP2-1.08";
+
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/C/CR/CRUX/${name}.tar.gz";
+      sha256 = "06y1djgzbn340hixav85728dvp8mj2mx2qf5fzkqxh145g5q860g";
+    };
+    buildInputs = [ ModuleBuildTiny TestLeakTrace  TestTCP ];
+    propagatedBuildInputs = [ AnyEvent NetSSLeay ];
+  };
+
   PSGI = buildPerlPackage rec {
     name = "PSGI-1.102";
     src = fetchurl {
···
       url = "mirror://cpan/authors/id/Z/ZE/ZEFRAM/${name}.tar.gz";
       sha256 = "d3a45cc137bb9f7d8848d5a10a5142d275a98f8dcfd3adb60593cee9d33fa6ae";
     };
+    buildInputs = [ ModuleBuild ];
+  };
+
+  SCGI = buildPerlPackage rec {
+    name = "SCGI-0.6";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/V/VI/VIPERCODE/${name}.tar.gz";
+      sha256 = "196rj47mh4fq2vlnw595q391zja5v6qg7s3sy0vy8igfyid8rdsq";
+    };
+    preConfigure = "export HOME=$(mktemp -d)";
     buildInputs = [ ModuleBuild ];
   };
 
···
     propagatedBuildInputs = [ TermProgressBarQuiet ];
   };
 
-  TermReadKey = buildPerlPackage {
-    name = "TermReadKey-2.31";
+  TermReadKey = buildPerlPackage rec {
+    name = "TermReadKey-${version}";
+    version = "2.37";
     src = fetchurl {
-      url = mirror://cpan/authors/id/J/JS/JSTOWE/TermReadKey-2.31.tar.gz;
+      url = "mirror://cpan/authors/id/J/JS/JSTOWE/${name}.tar.gz";
       sha256 = "1czarrdxgnxmmbaasjnq3sj14nf1cvzhm37padq6xvl7h7r2acb2";
     };
   };
···
     meta = {
       homepage = http://sourceforge.net/projects/perl-trg/;
       description = "Perl extension for the GNU Readline/History Library";
+      license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
+    };
+  };
+
+  TermReadLineTTYtter = buildPerlPackage rec {
+    name = "Term-ReadLine-TTYtter-1.4";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/C/CK/CKAISER/Term-ReadLine-TTYtter-1.4.tar.gz";
+      sha256 = "14xcqhg1vrwgv65nd2z8xzn0wgb18i17pzkkh8m15cp1rqrk2dxc";
+    };
+
+    outputs = [ "out" ];
+
+    meta = {
+      description = "a modified version of T::RL::Perl with several new nonstandard features specific to TTYtter";
       license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
     };
   };

pkgs/top-level/python-packages.nix

···
 
   acoustics = callPackage ../development/python-modules/acoustics { };
 
-  "3to2" = callPackage ../development/python-modules/3to2 { };
+  py3to2 = callPackage ../development/python-modules/3to2 { };
+  # Left for backwards compatibility
+  "3to2" = self.py3to2;
 
   aenum = callPackage ../development/python-modules/aenum { };
 
···
   nltk = callPackage ../development/python-modules/nltk.nix { };
 
   ntlm-auth = callPackage ../development/python-modules/ntlm-auth { };
-
-  pitz = callPackage ../applications/misc/pitz { };
 
   plantuml = callPackage ../tools/misc/plantuml { };
 
···
 
   csvkit =  callPackage ../development/python-modules/csvkit { };
 
-  cx_Freeze = buildPythonPackage rec {
-    name = "cx_freeze-${version}";
-    version = "4.3.4";
-
-    # build failures
-    disabled = isPyPy || isPy35;
-
-    # timestamp need to come after 1980 for zipfiles and nix store is set to epoch
-    prePatch = ''
-      substituteInPlace cx_Freeze/freezer.py --replace "os.stat(module.file).st_mtime" "time.time()"
-    '';
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/c/cx_Freeze/cx_Freeze-${version}.tar.gz";
-      sha256 = "1qhv0gq3ggr06k8cvzphma29zfqdajkx2yfzbw89s4vy23xbpis0";
-    };
-
-    meta = {
-      description = "A set of scripts and modules for freezing Python scripts into executables";
-      homepage = "http://cx-freeze.sourceforge.net/";
-      license = licenses.psfl;
-    };
-  };
+  cx_Freeze = callPackage ../development/python-modules/cx_freeze {};
 
   cvxopt = buildPythonPackage rec {
     name = "${pname}-${version}";
···
     };
   };
 
+  cld2-cffi = callPackage ../development/python-modules/cld2-cffi {};
+
   clf = buildPythonPackage rec {
     name = "clf-${version}";
     version = "0.5.2";
···
 
   cligj = callPackage ../development/python-modules/cligj { };
 
-  clepy = buildPythonPackage rec {
-    name = "clepy-0.3.20";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/c/clepy/${name}.tar.gz";
-      sha256 = "16vibfxms5z4ld8gbkra6dkhqm2cc3jnn0fwp7mw70nlwxnmm51c";
-    };
-
-    buildInputs = with self; [ self.mock self.nose self.decorator ];
-
-    meta = {
-      homepage = http://code.google.com/p/clepy/;
-      description = "Utilities created by the Cleveland Python users group";
-    };
-  };
-
-
   clientform = buildPythonPackage (rec {
     name = "clientform-0.2.10";
     disabled = isPy3k;
···
       sha256 = "11wcni2xmfmy001rj62q2pwf305vvngkrfm5c4zlwvgbvlsrvnnw";
     };
 
+    patches = [
+      (pkgs.fetchpatch {
+          url = "https://github.com/stefanofontanelli/ColanderAlchemy/commit/b45fe35f2936a5ccb705e9344075191e550af6c9.patch";
+          sha256 = "1kf278wjq49zd6fhpp55vdcawzdd107767shzfck522sv8gr6qvx";
+      })
+    ];
+
     buildInputs = with self; [ unittest2 ];
     propagatedBuildInputs = with self; [ colander sqlalchemy ];
 
···
     };
   };
 
-  credstash = buildPythonPackage rec {
-    pname    = "credstash";
-    version = "1.13.2";
-    name = "${pname}-${version}";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/${builtins.substring 0 1 pname}/${pname}/${name}.tar.gz";
-      sha256 = "b6283e565e3e441e8f74efcca54ece9697db16ce2e930fb5b6f7c0ab929c377e";
-    };
-
-    propagatedBuildInputs = with self; [ cryptography boto3 pyyaml docutils ];
-
-    # No tests in archive
-    doCheck = false;
-
-    meta = {
-      description = "A utility for managing secrets in the cloud using AWS KMS and DynamoDB";
-      homepage = https://github.com/LuminalOSS/credstash;
-      license = licenses.asl20;
-    };
-  };
+  credstash = callPackage ../development/python-modules/credstash { };
 
   cython = callPackage ../development/python-modules/Cython { };
 
···
     };
   };
 
-  MDP = buildPythonPackage rec {
-    version = "3.5";
-    name = "MDP-${version}";
-
-    src = pkgs.fetchurl {
-      url = "https://pypi.python.org/packages/source/M/MDP/${name}.tar.gz";
-      sha256 = "0aw1zxmyvx6gfmmnixbqmdaah28jl7rmqkzhxv53091asc23iw9k";
-    };
-
-    buildInputs = with self; [ pytest_29 ];
-    propagatedBuildInputs = with self; [ future numpy ];
-
-    doCheck = true;
-
-    meta = {
-      description = "Library for building complex data processing software by combining widely used machine learning algorithms";
-      homepage = http://mdp-toolkit.sourceforge.net;
-      license = licenses.bsd3;
-      maintainers = with maintainers; [ nico202 ];
-    };
-  };
+  MDP = callPackage ../development/python-modules/mdp {};
 
   minidb = buildPythonPackage rec {
     name = "minidb-2.0.1";
···
     };
   };
 
+  mxnet = buildPythonPackage rec {
+    inherit (pkgs.mxnet) name version src meta;
+
+    buildInputs = [ pkgs.mxnet ];
+    propagatedBuildInputs = with self; [ requests numpy graphviz ];
+
+    LD_LIBRARY_PATH = makeLibraryPath [ pkgs.mxnet ];
+
+    doCheck = !isPy3k;
+
+    preConfigure = ''
+      cd python
+    '';
+
+    postInstall = ''
+      rm -rf $out/mxnet
+      ln -s ${pkgs.mxnet}/lib/libmxnet.so $out/${python.sitePackages}/mxnet
+    '';
+  };
 
   pkginfo = buildPythonPackage rec {
     version = "1.3.2";
···
     };
   };
 
+  ijson = callPackage ../development/python-modules/ijson/default.nix {};
+
   imagesize = buildPythonPackage rec {
     name = "imagesize-${version}";
     version = "0.7.0";
···
       description = "Library for parsing MediaWiki articles and converting them to different output formats";
       homepage = "http://pediapress.com/code/";
       license = licenses.bsd3;
+      broken = true; # Requires different versions of packages
     };
   };
 
···
     inherit (pkgs.stdenv) mkDerivation;
     inherit pythonOlder;
   };
+
+  pyphen = callPackage ../development/python-modules/pyphen {};
 
   pypoppler = buildPythonPackage rec {
     name = "pypoppler-${version}";
···
 
   moretools = callPackage ../development/python-modules/moretools { };
 
-  moto = buildPythonPackage rec {
-    version = "0.4.25";
-    name    = "moto-${version}";
-    src = pkgs.fetchurl {
-      url    = "http://pypi.python.org/packages/df/9e/0b22ac0abf61711c86ae75a0548825e19cc123b522ff3508cbc43924969d/moto-0.4.25.tar.gz";
-      sha256 = "1gqm7h6bm5xkspd07bnjwdr2q6cvpxkayx0hkgk8fhkawbg0fqq7";
-    };
-
-    propagatedBuildInputs = with self; [
-      # Main dependencies
-      jinja2 werkzeug flask requests six boto httpretty xmltodict
-      # For tests
-      nose sure boto3 freezegun
-    ];
-
-    checkPhase = "nosetests";
-
-    # TODO: make this true; I think lots of the tests want network access but we can probably run the others
-    doCheck = false;
-  };
-
+  moto = callPackage ../development/python-modules/moto {};
 
   mox = buildPythonPackage rec {
     name = "mox-0.5.3";
···
     };
   };
 
-  nilearn = buildPythonPackage rec {
-    version = "0.2.5";
-    name = "nilearn-${version}";
-
-    # package seems to attempt Python 3 compatibility, but throws UnicodeDecodeError when building:
-    disabled = isPy3k;
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/n/nilearn/${name}.tar.gz";
-      sha256 = "1lmkrzr5x2yp129v2fvckrbdzf2kpcivdg9cacl519l3mb0acdv9";
-    };
-
-    checkPhase = "nosetests --exclude with_expand_user nilearn/tests";
-
-    buildInputs = with self; [ nose ];
-
-    propagatedBuildInputs = with self; [
-      matplotlib
-      nibabel
-      numpy
-      scikitlearn
-      scipy
-    ];
-
-    meta = {
-      homepage = http://nilearn.github.io;
-      description = "A module for statistical learning on neuroimaging data";
-      license = licenses.bsd3;
-    };
-  };
+  nilearn = callPackage ../development/python-modules/nilearn {};
 
   nipy = buildPythonPackage rec {
     version = "0.4.0";
···
        oslo-serialization oslo-utils iso8601 oslo-log oslo-i18n webob
      ];
      buildInputs = with self; [
-       oslo-middleware cachetools oslo-service futurist anyjson oslosphinx
+       oslo-middleware cachetools_1 oslo-service futurist anyjson oslosphinx
        testtools oslotest
      ];
 
···
      };
    };
 
-   cachetools = buildPythonPackage rec {
-     name = "cachetools-${version}";
-     version = "1.1.3";
-     disabled = isPyPy;  # a test fails
-
-     src = pkgs.fetchurl {
-       url = "mirror://pypi/c/cachetools/${name}.tar.gz";
-       sha256 = "0js7qx5pa8ibr8487lcf0x3a7w0xml0wa17snd6hjs0857kqhn20";
-     };
-
-     meta = with stdenv.lib; {
-       homepage = "https://github.com/tkem/cachetools";
-     };
-   };
+   cachetools_1 = callPackage ../development/python-modules/cachetools/1.nix {};
+   cachetools = callPackage ../development/python-modules/cachetools {};
 
    futurist = buildPythonPackage rec {
      name = "futurist-${version}";
···
     propagatedBuildInputs = with self; [
       pbr oslo-config oslo-context oslo-log oslo-utils oslo-serialization
       oslo-i18n stevedore six eventlet greenlet webob pyyaml kombu_3 trollius
-      aioeventlet cachetools oslo-middleware futurist redis oslo-service
+      aioeventlet cachetools_1 oslo-middleware futurist redis oslo-service
       eventlet pyzmq
     ];
 
···
     };
 
     propagatedBuildInputs = with self; [
-      pbr futures enum34 debtcollector cachetools oslo-serialization oslo-utils
+      pbr futures enum34 debtcollector cachetools_1 oslo-serialization oslo-utils
       jsonschema monotonic stevedore networkx futurist pbr automaton fasteners
     ];
     buildInputs = with self; [
···
     };
   };
 
-  ptpython = buildPythonPackage rec {
-    name = "ptpython-0.35";
-    propagatedBuildInputs = with self;
-        [ wcwidth six prompt_toolkit docopt jedi pygments];
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/p/ptpython/${name}.tar.gz";
-      sha256 = "e0d380fbccb03ed33a7f33d96988e66fbd286bc813c9ceea84a1b3b5615a5660";
-    };
-
-    meta = {
-      description = "An advanced Python REPL";
-      license = licenses.bsd3;
-      maintainers = with maintainers; [ mlieberman85 ];
-      platforms = platforms.all;
-    };
-  };
+  ptpython = callPackage ../development/python-modules/ptpython {};
 
   publicsuffix = buildPythonPackage rec {
     name = "publicsuffix-${version}";
···
 
   pywinrm = callPackage ../development/python-modules/pywinrm { };
 
-  PyXAPI = stdenv.mkDerivation rec {
-    name = "PyXAPI-0.1";
-
-    src = pkgs.fetchurl {
-      url = "http://www.pps.univ-paris-diderot.fr/~ylg/PyXAPI/${name}.tar.gz";
-      sha256 = "19lblwfq24bgsgfy7hhqkxdf4bxl40chcxdlpma7a0wfa0ngbn26";
-    };
-
-    buildInputs = [ self.python ];
-
-    installPhase = ''
-      mkdir -p "$out/lib/${python.libPrefix}/site-packages"
-
-      export PYTHONPATH="$out/lib/${python.libPrefix}/site-packages:$PYTHONPATH"
-
-      ${python}/bin/${python.executable} setup.py install \
-        --install-lib=$out/lib/${python.libPrefix}/site-packages \
-        --prefix="$out"
-    '';
-
-    meta = with stdenv.lib; {
-      description = "Python socket module extension & RFC3542 IPv6 Advanced Sockets API";
-      longDescription = ''
-        PyXAPI consists of two modules: `socket_ext' and `rfc3542'.
-        `socket_ext' extends the Python module `socket'. `socket' objects have
-        two new methods: `recvmsg' and `sendmsg'. It defines `ancillary data'
-        objects and some functions related to. `socket_ext' module also provides
-        functions to manage interfaces indexes defined in RFC3494 and not
-        available from standard Python module `socket'.
-        `rfc3542' is a full implementation of RFC3542 (Advanced Sockets
-        Application Program Interface (API) for IPv6).
-      '';
-      homepage = http://www.pps.univ-paris-diderot.fr/~ylg/PyXAPI/;
-      license = licenses.gpl2Plus;
-      maintainers = with maintainers; [ nckx ];
-    };
-  };
-
   pyxattr = buildPythonPackage (rec {
     name = "pyxattr-0.5.1";
 
···
 
   sqlmap = callPackage ../development/python-modules/sqlmap { };
   pgpdump = self.buildPythonPackage rec {
-    name = "pgpdump-1.5";
+    pname = "pgpdump";
+    version = "1.5";
+    name = "${pname}-${version}";
 
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/p/pgpdump/pgpdump-1.5.tar.gz";
-      sha256 = "1c4700857bf7ba735b08cfe4101aa3a4f5fd839657af249c17b2697c20829668";
+    src = fetchPypi {
+      inherit pname version;
+      sha256 = "0s4nh8h7qsdj2yf29bspjs1zvxd4lcd11r6g11dp7fppgf2h0iqw";
     };
+
+    # Disabling check because of: https://github.com/toofishes/python-pgpdump/issues/18
+    doCheck = false;
 
     meta = {
       description = "Python library for parsing PGP packets";
···
     version = "2.1.1";
 
     src = pkgs.fetchurl {
-      url = " mirror://pypi/p/python-daemon/${name}.tar.gz";
+      url = "mirror://pypi/p/python-daemon/${name}.tar.gz";
       sha256 = "17v80qb98p1gv4j9mq6wb55cv7hc4j1hzw5y2f4s5hrpxs3w3a2q";
     };
 
···
   };
 
 
-  unidecode = buildPythonPackage rec {
-    name = "Unidecode-0.04.18";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/U/Unidecode/${name}.tar.gz";
-      sha256 = "12hhblqy1ajvidm38im4171x4arg83pfmziyn53nizp29p3m14gi";
-    };
-
-    LC_ALL="en_US.UTF-8";
-
-    buildInputs = [ pkgs.glibcLocales ];
-
-    meta = {
-      homepage = http://pypi.python.org/pypi/Unidecode/;
-      description = "ASCII transliterations of Unicode text";
-      license = licenses.gpl2;
-      maintainers = with maintainers; [ domenkozar ];
-    };
-  };
-
+  unidecode = callPackage ../development/python-modules/unidecode {};
 
   pyusb = buildPythonPackage rec {
     name = "pyusb-1.0.0";
···
     };
   };
 
-  ws4py = buildPythonPackage rec {
-    name = "${pname}-${version}";
-    pname = "ws4py";
-    version = "0.4.2";
-
-    src = fetchPypi {
-      inherit pname version;
-      sha256 = "0zr3254ky6r7q15l3dhdczfa8i723055zdkqssjifsgcwvirriks";
-    };
-
-    buildInputs = with self; [ pytest mock ];
-    propagatedBuildInputs = with self; [ asyncio cherrypy gevent tornado ];
-
-    checkPhase = ''
-      pytest test
-    '';
-
-    meta = {
-      homepage = https://ws4py.readthedocs.org;
-      description = "A WebSocket package for Python";
-      maintainers = with maintainers; [ rickynils ];
-    };
-  };
+  ws4py = callPackage ../development/python-modules/ws4py {};
 
   gdata = buildPythonPackage rec {
     name = "gdata-${version}";
···
   thinc = callPackage ../development/python-modules/thinc { };
 
   spacy = callPackage ../development/python-modules/spacy { };
+
+  spacy_models = callPackage ../development/python-modules/spacy/models.nix { };
+
+  textacy = callPackage ../development/python-modules/textacy { };
+
+  pyemd  = callPackage ../development/python-modules/pyemd { };
 
   behave = callPackage ../development/python-modules/behave { };