Merge recent master into staging

Hydra nixpkgs: ?compare=1156478

.version

···
-14.10
+14.11

lib/customisation.nix

···
             makeOverridable f (origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs));
           deepOverride = newArgs:
             makeOverridable f (lib.overrideExisting (lib.mapAttrs (deepOverrider newArgs) origArgs) newArgs);
+          overrideDerivation = fdrv:
+            makeOverridable (args: overrideDerivation (f args) fdrv) origArgs;
         })
       else ff;
 

lib/licenses.nix

···
 
   unfreeRedistributableFirmware = "unfree-redistributable-firmware";
 
+  unlicense = {
+    shortName = "Unlicense";
+    fullName = "Unlicense";
+    url = http://unlicense.org/;
+  };
+
   wadalab = {
     shortName = "wadalab";
     fullName = "Wadalab Font License";

lib/maintainers.nix

···
   ertes = "Ertugrul Söylemez <[e-mail]>";
   falsifian = "James Cook <[e-mail]>";
   flosse = "Markus Kohlhase <[e-mail]>";
+  fpletz = "Franz Pletz <[e-mail]>";
   ftrvxmtrx = "Siarhei Zirukin <[e-mail]>";
   funfunctor = "Edward O'Callaghan <[e-mail]>";
   fuuzetsu = "Mateusz Kowalczyk <[e-mail]>";

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

···
 <para>This section lists the release notes for each stable version of NixOS.</para>
 </partintro>
 
-<xi:include href="rl-1410.xml" />
+<xi:include href="rl-1411.xml" />
 <xi:include href="rl-1404.xml" />
 <xi:include href="rl-1310.xml" />
 

nixos/doc/manual/release-notes/rl-1410.xml nixos/doc/manual/release-notes/rl-1411.xml

···
         xmlns:xlink="http://www.w3.org/1999/xlink"
         xmlns:xi="http://www.w3.org/2001/XInclude"
         version="5.0"
-        xml:id="sec-release-14.10">
+        xml:id="sec-release-14.11">
 
-<title>Release 14.10 (“Caterpillar”, 2014/10/??)</title>
+<title>Release 14.11 (“Caterpillar”, 2014/11/??)</title>
 
 <para>When upgrading from a previous release, please be aware of the
 following incompatible changes:
···
 
 </para>
 
-</chapter>
+</chapter>

nixos/modules/installer/tools/tools.nix

···
 # This module generates nixos-install, nixos-rebuild,
 # nixos-generate-config, etc.
 
-{ config, pkgs, modulesPath, lib, ... }:
+{ config, pkgs, modulesPath, ... }:
 
 let
 

nixos/modules/misc/ids.nix

···
       mailpile = 146;
       redmine = 147;
       seeks = 148;
-
-      prosody = 148;
+      prosody = 149;
 
       # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!
 
···
       mailpile = 146;
       redmine = 147;
       seeks = 148;
-
-      prosody = 148;
+      prosody = 149;
 
       # When adding a gid, make sure it doesn't match an existing uid. And don't use gids above 399!
 

nixos/modules/module-list.nix

···
   ./tasks/filesystems/cifs.nix
   ./tasks/filesystems/ext.nix
   ./tasks/filesystems/f2fs.nix
+  ./tasks/filesystems/jfs.nix
   ./tasks/filesystems/nfs.nix
   ./tasks/filesystems/reiserfs.nix
   ./tasks/filesystems/unionfs-fuse.nix

nixos/modules/security/grsecurity.nix

···
         type = types.bool;
         default = false;
         description = ''
-          Enable the stable grsecurity patch, based on Linux 3.2.
+          Enable the stable grsecurity patch, based on Linux 3.14.
         '';
       };
 
···
         type = types.bool;
         default = false;
         description = ''
-          Enable the testing grsecurity patch, based on Linux 3.13.
+          Enable the testing grsecurity patch, based on Linux 3.17.
         '';
       };
 

nixos/modules/services/databases/neo4j.nix

···
     org.neo4j.server.webadmin.rrdb.location=${cfg.dataDir}/data/rrd
     org.neo4j.server.webadmin.data.uri=/db/data/
     org.neo4j.server.webadmin.management.uri=/db/manage/
-    org.neo4j.server.db.tuning.properties=${pkgs.neo4j}/share/neo4j/conf/neo4j.properties
+    org.neo4j.server.db.tuning.properties=${cfg.package}/share/neo4j/conf/neo4j.properties
     org.neo4j.server.manage.console_engines=shell
     ${cfg.extraServerConfig}
   '';
···
       description = "Whether to enable neo4j.";
       default = false;
       type = types.uniq types.bool;
+    };
+
+    package = mkOption {
+      description = "Neo4j package to use.";
+      default = pkgs.neo4j;
+      type = types.package;
     };
 
     host = mkOption {
···
       after = [ "network-interfaces.target" ];
       environment = { NEO4J_INSTANCE = cfg.dataDir; };
       serviceConfig = {
-        ExecStart = "${pkgs.neo4j}/bin/neo4j console";
+        ExecStart = "${cfg.package}/bin/neo4j console";
         User = "neo4j";
         PermissionsStartOnly = true;
       };

nixos/modules/services/hardware/udev.nix

···
     hardware.firmware = mkOption {
       type = types.listOf types.path;
       default = [];
-      example = [ "/root/my-firmware" ];
       description = ''
         List of directories containing firmware files.  Such files
         will be loaded automatically if the kernel asks for them
···
         firmware file with the same name, the first path in the list
         takes precedence.  Note that you must rebuild your system if
         you add files to any of these directories.  For quick testing,
-        put firmware files in /root/test-firmware and add that
-        directory to the list.
-        Note that you can also add firmware packages to this
-        list as these are directories in the nix store.
+        put firmware files in <filename>/root/test-firmware</filename>
+        and add that directory to the list.  Note that you can also
+        add firmware packages to this list as these are directories in
+        the nix store.
       '';
       apply = list: pkgs.buildEnv {
         name = "firmware";
···
         if [ ! -e /var/lib/udev/prev-systemd -o "$(readlink /var/lib/udev/prev-systemd)" != ${config.systemd.package} ]; then
           echo "regenerating udev hardware database..."
           ${config.systemd.package}/bin/udevadm hwdb --update && ln -sfn ${config.systemd.package} /var/lib/udev/prev-systemd
+        fi
+
+        # Allow the kernel to find our firmware.
+        if [ -e /sys/module/firmware_class/parameters/path ]; then
+          echo -n "${config.hardware.firmware}" > /sys/module/firmware_class/parameters/path
         fi
       '';
 

nixos/modules/services/monitoring/graphite.nix

···
     GRAPHITE_URL = cfg.seyren.graphiteUrl;
   } // cfg.seyren.extraConfig;
 
+  pagerConfig = pkgs.writeText "alarms.yaml" cfg.pager.alerts;
+
   configDir = pkgs.buildEnv {
     name = "graphite-config";
     paths = lists.filter (el: el != null) [
···
 
     api = {
       enable = mkOption {
-        description = "Whether to enable graphite api.";
+        description = ''
+          Whether to enable graphite api. Graphite api is lightweight alternative
+          to graphite web, with api and without dashboard. It's advised to use
+          grafana as alternative dashboard and influxdb as alternative to
+          graphite carbon.
+
+          For more information visit
+          <link xlink:href="http://graphite-api.readthedocs.org/en/latest/"/>
+        '';
         default = false;
         type = types.uniq types.bool;
       };
 
       finders = mkOption {
-        description = "List of finder plugins load.";
+        description = "List of finder plugins to load.";
         default = [];
         example = [ pkgs.python27Packages.graphite_influxdb ];
         type = types.listOf types.package;
···
         '';
       };
     };
-  };
 
-  ###### implementation
+    pager = {
+      enable = mkOption {
+        description = ''
+          Whether to enable graphite-pager service. For more information visit
+          <link xlink:href="https://github.com/seatgeek/graphite-pager"/>
+        '';
+        default = false;
+        type = types.uniq types.bool;
+      };
 
-  config = mkIf (
-    cfg.carbon.enableAggregator ||
-    cfg.carbon.enableCache ||
-    cfg.carbon.enableRelay ||
-    cfg.web.enable ||
-    cfg.api.enable ||
-    cfg.seyren.enable
-  ) {
-    systemd.services.carbonCache = {
-      enable = cfg.carbon.enableCache;
-      description = "Graphite Data Storage Backend";
-      wantedBy = [ "multi-user.target" ];
-      after = [ "network-interfaces.target" ];
-      environment = carbonEnv;
-      serviceConfig = {
-        ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-cache"}";
-        User = "graphite";
-        Group = "graphite";
-        PermissionsStartOnly = true;
+      redisUrl = mkOption {
+        description = "Redis connection string.";
+        default = "redis://localhost:${toString config.services.redis.port}/";
+        type = types.str;
       };
-      preStart = ''
-        mkdir -p ${cfg.dataDir}/whisper
-        chmod 0700 ${cfg.dataDir}/whisper
-        chown -R graphite:graphite ${cfg.dataDir}
-      '';
-    };
 
-    systemd.services.carbonAggregator = {
-      enable = cfg.carbon.enableAggregator;
-      description = "Carbon Data Aggregator";
-      wantedBy = [ "multi-user.target" ];
-      after = [ "network-interfaces.target" ];
-      environment = carbonEnv;
-      serviceConfig = {
-        ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-aggregator"}";
-        User = "graphite";
-        Group = "graphite";
+      graphiteUrl = mkOption {
+        description = "URL to your graphite service.";
+        default = "http://${cfg.web.host}:${toString cfg.web.port}";
+        type = types.str;
       };
-    };
 
-    systemd.services.carbonRelay = {
-      enable = cfg.carbon.enableRelay;
-      description = "Carbon Data Relay";
-      wantedBy = [ "multi-user.target" ];
-      after = [ "network-interfaces.target" ];
-      environment = carbonEnv;
-      serviceConfig = {
-        ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-relay"}";
-        User = "graphite";
-        Group = "graphite";
+      alerts = mkOption {
+        description = "Alerts configuration for graphite-pager.";
+        default = ''
+          alerts:
+            - target: constantLine(100)
+              warning: 90
+              critical: 200
+              name: Test
+        '';
+        example = literalExample ''
+          pushbullet_key: pushbullet_api_key 
+          alerts:
+            - target: stats.seatgeek.app.deal_quality.venue_info_cache.hit
+              warning: .5
+              critical: 1
+              name: Deal quality venue cache hits
+        '';
+        type = types.lines;
       };
     };
+  };
 
-    systemd.services.graphiteWeb = {
-      enable = cfg.web.enable;
-      description = "Graphite Web Interface";
-      wantedBy = [ "multi-user.target" ];
-      after = [ "network-interfaces.target" ];
-      path = [ pkgs.perl ];
-      environment = {
-        PYTHONPATH = "${pkgs.python27Packages.graphite_web}/lib/python2.7/site-packages";
-        DJANGO_SETTINGS_MODULE = "graphite.settings";
-        GRAPHITE_CONF_DIR = configDir;
-        GRAPHITE_STORAGE_DIR = dataDir;
+  ###### implementation
+
+  config = mkMerge [
+    (mkIf cfg.carbon.enableCache {
+      systemd.services.carbonCache = {
+        description = "Graphite Data Storage Backend";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" ];
+        environment = carbonEnv;
+        serviceConfig = {
+          ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-cache"}";
+          User = "graphite";
+          Group = "graphite";
+          PermissionsStartOnly = true;
+        };
+        preStart = ''
+          mkdir -p ${cfg.dataDir}/whisper
+          chmod 0700 ${cfg.dataDir}/whisper
+          chown -R graphite:graphite ${cfg.dataDir}
+        '';
       };
-      serviceConfig = {
-        ExecStart = ''
-          ${pkgs.python27Packages.waitress}/bin/waitress-serve \
-          --host=${cfg.web.host} --port=${toString cfg.web.port} \
-          --call django.core.handlers.wsgi:WSGIHandler'';
-        User = "graphite";
-        Group = "graphite";
-        PermissionsStartOnly = true;
+    })
+
+    (mkIf cfg.carbon.enableAggregator {
+      systemd.services.carbonAggregator = {
+        enable = cfg.carbon.enableAggregator;
+        description = "Carbon Data Aggregator";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" ];
+        environment = carbonEnv;
+        serviceConfig = {
+          ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-aggregator"}";
+          User = "graphite";
+          Group = "graphite";
+        };
       };
-      preStart = ''
-        if ! test -e ${dataDir}/db-created; then
-          mkdir -p ${dataDir}/{whisper/,log/webapp/}
-          chmod 0700 ${dataDir}/{whisper/,log/webapp/}
+    })
 
-          # populate database
-          ${pkgs.python27Packages.graphite_web}/bin/manage-graphite.py syncdb --noinput
+    (mkIf cfg.carbon.enableRelay {
+      systemd.services.carbonRelay = {
+        description = "Carbon Data Relay";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" ];
+        environment = carbonEnv;
+        serviceConfig = {
+          ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-relay"}";
+          User = "graphite";
+          Group = "graphite";
+        };
+      };
+    })
 
-          # create index
-          ${pkgs.python27Packages.graphite_web}/bin/build-index.sh
+    (mkIf (cfg.carbon.enableCache || cfg.carbon.enableAggregator || cfg.carbon.enableRelay) {
+      environment.systemPackages = [
+        pkgs.pythonPackages.carbon
+      ];
+    })
 
-          touch ${dataDir}/db-created
+    (mkIf cfg.web.enable {
+      systemd.services.graphiteWeb = {
+        description = "Graphite Web Interface";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" ];
+        path = [ pkgs.perl ];
+        environment = {
+          PYTHONPATH = "${pkgs.python27Packages.graphite_web}/lib/python2.7/site-packages";
+          DJANGO_SETTINGS_MODULE = "graphite.settings";
+          GRAPHITE_CONF_DIR = configDir;
+          GRAPHITE_STORAGE_DIR = dataDir;
+        };
+        serviceConfig = {
+          ExecStart = ''
+            ${pkgs.python27Packages.waitress}/bin/waitress-serve \
+            --host=${cfg.web.host} --port=${toString cfg.web.port} \
+            --call django.core.handlers.wsgi:WSGIHandler'';
+          User = "graphite";
+          Group = "graphite";
+          PermissionsStartOnly = true;
+        };
+        preStart = ''
+          if ! test -e ${dataDir}/db-created; then
+            mkdir -p ${dataDir}/{whisper/,log/webapp/}
+            chmod 0700 ${dataDir}/{whisper/,log/webapp/}
 
-          chown -R graphite:graphite ${cfg.dataDir}
-        fi
-      '';
-    };
+            # populate database
+            ${pkgs.python27Packages.graphite_web}/bin/manage-graphite.py syncdb --noinput
 
-    systemd.services.graphiteApi = {
-      enable = cfg.api.enable;
-      description = "Graphite Api Interface";
-      wantedBy = [ "multi-user.target" ];
-      after = [ "network-interfaces.target" ];
-      environment = {
-        PYTHONPATH =
-          "${cfg.api.package}/lib/python2.7/site-packages:" +
-          concatMapStringsSep ":" (f: f + "/lib/python2.7/site-packages") cfg.api.finders;
-        GRAPHITE_API_CONFIG = graphiteApiConfig;
-        LD_LIBRARY_PATH = "${pkgs.cairo}/lib";
+            # create index
+            ${pkgs.python27Packages.graphite_web}/bin/build-index.sh
+
+            touch ${dataDir}/db-created
+
+            chown -R graphite:graphite ${cfg.dataDir}
+          fi
+        '';
       };
-      serviceConfig = {
-        ExecStart = ''
-          ${pkgs.python27Packages.waitress}/bin/waitress-serve \
-          --host=${cfg.api.host} --port=${toString cfg.api.port} \
-          graphite_api.app:app 
+
+      environment.systemPackages = [ pkgs.python27Packages.graphite_web ];
+    })
+
+    (mkIf cfg.api.enable { 
+      systemd.services.graphiteApi = {
+        description = "Graphite Api Interface";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" ];
+        environment = {
+          PYTHONPATH =
+            "${cfg.api.package}/lib/python2.7/site-packages:" +
+            concatMapStringsSep ":" (f: f + "/lib/python2.7/site-packages") cfg.api.finders;
+          GRAPHITE_API_CONFIG = graphiteApiConfig;
+          LD_LIBRARY_PATH = "${pkgs.cairo}/lib";
+        };
+        serviceConfig = {
+          ExecStart = ''
+            ${pkgs.python27Packages.waitress}/bin/waitress-serve \
+            --host=${cfg.api.host} --port=${toString cfg.api.port} \
+            graphite_api.app:app 
+          '';
+          User = "graphite";
+          Group = "graphite";
+          PermissionsStartOnly = true;
+        };
+        preStart = ''
+          if ! test -e ${dataDir}/db-created; then
+            mkdir -p ${dataDir}/cache/
+            chmod 0700 ${dataDir}/cache/
+
+            touch ${dataDir}/db-created
+
+            chown -R graphite:graphite ${cfg.dataDir}
+          fi
         '';
-        User = "graphite";
-        Group = "graphite";
-        PermissionsStartOnly = true;
       };
-      preStart = ''
-        if ! test -e ${dataDir}/db-created; then
-          mkdir -p ${dataDir}/cache/
-          chmod 0700 ${dataDir}/cache/
+    })
 
-          touch ${dataDir}/db-created
+    (mkIf cfg.seyren.enable {
+      systemd.services.seyren = {
+        description = "Graphite Alerting Dashboard";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" "mongodb.service" ];
+        environment = seyrenConfig;
+        serviceConfig = {
+          ExecStart = "${pkgs.seyren}/bin/seyren -httpPort ${toString cfg.seyren.port}";
+          WorkingDirectory = dataDir;
+          User = "graphite";
+          Group = "graphite"; 
+        };
+        preStart = ''
+          if ! test -e ${dataDir}/db-created; then
+            mkdir -p ${dataDir}
+            chown -R graphite:graphite ${dataDir}
+          fi
+        '';
+      };
 
-          chown -R graphite:graphite ${cfg.dataDir}
-        fi
-      '';
-    };
+      services.mongodb.enable = mkDefault true;
+    })
 
-    systemd.services.seyren = {
-      enable = cfg.seyren.enable;
-      description = "Graphite Alerting Dashboard";
-      wantedBy = [ "multi-user.target" ];
-      after = [ "network-interfaces.target" "mongodb.service" ];
-      environment = seyrenConfig;
-      serviceConfig = {
-        ExecStart = "${pkgs.seyren}/bin/seyren -httpPort ${toString cfg.seyren.port}";
-        WorkingDirectory = dataDir;
-        User = "graphite";
-        Group = "graphite"; 
+    (mkIf cfg.pager.enable {
+      systemd.services.graphitePager = {
+        description = "Graphite Pager Alerting Daemon";
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network-interfaces.target" "redis.service" ];
+        environment = {
+          REDIS_URL = cfg.pager.redisUrl;
+          GRAPHITE_URL = cfg.pager.graphiteUrl;
+        };
+        serviceConfig = {
+          ExecStart = "${pkgs.pythonPackages.graphite_pager}/bin/graphite-pager --config ${pagerConfig}";
+          User = "graphite";
+          Group = "graphite"; 
+        };
       };
-      preStart = ''
-        if ! test -e ${dataDir}/db-created; then
-          mkdir -p ${dataDir}
-          chown -R graphite:graphite ${dataDir}
-        fi
-      '';
-    };
 
-    services.mongodb.enable = mkDefault cfg.seyren.enable;
+      services.redis.enable = mkDefault true;
 
-    environment.systemPackages = [
-      pkgs.pythonPackages.carbon
-      pkgs.python27Packages.graphite_web
-      pkgs.python27Packages.waitress
-    ];
+      environment.systemPackages = [ pkgs.pythonPackages.graphite_pager ];
+    })
 
-    users.extraUsers = singleton {
-      name = "graphite";
-      uid = config.ids.uids.graphite;
-      description = "Graphite daemon user";
-      home = dataDir;
-    };
-    users.extraGroups.graphite.gid = config.ids.gids.graphite;
-  };
+    {
+      users.extraUsers = singleton {
+        name = "graphite";
+        uid = config.ids.uids.graphite;
+        description = "Graphite daemon user";
+        home = dataDir;
+      };
+      users.extraGroups.graphite.gid = config.ids.gids.graphite;
+    }
+  ];
 }

nixos/modules/services/networking/cjdns-hosts.sh

···
+pubs=($pubs)
+hosts=($hosts)
+
+lines="''\n"
+for ((i = 0; i < ${#pubs[*]}; i++)); do
+    addr=$($cjdns/bin/publictoip6 ${pubs[i]})
+    lines="${lines}$addr ${hosts[i]}\n"
+done
+lines="${lines}''"
+
+echo -ne $lines > $out

nixos/modules/services/networking/cjdns.nix

···
 
 let
 
+  pkg = pkgs.cjdns;
+
   cfg = config.services.cjdns;
 
+  connectToSubmodule =
+  { options, ... }:
+  { options =
+    { password = mkOption {
+      type = types.str;
+      description = "Authorized password to the opposite end of the tunnel.";
+      };
+      publicKey = mkOption {
+        type = types.str;
+        description = "Public key at the opposite end of the tunnel.";
+      };
+      hostname = mkOption {
+        default = "";
+        example = "foobar.hype";
+        type = types.str;
+        description = "Optional hostname to add to /etc/hosts; prevents reverse lookup failures.";
+      };
+    };
+  };
+
+  peers = mapAttrsToList (n: v: v) (cfg.ETHInterface.connectTo // cfg.UDPInterface.connectTo);
+
+  pubs  = toString (map (p: if p.hostname == "" then "" else p.publicKey) peers);
+  hosts = toString (map (p: if p.hostname == "" then "" else p.hostname)  peers);
+
+  cjdnsHosts =
+    if hosts != "" then
+      import (pkgs.stdenv.mkDerivation {
+        name = "cjdns-hosts";
+        builder = ./cjdns-hosts.sh;
+
+        inherit (pkgs) cjdns;
+        inherit pubs hosts;
+      })
+    else "";
+
   # would be nice to  merge 'cfg' with a //,
   # but the json nesting is wacky.
   cjdrouteConf = builtins.toJSON ( {
···
 
       enable = mkOption {
         type = types.bool;
-	default = false;
+        default = false;
         description = ''
           Whether to enable the cjdns network encryption
           and routing engine. A file at /etc/cjdns.keys will
           be created if it does not exist to contain a random
           secret key that your IPv6 address will be derived from.
+        '';
+      };
+
+      confFile = mkOption {
+        type = types.str;
+        default = "";
+        example = "/etc/cjdroute.conf";
+        description = ''
+          Ignore all other cjdns options and load configuration from this file.
         '';
       };
 
       authorizedPasswords = mkOption {
         type = types.listOf types.str;
-	default = [ ];
-	example = [
+        default = [ ];
+        example = [
           "snyrfgkqsc98qh1y4s5hbu0j57xw5s0"
-	  "z9md3t4p45mfrjzdjurxn4wuj0d8swv"
-	  "49275fut6tmzu354pq70sr5b95qq0vj"
+          "z9md3t4p45mfrjzdjurxn4wuj0d8swv"
+          "49275fut6tmzu354pq70sr5b95qq0vj"
         ];
-	description = ''
-	  Any remote cjdns nodes that offer these passwords on 
-	  connection will be allowed to route through this node.
+        description = ''
+          Any remote cjdns nodes that offer these passwords on 
+          connection will be allowed to route through this node.
         '';
       };
     
       admin = {
         bind = mkOption {
           type = types.string;
-	  default = "127.0.0.1:11234";
-	  description = ''
+          default = "127.0.0.1:11234";
+          description = ''
             Bind the administration port to this address and port.
-	  '';
+          '';
         };
       };
 
       UDPInterface = {
         bind = mkOption {
           type = types.string;
-	  default = "";
+          default = "";
           example = "192.168.1.32:43211";
           description = ''
-	    Address and port to bind UDP tunnels to.
-	  '';
- 	};
+            Address and port to bind UDP tunnels to.
+          '';
+         };
         connectTo = mkOption {
-          type = types.attrsOf ( types.submodule (
-	    { options, ... }:
-            { options = {
-                # TODO make host an option, and add it to networking.extraHosts
-                password = mkOption {
-                  type = types.str;
-                  description = "Authorized password to the opposite end of the tunnel.";
-                };
-                publicKey = mkOption {
-                  type = types.str;
-                  description = "Public key at the opposite end of the tunnel.";
-                };
-              };
-            }
-          ));
-	  default = { };
+          type = types.attrsOf ( types.submodule ( connectToSubmodule ) );
+          default = { };
           example = {
             "192.168.1.1:27313" = {
-	      password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";
+              hostname = "homer.hype";
+              password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";
               publicKey = "371zpkgs8ss387tmr81q04mp0hg1skb51hw34vk1cq644mjqhup0.k";
             };
           };
           description = ''
-	    Credentials for making UDP tunnels.
-	  '';
-	};
+            Credentials for making UDP tunnels.
+          '';
+        };
       };
 
       ETHInterface = {
         bind = mkOption {
-	  default = "";
-	  example = "eth0";
-	  description = ''
-	    Bind to this device for native ethernet operation.
-	  '';
-        };
+        default = "";
+        example = "eth0";
+        description = ''
+          Bind to this device for native ethernet operation.
+        '';
+      };
 
         beacon = mkOption {
-	  type = types.int;
+          type = types.int;
           default = 2;
           description = ''
             Auto-connect to other cjdns nodes on the same network.
             Options:
-	      0: Disabled.
+              0: Disabled.
               1: Accept beacons, this will cause cjdns to accept incoming
                  beacon messages and try connecting to the sender.
               2: Accept and send beacons, this will cause cjdns to broadcast
···
         };
 
         connectTo = mkOption {
-          type = types.attrsOf ( types.submodule (
-	    { options, ... }:
-            { options = {
-                password = mkOption {
-                  type = types.str;
-                  description = "Authorized password to the opposite end of the tunnel.";
-                };
-                publicKey = mkOption {
-                  type = types.str;
-                  description = "Public key at the opposite end of the tunnel.";
-                };
-              };
-            }
-          ));
-	  default = { };
+          type = types.attrsOf ( types.submodule ( connectToSubmodule ) );
+          default = { };
           example = {
             "01:02:03:04:05:06" = {
-	      password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";
+              hostname = "homer.hype";
+              password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";
               publicKey = "371zpkgs8ss387tmr81q04mp0hg1skb51hw34vk1cq644mjqhup0.k";
             };
           };
-	  description = ''
-	    Credentials for connecting look similar to UDP credientials
+          description = ''
+            Credentials for connecting look similar to UDP credientials
             except they begin with the mac address.
-	  '';
-	};
+          '';
+        };
       };
 
     };
···
       wantedBy = [ "multi-user.target" ];
       after = [ "network-interfaces.target" ];
 
-      script = ''
-        source /etc/cjdns.keys
-        echo '${cjdrouteConf}' | sed \
-	  -e "s/@CJDNS_ADMIN_PASSWORD@/$CJDNS_ADMIN_PASSWORD/g" \
-          -e "s/@CJDNS_PRIVATE_KEY@/$CJDNS_PRIVATE_KEY/g" \
-            | ${pkgs.cjdns}/bin/cjdroute
-      '';
+      script = (
+        if cfg.confFile != "" then "${pkg}/bin/cjdroute < ${cfg.confFile}" else
+          ''
+            source /etc/cjdns.keys
+            echo '${cjdrouteConf}' | sed \
+                -e "s/@CJDNS_ADMIN_PASSWORD@/$CJDNS_ADMIN_PASSWORD/g" \
+                -e "s/@CJDNS_PRIVATE_KEY@/$CJDNS_PRIVATE_KEY/g" \
+                | ${pkg}/bin/cjdroute
+         ''
+      );
 
       serviceConfig = {
         Type = "forking";
-	Restart = "on-failure";
+        Restart = "on-failure";
       };
     };
 
-    system.activationScripts.cjdns = ''
+    system.activationScripts.cjdns = if (cfg.confFile == "") then "" else ''
+      cjdnsWriteKeys() {
+        private=$1
+        ipv6=$2
+        public=$3
+
+        echo "CJDNS_PRIVATE_KEY=$1" >> /etc/cjdns.keys
+        echo -e "CJDNS_IPV6=$2\nCJDNS_PUBLIC_KEY=$3" > /etc/cjdns.public
+
+        chmod 600 /etc/cjdns.keys
+        chmod 444 /etc/cjdns.public
+      }
+
       grep -q "CJDNS_PRIVATE_KEY=" /etc/cjdns.keys || \
-        echo "CJDNS_PRIVATE_KEY=$(${pkgs.cjdns}/bin/makekey)" \
-	  >> /etc/cjdns.keys
+          cjdnsWriteKeys $(${pkg}/bin/makekeys)
 
       grep -q "CJDNS_ADMIN_PASSWORD=" /etc/cjdns.keys || \
-        echo "CJDNS_ADMIN_PASSWORD=$(${pkgs.coreutils}/bin/head -c 96 /dev/urandom | ${pkgs.coreutils}/bin/tr -dc A-Za-z0-9)" \
-	  >> /etc/cjdns.keys
-
-      chmod 600 /etc/cjdns.keys
+          echo "CJDNS_ADMIN_PASSWORD=$(${pkgs.coreutils}/bin/head -c 96 /dev/urandom | ${pkgs.coreutils}/bin/tr -dc A-Za-z0-9)" \
+          >> /etc/cjdns.keys
     '';
 
+    networking.extraHosts = "${cjdnsHosts}";
+
     assertions = [
-      { assertion = ( cfg.ETHInterface.bind != "" || cfg.UDPInterface.bind != "" );
+      { assertion = ( cfg.ETHInterface.bind != "" || cfg.UDPInterface.bind != "" || cfg.confFile == "" );
         message = "Neither cjdns.ETHInterface.bind nor cjdns.UDPInterface.bind defined.";
       }
       { assertion = config.networking.enableIPv6;

nixos/modules/services/x11/desktop-managers/default.nix

···
   # determines the default: later modules (if enabled) are preferred.
   # E.g., if KDE is enabled, it supersedes xterm.
   imports = [
-    ./none.nix ./xterm.nix ./xfce.nix ./kde4.nix ./kde4_next.nix
+    ./none.nix ./xterm.nix ./xfce.nix ./kde4.nix
     ./e17.nix ./e18.nix ./e19.nix ./gnome3.nix ./xbmc.nix
   ];
 

nixos/modules/services/x11/desktop-managers/kde4.nix

···
           pkgs.strigi # used by nepomuk
           pkgs.mysql # used by akonadi
         ]
-      ++ [ nepomukConfig ] ++ phononBackendPackages
-      ++ config.environment.kdePackages;
+      ++ lib.optional config.hardware.pulseaudio.enable pkgs.kde4.kmix  # Perhaps this should always be enabled
+      ++ lib.optional config.hardware.bluetooth.enable pkgs.kde4.bluedevil
+      ++ lib.optional config.networking.networkmanager.enable pkgs.kde4.networkmanagement
+      ++ [ nepomukConfig ] ++ phononBackendPackages;
 
     environment.pathsToLink = [ "/share" ];
 

nixos/modules/services/x11/desktop-managers/kde4_next.nix

···
-{ config, lib, pkgs, ... }:
-
-with lib;
-
-let
-
-  xcfg = config.services.xserver;
-  cfg = xcfg.desktopManager.kde4_next;
-  xorg = pkgs.xorg;
-  kde = pkgs.kde4_next;
-
-  # Disable Nepomuk and Strigi by default.  As of KDE 4.7, they don't
-  # really work very well (e.g. searching files often fails to find
-  # files), segfault sometimes and consume significant resources.
-  # They can be re-enabled in the KDE System Settings under "Desktop
-  # Search".
-  nepomukConfig = pkgs.writeTextFile
-    { name = "nepomuk-config";
-      destination = "/share/config/nepomukserverrc";
-      text =
-        ''
-          [Basic Settings]
-          Start Nepomuk=false
-
-          [Service-nepomukstrigiservice]
-          autostart=false
-        '';
-    };
-
-  phononBackends = {
-    gstreamer = [
-      pkgs.phonon_backend_gstreamer
-      pkgs.gst_all.gstPluginsBase
-      pkgs.gst_all.gstPluginsGood
-      pkgs.gst_all.gstPluginsUgly
-      pkgs.gst_all.gstPluginsBad
-      pkgs.gst_all.gstFfmpeg # for mp3 playback
-      pkgs.gst_all.gstreamer # needed?
-    ];
-
-    vlc = [pkgs.phonon_backend_vlc];
-  };
-
-  phononBackendPackages = flip concatMap cfg.phononBackends
-    (name: attrByPath [name] (throw "unknown phonon backend `${name}'") phononBackends);
-
-in
-
-{
-  options = {
-
-    services.xserver.desktopManager.kde4_next = {
-      enable = mkOption {
-        type = types.bool;
-        default = false;
-        description = "Enable the KDE 4 desktop environment.";
-      };
-
-      phononBackends = mkOption {
-        type = types.listOf types.str;
-        default = ["gstreamer"];
-        example = ["gstreamer" "vlc"];
-        description = "Which phonon multimedia backend kde should use";
-      };
-    };
-
-  };
-
-
-  config = mkIf (xcfg.enable && cfg.enable) {
-
-    # If KDE 4 is enabled, make it the default desktop manager (unless
-    # overridden by the user's configuration).
-    # !!! doesn't work yet ("Multiple definitions. Only one is allowed
-    # for this option.")
-    # services.xserver.desktopManager.default = mkOverride 900 "kde4";
-
-    services.xserver.desktopManager.session = singleton
-      { name = "kde4_next";
-        bgSupport = true;
-        start =
-          ''
-            # The KDE icon cache is supposed to update itself
-            # automatically, but it uses the timestamp on the icon
-            # theme directory as a trigger.  Since in Nix the
-            # timestamp is always the same, this doesn't work.  So as
-            # a workaround, nuke the icon cache on login.  This isn't
-            # perfect, since it may require logging out after
-            # installing new applications to update the cache.
-            # See http://lists-archives.org/kde-devel/26175-what-when-will-icon-cache-refresh.html
-            rm -fv $HOME/.kde/cache-*/icon-cache.kcache
-
-            # Qt writes a weird ‘libraryPath’ line to
-            # ~/.config/Trolltech.conf that causes the KDE plugin
-            # paths of previous KDE invocations to be searched.
-            # Obviously using mismatching KDE libraries is potentially
-            # disastrous, so here we nuke references to the Nix store
-            # in Trolltech.conf.  A better solution would be to stop
-            # Qt from doing this wackiness in the first place.
-            if [ -e $HOME/.config/Trolltech.conf ]; then
-                sed -e '/nix\\store\|nix\/store/ d' -i $HOME/.config/Trolltech.conf
-            fi
-
-            # Start KDE.
-            exec ${kde.kdebase_workspace}/bin/startkde
-          '';
-      };
-
-    security.setuidOwners = singleton
-      { program = "kcheckpass";
-        source = "${kde.kdebase_workspace}/lib/kde4/libexec/kcheckpass";
-        owner = "root";
-        group = "root";
-        setuid = true;
-      };
-
-    environment.systemPackages =
-        [ kde.kdelibs
-
-          kde.kde_baseapps # Splitted kdebase
-          kde.kde_workspace
-          kde.kde_runtime
-          kde.konsole
-          kde.kate
-
-          kde.kde_wallpapers # contains kdm's default background
-          kde.oxygen_icons
-          pkgs.virtuoso # to enable Nepomuk to find Virtuoso
-
-          # Starts KDE's Polkit authentication agent.
-          kde.polkit_kde_agent
-
-          # Miscellaneous runtime dependencies.
-          kde.qt4 # needed for qdbus
-          pkgs.shared_mime_info
-          xorg.xmessage # so that startkde can show error messages
-          xorg.xset # used by startkde, non-essential
-          xorg.xauth # used by kdesu
-          pkgs.shared_desktop_ontologies # used by nepomuk
-          pkgs.strigi # used by nepomuk
-          pkgs.mysql # used by akonadi
-        ]
-      ++ lib.optional config.hardware.pulseaudio.enable kde.kmix  # Perhaps this should always be enabled
-      ++ lib.optional config.hardware.bluetooth.enable kde.bluedevil
-      ++ lib.optional config.networking.networkmanager.enable kde.networkmanagement
-      ++ [ nepomukConfig ] ++ phononBackendPackages;
-
-    environment.pathsToLink = [ "/share" ];
-
-    environment.etc = singleton
-      { source = "${pkgs.xkeyboard_config}/etc/X11/xkb";
-        target = "X11/xkb";
-      };
-
-    # Enable helpful DBus services.
-    services.udisks2.enable = true;
-    services.upower.enable = config.powerManagement.enable;
-
-    security.pam.services.kde = { allowNullPassword = true; };
-
-  };
-
-}

nixos/modules/system/boot/systemd.nix

···
 
   systemd = cfg.package;
 
+
   makeUnit = name: unit:
+    let
+      pathSafeName = lib.replaceChars ["@" "\\"] ["-" "-"] name;
+    in
     if unit.enable then
-      pkgs.runCommand "unit" { preferLocalBuild = true; inherit (unit) text; }
+      pkgs.runCommand "unit-${pathSafeName}" { preferLocalBuild = true; inherit (unit) text; }
         ''
           mkdir -p $out
           echo -n "$text" > $out/${shellEscape name}
         ''
     else
-      pkgs.runCommand "unit" { preferLocalBuild = true; }
+      pkgs.runCommand "unit-${pathSafeName}-disabled" { preferLocalBuild = true; }
         ''
           mkdir -p $out
           ln -s /dev/null $out/${shellEscape name}

nixos/modules/tasks/filesystems/jfs.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  inInitrd = any (fs: fs == "jfs") config.boot.initrd.supportedFilesystems;
+in
+{
+  config = mkIf (any (fs: fs == "jfs") config.boot.supportedFilesystems) {
+
+    system.fsPackages = [ pkgs.jfsutils ];
+
+    boot.initrd.kernelModules = mkIf inInitrd [ "jfs" ];
+
+    boot.initrd.extraUtilsCommands = mkIf inInitrd ''
+      cp -v ${pkgs.jfsutils}/sbin/fsck.jfs "$out/bin/"
+    '';
+  };
+}

nixos/release-small.nix

···
       mysql51
       mysql55
       nginx
+      openjdk
       openssh
       php
       postgresql92

nixos/release.nix

···
   # ‘nix-build tests/login.nix -A result’.
   tests.avahi = callTest tests/avahi.nix {};
   tests.bittorrent = callTest tests/bittorrent.nix {};
+  tests.blivet = callTest tests/blivet.nix {};
   tests.containers = callTest tests/containers.nix {};
   tests.firefox = callTest tests/firefox.nix {};
   tests.firewall = callTest tests/firewall.nix {};

nixos/tests/blivet.nix

···
+import ./make-test.nix ({ pkgs, ... }: with pkgs.pythonPackages; rec {
+  name = "blivet";
+
+  machine = {
+    environment.systemPackages = [ pkgs.python blivet mock ];
+    boot.supportedFilesystems = [ "btrfs" "jfs" "reiserfs" "xfs" ];
+    virtualisation.memorySize = 768;
+  };
+
+  debugBlivet       = false;
+  debugProgramCalls = false;
+
+  pythonTestRunner = pkgs.writeText "run-blivet-tests.py" ''
+    import sys
+    import logging
+
+    from unittest import TestLoader
+    from unittest.runner import TextTestRunner
+
+    ${pkgs.lib.optionalString debugProgramCalls ''
+      blivet_program_log = logging.getLogger("program")
+      blivet_program_log.setLevel(logging.DEBUG)
+      blivet_program_log.addHandler(logging.StreamHandler(sys.stderr))
+    ''}
+
+    ${pkgs.lib.optionalString debugBlivet ''
+      blivet_log = logging.getLogger("blivet")
+      blivet_log.setLevel(logging.DEBUG)
+      blivet_log.addHandler(logging.StreamHandler(sys.stderr))
+    ''}
+
+    runner = TextTestRunner(verbosity=2, failfast=False, buffer=False)
+    result = runner.run(TestLoader().discover('tests/', pattern='*_test.py'))
+    sys.exit(not result.wasSuccessful())
+  '';
+
+  blivetTest = pkgs.writeScript "blivet-test.sh" ''
+    #!${pkgs.stdenv.shell} -e
+
+    # Use the hosts temporary directory, because we have a tmpfs within the VM
+    # and we don't want to increase the memory size of the VM for no reason.
+    mkdir -p /tmp/xchg/bigtmp
+    TMPDIR=/tmp/xchg/bigtmp
+    export TMPDIR
+
+    mkPythonPath() {
+      nix-store -qR "$@" \
+        | sed -e 's|$|/lib/${pkgs.python.libPrefix}/site-packages|'
+    }
+
+    cp -Rd "${blivet.src}/tests" .
+
+    # Skip SELinux tests
+    rm -f tests/formats_test/selinux_test.py
+
+    # Race conditions in growing/shrinking during resync
+    rm -f tests/devicelibs_test/mdraid_*
+
+    # Deactivate small BTRFS device test, because it fails with newer btrfsprogs
+    sed -i -e '/^class *BTRFSAsRootTestCase3(/,/^[^ ]/ {
+      /^class *BTRFSAsRootTestCase3(/d
+      /^$/d
+      /^ /d
+    }' tests/devicelibs_test/btrfs_test.py
+
+    # How on earth can these tests ever work even upstream? O_o
+    sed -i -e '/def testDiskChunk[12]/,/^ *[^ ]/{n; s/^ */&return # /}' \
+      tests/partitioning_test.py
+
+    # fix hardcoded temporary directory
+    sed -i \
+      -e '1i import tempfile' \
+      -e 's|_STORE_FILE_PATH = .*|_STORE_FILE_PATH = tempfile.gettempdir()|' \
+      tests/loopbackedtestcase.py
+
+    PYTHONPATH=".:$(mkPythonPath "${blivet}" "${mock}" | paste -sd :)" \
+      python "${pythonTestRunner}"
+  '';
+
+  testScript = ''
+    $machine->waitForUnit("multi-user.target");
+    $machine->succeed("${blivetTest}");
+    $machine->execute("rm -rf /tmp/xchg/bigtmp");
+  '';
+})

nixos/tests/partition.nix

···
 
   machine = { config, pkgs, ... }: {
     environment.systemPackages = [
-      pkgs.pythonPackages.nixpart
+      pkgs.pythonPackages.nixpart0
       pkgs.file pkgs.btrfsProgs pkgs.xfsprogs pkgs.lvm2
     ];
     virtualisation.emptyDiskImages = [ 4096 4096 ];
···
       ensurePartition("swap", "swap");
       ensurePartition("boot", "f2fs");
       ensurePartition("root", "f2fs");
-      remoteAndCheck;
+      remountAndCheck;
       ensureMountPoint("/mnt/boot", "f2fs");
     };
 

pkgs/applications/audio/ncmpcpp/beta.nix

···
+{ stdenv, fetchurl, ncurses, curl, taglib, fftw, mpd_clientlib, pkgconfig
+, boost, readline, libiconvOrEmpty }:
+
+stdenv.mkDerivation rec {
+  version = "0.6_beta5";
+  name = "ncmpcpp-${version}";
+
+  src = fetchurl {
+    url = "http://ncmpcpp.rybczak.net/stable/ncmpcpp-${version}.tar.bz2";
+    sha256 = "05h4mahnh39y9ab333whsgspj5mnbdkqfssgfi4r0zf1fvjwlwj6";
+  };
+
+  buildInputs = [ ncurses curl taglib fftw mpd_clientlib pkgconfig boost readline ]
+    ++ libiconvOrEmpty;
+
+  configureFlags = [
+    "BOOST_LIB_SUFFIX="
+  ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "Curses-based interface for MPD (music player daemon)";
+    homepage    = http://unkart.ovh.org/ncmpcpp/;
+    license     = licenses.gpl2Plus;
+    maintainers = with maintainers; [ fpletz ];
+    platforms   = platforms.all;
+  };
+}
+

pkgs/applications/editors/emacs-24/default.nix

···
 assert stdenv.isDarwin -> libXaw != null;	# fails to link otherwise
 
 stdenv.mkDerivation rec {
-  name = "emacs-24.3";
+  name = "emacs-24.4";
 
   builder = ./builder.sh;
 
   src = fetchurl {
     url    = "mirror://gnu/emacs/${name}.tar.xz";
-    sha256 = "1385qzs3bsa52s5rcncbrkxlydkw0ajzrvfxgv8rws5fx512kakh";
+    sha256 = "1zflm6ac34s6v166p58ilxrxbxjm0q2wfc25f8y0mjml1lbr3qs7";
   };
 
   patches = [ ./darwin-new-sections.patch ];

pkgs/applications/editors/emacs-24/macport.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  emacsName = "emacs-24.3";
-  name = "${emacsName}-mac-4.8";
+  emacsName = "emacs-24.4";
+  name = "${emacsName}-mac-5.0";
 
   #builder = ./builder.sh;
 
   src = fetchurl {
     url = "mirror://gnu/emacs/${emacsName}.tar.xz";
-    sha256 = "1385qzs3bsa52s5rcncbrkxlydkw0ajzrvfxgv8rws5fx512kakh";
+    sha256 = "1zflm6ac34s6v166p58ilxrxbxjm0q2wfc25f8y0mjml1lbr3qs7";
   };
 
   macportSrc = fetchurl {
     url = "ftp://ftp.math.s.chiba-u.ac.jp/emacs/${name}.tar.gz";
-    sha256 = "194y341zrpjp75mc3099kjc0inr1d379wwsnav257bwsc967h8yx";
+    sha256 = "14ipkwmzv0b02sclhgp2xj0cvhl3gk40sc2l21s87621kk640dzv";
   };
 
   patches = [ ./darwin-new-sections.patch ];

pkgs/applications/editors/emacs-modes/git-modes/default.nix

···
+{ stdenv, fetchFromGitHub, emacs }:
+
+let
+  version = "0.15.0-8-g4e10851";
+in
+stdenv.mkDerivation {
+  name = "git-modes-${version}";
+
+  src = fetchFromGitHub {
+    owner = "magit";
+    repo = "git-modes";
+    rev = "4e10851843145e0c05fc665683d3b487a57ad114";
+    sha256 = "13j794a2p4ql9dnw2z0c1m0ybclxsicbk8cmmfqcchs4ygiyc6ag";
+  };
+
+  buildInputs = [ emacs ];
+
+  installPhase = ''
+    mkdir -p $out/share/emacs/site-lisp
+    mv *.el *.elc $out/share/emacs/site-lisp/
+  '';
+
+  meta = {
+    homepage = "https://github.com/magit/git-modes";
+    description = "Emacs modes for various Git-related files";
+    license = stdenv.lib.licenses.gpl3Plus;
+    maintainers = with stdenv.lib.maintainers; [ simons ];
+  };
+}

pkgs/applications/editors/emacs-modes/magit/default.nix

···
-{ stdenv, fetchurl, emacs, texinfo }:
+{ stdenv, fetchFromGitHub, emacs, texinfo, gitModes, git }:
 
 let
-  version = "1.2.0";
+  version = "90141016";
 in
 stdenv.mkDerivation rec {
   name = "magit-${version}";
 
-  src = fetchurl {
-    url = "https://github.com/downloads/magit/magit/${name}.tar.gz";
-    sha256 = "1a8vvilhd5y5vmlpsh194qpl4qlg0a1brylfscxcacpfp0cmhlzg";
+  src = fetchFromGitHub {
+    owner = "magit";
+    repo = "magit";
+    rev = version;
+    sha256 = "11d3gzj0hlb7wqsjzjb0vf9i0ik4xzwdyayjy4hfgx0gjmymkfx3";
   };
 
-  buildInputs = [ emacs texinfo ];
+  buildInputs = [ emacs texinfo git ];
+  propagatedUserEnvPkgs = [ gitModes ];
+
+  configurePhase = ''
+    makeFlagsArray=(
+      PREFIX="$out"
+      EFLAGS="-L ${gitModes}/share/emacs/site-lisp"
+      lispdir="$out/share/emacs/site-lisp"
+    )
+  '';
 
-  configurePhase = "makeFlagsArray=( PREFIX=$out SYSCONFDIR=$out/etc )";
+  doCheck = true;
+  checkTarget = "test";
 
-  # Add (require 'magit-site-init) to your ~/.emacs file to set-up magit mode.
   postInstall = ''
-    mv $out/etc/emacs/site-start.d/50magit.el $out/share/emacs/site-lisp/magit-site-init.el
-    sed -i -e 's|50magit|magit-site-init|' $out/share/emacs/site-lisp/magit-site-init.el
-    rmdir $out/etc/emacs/site-start.d $out/etc/emacs $out/etc
+    mkdir -p $out/bin
+    mv "bin/"* $out/bin/
   '';
 
   meta = {
···
       save you from learning Git itself.
     '';
 
-    platforms = stdenv.lib.platforms.all;
     maintainers = with stdenv.lib.maintainers; [ simons ];
   };
 }

pkgs/applications/editors/vim/macvim.nix

···
-{ stdenv, stdenvAdapters, gccApple, fetchFromGitHub, ncurses, gettext,
+{ stdenv, fetchFromGitHub, ncurses, gettext,
   pkgconfig, cscope, python, ruby, tcl, perl, luajit
 }:
 
-let inherit (stdenvAdapters.overrideGCC stdenv gccApple) mkDerivation;
-in mkDerivation rec {
+stdenv.mkDerivation rec {
   name = "macvim-${version}";
 
-  version = "7.4.355";
+  version = "7.4.479";
 
   src = fetchFromGitHub {
     owner = "genoma";
     repo = "macvim";
-    rev = "c18a61f9723565664ffc2eda9179e96c95860e25";
+    rev = "f9c084b97fa9d5cad2448dfd3eff3d9b7f0fac59";
     sha256 = "190bngg8m4bwqcia7w24gn7mmqkhk0mavxy81ziwysam1f652ymf";
   };
 
···
       "--enable-perlinterp=dynamic"
       "--enable-rubyinterp=dynamic"
       "--enable-tclinterp=yes"
+      "--without-local-dir"
       "--with-luajit"
       "--with-lua-prefix=${luajit}"
       "--with-ruby-command=${ruby}/bin/ruby"
···
       "--with-tlib=ncurses"
       "--with-compiledby=Nix"
   ];
+
+  makeFlags = ''PREFIX=$(out) CPPFLAGS="-Wno-error"'';
 
   preConfigure = ''
     DEV_DIR=$(/usr/bin/xcode-select -print-path)/Platforms/MacOSX.platform/Developer

pkgs/applications/editors/vim/macvim.patch

···
    # Use ||, not &&, to avoid exiting from the if with $? = 1, which
    # would make configure fail if this is the last instruction.
    $ac_cs_success || as_fn_exit 1
+
+diff --git a/src/Makefile b/src/Makefile
+index 1c4d104..fff2015 100644
+--- a/src/Makefile
++++ b/src/Makefile
+@@ -1298,7 +1298,7 @@ MACVIMGUI_SRC	= gui.c gui_beval.c MacVim/gui_macvim.m MacVim/MMBackend.m \
+ 		  MacVim/MacVim.m
+ MACVIMGUI_OBJ	= objects/gui.o objects/gui_beval.o objects/pty.o \
+ 		  objects/gui_macvim.o objects/MMBackend.o objects/MacVim.o
+-MACVIMGUI_DEFS	= -DFEAT_GUI_MACVIM -Wall -Wno-unknown-pragmas -pipe
++MACVIMGUI_DEFS	= -DMACOS_X_UNIX -DFEAT_GUI_MACVIM -Wall -Wno-unknown-pragmas -pipe
+ MACVIMGUI_IPATH	=
+ MACVIMGUI_LIBS_DIR =
+ MACVIMGUI_LIBS1	= -framework Cocoa -framework Carbon
+
+diff --git a/src/if_python.c b/src/if_python.c
+index b356bf7..b7bfa78 100644
+--- a/src/if_python.c
++++ b/src/if_python.c
+@@ -55,11 +55,7 @@
+ 
+ #define PY_SSIZE_T_CLEAN
+ 
+-#ifdef FEAT_GUI_MACVIM
+-# include <Python/Python.h>
+-#else
+-# include <Python.h>
+-#endif
++#include <Python.h>
+ 
+ #if !defined(PY_VERSION_HEX) || PY_VERSION_HEX < 0x02050000
+ # undef PY_SSIZE_T_CLEAN
+ MACVIMGUI_LIBS1	= -framework Cocoa -framework Carbon

pkgs/applications/editors/yi/yi-custom.nix

···
 # ‘reload’ and similar functions should all work as long as the user
 # doesn't need new libraries at which point they should add them to
 # extraPackages and rebuild from the expression.
-{ cabal, yi, extraPackages, makeWrapper }:
-
+{ cabal, yi, extraPackages, makeWrapper, ghcWithPackages }:
+let
+  w = ghcWithPackages (self: [ yi ] ++ extraPackages self);
+  wrappedGhc = w.override { ignoreCollisions = true; };
+in
 cabal.mkDerivation (self: rec {
   pname = "yi-custom";
   version = "0.0.0.1";
   src = ./yi-custom-cabal;
   isLibrary = true;
-  buildDepends = extraPackages ++ [ yi ];
+  buildDepends = [ yi ];
   buildTools = [ makeWrapper ];
   noHaddock = true;
   doCheck = false;
 
-  # Allows Yi to find the libraries it needs at runtime. We drop ‘:’
-  # from this GHC_PACKAGE_PATH because we're wrapping over a different
-  # wrapper that used --prefix: if we didn't, we end up with a
-  # double-colon, confusing GHC.
+  # put custom GHC env in front which stops crap from being picked up
+  # from user database
   postInstall = ''
-    makeWrapper ${yi}/bin/yi $out/bin/yi --set GHC_PACKAGE_PATH ''${GHC_PACKAGE_PATH%?}
+    makeWrapper ${yi}/bin/yi $out/bin/yi --prefix PATH : ${wrappedGhc}/bin
   '';
-
   meta = {
     homepage = "http://haskell.org/haskellwiki/Yi";
     description = "Wrapper over user-specified Haskell libraries for use in Yi config";
     license = self.stdenv.lib.licenses.publicDomain;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
-    # The wrapper does not yet work properly if we actually try to use it.
-    broken = true;
   };
 
 })

pkgs/applications/editors/yi/yi.nix

···
 
 { cabal, binary, Cabal, cautiousFile, dataDefault, derive, dlist
 , dynamicState, dyre, filepath, glib, gtk, hashable, hint, HUnit
-, lens, makeWrapper, mtl, ooPrototypes, pango, parsec, pointedlist
-, QuickCheck, random, regexBase, regexTdfa, safe, semigroups, split
-, tagged, tasty, tastyHunit, tastyQuickcheck, text, time
-, transformersBase, unixCompat, unorderedContainers, utf8String
-, vty, wordTrie, xdgBasedir, yiLanguage, yiRope
+, lens, mtl, ooPrototypes, pango, parsec, pointedlist, QuickCheck
+, random, regexBase, regexTdfa, safe, semigroups, split, tagged
+, tasty, tastyHunit, tastyQuickcheck, text, time, transformersBase
+, unixCompat, unorderedContainers, utf8String, vty, wordTrie
+, xdgBasedir, yiLanguage, yiRope
 }:
 
 cabal.mkDerivation (self: {
···
     filepath HUnit lens QuickCheck semigroups tasty tastyHunit
     tastyQuickcheck text yiLanguage yiRope
   ];
-  buildTools = [ makeWrapper ];
   configureFlags = "-fpango -fvty";
   noHaddock = self.stdenv.lib.versionOlder self.ghc.version "7.8";
-  postInstall = ''
-    wrapProgram $out/bin/yi --suffix GHC_PACKAGE_PATH : $out/lib/ghc-${self.ghc.version}/package.conf.d/yi-$version.installedconf:$GHC_PACKAGE_PATH
-  '';
   meta = {
     homepage = "http://haskell.org/haskellwiki/Yi";
     description = "The Haskell-Scriptable Editor";

pkgs/applications/graphics/ImageMagick/default.nix

···
 }:
 
 let
-  version = "6.8.9-0";
+  version = "6.8.9-8";
 in
 stdenv.mkDerivation rec {
   name = "ImageMagick-${version}";
 
   src = fetchurl {
     url = "mirror://imagemagick/${name}.tar.xz";
-    sha256 = "1lapn2798fkc2wn81slpms5p21kq4dsyg45khsk7n8p69cvrmw2b";
+    sha256 = "1c792hbwi308lm9xkml319xaa4w3bz6hwy6i92jwrm7kqr4h8di7";
   };
 
   enableParallelBuilding = true;

pkgs/applications/graphics/sxiv/default.nix

···
     homepage = "https://github.com/muennich/sxiv";
     license = stdenv.lib.licenses.gpl2Plus;
     platforms = stdenv.lib.platforms.linux;
+    maintainers = with stdenv.lib.maintainers; [ fuuzetsu ];
   };
 }

pkgs/applications/misc/blender/default.nix

···
 with lib;
 
 stdenv.mkDerivation rec {
-  name = "blender-2.72";
+  name = "blender-2.72b";
 
   src = fetchurl {
     url = "http://download.blender.org/source/${name}.tar.gz";
-    sha256 = "0wydh5bs1pxnx3ya65lfy3val1s8wz027a5kb4va6wg3aqnwlvlv";
+    sha256 = "0ixz8h3c08p4f84x8r85nzddwvc0h5lw1ci8gdg2x3m2mw2cfdj4";
   };
 
   buildInputs =

pkgs/applications/misc/calibre/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "calibre-2.5.0";
+  name = "calibre-2.6.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/calibre/${name}.tar.xz";
-    sha256 = "0zl2rpwn5xdgwm4ffb5pizk3247wfghl8ilz0i80hyp36zzxgl8p";
+    sha256 = "0z7nnqsal8yfi83fqari7z9xywq6l84jm0nma2mw0gvybysys4cv";
   };
 
   inherit python;

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.5-source.tar.gz;
+    sha256 = "0sl47zqf4c9fhs4h5zg046vixjmwgy4vhljhr5g4md733nash7z4";
+  };
+
+  tess_src = fetchurl {
+    url = http://tesseract-ocr.googlecode.com/files/tesseract-ocr-3.02.02.tar.gz;
+    sha256 = "0g81m9y4iydp7kgr56mlkvjdwpp3mb01q385yhdnyvra7z5kkk96";
+  };
+
+  gocr_src = fetchurl {
+    url = http://www-e.uni-magdeburg.de/jschulen/ocr/gocr-0.49.tar.gz;
+    sha256 = "06hpzp7rkkwfr1fvmc8kcfz9v490i9yir7f7imh13gmka0fr6afc";
+  };
+
+in stdenv.mkDerivation rec {
+  name = "k2pdfopt";
+  src = fetchzip {
+    url = http://www.willus.com/k2pdfopt/src/k2pdfopt_v2.21_src.zip;
+    sha256 = "1vy0yw41z6p95gmivjk4r534zbg0kqap4lr9ps56kvjw51q8r54j";
+  };
+
+  buildInputs = [ libX11 libXext autoconf automake libtool leptonica libpng libtiff zlib
+                    openjpeg freetype jbig2dec djvulibre openssl ];
+  NIX_LDFLAGS = "-lX11 -lXext";
+
+  k2_pa = ./k2pdfopt.patch;
+  tess_pa = ./tesseract.patch;
+
+  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.5-source/source/fitz/
+    cp $src/mupdf_mod/pdf-* mupdf-1.5-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
+
+    cp -a $src k2pdfopt_v2.21
+    chmod -R +w k2pdfopt_v2.21
+
+    patch -p0 -i $tess_pa
+    patch -p0 -i $k2_pa
+
+    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.5-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
+  '';
+
+  meta = with stdenv.lib; {
+    description = "K2pdfopt optimizes PDF/DJVU files for mobile e-readers (e.g. the Kindle) and smartphones.";
+    homepage = http://www.willus.com/k2pdfopt;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.bosu ];
+  };
+}
+

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)
+ 
+     {
+-    sort(a,(long)n);
++    willus_sort(a,(long)n);
+     }
+ 
+ 
+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 @@
+ 
+ 
+ 
+-void sort(float *x,int n)
++void willus_sort(float *x,int n)
+ 
+     {
+     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
+@@ -29,6 +29,8 @@
+ #ifdef HAVE_GOCR_LIB
+ #include <gocr.h>
+ 
++job_t *JOB;
++
+ /*
+ ** bmp8 must be grayscale
+ ** (x1,y1) and (x2,y2) from top left of bitmap
+@@ -66,6 +68,7 @@
+     h=y2-y1+1;
+     dh=h+bw*2;
+     job=&_job;
++    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 @@
+ 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
+ 
+ lib_LTLIBRARIES += libtesseract.la
+ libtesseract_la_LDFLAGS = 

pkgs/applications/misc/qpdfview/default.nix

···
+{stdenv, fetchurl, qt4, pkgconfig, popplerQt4, djvulibre, libspectre, cups
+, file, ghostscript
+}:
+let
+  s = # Generated upstream information
+  rec {
+    baseName="qpdfview";
+    version="0.4.12";
+    name="${baseName}-${version}";
+    url="https://launchpad.net/qpdfview/trunk/${version}/+download/qpdfview-${version}.tar.gz";
+    sha256="1h6lrrh1vblqkxrd89nmid7d21anyn30iahj24z62yny35lidf0g";
+  };
+  buildInputs = [
+    qt4 popplerQt4 pkgconfig djvulibre libspectre cups file ghostscript
+  ];
+in
+stdenv.mkDerivation {
+  inherit (s) name version;
+  inherit buildInputs;
+  src = fetchurl {
+    inherit (s) url sha256;
+  };
+  configurePhase = ''
+    qmake *.pro
+    for i in *.pro; do 
+      qmake "$i" -o "Makefile.$(basename "$i" .pro)"
+    done
+    sed -e "s@/usr/@$out/@g" -i Makefile*
+  '';
+  meta = {
+    inherit (s) version;
+    description = "A tabbed document viewer";
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = [stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.linux;
+    homepage = "https://launchpad.net/qpdfview";
+    updateWalker = true;
+  };
+}

pkgs/applications/networking/browsers/conkeror/default.nix

···
-{ stdenv, fetchgit, unzip, xulrunner, makeWrapper }:
+{ stdenv, fetchgit, unzip, firefox, makeWrapper }:
 
 stdenv.mkDerivation {
   name = "conkeror-1.0pre-20140616";
 
   src = fetchgit {
     url = git://repo.or.cz/conkeror.git;
-    rev = "8a26fff5896a3360549e2adfbf06b1d57e909266";
-    sha256 = "56f1c71ca1753a63d7599d3e8bf52277711b2693e7709ed7c146f34940441cb4";
+    rev = "98e89c7e5ff3a1069a0984338da01273cdb189a2";
+    sha256 = "284ba966efebfa0aaa768abc1a4f901e2ecf5db9d0391d904a49118b0b94fcd7";
   };
 
   buildInputs = [ unzip makeWrapper ];
···
     mkdir -p $out/libexec/conkeror
     cp -r * $out/libexec/conkeror
 
-    makeWrapper ${xulrunner}/bin/xulrunner $out/bin/conkeror \
-      --add-flags $out/libexec/conkeror/application.ini
+    makeWrapper ${firefox}/bin/firefox $out/bin/conkeror \
+      --add-flags "-app $out/libexec/conkeror/application.ini"
   '';
 
   meta = {

pkgs/applications/networking/browsers/firefox/default.nix

···
     ]
     ++ (if debugBuild then [ "--enable-debug" "--enable-profiling"]
                       else [ "--disable-debug" "--enable-release"
-                             "--enable-optimize${lib.optionalString (stdenv.system == "i686-linux") "=-O3"}"
+                             "--enable-optimize${lib.optionalString (stdenv.system == "i686-linux") "=-O1"}"
                              "--enable-strip" ])
     ++ lib.optional enableOfficialBranding "--enable-official-branding";
 

pkgs/applications/networking/browsers/mozilla-plugins/flashplayer-11/default.nix

···
 
 let
   # -> http://get.adobe.com/flashplayer/
-  version = "11.2.202.406";
+  version = "11.2.202.411";
 
   src =
     if stdenv.system == "x86_64-linux" then
···
       else rec {
         inherit version;
         url = "http://fpdownload.macromedia.com/get/flashplayer/pdc/${version}/install_flash_player_11_linux.x86_64.tar.gz";
-        sha256 = "05akcw89kz0cnhan6wp72banz2asmvqfhb2cw1krn66qgd7bl0x0";
+        sha256 = "1983rj824bhzk48yhgminsiil778vwq0217hfrhbmymhrq3p7gzd";
       }
     else if stdenv.system == "i686-linux" then
       if debug then
···
       else rec {
         inherit version;
         url = "http://fpdownload.macromedia.com/get/flashplayer/pdc/${version}/install_flash_player_11_linux.i386.tar.gz";
-        sha256 = "10f3842vi80kszj42f4c8sw7plrmvsin5k860cqvlzgdhndz8i4b";
+        sha256 = "1bxp94s63i3136pjxgcm8106mqzaj4h096mkf7iq6ddkcvi0cxzn";
       }
     else throw "Flash Player is not supported on this platform";
 

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

···
+{ stdenv, fetchurl, pythonPackages, pyqt4, cython, libvncserver, zlib, twisted, gnutls }:
+
+pythonPackages.buildPythonPackage rec {
+  name = "blink-${version}";
+  version = "0.9.1";
+  
+  src = fetchurl {
+    url = "http://download.ag-projects.com/BlinkQt/${name}.tar.gz";
+    sha256 = "f578e5186893c3488e7773fbb775028ae54540433a0c51aefa5af983ca2bfdae";
+  };
+
+  patches = [ ./pythonpath.patch ];
+
+  propagatedBuildInputs = [ pyqt4 pythonPackages.cjson pythonPackages.sipsimple twisted ];
+
+  buildInputs = [ cython zlib libvncserver ];
+
+  postInstall = ''
+    wrapProgram $out/bin/blink \
+      --prefix LD_LIBRARY_PATH : ${gnutls}/lib
+  '';
+
+  meta = {
+    homepage = http://icanblink.com/;
+    description = "A state of the art, easy to use SIP client";
+  };
+}

pkgs/applications/networking/instant-messengers/blink/pythonpath.patch

···
+diff --git a/blink/resources.py b/blink/resources.py
+index 524d9e5..c271887 100644
+--- a/blink/resources.py
++++ b/blink/resources.py
+@@ -64,6 +64,7 @@ class Resources(object):
+             if script == '':
+                 application_directory = os.path.realpath(script) # executed in interactive interpreter
+             else:
++                script = os.path.join(sys.path[0], script)
+                 binary_directory = os.path.dirname(os.path.realpath(script))
+                 if os.path.basename(binary_directory) == 'bin':
+                     application_directory = os.path.dirname(binary_directory)

pkgs/applications/networking/irc/chatzilla/default.nix

···
-{ stdenv, fetchurl, unzip, xulrunner, makeWrapper }:
+{ stdenv, fetchurl, unzip, firefox, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "chatzilla-0.9.90.1";
+  name = "chatzilla-0.9.91";
 
   src = fetchurl {
     # Obtained from http://chatzilla.rdmsoft.com/xulrunner/.
     url = "http://chatzilla.rdmsoft.com/xulrunner/download/${name}.en-US.xulapp";
-    sha256 = "0z38jig91h10cb14rvs30rpg2pgn3v890nyxyy8lxzbv5ncxmngw";
+    sha256 = "1bmjw2wvp8gh7fdl8czkxc55iari6dy672446hps20xixrh8hl8r";
   };
 
   buildInputs = [ unzip makeWrapper ];
···
     mkdir -p $out/libexec/chatzilla
     unzip $src -d $out/libexec/chatzilla
 
-    makeWrapper ${xulrunner}/bin/xulrunner $out/bin/chatzilla \
-      --add-flags $out/libexec/chatzilla/application.ini
+    makeWrapper ${firefox}/bin/firefox $out/bin/chatzilla \
+      --add-flags "-app $out/libexec/chatzilla/application.ini"
 
     sed -i $out/libexec/chatzilla/application.ini -e 's/.*MaxVersion.*/MaxVersion=99.*/'
   '';

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

···
-{ fetchurl, stdenv, bash, emacs, gdb, glib, gmime, gnupg,
+{ fetchurl, stdenv, bash, emacs, fixDarwinDylibNames,
+  gdb, glib, gmime, gnupg,
   pkgconfig, talloc, xapian
 }:
 
···
     sha256 = "1pdp9l7yv71d3fjb30qyccva8h03hvg88q4a00yi50v2j70kvmgj";
   };
 
-  buildInputs = [ bash emacs gdb glib gmime gnupg pkgconfig talloc xapian ];
+  buildInputs = [ bash emacs gdb glib gmime gnupg pkgconfig talloc xapian ]
+    ++ stdenv.lib.optionals stdenv.isDarwin [ fixDarwinDylibNames ];
 
   patchPhase = ''
-    (cd test && for prg in \
-        aggregate-results.sh \
-        argument-parsing \
-        atomicity \
-        author-order \
-        basic \
-        crypto \
-        count \
-        dump-restore \
-        emacs \
-        emacs-large-search-buffer \
-        encoding \
-        from-guessing \
-        help-test \
-        hooks \
-        json \
-        long-id \
-        maildir-sync \
-        multipart \
-        new \
-        notmuch-test \
-        python \
-        raw \
-        reply \
-        search \
-        search-by-folder \
-        search-insufficient-from-quoting \
-        search-folder-coherence \
-        search-limiting \
-        search-output \
-        search-position-overlap-bug \
-        symbol-hiding \
-        tagging \
-        test-lib.sh \
-        test-verbose \
-        thread-naming \
-        thread-order \
-        uuencode \
-    ;do
-      substituteInPlace "$prg" \
-        --replace "#!/usr/bin/env bash" "#!${bash}/bin/bash"
-    done)
+    find test -type f -exec \
+      sed -i \
+        "1s_#!/usr/bin/env bash_#!${bash}/bin/bash_" \
+        "{}" ";"
 
     for src in \
       crypto.c \
···
         --replace \"gpg\" \"${gnupg}/bin/gpg2\"
     done
   '';
+
+  preFixup = if stdenv.isDarwin then
+    ''
+      prg="$out/bin/notmuch"
+      target="libnotmuch.3.dylib"
+      echo "$prg: fixing link to $target"
+      install_name_tool -change "$target" "$out/lib/$target" "$prg"
+    ''
+  else
+    "";
 
   # XXX: emacs tests broken
   doCheck = false;

pkgs/applications/networking/newsreaders/liferea/default.nix

···
 }:
 
 let pname = "liferea";
-    version = "1.10.11";
+    version = "1.10.12";
 in
 stdenv.mkDerivation rec {
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "https://github.com/lwindolf/${pname}/releases/download/v${version}/${name}.tar.bz2";
-    sha256 = "0mf5mpdj60j8if4qi5656l4pzhgwzhshf31yp0h53l1j442v109a";
+    sha256 = "0c046r3cgf2adcjkgcny1gf2yj3hs0fhrc1zmcz2ja7grcbx46si";
   };
 
   buildInputs = with gst_all_1; [

pkgs/applications/networking/remote/freerdp/unstable.nix

···
-{ stdenv
-, fetchgit
-, cmake
-, openssl
-, printerSupport ? true, cups
-, pkgconfig
-, zlib
-, libX11
-, libXcursor
-, libXdamage
-, libXext
-, alsaLib
-, ffmpeg
-, libxkbfile
-#, xmlto, docbook_xml_dtd_412, docbook_xml_xslt
-, libXinerama
-#, directfb
-#, cunit
-, libXv
-, pulseaudioSupport ? true, pulseaudio
+{ stdenv, fetchFromGitHub, cmake, pkgconfig, openssl, zlib, libX11, libXcursor
+, libXdamage, libXext, glib, alsaLib, ffmpeg, libxkbfile, libXinerama, libXv
+, pulseaudio ? null, cups ? null, pcsclite ? null
 }:
 
-assert printerSupport -> cups != null;
-
-let rev = "ec6effcb1e7759551cf31f5b18d768afc67db97d"; in
-
 stdenv.mkDerivation rec {
-  name = "freerdp-1.1pre-${stdenv.lib.strings.substring 0 7 rev}";
+  name = "freerdp-1.2.0-beta1";
 
-  src = fetchgit {
-    url = git://github.com/FreeRDP/FreeRDP.git;
-    inherit rev;
-    sha256 = "4e5af9a6769c4b34c6b75dffe83a385d1d86068c523ea9f62fabc651a2958455";
+  src = fetchFromGitHub {
+    owner = "FreeRDP";
+    repo = "FreeRDP";
+    rev = "1.2.0-beta1+android7";
+    sha256 = "08nn18jydblrif1qs92pakzd3ww7inr0i378ssn1bjp09lm1bkk0";
   };
 
   buildInputs = [
-    cmake
-    openssl
-    pkgconfig
-    zlib
-    libX11
-    libXcursor
-    libXdamage
-    libXext
-#    directfb
-#    cunit
-    alsaLib
-    ffmpeg
-    libxkbfile
-#    xmlto docbook_xml_dtd_412 docbook_xml_xslt
-    libXinerama
-    libXv
-  ] ++ stdenv.lib.optional printerSupport cups;
+    cmake pkgconfig openssl zlib libX11 libXcursor libXdamage libXext glib
+    alsaLib ffmpeg libxkbfile libXinerama libXv cups pulseaudio pcsclite
+  ];
 
   doCheck = false;
 
-  checkPhase = ''LD_LIBRARY_PATH="libfreerdp-cache:libfreerdp-chanman:libfreerdp-common:libfreerdp-core:libfreerdp-gdi:libfreerdp-kbd:libfreerdp-rail:libfreerdp-rfx:libfreerdp-utils" cunit/test_freerdp'';
-
-  cmakeFlags = [ "-DWITH_DIRECTFB=OFF" "-DWITH_CUNIT=OFF" "-DWITH_MANPAGES=OFF" 
-  ] ++ stdenv.lib.optional pulseaudioSupport "-DWITH_PULSEAUDIO=ON";
+  cmakeFlags = [
+    "-DCMAKE_INSTALL_LIBDIR=lib"
+    "-DWITH_CUNIT=OFF"
+  ] ++ stdenv.lib.optional (pulseaudio != null) "-DWITH_PULSE=ON"
+    ++ stdenv.lib.optional (cups != null) "-DWITH_CUPS=ON"
+    ++ stdenv.lib.optional (pcsclite != null) "-DWITH_PCSC=ON";
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "A Remote Desktop Protocol Client";
-
     longDescription = ''
       FreeRDP is a client-side implementation of the Remote Desktop Protocol (RDP)
       following the Microsoft Open Specifications.
     '';
-
     homepage = http://www.freerdp.com/;
-
-    license = "free-non-copyleft";
-
-    broken = true;  # fails to build
+    license = licenses.asl20;
+    maintainers = with maintainers; [ wkennington ];
+    platforms = platforms.unix;
   };
 }
 

pkgs/applications/office/zotero/default.nix

···
 assert (stdenv.system == "x86_64-linux" || stdenv.system == "i686-linux");
 
 let
-  version = "4.0.22";
+  version = "4.0.23";
   arch = if stdenv.system == "x86_64-linux"
            then "linux-x86_64"
            else "linux-i686";
···
   src = fetchurl {
     url = "https://download.zotero.org/standalone/${version}/Zotero-${version}_${arch}.tar.bz2";
     sha256 = if stdenv.system == "x86_64-linux"
-               then "0dq4x1cc0lnhs7g6w85qjdlb7sajr13mr2zcf4yvrciwhwy3r1i1"
-               else "0s4j2karaq85fwnd1niz8hzx5k71cqs493g38pg337i3iwxad9hg";
+               then "1fz5xn69vapfw8d20207zr9p5r1h9x5kahh334pl2dn1h8il0sm8"
+               else "1kmsvvg2lh881rzy3rxbigzivixjamyrwf5x7vmn1kzhvsvifrng";
   };
 
   # Strip the bundled xulrunner

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

···
 
 cabal.mkDerivation (self: {
   pname = "git-annex";
-  version = "5.20140927";
-  sha256 = "02zmg8pcrdavfna2xy51n6chn6i5g0b8p20rba1vj29rlfj3cask";
+  version = "5.20141013";
+  sha256 = "1p2hvw2x0rm9nhk176mzwisl75xphqxv7mhd43mvwlb3q9f57lnc";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [
···
     license = self.stdenv.lib.licenses.gpl3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ simons ];
-    broken = true;
   };
 })

pkgs/applications/video/xbmc/plugins.nix

···
 
     plugin = "svtplay";
     namespace = "plugin.video.svtplay";
-    version = "4.0.6";
+    version = "4.0.8";
 
     src = fetchFromGitHub {
       owner = "nilzen";
       repo = "xbmc-" + plugin;
-      rev = "4f27254edbd6dc48350152832833c5b164ca58de";
-      sha256 = "11r8vljpx9fxwdx20cvkb5szlaypfrn6c235jwcg61s4hmjy4kl8";
+      rev = "967dc429201200200dba0e755ede3a0e9cb1b137";
+      sha256 = "0kaxcci9zbblpkn1mrmdl49844r90agww41frz9vw6q2ajq1z16k";
     };
 
     meta = with stdenv.lib; {

pkgs/applications/virtualization/docker/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "docker-${version}";
-  version = "1.2.0";
+  version = "1.3.0";
 
   src = fetchurl {
     url = "https://github.com/dotcloud/docker/archive/v${version}.tar.gz";
-    sha256 = "1nk74p9k17bllgw4992ixx7z3w87icp2wabbpbgfyi20k2q9mayp";
+    sha256 = "09bn88i8acv7kw39js1p7mgf3sglq7d782xnafkp0i97svf0x4y9";
   };
 
   buildInputs = [ makeWrapper go sqlite lxc iproute bridge_utils devicemapper btrfsProgs iptables e2fsprogs];
···
   buildPhase = ''
     patchShebangs ./hack
     export AUTO_GOPATH=1
-    export DOCKER_GITCOMMIT="fa7b24f"
+    export DOCKER_GITCOMMIT="c78088f"
     ./hack/make.sh dynbinary
   '';
 

pkgs/applications/virtualization/virtualbox/default.nix

···
 , javaBindings ? false, jdk ? null
 , pythonBindings ? false, python ? null
 , enableExtensionPack ? false, requireFile ? null, patchelf ? null
+, pulseSupport ? false, pulseaudio ? null
 }:
 
 with stdenv.lib;
···
       libcap glib lvm2 python alsaLib curl libvpx pam xorriso makeself perl
       pkgconfig which libXmu ]
     ++ optional javaBindings jdk
-    ++ optional pythonBindings python;
+    ++ optional pythonBindings python
+    ++ optional pulseSupport pulseaudio;
 
   prePatch = ''
     set -x
···
     ./configure --with-qt4-dir=${qt4} \
       ${optionalString (!javaBindings) "--disable-java"} \
       ${optionalString (!pythonBindings) "--disable-python"} \
-      --disable-pulse --disable-hardening --disable-kmods \
+      ${optionalString (!pulseSupport) "--disable-pulse"} \
+      --disable-hardening --disable-kmods \
       --with-mkisofs=${xorriso}/bin/xorrisofs
     sed -e 's@PKG_CONFIG_PATH=.*@PKG_CONFIG_PATH=${libIDL}/lib/pkgconfig:${glib}/lib/pkgconfig ${libIDL}/bin/libIDL-config-2@' \
         -i AutoConfig.kmk

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

···
-{ stdenv, fetchurl, pkgconfig, wayland, mesa, libxkbcommon
-, cairo, libxcb, libXcursor, x11, udev, libdrm, mtdev
-, libjpeg, pam, autoconf, automake, libtool, dbus }:
+{ stdenv, fetchurl, pkgconfig, wayland, mesa, libxkbcommon, cairo, libxcb
+, libXcursor, x11, udev, libdrm, mtdev, libjpeg, pam, dbus, libinput
+, pango ? null, libunwind ? null, freerdp ? null, vaapi ? null, libva ? null
+, libwebp ? null
+}:
 
-let version = "1.5.0"; in
+let version = "1.6.0"; in
 
 stdenv.mkDerivation rec {
   name = "weston-${version}";
 
   src = fetchurl {
     url = "http://wayland.freedesktop.org/releases/${name}.tar.xz";
-    sha256 = "113nig2dmbgrjhi79k0zw77vicnx8vkaihawd0nsg6n79ah8nf06";
+    sha256 = "0kb1mb54l7adihmr2y77xgsdb00dvifnq886q2mmy0mz7g8sagnw";
   };
 
-  #ToDo: libinput can be split away
   buildInputs = [
-    pkgconfig wayland mesa libxkbcommon
-    cairo libxcb libXcursor x11 udev libdrm mtdev libjpeg pam dbus.libs
+    pkgconfig wayland mesa libxkbcommon cairo libxcb libXcursor x11 udev libdrm
+    mtdev libjpeg pam dbus.libs libinput pango libunwind freerdp vaapi libva
+    libwebp
   ];
-
-  NIX_CFLAGS_COMPILE = "-I${libdrm}/include/libdrm";
 
   configureFlags = [
+    "--enable-xwayland"
+    "--enable-x11-compositor"
+    "--enable-drm-compositor"
+    "--enable-wayland-compositor"
+    "--enable-headless-compositor"
+    "--enable-fbdev-compositor"
+    "--enable-screen-sharing"
+    "--enable-clients"
+    "--enable-weston-launch"
     "--disable-setuid-install" # prevent install target to chown root weston-launch, which fails
-  ];
+  ] ++ stdenv.lib.optional (freerdp != null) "--enable-rdp-compositor"
+    ++ stdenv.lib.optional (vaapi != null) "--enabe-vaapi-recorder";
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "Reference implementation of a Wayland compositor";
     homepage = http://wayland.freedesktop.org/;
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.linux;
+    license = licenses.mit;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ wkennington ];
   };
 }

pkgs/build-support/build-fhs-chrootenv/mount.sh.in

···
 mount --bind /etc $chrootenvDest/host-etc
 
 # Bind mount /tmp
-mount --bind /tmp/chrootenv-@name@ /run/chrootenv/steam/tmp
+mount --bind /tmp/chrootenv-@name@ $chrootenvDest/tmp

pkgs/build-support/cabal/default.nix

···
                 propagatedUserEnvPkgs = filter (y : ! (y == null)) x.propagatedUserEnvPkgs;
                 doCheck               = enableCheckPhase && x.doCheck;
                 hyperlinkSource       = enableHyperlinkSource && x.hyperlinkSource;
+                # Disable Darwin builds: <https://github.com/NixOS/nixpkgs/issues/2689>.
+                meta                  = let meta = x.meta or {};
+                                            hydraPlatforms = meta.hydraPlatforms or meta.platforms or [];
+                                            noElem         = p: ps: !stdenv.lib.elem p ps;
+                                            noDarwin       = p: noElem p stdenv.lib.platforms.darwin;
+                                        in
+                                        meta // { hydraPlatforms = filter noDarwin hydraPlatforms; };
               };
 
         defaults =
···
               ''}
               ${optionalString (self.enableSharedExecutables && self.stdenv.isDarwin) ''
                 configureFlags+=" --ghc-option=-optl=-Wl,-headerpad_max_install_names"
-              ''}
-              ${optionalString (versionOlder "7.8" ghc.version) ''
-                configureFlags+=" --ghc-option=-j$NIX_BUILD_CORES"
               ''}
 
               echo "configure flags: $extraConfigureFlags $configureFlags"

pkgs/build-support/grsecurity/default.nix

···
 
     grKernel = if cfg.stable
                then mkKernel pkgs.linux_3_14 stable-patch
-               else mkKernel pkgs.linux_3_16 test-patch;
+               else mkKernel pkgs.linux_3_17 test-patch;
 
     ## -- grsecurity configuration ---------------------------------------------
 

pkgs/build-support/substitute-files/substitute-all-files.nix

···
+{ stdenv }:
+
+args:
+
+stdenv.mkDerivation ({
+  name = if args ? name then args.name else baseNameOf (toString args.src);
+  builder = with stdenv.lib; builtins.toFile "builder.sh" ''
+    source $stdenv/setup
+    set -o pipefail
+
+    eval "$preInstall"
+
+    args=
+
+    cd "$src"
+    echo -ne "${concatStringsSep "\\0" args.files}" | xargs -0 -n1 -I {} -- find {} -type f -print0 | while read -d "" line; do
+      mkdir -p "$out/$(dirname "$line")"
+      substituteAll "$line" "$out/$line"
+    done
+  '';
+  preferLocalBuild = true;
+} // args)

pkgs/build-support/vm/default.nix

···
       fullName = "Debian 7.6 Wheezy (i386)";
       packagesList = fetchurl {
         url = mirror://debian/dists/wheezy/main/binary-i386/Packages.bz2;
-        sha256 = "773ba601513cd7ef1d5192ad8baa795fa050573d82568c577cdf79adade698a3";
+        sha256 = "1j093d6dwixyrk87sdvaayh3ffcn5aqwik36blndiw5njw2qkzgj";
       };
       urlPrefix = mirror://debian;
       packages = commonDebianPackages;
···
       fullName = "Debian 7.6 Wheezy (amd64)";
       packagesList = fetchurl {
         url = mirror://debian/dists/wheezy/main/binary-amd64/Packages.bz2;
-        sha256 = "11a8bd3648d51f51e56c9f5382168cc47267d67ef6a050826e1cd358ed46cc17";
+        sha256 = "1n46fxq8a2dm1i7ysc80s5lg10z5dh0hyd8k3h532n5wzs44xqcc";
       };
       urlPrefix = mirror://debian;
       packages = commonDebianPackages;

pkgs/desktops/e19/econnman.nix

···
   meta = {
     description = "Econnman is a user interface for the connman network connection manager";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.lgpl3;
   };

pkgs/desktops/e19/efl.nix

···
 
 stdenv.mkDerivation rec {
   name = "efl-${version}";
-  version = "1.11.2";
+  version = "1.11.3";
   src = fetchurl {
     url = "http://download.enlightenment.org/rel/libs/efl/${name}.tar.gz";
-    sha256 = "123jrcifd7i0r9zh8qllqiz3d378fyy7fzkanyki9wbxlz91rk7k";
+    sha256 = "0s9pm3lfp7f2yf877xywjw8ihgr2yrns3gibak0gcwx7d8bfljfr";
   };
 
   buildInputs = [ pkgconfig openssl zlib freetype fontconfig fribidi SDL2 SDL mesa giflib libpng libtiff glib gst_all_1.gstreamer gst_all_1.gst-plugins-base gst_all_1.gst-libav pulseaudio libsndfile xlibs.libXcursor xlibs.printproto xlibs.libX11 libdrm udev utillinuxCurses luajit ];
···
   meta = {
     description = "Enlightenment Core libraries";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.lgpl3;
   };

pkgs/desktops/e19/elementary.nix

···
 { stdenv, fetchurl, pkgconfig, e19, libcap, gdbm }:
 stdenv.mkDerivation rec {
   name = "elementary-${version}";
-  version = "1.11.2";
+  version = "1.11.3";
   src = fetchurl {
     url = "http://download.enlightenment.org/rel/libs/elementary/${name}.tar.gz";
-    sha256 = "041hwp81qyq4wsw483g2jh52gcanqg046f91pmd0vzgwcgxyixqq";
+    sha256 = "1yr96imam9sckgagnp7wdvwmvr1xwakw29dih3gxp7nz7xsa0j8k";
   };
   buildInputs = [ pkgconfig e19.efl gdbm ] ++ stdenv.lib.optionals stdenv.isLinux [ libcap ];
   preConfigure = ''
···
   meta = {
     description = "Widget set/toolkit";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.lgpl2;
   };

pkgs/desktops/e19/emotion.nix

···
   meta = {
     description = "Extra video decoders";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.bsd2;
   };

pkgs/desktops/e19/enlightenment.nix

···
 
 stdenv.mkDerivation rec {
   name = "enlightenment-${version}";
-  version = "0.19.0";
+  version = "0.19.1";
   src = fetchurl {
     url = "http://download.enlightenment.org/rel/apps/enlightenment/${name}.tar.xz";
-    sha256 = "0d9s8gwma32hj8h000k1bzibr3zj8qajcf14va3w81k87gkilxfp";
+    sha256 = "016z1vilhjarpxzn5bwcw696d8b66rklnhkrwzfa5mcxn8gpmvap";
   };
   buildInputs = [ pkgconfig e19.efl e19.elementary xlibs.libXdmcp xlibs.libxcb xlibs.xcbutilkeysyms xlibs.libXrandr libffi pam alsaLib luajit bzip2 libpthreadstubs gdbm ] ++ stdenv.lib.optionals stdenv.isLinux [ libcap ];
   preConfigure = ''
···
   meta = {
     description = "The Compositing Window Manager and Desktop Shell";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.bsd2;
   };

pkgs/desktops/e19/evas.nix

···
   meta = {
     description = "Extra image decoders";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.gpl2;
   };

pkgs/desktops/e19/terminology.nix

···
 { stdenv, fetchurl, pkgconfig, e19 }:
 stdenv.mkDerivation rec {
   name = "terminology-${version}";
-  version = "0.6.1";
+  version = "0.7.0";
   src = fetchurl {
     url = "http://download.enlightenment.org/rel/apps/terminology/${name}.tar.gz";
-    sha256 = "1wi9njyfs95y4nb9jd30032qqka5cg7k0wacck8s1yqxwg5ng38x";
+    sha256 = "1x248dh9r292r8ycvf43vrfk4l8wpli50sgywp0zy3q93f8ljgs5";
   };
   buildInputs = [ pkgconfig e19.efl e19.elementary ];
   preConfigure = ''
···
   meta = {
     description = "The best terminal emulator written with the EFL";
     homepage = http://enlightenment.org/;
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.bsd2;
   };

pkgs/desktops/gnome-3/3.10/core/libgnome-keyring/default.nix

···
   meta = {
     description = "Framework for managing passwords and other secrets";
     homepage = http://live.gnome.org/GnomeKeyring;
-    # TODO license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];
+    license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];
     inherit (glib.meta) platforms maintainers;
 
     longDescription = ''

pkgs/desktops/gnome-3/3.10/core/yelp-xsl/default.nix

···
     homepage = https://wiki.gnome.org/Apps/Yelp;
     description = "Yelp's universal stylesheets for Mallard and DocBook";
     maintainers = with maintainers; [ lethalman ];
-    # TODO license = [licenses.gpl2 licenses.lgpl2];
+    license = [licenses.gpl2 licenses.lgpl2];
     platforms = platforms.linux;
   };
 }

pkgs/desktops/gnome-3/3.10/default.nix

···
 
   gitg = callPackage ./misc/gitg { };
 
-  libgit2-glib = callPackage ./misc/libgit2-glib { };
+  libgit2-glib = callPackage ./misc/libgit2-glib {
+    libgit2 = pkgs.libgit2.override { libssh2 = null; };
+  };
 
   libmediaart = callPackage ./misc/libmediaart { };
   

pkgs/desktops/gnome-3/3.12/core/libgnome-keyring/default.nix

···
   meta = {
     description = "Framework for managing passwords and other secrets";
     homepage = http://live.gnome.org/GnomeKeyring;
-    # TODO license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];
+    license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];
     inherit (glib.meta) platforms maintainers;
 
     longDescription = ''

pkgs/desktops/gnome-3/3.12/core/yelp-xsl/default.nix

···
     homepage = https://wiki.gnome.org/Apps/Yelp;
     description = "Yelp's universal stylesheets for Mallard and DocBook";
     maintainers = with maintainers; [ lethalman ];
-    # TODO license = [licenses.gpl2 licenses.lgpl2];
+    license = [licenses.gpl2 licenses.lgpl2];
     platforms = platforms.linux;
   };
 }

pkgs/desktops/gnome-3/3.12/default.nix

···
 
   libgda = callPackage ./misc/libgda { };
 
-  libgit2-glib = callPackage ./misc/libgit2-glib { };
+  libgit2-glib = callPackage ./misc/libgit2-glib {
+    libgit2 = pkgs.libgit2.override { libssh2 = null; };
+  };
 
   libmediaart = callPackage ./misc/libmediaart { };
 

pkgs/development/compilers/ghc/7.8.3.nix

···
   # that in turn causes GHCi to abort
   stripDebugFlags = [ "-S" "--keep-file-symbols" ];
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = "http://haskell.org/ghc";
     description = "The Glasgow Haskell Compiler";
-    maintainers = [
-      stdenv.lib.maintainers.marcweber
-      stdenv.lib.maintainers.andres
-      stdenv.lib.maintainers.simons
-    ];
-    inherit (ghc.meta) license platforms;
+    maintainers = [ maintainers.marcweber maintainers.andres maintainers.simons ];
+    inherit (ghc.meta) license;
+    # Filter old "i686-darwin" platform which is unsupported these days.
+    platforms = filter (x: elem x platforms.all) ghc.meta.platforms;
+    # Disable Darwin builds: <https://github.com/NixOS/nixpkgs/issues/2689>.
+    hydraPlatforms = filter (x: !elem x platforms.darwin) meta.platforms;
   };
 
 }

pkgs/development/compilers/idris/default.nix

···
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ aycanirican ];
   };
-})
+})

pkgs/development/compilers/julia/0.3.1.nix

···
+{ stdenv, fetchgit, gfortran, perl, m4, llvm, gmp, pcre, zlib
+ , readline, fftwSinglePrec, fftw, libunwind, suitesparse, glpk, fetchurl
+ , ncurses, libunistring, lighttpd, patchelf, openblas, liblapack
+ , tcl, tk, xproto, libX11, git, mpfr, which
+ } :
+
+assert stdenv.isLinux; 
+
+let
+  realGcc = stdenv.gcc.gcc;
+in
+stdenv.mkDerivation rec {
+  pname = "julia";
+  version = "0.3.1";
+  name = "${pname}-${version}";
+
+  dsfmt_ver = "2.2";
+  grisu_ver = "1.1.1";
+  openblas_ver = "v0.2.10";
+  lapack_ver = "3.5.0";
+  arpack_ver = "3.1.5";
+  lighttpd_ver = "1.4.29";
+  patchelf_ver = "0.6";
+  pcre_ver = "8.31";
+  utf8proc_ver = "1.1.6";
+
+  dsfmt_src = fetchurl {
+    url = "http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/dSFMT-src-${dsfmt_ver}.tar.gz";
+    name = "dsfmt-${dsfmt_ver}.tar.gz";
+    sha256 = "bc3947a9b2253a869fcbab8ff395416cb12958be9dba10793db2cd7e37b26899";
+  };
+  grisu_src = fetchurl {
+    url = "http://double-conversion.googlecode.com/files/double-conversion-${grisu_ver}.tar.gz";
+    sha256 = "e1cabb73fd69e74f145aea91100cde483aef8b79dc730fcda0a34466730d4d1d";
+  };
+  openblas_src = fetchurl {
+    url = "https://github.com/xianyi/OpenBLAS/tarball/${openblas_ver}";
+    name = "openblas-${openblas_ver}.tar.gz";
+    sha256 = "06i0q4qnd5q5xljzrgvda0gjsczc6l2pl9hw6dn2qjpw38al73za";
+  };
+  arpack_src = fetchurl rec {
+    url = "http://forge.scilab.org/index.php/p/arpack-ng/downloads/get/arpack-ng_${arpack_ver}.tar.gz";
+    sha256 = "05fmg4m0yri47rzgsl2mnr1qbzrs7qyd557p3v9wwxxw0rwcwsd2";
+  };
+  lapack_src = fetchurl {
+    url = "http://www.netlib.org/lapack/lapack-${lapack_ver}.tgz";
+    name = "lapack-${lapack_ver}.tgz";
+    sha256 = "0lk3f97i9imqascnlf6wr5mjpyxqcdj73pgj97dj2mgvyg9z1n4s";
+  };
+  lighttpd_src = fetchurl {
+    url = "http://download.lighttpd.net/lighttpd/releases-1.4.x/lighttpd-${lighttpd_ver}.tar.gz";
+    sha256 = "ff9f4de3901d03bb285634c5b149191223d17f1c269a16c863bac44238119c85";
+  };
+  patchelf_src = fetchurl {
+    url = "http://hydra.nixos.org/build/1524660/download/2/patchelf-${patchelf_ver}.tar.bz2";
+    sha256 = "00bw29vdsscsili65wcb5ay0gvg1w0ljd00sb5xc6br8bylpyzpw";
+  };
+  pcre_src = fetchurl {
+    url = "ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-${pcre_ver}.tar.bz2";
+    sha256 = "0g4c0z4h30v8g8qg02zcbv7n67j5kz0ri9cfhgkpwg276ljs0y2p";
+  };
+  utf8proc_src = fetchurl {
+    url = "http://www.public-software-group.org/pub/projects/utf8proc/v${utf8proc_ver}/utf8proc-v${utf8proc_ver}.tar.gz";
+    sha256 = "1rwr84pw92ajjlbcxq0da7yxgg3ijngmrj7vhh2qzsr2h2kqzp7y";
+  };
+
+  src = fetchgit {
+    url = "git://github.com/JuliaLang/julia.git";
+    rev = "refs/tags/v0.3.1";
+    sha256 = "1m6jyh7dn03q00gpwb64pq6dypglj4yqac7rkw21z2jknb5x33vb";
+  };
+
+  buildInputs = [ gfortran perl m4 gmp pcre llvm readline zlib
+    fftw fftwSinglePrec libunwind suitesparse glpk ncurses libunistring patchelf
+    openblas liblapack tcl tk xproto libX11 git mpfr which
+    ];
+
+  configurePhase = ''
+    for i in GMP LLVM PCRE READLINE FFTW LIBUNWIND SUITESPARSE GLPK LIGHTTPD ZLIB MPFR;
+    do
+      makeFlags="$makeFlags USE_SYSTEM_$i=1 "
+    done
+
+    copy_kill_hash(){
+      cp "$1" "$2/$(basename "$1" | sed -e 's/^[a-z0-9]*-//')"
+    }
+
+    for i in "${grisu_src}" "${dsfmt_src}" "${arpack_src}" "${patchelf_src}" \
+        "${pcre_src}" "${utf8proc_src}" "${lapack_src}" "${openblas_src}"; do
+      copy_kill_hash "$i" deps
+    done
+
+    ${if realGcc ==null then "" else 
+    ''export NIX_LDFLAGS="$NIX_LDFLAGS -L${realGcc}/lib -L${realGcc}/lib64 -lpcre -llapack -lm -lfftw3f -lfftw3 -lglpk -lunistring -lz -lgmp -lmpfr -lblas -lopenblas -L$out/lib"''}
+    export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -fPIC "
+
+    export LDFLAGS="-L${suitesparse}/lib -L$out/lib/julia -Wl,-rpath,$out/lib/julia"
+
+    export GLPK_PREFIX="${glpk}/include"
+
+    mkdir -p "$out/lib"
+    sed -e "s@/usr/local/lib@$out/lib@g" -i deps/Makefile
+    sed -e "s@/usr/lib@$out/lib@g" -i deps/Makefile
+
+    export makeFlags="$makeFlags PREFIX=$out SHELL=${stdenv.shell} prefix=$out"
+
+    export dontPatchELF=1
+
+    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$PWD/usr/lib:$PWD/usr/lib/julia"
+
+    patchShebangs . contrib
+
+    export PATH="$PATH:${stdenv.gcc.libc}/sbin"
+
+    # ldconfig doesn't seem to ever work on NixOS; system-wide ldconfig cache
+    # is probably not what we want anyway on non-NixOS
+    sed -e "s@/sbin/ldconfig@true@" -i src/ccall.*
+
+    ln -s "${openblas}/lib/libopenblas.so" "$out/lib/libblas.so"
+  '';
+
+  preBuild = ''
+    mkdir -p usr/lib
+    
+    echo "$out"
+    mkdir -p "$out/lib"
+    (
+    cd "$(mktemp -d)"
+    for i in "${suitesparse}"/lib/lib*.a; do
+      ar -x $i
+    done
+    gcc *.o --shared -o "$out/lib/libsuitesparse.so"
+    )
+    cp "$out/lib/libsuitesparse.so" usr/lib
+    for i in umfpack cholmod amd camd colamd spqr; do
+      ln -s libsuitesparse.so "$out"/lib/lib$i.so;
+      ln -s libsuitesparse.so "usr"/lib/lib$i.so;
+    done
+  '';
+
+  dontStrip = true;
+
+  enableParallelBuilding = true;
+
+  postInstall = ''
+    rm -f "$out"/lib/julia/sys.{so,dylib,dll}
+  '';
+
+  meta = {
+    description = "High-level performance-oriented dynamical language for technical computing";
+    homepage = "http://julialang.org/";
+    license = stdenv.lib.licenses.mit;
+    maintainers = [ stdenv.lib.maintainers.raskin ];
+    platforms = with stdenv.lib.platforms; linux;
+    broken = false;
+  };
+}

pkgs/development/compilers/lessc/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "lessc-${version}";
-  version = "1.4.2";
+  version = "1.7.5";
 
   src = fetchgit {
     url = https://github.com/less/less.js.git;
     rev = "refs/tags/v${version}";
-    sha256 = "1v3b4f1np3mxkj0irh1pk52r26nzpf4k2ax14cbn7mxx16mqjp50";
+    sha256 = "0r8bcad247v5fyh543a7dppmfbf49ai4my3vcizk42fsbnjs8q2x";
   };
 
   phases = [ "installPhase" ];

pkgs/development/compilers/oraclejdk/jdk7-linux.nix

···
 import ./jdk-linux-base.nix {
   productVersion = "7";
-  patchVersion = "67";
+  patchVersion = "72";
   downloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html;
-  sha256_i686 = "0p58pag1x85r911lxhmr4blk687ivjqigflx175vp7rcmmj108xn";
-  sha256_x86_64 = "0db36jg08qy8712qy6lgyifdqlqb468rrnjm3aa6937ixl9ixpal";
+  sha256_i686 = "01zl82hnb9pynxw04zaq4745av42cga97cbckcwb8lh752hchxh3";
+  sha256_x86_64 = "13nyx8p27crnnybkzdaiv9l1azap7c8g4na6xasrnjvx3f7467fx";
   jceName = "UnlimitedJCEPolicyJDK7.zip";
   jceDownloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html;
   sha256JCE = "7a8d790e7bd9c2f82a83baddfae765797a4a56ea603c9150c87b7cdb7800194d";

pkgs/development/compilers/rustc/0.11.nix pkgs/development/compilers/rustc/0.12.nix

···
 
 */
 
-with ((import ./common.nix) {inherit stdenv; version = "0.11.0"; });
+with ((import ./common.nix) {inherit stdenv; version = "0.12.0"; });
 
 let snapshot = if stdenv.system == "i686-linux"
-      then "84339ea0f796ae468ef86797ef4587274bec19ea"
+      then "555aca74f9a268f80cab2df1147dc6406403e9e4"
       else if stdenv.system == "x86_64-linux"
-      then "bd8a6bc1f28845b7f4b768f6bfa06e7fbdcfcaae"
+      then "6a43c2f6c8ba2cbbcb9da1f7b58f748aef99f431"
       else if stdenv.system == "i686-darwin"
-      then "3f25b2680efbab16ad074477a19d49dcce475977"
+      then "331bd7ef519cbb424188c546273e8c7d738f0894"
       else if stdenv.system == "x86_64-darwin"
-      then "4a8c2e1b7634d73406bac32a1a97893ec3ed818d"
+      then "2c83a79a9febfe1d326acb17c3af76ba053c6ca9"
       else abort "no-snapshot for platform ${stdenv.system}";
-    snapshotDate = "2014-06-21";
-    snapshotRev = "db9af1d";
+    snapshotDate = "2014-10-04";
+    snapshotRev = "749ff5e";
     snapshotName = "rust-stage0-${snapshotDate}-${snapshotRev}-${platform}-${snapshot}.tar.bz2";
 
 in stdenv.mkDerivation {
···
   inherit meta;
 
   src = fetchurl {
-    url = http://static.rust-lang.org/dist/rust-0.11.0.tar.gz;
-    sha256 = "1fhi8iiyyj5j48fpnp93sfv781z1dm0xy94h534vh4mz91jf7cyi";
+    url = http://static.rust-lang.org/dist/rust-0.12.0.tar.gz;
+    sha256 = "1dv9wxh41230zknbwj34zgjnh1kgvvy6k12kbiy9bnch9nr6cgl8";
   };
 
   # We need rust to build rust. If we don't provide it, configure will try to download it.
···
   patches = [ ./hardcode_paths.patch ./local_stage0.patch ];
   postPatch = ''
     substituteInPlace src/librustc/back/link.rs \
-      --subst-var-by "ccPath" "${stdenv.gcc}/bin/cc" \
+      --subst-var-by "ccPath" "${stdenv.gcc}/bin/cc"
+    substituteInPlace src/librustc_back/archive.rs \
       --subst-var-by "arPath" "${stdenv.gcc.binutils}/bin/ar"
   '';
 

pkgs/development/compilers/rustc/hardcode_paths.patch

···
 diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
-index 7a3e912..ced75fa 100644
+index 1cc60fc..2e94b99 100644
 --- a/src/librustc/back/link.rs
 +++ b/src/librustc/back/link.rs
-@@ -766,24 +766,15 @@ pub fn output_lib_filename(id: &CrateId) -> String {
+@@ -383,18 +383,9 @@ pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> Stri
  
  pub fn get_cc_prog(sess: &Session) -> String {
      match sess.opts.cg.linker {
···
 -    // In the future, FreeBSD will use clang as default compiler.
 -    // It would be flexible to use cc (system's default C compiler)
 -    // instead of hard-coded gcc.
--    // For win32, there is no cc command, so we add a condition to make it use gcc.
+-    // For Windows, there is no cc command, so we add a condition to make it use gcc.
 -    match sess.targ_cfg.os {
--        abi::OsWin32 => "gcc",
+-        abi::OsWindows => "gcc",
 -        _ => "cc",
 -    }.to_string()
  }
  
- pub fn get_ar_prog(sess: &Session) -> String {
-     match sess.opts.cg.ar {
-         Some(ref ar) => (*ar).clone(),
--        None => "ar".to_string()
-+        None => "@arPath@".to_string()
-     }
- }
- 
+ pub fn remove(sess: &Session, path: &Path) {
+diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs
+index 060dda5..fecf76b 100644
+--- a/src/librustc_back/archive.rs
++++ b/src/librustc_back/archive.rs
+@@ -53,7 +53,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>,
+           paths: &[&Path]) -> ProcessOutput {
+     let ar = match *maybe_ar_prog {
+         Some(ref ar) => ar.as_slice(),
+-        None => "ar"
++        None => "@arPath@"
+     };
+     let mut cmd = Command::new(ar);

pkgs/development/compilers/rustc/local_stage0.patch

···
 index e78f231..6b6773b 100755
 --- a/src/etc/local_stage0.sh
 +++ b/src/etc/local_stage0.sh
-@@ -53,8 +53,3 @@ if [ -z $TARG_DIR ]; then
+@@ -53,11 +53,6 @@
  fi
-
+ 
  cp ${PREFIX}/bin/rustc${BIN_SUF} ${TARG_DIR}/stage0/bin/
 -cp ${PREFIX}/${LIB_DIR}/${RUSTLIBDIR}/${TARG_DIR}/${LIB_DIR}/* ${TARG_DIR}/stage0/${LIB_DIR}/
 -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}extra*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
 -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}rust*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
 -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}std*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
 -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}syntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+ 
+ # do not fail if one of the above fails, as all we need is a working rustc!
+ exit 0

pkgs/development/compilers/scala/default.nix

···
 { stdenv, fetchurl, makeWrapper, jre }:
 
 stdenv.mkDerivation rec {
-  name = "scala-2.11.1";
+  name = "scala-2.11.2";
 
   src = fetchurl {
     url = "http://www.scala-lang.org/files/archive/${name}.tgz";
-    sha256 = "1vjsmqjwpxavyj29wrbvvx7799fsa65d4iha5mj63cgs8qp605gk";
+    sha256 = "0mnjhjiixjphr9v101v408815hkl6hlghx9h7lmmylv5z7gk3p8k";
   };
 
   buildInputs = [ jre makeWrapper ] ;

pkgs/development/coq-modules/flocq/default.nix

···
+{stdenv, bash, which, autoconf, automake, fetchurl, coq}:
+
+stdenv.mkDerivation rec {
+
+  name = "coq-flocq-${coq.coq-version}-${version}";
+  version = "2.4.0";
+
+  src = fetchurl {
+    url = https://gforge.inria.fr/frs/download.php/file/33979/flocq-2.4.0.tar.gz;
+    sha256 = "020x4nkkrvndkvp5zwb9vads8a2jh603khcwrm40yhqldgfd8zlv";
+  };
+
+  buildInputs = [ coq.ocaml coq.camlp5 bash which autoconf automake ];
+  propagatedBuildInputs = [ coq ];
+
+  buildPhase = ''
+    ${bash}/bin/bash autogen.sh
+    ${bash}/bin/bash configure --libdir=$out/lib/coq/${coq.coq-version}/user-contrib/Flocq
+    ./remake
+  '';
+
+  installPhase = ''
+    ./remake install
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = http://flocq.gforge.inria.fr/;
+    description = "Flocq (Floats for Coq) is a floating-point formalization for the Coq system";
+    maintainers = with maintainers; [ jwiegley ];
+    platforms = coq.meta.platforms;
+  };
+
+}

pkgs/development/interpreters/clisp/2.33.2.nix

···
+{ stdenv, fetchurl, libsigsegv, gettext, ncurses, readline, libX11
+, libXau, libXt, pcre, zlib, libXpm, xproto, libXext, xextproto
+, libffi, libffcall, coreutils, automake, autoconf, linuxHeaders
+, groff
+}:
+        
+stdenv.mkDerivation rec {
+  version = "2.33.2";
+  name = "clisp-${version}";
+  
+  src = fetchurl {
+    url = "mirror://gnu/clisp/release/${version}/${name}.tar.gz";
+    sha256 = "0rqyggviixaa68n5ll092ll4a2xy4y7jraq65l0gn0hkjhjnm5zh";
+  };
+
+  buildInputs =
+    [ libsigsegv gettext ncurses readline libX11 libXau libXt pcre
+      zlib libXpm xproto libXext xextproto libffi libffcall 
+      automake autoconf groff
+    ]
+    ++ (stdenv.lib.optional stdenv.isLinux linuxHeaders)
+    ;
+
+  # First, replace port 9090 (rather low, can be used)
+  # with 64237 (much higher, IANA private area, not
+  # anything rememberable).
+  # Also remove reference to a type that disappeared from recent glibc
+  # (seems the correct thing to do, found no reference to any solution)
+  postPatch = ''
+    sed -i 's@/bin/pwd@${coreutils}&@' src/clisp-link.in
+    find . -type f | xargs sed -e 's/-lICE/-lXau &/' -i
+
+    substituteInPlace modules/bindings/glibc/linux.lisp --replace "(def-c-type __swblk_t)" ""
+  '';
+  
+  configureFlags =
+    ''
+      builddir
+      --with-readline --with-ffcall --with-dynamic-ffi
+      --with-module=readline --with-module=i18n --with-module=pcre
+      --with-module=syscalls --with-modules=zlib --with-module=curses
+    '';
+
+  preBuild = ''
+    echo Pre-build starting!
+    sed -e '/avcall.h/a\#include "config.h"' -i src/foreign.d
+    sed -e '/asm\/page.h/d' -i src/unix.d
+    cd builddir
+    ./makemake $configureFlags > Makefile
+    make config.lisp
+    cat config.lisp
+  '';
+
+  NIX_CFLAGS_COMPILE="-O0 -lreadline -lncursesw";
+
+  # TODO : make mod-check fails
+  doCheck = false;
+
+  meta = {
+    description = "ANSI Common Lisp Implementation";
+    homepage = http://clisp.cons.org;
+    maintainers = [stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.linux;
+    branch = "2.44";
+  };
+}

pkgs/development/interpreters/elixir/default.nix

···
 { stdenv, fetchurl, erlang, rebar, makeWrapper, coreutils, curl, bash, cacert }:
 
 let
-  version = "1.0.0";
+  version = "1.0.2";
 in
 stdenv.mkDerivation {
   name = "elixir-${version}";
 
   src = fetchurl {
     url = "https://github.com/elixir-lang/elixir/archive/v${version}.tar.gz";
-    sha256 = "1ci8g6nh89xnn0ax9kazcs47w406nqsj1d4rf8sb1b6abfq78xsj";
+    sha256 = "6156ee396e85045358d11a6839e157e8fa9573b7414bddbd2c91843ed2b4b962";
   };
 
   buildInputs = [ erlang rebar makeWrapper ];

pkgs/development/interpreters/j/default.nix

···
   /* doConfigure should be removed if not needed */
   phaseNames = ["doUnpack" "doBuildJ" "doDeploy"];
 
-  bits = if a.stdenv.system == "i686-linux" then 
-    "32"
-  else if a.stdenv.system == "x86_64-linux" then
+  bits = if a.stdenv.is64bit then
     "64"
-  else 
-    throw "Oops, unknown system: ${a.stdenv.system}";
+  else if a.stdenv.isi686 then
+    "32"
+  else
+    builtins.trace "assuming ${a.stdenv.system} is 32 bits" "32";
 
   doBuildJ = a.fullDepEntry ''
     sed -i bin/jconfig -e 's@bits=32@bits=${bits}@g; s@readline=0@readline=1@; s@LIBREADLINE=""@LIBREADLINE=" -lreadline "@'
···
       raskin
     ];
     platforms = with a.lib.platforms;
-      linux;
+      unix;
     license = a.lib.licenses.gpl3Plus;
   };
   passthru = {

pkgs/development/interpreters/nix-exec/default.nix

···
 { stdenv, fetchurl, pkgconfig, nix }: let
-  version = "1.0.0";
+  version = "1.1.0";
 in stdenv.mkDerivation {
   name = "nix-exec-${version}";
 
   src = fetchurl {
     url = "https://github.com/shlevy/nix-exec/releases/download/v${version}/nix-exec-${version}.tar.xz";
 
-    sha256 = "0w89ma69iil1ki68zvs1l0ii0d87in64791l3a4yzyv9d3ncl3w6";
+    sha256 = "0w1dq2svv1l8x18q5syraf80xpyyrcxbrab51cszc3v4m04b4saa";
   };
 
   buildInputs = [ pkgconfig nix ];

pkgs/development/interpreters/pypy/2.4/default.nix

···
 { stdenv, fetchurl, zlib ? null, zlibSupport ? true, bzip2, pkgconfig, libffi
 , sqlite, openssl, ncurses, pythonFull, expat, tcl, tk, x11, libX11
-, makeWrapper }:
+, makeWrapper, callPackage, self }:
 
 assert zlibSupport -> zlib != null;
 
···
       inherit zlibSupport libPrefix;
       executable = "pypy";
       isPypy = true;
+      buildEnv = callPackage ../../python/wrapper.nix { python = self; };
     };
 
     enableParallelBuilding = true;

pkgs/development/interpreters/python/2.6/default.nix

···
 { stdenv, fetchurl, zlib ? null, zlibSupport ? true, bzip2, includeModules ? false
-, sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm}:
+, sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm, self, callPackage }:
 
 assert zlibSupport -> zlib != null;
 
···
       inherit zlibSupport;
       isPy2 = true;
       isPy26 = true;
+      buildEnv = callPackage ../wrapper.nix { python = self; };
       libPrefix = "python${majorVersion}";
       executable = libPrefix;
       sitePackages = "lib/${libPrefix}/site-packages";

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

···
 { stdenv, fetchurl, zlib ? null, zlibSupport ? true, bzip2, includeModules ? false
-, sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm, libX11 }:
+, sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm, libX11, self, callPackage }:
 
 assert zlibSupport -> zlib != null;
 
···
       inherit zlibSupport;
       isPy2 = true;
       isPy27 = true;
+      buildEnv = callPackage ../wrapper.nix { python = self; };
       libPrefix = "python${majorVersion}";
       executable = libPrefix;
       sitePackages = "lib/${libPrefix}/site-packages";

pkgs/development/interpreters/python/3.2/default.nix

···
 , sqlite
 , tcl, tk
 , zlib
+, callPackage
+, self
 }:
 
 assert readline != null -> ncurses != null;
···
     zlibSupport = zlib != null;
     sqliteSupport = sqlite != null;
     dbSupport = db != null;
+    buildEnv = callPackage ../wrapper.nix { python = self; };
     readlineSupport = readline != null;
     opensslSupport = openssl != null;
     tkSupport = (tk != null) && (tcl != null) && (libX11 != null) && (xproto != null);

pkgs/development/interpreters/python/3.3/default.nix

···
 , sqlite
 , tcl, tk
 , zlib
+, callPackage
+, self
 }:
 
 assert readline != null -> ncurses != null;
···
     tkSupport = (tk != null) && (tcl != null) && (libX11 != null) && (xproto != null);
     libPrefix = "python${majorVersion}";
     executable = "python3.3m";
+    buildEnv = callPackage ../wrapper.nix { python = self; };
     isPy3 = true;
     isPy33 = true;
     is_py3k = true;  # deprecated

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

···
 , sqlite
 , tcl, tk
 , zlib
+, callPackage
+, self
 }:
 
 assert readline != null -> ncurses != null;
···
     tkSupport = (tk != null) && (tcl != null) && (libX11 != null) && (xproto != null);
     libPrefix = "python${majorVersion}";
     executable = "python3.4m";
+    buildEnv = callPackage ../wrapper.nix { python = self; };
     isPy3 = true;
     isPy34 = true;
     is_py3k = true;  # deprecated

pkgs/development/interpreters/python/wrapper.nix

···
-{ stdenv, python, buildEnv, makeWrapper, recursivePthLoader, extraLibs ? [], postBuild ? ""
+{ stdenv, python, buildEnv, makeWrapper
+, extraLibs ? []
+, postBuild ? ""
 , ignoreCollisions ? false }:
 
 # Create a python executable that knows about additional packages.
-
+let
+  recursivePthLoader = import ../../python-modules/recursive-pth-loader/default.nix { stdenv = stdenv; python = python; };
+in
 (buildEnv {
-  name = "python-${python.version}-env";
+  name = "${python.name}-env";
   paths = stdenv.lib.filter (x : x ? pythonPath) (stdenv.lib.closePropagation extraLibs) ++ [ python recursivePthLoader ];
 
   inherit ignoreCollisions;

pkgs/development/interpreters/racket/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "racket";
-  version = "6.0.1";
+  version = "6.1";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "http://mirror.racket-lang.org/installers/${version}/${name}-src.tgz";
-    sha256 = "e2bc0d4d0fcdfc3327a58c931f203c07a06d4724703f9708ba2e4c8ea0f9694d";
+    sha256 = "fde283bf5899bb9266ce721db44631c9bac4a4864a7c3211de413fd9503178c6";
   };
 
   # Various racket executables do run-time searches for these.

pkgs/development/interpreters/xulrunner/default.nix

···
 , freetype, fontconfig, file, alsaLib, nspr, nss, libnotify
 , yasm, mesa, sqlite, unzip, makeWrapper, pysqlite
 , hunspell, libevent, libstartup_notification, libvpx
-, cairo, gstreamer, gst_plugins_base, icu
+, cairo, gstreamer, gst_plugins_base, icu, firefox
 , debugBuild ? false
 }:
 
 assert stdenv.gcc ? libc && stdenv.gcc.libc != null;
 
-let version = "31.0"; in
+let version = firefox.version; in
 
 stdenv.mkDerivation rec {
   name = "xulrunner-${version}";
 
-  src = fetchurl {
-    url = "http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/${version}/source/firefox-${version}.source.tar.bz2";
-    sha1 = "a6c3e25ee3aeb7da42db2aaeb50a385d63532beb";
-  };
+  src = firefox.src;
 
   buildInputs =
     [ pkgconfig gtk perl zip libIDL libjpeg zlib bzip2
···
       "--disable-updater"
       "--disable-pulseaudio"
     ]
-    ++ (if debugBuild then [ "--enable-debug" "--enable-profiling"]
-                      else [ "--disable-debug" "--enable-release"
-                             "--enable-optimize" "--enable-strip" ]);
+    ++ (if debugBuild
+        then [ "--enable-debug" "--enable-profiling"]
+        else [ "--disable-debug" "--enable-release" "--enable-strip"
+               "--enable-optimize${lib.optionalString (stdenv.system == "i686-linux") "=-O1"}" ]);
 
   enableParallelBuilding = true;
 

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

···
 assert freetypeSupport -> freetype != null;
 
 stdenv.mkDerivation rec {
-  name = "ffmpeg-1.2.8";
+  name = "ffmpeg-1.2.9";
 
   src = fetchurl {
     url = "http://www.ffmpeg.org/releases/${name}.tar.bz2";
-    sha256 = "0n9fklr8zqkd60dc5ai161l6k4dbiac5hqy0pi1w82yamc25k6s2";
+    sha256 = "02wsnlix92a9k8wf3b4bad3a14v1c5iiz0fv6wlk1zn82cp93paw";
   };
 
   # `--enable-gpl' (as well as the `postproc' and `swscale') mean that
···
   meta = {
     homepage = http://www.ffmpeg.org/;
     description = "A complete, cross-platform solution to record, convert and stream audio and video";
+    license = if faacSupport then stdenv.lib.licenses.unfree else stdenv.lib.licenses.gpl2Plus;
     maintainers = with stdenv.lib.maintainers; [ the-kenny ];
+    platforms = stdenv.lib.platforms.unix;
     branch = "1";
   };
 }

pkgs/development/libraries/git2/default.nix

···
-{stdenv, fetchurl, cmake, zlib, python}:
+{stdenv, fetchurl, cmake, zlib, python, libssh2, openssl, http-parser}:
 
 stdenv.mkDerivation rec {
   version = "0.21.1";
···
   cmakeFlags = "-DTHREADSAFE=ON";
 
   nativeBuildInputs = [ cmake python ];
-  buildInputs = [ zlib ];
+  buildInputs = [ zlib libssh2 openssl http-parser ];
 
   meta = {
     description = "the Git linkable library";

pkgs/development/libraries/haskell/Decimal/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, deepseq, HUnit, QuickCheck, testFramework
+, testFrameworkHunit, testFrameworkQuickcheck2
+}:
+
+cabal.mkDerivation (self: {
+  pname = "Decimal";
+  version = "0.4.2";
+  sha256 = "0qa2z2lq1hrvakhyhj624mg8sd05ikhb66zwpa6x9vcyji93dxf5";
+  buildDepends = [ deepseq ];
+  testDepends = [
+    deepseq HUnit QuickCheck testFramework testFrameworkHunit
+    testFrameworkQuickcheck2
+  ];
+  meta = {
+    homepage = "https://github.com/PaulJohnson/Haskell-Decimal";
+    description = "Decimal numbers with variable precision";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/HTF/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, aeson, base64Bytestring, cpphs, Diff, filepath
-, haskellSrcExts, HUnit, liftedBase, monadControl, mtl, QuickCheck
-, random, regexCompat, temporary, text, time, unorderedContainers
-, vector, xmlgen
+{ cabal, aeson, aesonPretty, base64Bytestring, cpphs, Diff
+, filepath, haskellLexer, haskellSrc, HUnit, liftedBase
+, monadControl, mtl, QuickCheck, random, regexCompat, temporary
+, text, time, unorderedContainers, vector, xmlgen
 }:
 
 cabal.mkDerivation (self: {
   pname = "HTF";
-  version = "0.12.1.0";
-  sha256 = "1symg1y6i47rd1jshj84cwpn5vgmvh6v07jidjg5w5w3syyxqnz4";
+  version = "0.12.2.2";
+  sha256 = "02n3nqghcl9wmcr2iar9bg8nziddsvp43rzyasq4fnh166y87gc4";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
-    aeson base64Bytestring cpphs Diff haskellSrcExts HUnit liftedBase
-    monadControl mtl QuickCheck random regexCompat text time vector
-    xmlgen
+    aeson base64Bytestring cpphs Diff haskellLexer haskellSrc HUnit
+    liftedBase monadControl mtl QuickCheck random regexCompat text time
+    vector xmlgen
   ];
   testDepends = [
-    aeson filepath HUnit mtl random regexCompat temporary text
-    unorderedContainers
+    aeson aesonPretty filepath HUnit mtl random regexCompat temporary
+    text unorderedContainers
   ];
   doCheck = false;
   meta = {

pkgs/development/libraries/haskell/HandsomeSoup/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, HTTP, hxt, hxtHttp, MaybeT, mtl, network, parsec
-, transformers
+{ cabal, hspec, HTTP, hxt, hxtHttp, MaybeT, mtl, network
+, networkUri, parsec, transformers
 }:
 
 cabal.mkDerivation (self: {
   pname = "HandsomeSoup";
-  version = "0.3.2";
-  sha256 = "0ixqk32sfv6kj41vc6fzflv6f6jwvnkvcdf9pmgkc675218ggh53";
+  version = "0.3.3";
+  sha256 = "0g2b3mw0asam005kz77zm3bsrjaa7q3n6wdj3ahr7hppivsdwizk";
+  isLibrary = true;
+  isExecutable = true;
   buildDepends = [
-    HTTP hxt hxtHttp MaybeT mtl network parsec transformers
+    HTTP hxt hxtHttp MaybeT mtl network networkUri parsec transformers
   ];
+  testDepends = [ hspec hxt ];
+  doCheck = false;
   meta = {
     homepage = "https://github.com/egonSchiele/HandsomeSoup";
     description = "Work with HTML more easily in HXT";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    broken = true;
   };
 })

pkgs/development/libraries/haskell/JuicyPixels-util/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "JuicyPixels-util";
-  version = "0.1";
-  sha256 = "181wryax2k43qlblink9vcg2hk8f2qxn02ifmgxa2fl95z5ar0dc";
+  version = "0.2";
+  sha256 = "1b2rx5g8kd83hl50carr02mz21gvkasnsddw1f3pfvfsyfv3yyrc";
   buildDepends = [ JuicyPixels vector ];
   meta = {
     homepage = "https://github.com/fumieval/JuicyPixels-util";

pkgs/development/libraries/haskell/aeson/0.8.0.1.nix pkgs/development/libraries/haskell/aeson/0.8.0.2.nix

···
 
 cabal.mkDerivation (self: {
   pname = "aeson";
-  version = "0.8.0.1";
-  sha256 = "0363pzla3kjk2ckmm7j07hav3bgq31jkrya5jhl9dn0nv4l4slxk";
+  version = "0.8.0.2";
+  sha256 = "1mc8cwmswx69r77wv7dfim525jqajnlxbcx5xf3ygpszzf6mh1q7";
   buildDepends = [
     attoparsec blazeBuilder deepseq dlist hashable mtl scientific syb
     text time unorderedContainers vector

pkgs/development/libraries/haskell/asn1-encoding/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, asn1Types, mtl, text, time }:
+{ cabal, asn1Types, hourglass, mtl, tasty, tastyQuickcheck, text }:
 
 cabal.mkDerivation (self: {
   pname = "asn1-encoding";
-  version = "0.8.1.3";
-  sha256 = "000rajx9gdxfyx521yg2mvp1z8h61sr96w1lzwawiw7n5ng6v8ni";
-  isLibrary = true;
-  isExecutable = true;
-  buildDepends = [ asn1Types mtl text time ];
+  version = "0.9.0";
+  sha256 = "02x3lzyl4gavl3lc2lrg8rknyvs6r2hf8kmm7xrmma5m857iks8p";
+  buildDepends = [ asn1Types hourglass mtl ];
+  testDepends = [
+    asn1Types hourglass mtl tasty tastyQuickcheck text
+  ];
+  doCheck = false;
   meta = {
     homepage = "http://github.com/vincenthz/hs-asn1";
     description = "ASN1 data reader and writer in RAW, BER and DER forms";

pkgs/development/libraries/haskell/asn1-parse/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, asn1Encoding, asn1Types, mtl, text, time }:
+{ cabal, asn1Encoding, asn1Types, mtl, text }:
 
 cabal.mkDerivation (self: {
   pname = "asn1-parse";
-  version = "0.8.1";
-  sha256 = "021mbm5aayfx9vhxq4x1jj3gpnzq0bqaqcl1zsaa2a6l0qzpnmh9";
-  buildDepends = [ asn1Encoding asn1Types mtl text time ];
+  version = "0.9.0";
+  sha256 = "0m093wwndyxvy72qlnb70bp8w5ahimrlv1dp972l9s9l5jc4pjg3";
+  buildDepends = [ asn1Encoding asn1Types mtl text ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-asn1";
     description = "Simple monadic parser for ASN1 stream types";

pkgs/development/libraries/haskell/asn1-types/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, time }:
+{ cabal, hourglass }:
 
 cabal.mkDerivation (self: {
   pname = "asn1-types";
-  version = "0.2.3";
-  sha256 = "1cdzhj6zls6qmy82218cj2a25b7rkxsjbcqnx4zng3wp6s5pghw4";
-  buildDepends = [ time ];
+  version = "0.3.0";
+  sha256 = "1am8nmfarv7ymy3rqm0js2i82v6n6qwz0lnzb1qdmy4ligcdm65r";
+  buildDepends = [ hourglass ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-asn1-types";
     description = "ASN.1 types";

pkgs/development/libraries/haskell/auto-update/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "auto-update";
-  version = "0.1.1.5";
-  sha256 = "1gwx9k953nhw6n4d8a4jw3sfp51761s5qjsql73pr8i6gri0849h";
+  version = "0.1.2";
+  sha256 = "0ccix41jjpqkzvnfr5md1cbhsa9fkv6dy7yw73j8dnvqbqnz1z0l";
   meta = {
     homepage = "https://github.com/yesodweb/wai";
     description = "Efficiently run periodic, on-demand actions";

pkgs/development/libraries/haskell/basic-prelude/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "basic-prelude";
-  version = "0.3.9";
-  sha256 = "0f2l8xryagl1f0d30gq1hhydjnn77qhhwgg9l44gvqn30y2n66h7";
+  version = "0.3.10";
+  sha256 = "10013ni7kpqlc6s3ryfvmklw3ic5h48rm4wsrb31pcp5xja0qk59";
   buildDepends = [
     hashable liftedBase ReadArgs safe systemFilepath text transformers
     unorderedContainers vector

pkgs/development/libraries/haskell/binary-conduit/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "binary-conduit";
-  version = "1.2.2";
-  sha256 = "12dgqydc4zj1ffrcfqpd1dg40dc9hpynj1j69611kzpcqbj275pf";
+  version = "1.2.3";
+  sha256 = "0ymhxyf754j1pki7ap2vay8f9j49rzsjzp5yr253sn5wpw3qg8fr";
   buildDepends = [ binary conduit resourcet vector ];
   testDepends = [
     binary conduit hspec QuickCheck quickcheckAssertions resourcet
   ];
   jailbreak = true;
   meta = {
-    homepage = "http://github.com/qnikst/binary-conduit";
+    homepage = "http://github.com/qnikst/binary-conduit/";
     description = "data serialization/deserialization conduit library";
     license = self.stdenv.lib.licenses.mit;
     platforms = self.ghc.meta.platforms;

pkgs/development/libraries/haskell/cairo/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "cairo";
-  version = "0.13.0.3";
-  sha256 = "0jlxgxsby8qscyfq517xlaib8xkp310gbjbmk9yyi7sd5bnmblh9";
+  version = "0.13.0.4";
+  sha256 = "0sj6c83md51qvjpp3dckv3hvg9dm2qkiw1wzlvdypdd1c09957n2";
   buildDepends = [ mtl text utf8String ];
   buildTools = [ gtk2hsBuildtools ];
   extraLibraries = [ cairo libc pkgconfig zlib ];

pkgs/development/libraries/haskell/charsetdetect-ae/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal }:
+
+cabal.mkDerivation (self: {
+  pname = "charsetdetect-ae";
+  version = "1.0.1";
+  sha256 = "0bvdnv608glim8yn4dvh3av7x0fxxp3z6719j0n005bygdfgjxna";
+  meta = {
+    homepage = "http://github.com/Aelve/charsetdetect-ae";
+    description = "Character set detection using Mozilla's Universal Character Set Detector";
+    license = "LGPL";
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
+  };
+})

pkgs/development/libraries/haskell/classy-prelude-conduit/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "classy-prelude-conduit";
-  version = "0.10.0";
-  sha256 = "0ziggymy37iz68c2rjdjdzjsamnvn81r836a6xx2nhqjivmfmlav";
+  version = "0.10.1";
+  sha256 = "0q6x0mb24yslgqjazg443v9w15x3j4xn32m6p9iwbmafyfbp9vs4";
   buildDepends = [
     classyPrelude conduit conduitCombinators monadControl resourcet
     systemFileio transformers void

pkgs/development/libraries/haskell/classy-prelude/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "classy-prelude";
-  version = "0.10.0";
-  sha256 = "007a1gs9wgfw7gkm4jyh0fndcnxwkffzdm5rgxw08f1g8s0yqwf3";
+  version = "0.10.1";
+  sha256 = "1x22kq808ncgbi32idwn2232fy0hji3a7p9l9ardpg7hb6q1w76g";
   buildDepends = [
     basicPrelude bifunctors chunkedData enclosedExceptions exceptions
     hashable liftedBase monoTraversable mtl primitive semigroups stm

pkgs/development/libraries/haskell/concreteTyperep/default.nix

···
   testDepends = [
     binary hashable QuickCheck testFramework testFrameworkQuickcheck2
   ];
+  doCheck = false;
   meta = {
     description = "Binary and Hashable instances for TypeRep";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/crypto-pubkey-types/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "crypto-pubkey-types";
-  version = "0.4.2.2";
-  sha256 = "18z1fnh2xjq600ya8m175m64nwr6bwscr2q47zjy7k38zlm9c8h5";
+  version = "0.4.2.3";
+  sha256 = "1isfyr1ly9hv8idslpjbyc9hhgb1zqd9gfc1s4kvwy4gcdsvrx52";
   buildDepends = [ asn1Types ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";

pkgs/development/libraries/haskell/digestive-functors-heist/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "digestive-functors-heist";
-  version = "0.8.6.0";
-  sha256 = "0n73hw8xl70x7c3hn4hz1qqijvvhv0qk30q0c22lnbjaf4n8dki2";
+  version = "0.8.6.1";
+  sha256 = "1l8ppn2h1nxzn5wxnglc2fyi7r90177v75yf4n7cyvzrcxdaz4bb";
   buildDepends = [
     blazeBuilder digestiveFunctors heist mtl text xmlhtml
   ];

pkgs/development/libraries/haskell/dynamic-cabal/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "dynamic-cabal";
-  version = "0.3.2";
-  sha256 = "0f0g4kml17j1j101gnpjjpdmny4m2wgr0dbjq18fw1s3nxc3jagm";
+  version = "0.3.3";
+  sha256 = "0fq6q0j2fx7ygarzgsvb7scssjnrxjrq188d0habfar6bdm0vqdg";
   buildDepends = [
     dataDefault filepath ghcPaths haskellGenerate haskellSrcExts time
     void

pkgs/development/libraries/haskell/ekg/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ekg";
-  version = "0.4.0.3";
-  sha256 = "0fynng6r0aj25k4j8ba3fvq4a6kgijil4m9ygd99xq8c1cvj2zyy";
+  version = "0.4.0.4";
+  sha256 = "1v1kskl1fwwpv72lay8c7nlvg2dswf6wij176fjfml1v8lmll2lr";
   buildDepends = [
     aeson ekgCore filepath network snapCore snapServer text time
     transformers unorderedContainers

pkgs/development/libraries/haskell/extra/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, filepath, QuickCheck, time }:
+
+cabal.mkDerivation (self: {
+  pname = "extra";
+  version = "0.3.2";
+  sha256 = "0in340mmbgqkafj60pas7dm6bn080nimxk8b9b6xzv0giih6dx66";
+  buildDepends = [ filepath time ];
+  testDepends = [ QuickCheck time ];
+  meta = {
+    homepage = "https://github.com/ndmitchell/extra#readme";
+    description = "Extra functions I use";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ aycanirican ];
+  };
+})

pkgs/development/libraries/haskell/fast-logger/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "fast-logger";
-  version = "2.2.0";
-  sha256 = "02gc5f7vgwfdlhfawki4xxrl33lbdl05wh64qm3mb3h2dv1gnwrr";
+  version = "2.2.3";
+  sha256 = "0zap61gz0snbq42h8nyjh637fr2cm1ny9f77sqd6v3yfqjq0ljh3";
   buildDepends = [ autoUpdate blazeBuilder filepath text ];
   testDepends = [ hspec ];
   meta = {

pkgs/development/libraries/haskell/fay/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "fay";
-  version = "0.21.0.1";
-  sha256 = "0lrnn73xqgkgh5zd4ngvl0lyzqbx5kp52j14dj2xbkbxnnivwgl4";
+  version = "0.21.0.2";
+  sha256 = "0hq9jfyl5ki3jcwffb9q7cxrgpchajgwk4j44kz37y1wji63lk96";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/fb/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "fb";
-  version = "1.0.6";
-  sha256 = "16dwvh2xn14gpni0qpabqfifywrkdz1p0mmq6yyf3k19ix3xg9im";
+  version = "1.0.7";
+  sha256 = "0ghyddxf4aqidqvbm93pjgaban0whfj4y1w11b7nxy89srhyjhh8";
   buildDepends = [
     aeson attoparsec base16Bytestring base64Bytestring cereal conduit
     conduitExtra cryptoApi cryptohash cryptohashCryptoapi dataDefault

pkgs/development/libraries/haskell/focus/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, lochTh, placeholders }:
+{ cabal }:
 
 cabal.mkDerivation (self: {
   pname = "focus";
-  version = "0.1.2";
-  sha256 = "0j157nv668621i94iqg923bfg7594bpfn0q9scb62cik2yikc1p0";
-  buildDepends = [ lochTh placeholders ];
+  version = "0.1.3";
+  sha256 = "11l6rlr22m0z41c9fynpisj0cnx70zzcxhsakz9b09ap8wj0raqy";
   meta = {
     homepage = "https://github.com/nikita-volkov/focus";
     description = "A general abstraction for manipulating elements of container data structures";

pkgs/development/libraries/haskell/gio/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "gio";
-  version = "0.13.0.1";
-  sha256 = "03194npzv48flg6pba3m8c5gfmmy34z0545y84wa979z21fbv22m";
+  version = "0.13.0.2";
+  sha256 = "12wcgycljlrxbf9hdp0c9n6d2h709wb3jk94v3lngwc7z5lnv5hs";
   buildDepends = [ glib mtl ];
   buildTools = [ gtk2hsBuildtools ];
   pkgconfigDepends = [ glib ];

pkgs/development/libraries/haskell/glib/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "glib";
-  version = "0.13.0.4";
-  sha256 = "1ckl6liw6x4hqirki1vcxrvdca0cf17kpxnngrfnxvndlwghly68";
+  version = "0.13.0.5";
+  sha256 = "0drpsdzdk47qkcn9jca8i4xrhhcql5gphm9wx2xaavqs8g7aqkg3";
   buildDepends = [ text utf8String ];
   buildTools = [ gtk2hsBuildtools ];
   extraLibraries = [ libc pkgconfig ];

pkgs/development/libraries/haskell/gtk/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "gtk";
-  version = "0.13.0.2";
-  sha256 = "0m5gvs2zsm8y742yvfcd8h6qqihgjjyhhz8f4dxg589bhckv3amj";
+  version = "0.13.0.3";
+  sha256 = "1l42hn3mhycq2b7z517jjyz3s8kvf5nyy0m674da0h2rixw9r5fh";
   buildDepends = [ cairo gio glib mtl pango text ];
   buildTools = [ gtk2hsBuildtools ];
   extraLibraries = [ libc pkgconfig ];

pkgs/development/libraries/haskell/gtk3/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "gtk3";
-  version = "0.13.0.2";
-  sha256 = "0j5df9xah5ya91x3d7cyy5zw7mkw3j2y7n0vv5s78w0adchaxzzl";
+  version = "0.13.0.3";
+  sha256 = "12ywqxvmakcdmfj5y4jpn91rxa4xskd0w3hn2l679dk6lxyl15q7";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ cairo gio glib mtl pango text time transformers ];

pkgs/development/libraries/haskell/gtksourceview2/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "gtksourceview2";
-  version = "0.13.1.0";
-  sha256 = "1znmr694jxam9n5lgikrhf8wb4jwdml82a3mgnpfr482a8knndbn";
+  version = "0.13.1.1";
+  sha256 = "09439drmwfy5bqni1clcn0nng30irn9x43fjak9jljggg1yij9xw";
   buildDepends = [ glib gtk mtl text ];
   buildTools = [ gtk2hsBuildtools ];
   extraLibraries = [ libc pkgconfig ];

pkgs/development/libraries/haskell/hakyll/default.nix

···
   sha256 = "1igna446dsidlq3f9myclgcdawgvyyjxjk3r3icjra6zgdqd6j4l";
   isLibrary = true;
   isExecutable = true;
+  patches = [ ./deps.patch ];
+  doCheck = !self.stdenv.isDarwin;
   buildDepends = [
     binary blazeHtml blazeMarkup cmdargs cryptohash dataDefault deepseq
     filepath fsnotify httpConduit httpTypes lrucache mtl network
···
     filepath fsnotify httpConduit httpTypes HUnit lrucache mtl network
     networkUri pandoc pandocCiteproc parsec QuickCheck random regexBase
     regexTdfa snapCore snapServer systemFilepath tagsoup testFramework
-    testFrameworkHunit testFrameworkQuickcheck2 text time utillinux
-  ];
+    testFrameworkHunit testFrameworkQuickcheck2 text time
+  ] ++ (self.stdenv.lib.optional self.stdenv.isLinux utillinux);
   meta = {
     homepage = "http://jaspervdj.be/hakyll";
     description = "A static website compiler library";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
-    broken = true;
+    broken = self.stdenv.lib.versionOlder "7.7" self.ghc.version;
   };
 })

pkgs/development/libraries/haskell/hakyll/deps.patch

···
+--- a/hakyll.cabal.orig	2014-10-16 17:34:22.000000000 -0500
++++ b/hakyll.cabal	2014-10-16 17:34:30.000000000 -0500
+@@ -163,7 +163,7 @@
+     pandoc-citeproc >= 0.4    && < 0.5,
+     parsec          >= 3.0    && < 3.2,
+     process         >= 1.0    && < 1.3,
+-    random          >= 1.0    && < 1.1,
++    random          >= 1.0    && < 1.2,
+     regex-base      >= 0.93   && < 0.94,
+     regex-tdfa      >= 1.1    && < 1.3,
+     tagsoup         >= 0.13.1 && < 0.14,
+@@ -250,7 +250,7 @@
+     pandoc-citeproc >= 0.4    && < 0.5,
+     parsec          >= 3.0    && < 3.2,
+     process         >= 1.0    && < 1.3,
+-    random          >= 1.0    && < 1.1,
++    random          >= 1.0    && < 1.2,
+     regex-base      >= 0.93   && < 0.94,
+     regex-tdfa      >= 1.1    && < 1.3,
+     tagsoup         >= 0.13.1 && < 0.14,

pkgs/development/libraries/haskell/haskell-generate/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "haskell-generate";
-  version = "0.2.1";
-  sha256 = "1b7jy4a83lv9zwkzsgbipv7vlzcj27g1h3az7nxxc2gbmyrc15f4";
+  version = "0.2.2";
+  sha256 = "1wdfs28p195szg6jxq0qbyj4jdbqnsp9frgjnp25mzf14y9i1yid";
   buildDepends = [ haskellSrcExts transformers ];
   testDepends = [ doctest filepath ];
   meta = {

pkgs/development/libraries/haskell/hcltest/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hcltest";
-  version = "0.3.4";
-  sha256 = "0p8skabp6z4i5xr22qxk1sij2ayla2iqylvlzxfxa8yw1fxs8wsq";
+  version = "0.3.6";
+  sha256 = "145l3kfxi1slngcmh4dnn09hhpr5v6s5nppk0i5a5jzxpp2yx6sd";
   buildDepends = [
     dlist either filepath free lens mmorph monadControl mtl
     optparseApplicative randomShuffle split stm tagged tasty temporary
···
     description = "A testing library for command line applications";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-    broken = true;
   };
 })

pkgs/development/libraries/haskell/hindent/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hindent";
-  version = "3.8";
-  sha256 = "015madajwljh2an3djla0qdds8bg7kgcdn3xb30cdf6gb77mf1xv";
+  version = "3.9";
+  sha256 = "0x8qm39rmaw1s0fbljr9zp6vnqxfcs1w6a3ylrknwqgwbzzr5hbn";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ dataDefault haskellSrcExts monadLoops mtl text ];
   testDepends = [
     dataDefault haskellSrcExts hspec monadLoops mtl text
   ];
+  doCheck = false;
   meta = {
     description = "Extensible Haskell pretty printer";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    broken = true;
   };
 })

pkgs/development/libraries/haskell/hoogle/4.2.34.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, aeson, binary, blazeBuilder, Cabal, caseInsensitive
+, cmdargs, conduit, deepseq, filepath, haskellSrcExts, httpTypes
+, parsec, QuickCheck, random, resourcet, safe, shake, tagsoup, text
+, time, transformers, uniplate, vector, vectorAlgorithms, wai, warp
+}:
+
+cabal.mkDerivation (self: {
+  pname = "hoogle";
+  version = "4.2.34";
+  sha256 = "0vldc7s3nq70jxmnxdzlfrlwg0pxw0lq1lcd53klj2ksjkqhm5jg";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    aeson binary blazeBuilder Cabal caseInsensitive cmdargs conduit
+    deepseq filepath haskellSrcExts httpTypes parsec QuickCheck random
+    resourcet safe shake tagsoup text time transformers uniplate vector
+    vectorAlgorithms wai warp
+  ];
+  testDepends = [ filepath ];
+  testTarget = "--test-option=--no-net";
+  meta = {
+    homepage = "http://www.haskell.org/hoogle/";
+    description = "Haskell API Search";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    hydraPlatforms = self.stdenv.lib.platforms.none;
+  };
+})

pkgs/development/libraries/haskell/hourglass/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hourglass";
-  version = "0.2.5";
-  sha256 = "08nw9zqa0y09lw0c6qlh9pn8vr6h03mw1i7n7w0y3fv94az9vg9v";
+  version = "0.2.6";
+  sha256 = "029fmx5r6krj7y7mn4b4m2lpaa3iw6vhyznrib5lhf469i1jp9m3";
   buildDepends = [ deepseq ];
   testDepends = [
     deepseq mtl tasty tastyHunit tastyQuickcheck time

pkgs/development/libraries/haskell/hspec-checkers/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, checkers, hspec }:
+
+cabal.mkDerivation (self: {
+  pname = "hspec-checkers";
+  version = "0.1.0";
+  sha256 = "043qzgjp9ch9wqm269dd87jn8wk5c90q25098hnz8ilv5pnywk6d";
+  buildDepends = [ checkers hspec ];
+  testDepends = [ checkers hspec ];
+  meta = {
+    description = "Allows to use checkers properties from hspec";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/hspec-meta/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hspec-meta";
-  version = "1.11.4";
-  sha256 = "047vp6wibkwgs9rryjpys2qqn4s5p91mh36w0gnxwhggp8nhfqg3";
+  version = "1.12.1";
+  sha256 = "1920gpcam7y3slg1an8ywhw6lxammgy21nmxbxlh77iz65rldzls";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/hspec/default.nix

···
 
 { cabal, ansiTerminal, async, deepseq, filepath, ghcPaths
 , hspecExpectations, hspecMeta, HUnit, QuickCheck, quickcheckIo
-, random, setenv, silently, tfRandom, time, transformers
+, random, setenv, silently, stringbuilder, tfRandom, time
+, transformers
 }:
 
 cabal.mkDerivation (self: {
   pname = "hspec";
-  version = "1.11.4";
-  sha256 = "044vr6xyk0ih20faa4gbl4y4v6vkss0x2gmxgkk96ha6chws2svn";
+  version = "1.12.1";
+  sha256 = "0w42lsl5qs452f04qpbr6nvs4qgp7cwd9262f34vzjq8m83nhjwk";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
···
   testDepends = [
     ansiTerminal async deepseq filepath ghcPaths hspecExpectations
     hspecMeta HUnit QuickCheck quickcheckIo random setenv silently
-    tfRandom time transformers
+    stringbuilder tfRandom time transformers
   ];
   doCheck = false;
   meta = {

pkgs/development/libraries/haskell/hspec2/default.nix

···
 
 { cabal, ansiTerminal, async, deepseq, filepath, ghcPaths
 , hspecExpectations, hspecMeta, HUnit, QuickCheck, quickcheckIo
-, random, setenv, silently, tfRandom, time, transformers
+, random, setenv, silently, stringbuilder, tfRandom, time
+, transformers
 }:
 
 cabal.mkDerivation (self: {
   pname = "hspec2";
-  version = "0.4.2";
-  sha256 = "1wk1lvy3lngfa60n0dyllfqbj4gd4v0qxjw7gpvzknfk2y10536x";
+  version = "0.5.1";
+  sha256 = "1ax507vb0zm5jalp6pvlk1fjfil766pf7w61d1igpxr0s00lnvlq";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
···
   testDepends = [
     ansiTerminal async deepseq filepath ghcPaths hspecExpectations
     hspecMeta HUnit QuickCheck quickcheckIo random setenv silently
-    tfRandom time transformers
+    stringbuilder tfRandom time transformers
   ];
   meta = {
     homepage = "http://hspec.github.io/";

pkgs/development/libraries/haskell/hxt-regex-xmlschema/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, hxtCharproperties, parsec }:
+{ cabal, HUnit, hxtCharproperties, parsec, text }:
 
 cabal.mkDerivation (self: {
   pname = "hxt-regex-xmlschema";
-  version = "9.1.0";
-  sha256 = "0l97rkrvl6pmxdgiwbwh2s3l00lyaihrhsffhh69639bgs67zgwr";
-  buildDepends = [ hxtCharproperties parsec ];
+  version = "9.2.0";
+  sha256 = "0pcbyvc71173ad0zkgpdpyyljngrk4p1jjjaw5wbwcvm4ijh44g3";
+  buildDepends = [ hxtCharproperties parsec text ];
+  testDepends = [ HUnit parsec text ];
   meta = {
     homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema";
     description = "A regular expression library for W3C XML Schema regular expressions";

pkgs/development/libraries/haskell/io-streams/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "io-streams";
-  version = "1.2.0.0";
-  sha256 = "1lisvwy4pj0ywm1i61qan3vxisl4xazz7z8i8iybww1dv3j6mrn2";
+  version = "1.2.0.1";
+  sha256 = "12r7j8dzj80f4s9942a6pi60pd9jh44sqyl6hcn0npzmdyl7hg1k";
   buildDepends = [
     attoparsec blazeBuilder network primitive text time transformers
     vector zlibBindings

pkgs/development/libraries/haskell/ixset/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ixset";
-  version = "1.0.5";
-  sha256 = "1hznn7f8f13x5125n76dchayi16z72050qbwifnkrca54nf9q2ns";
+  version = "1.0.6";
+  sha256 = "097f9fkm9a2n67bzagr9h2v7acdn8h1ayv9c83n7nv1dh157bpyv";
   buildDepends = [ safecopy syb sybWithClass ];
   meta = {
     homepage = "http://happstack.com";

pkgs/development/libraries/haskell/json-rpc/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "json-rpc";
-  version = "0.2.0.2";
-  sha256 = "00ha6hjg9ccwa48ab5ibnkiiri7ki3rv7ms2h9qbwr30lxyb0r88";
+  version = "0.2.1.1";
+  sha256 = "0h6dkb1rgd6qxzcxvqvgwilmibkdbqpjvflijwf54fx2z687fjld";
   buildDepends = [
     aeson async conduit conduitExtra deepseq hashable mtl stm
     stmConduit text unorderedContainers

pkgs/development/libraries/haskell/lambdabot/default.nix

···
   sha256 = "19pkm4m2xk9ziai3ka4scxjavi0as8dmivz9q6vg3npmv0kyhkhb";
   isLibrary = true;
   isExecutable = true;
+  patches = [ ./deps.patch ];
   buildDepends = [
     arrows binary brainfuck dataMemocombinators dependentMap
     dependentSum dependentSumTemplate dice editDistance filepath

pkgs/development/libraries/haskell/lambdabot/deps.patch

···
+--- a/lambdabot.cabal.orig	2014-10-16 17:39:16.000000000 -0500
++++ b/lambdabot.cabal	2014-10-16 18:26:58.000000000 -0500
+@@ -166,7 +166,7 @@
+                         edit-distance           >= 0.2,
+                         filepath                >= 1.3,
+                         haskeline               >= 0.7,
+-                        haskell-src-exts        >= 1.14.0,
++                        haskell-src-exts        >= 1.14.0 && < 1.16,
+                         hstatsd                 >= 0.1,
+                         hslogger                >= 1.2.1,
+                         HTTP                    >= 4000,
+@@ -174,7 +174,8 @@
+                         misfortune              >= 0.1,
+                         monad-control           >= 0.3,
+                         mtl                     >= 2,
+-                        network                 >= 2.3.0.13,
++                        network                 >= 2.6,
++                        network-uri             >= 2.6,
+                         oeis                    >= 0.3.1,
+                         time                    >= 1.4,
+                         parsec                  >= 3,

pkgs/development/libraries/haskell/monadloc-pp/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "monadloc-pp";
-  version = "0.3";
-  sha256 = "0jr9ngcj3l6kd5cscll5kr3a4bp52sdjgrdxd1j5a21jyc3gdyvn";
+  version = "0.3.1";
+  sha256 = "0ch25kcz63xhinwd6mjqbhm282hfh280s3z910wnvdp3krgx0mpc";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [ filepath haskellSrcExts monadloc syb ];
   jailbreak = true;
   meta = {
-    homepage = "http://github.com/pepeiborra/monadloc";
+    homepage = "http://github.com/pepeiborra/monadloc-pp";
     description = "A preprocessor for generating monadic call traces";
     license = self.stdenv.lib.licenses.publicDomain;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ tomberek ];
-    broken = true;
   };
 })

pkgs/development/libraries/haskell/mtl/2.1.3.1.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, transformers }:
+
+cabal.mkDerivation (self: {
+  pname = "mtl";
+  version = "2.1.3.1";
+  sha256 = "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp";
+  buildDepends = [ transformers ];
+  meta = {
+    homepage = "http://github.com/ekmett/mtl";
+    description = "Monad classes, using functional dependencies";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    hydraPlatforms = self.stdenv.lib.platforms.none;
+  };
+})

pkgs/development/libraries/haskell/mysql/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "mysql";
-  version = "0.1.1.6";
-  sha256 = "1sxzx5f4ysxhq1nimkj4xwf87i7prwp5wg0kjbhv9pbn65zc9mmj";
+  version = "0.1.1.7";
+  sha256 = "0hl8z8ynadvvhn4garjrax2b59iqddj884mv3s6804lcjjyc49d0";
   buildTools = [ mysqlConfig ];
   extraLibraries = [ zlib ];
   meta = {

pkgs/development/libraries/haskell/network-simple/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "network-simple";
-  version = "0.4.0.1";
-  sha256 = "113vaxgsfny9iv6hnbywk97qr1y6qkap49p803anakamss4bdmyj";
+  version = "0.4.0.2";
+  sha256 = "0k155m1s7k157rpsz8ww9cs7jyw3faybwfmw97agvskhb4axw6hf";
   buildDepends = [ exceptions network transformers ];
   jailbreak = true;
   meta = {

pkgs/development/libraries/haskell/pandoc-citeproc/0.4.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, aeson, aesonPretty, attoparsec, filepath, hexpat
+, hsBibutils, mtl, pandoc, pandocTypes, parsec, rfc5051, split, syb
+, tagsoup, temporary, text, time, vector, yaml
+}:
+
+cabal.mkDerivation (self: {
+  pname = "pandoc-citeproc";
+  version = "0.4.0.1";
+  sha256 = "1z21mdxa2hrwqdclriyn3s1qqij3ccbkg7hb0acxrk3pzgidcinx";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    aeson aesonPretty attoparsec filepath hexpat hsBibutils mtl pandoc
+    pandocTypes parsec rfc5051 split syb tagsoup temporary text time
+    vector yaml
+  ];
+  testDepends = [
+    aeson filepath pandoc pandocTypes temporary text yaml
+  ];
+  doCheck = false;
+  meta = {
+    description = "Supports using pandoc with citeproc";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    hydraPlatforms = self.stdenv.lib.platforms.none;
+  };
+})

pkgs/development/libraries/haskell/pandoc-citeproc/0.5.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, aeson, aesonPretty, attoparsec, filepath, hexpat
+, hsBibutils, mtl, pandoc, pandocTypes, parsec, rfc5051, split, syb
+, tagsoup, temporary, text, time, vector, yaml
+}:
+
+cabal.mkDerivation (self: {
+  pname = "pandoc-citeproc";
+  version = "0.5";
+  sha256 = "00azhpll0xnb9nnkh7c3hbfk0fzmvh5cgdxlgx7jvaglrmsnvzw3";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    aeson aesonPretty attoparsec filepath hexpat hsBibutils mtl pandoc
+    pandocTypes parsec rfc5051 split syb tagsoup temporary text time
+    vector yaml
+  ];
+  testDepends = [
+    aeson filepath pandoc pandocTypes temporary text yaml
+  ];
+  doCheck = false;
+  meta = {
+    description = "Supports using pandoc with citeproc";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    hydraPlatforms = self.stdenv.lib.platforms.none;
+  };
+})

pkgs/development/libraries/haskell/pango/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "pango";
-  version = "0.13.0.2";
-  sha256 = "1f546k53j5ymb1321n31na0fpm69idx5l0nh9s75yallbij3gyfg";
+  version = "0.13.0.3";
+  sha256 = "0xvmv1r7lh727w1pag8myp069s4wnvgsqlr3c3ir1gyzxy5jq69f";
   buildDepends = [ cairo glib mtl text ];
   buildTools = [ gtk2hsBuildtools ];
   extraLibraries = [ libc pkgconfig ];

pkgs/development/libraries/haskell/persistent-postgresql/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "persistent-postgresql";
-  version = "2.1";
-  sha256 = "0458z9n61wn8g55cp8a9061qgc99i5yp3wmwmf3x4p4vfkl5kw9c";
+  version = "2.1.0.1";
+  sha256 = "0ndy8vbzxqcdx9hqmpmp9f7b8cd6lpgzzc8m7jlwzjz4agc51767";
   buildDepends = [
     aeson blazeBuilder conduit monadControl monadLogger persistent
     postgresqlLibpq postgresqlSimple resourcet text time transformers

pkgs/development/libraries/haskell/persistent/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "persistent";
-  version = "2.1";
-  sha256 = "0ybjjya8q4kwnq6lksahpm0g8wzxwzfqxqmkrw18vw4fb7kry58k";
+  version = "2.1.0.1";
+  sha256 = "0506w53shy0ck7vyncrhh5prp9jri8bbp2awzbkavfxiwzra1l83";
   buildDepends = [
     aeson attoparsec base64Bytestring blazeHtml blazeMarkup conduit
     exceptions fastLogger liftedBase monadControl monadLogger mtl

pkgs/development/libraries/haskell/pipes-attoparsec/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "pipes-attoparsec";
-  version = "0.5.1";
-  sha256 = "0qvsvbcn211xp4c669cpljmnsqn9zk1rn94ya1dbq77l970s8xah";
+  version = "0.5.1.1";
+  sha256 = "1ns8s3p6jh4iya71z3j81cqnrfnr4n92kblwgkjlapb23dykl2qz";
   buildDepends = [ attoparsec pipes pipesParse text transformers ];
   testDepends = [
     attoparsec HUnit mmorph pipes pipesParse tasty tastyHunit text

pkgs/development/libraries/haskell/rest-gen/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "rest-gen";
-  version = "0.16.0.2";
-  sha256 = "0sh3sgv02x49pr02yb9jsd694g27xifnclrcc6npkkbkcvy9m7y7";
+  version = "0.16.0.3";
+  sha256 = "1gl0dhl2dajlgms8f297x1763dqbrp9cszfq2qggzcdn896zxxgn";
   buildDepends = [
     aeson blazeHtml Cabal codeBuilder fclabels filepath hashable
     haskellSrcExts hslogger HStringTemplate hxt jsonSchema restCore

pkgs/development/libraries/haskell/rethinkdb/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "rethinkdb";
-  version = "1.15.0.0";
-  sha256 = "0zswbz73c8h7h31ppw5251l6spn6y5ha3hm9hb90j04hjg8g235i";
+  version = "1.15.1.0";
+  sha256 = "139a5xii9fkywr1fq7z37wvs732w6j06005z6r7ycr99swrzpgvq";
   buildDepends = [
     aeson base64Bytestring binary dataDefault mtl network scientific
     text time unorderedContainers utf8String vector
   ];
   testDepends = [ doctest ];
+  jailbreak = true;
+  doCheck = false;
   meta = {
     homepage = "http://github.com/atnnn/haskell-rethinkdb";
-    description = "A driver for the RethinkDB database server";
+    description = "A driver for RethinkDB 1.15";
     license = self.stdenv.lib.licenses.asl20;
     platforms = self.ghc.meta.platforms;
-    broken = true;
   };
 })

pkgs/development/libraries/haskell/sdl2/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "sdl2";
-  version = "1.1.2";
-  sha256 = "1viy6f8iqbw264hmsvfqjf8b27h8klyybywd5976yin6ianbqm2a";
+  version = "1.1.3";
+  sha256 = "111kbairf50j8kkndcc54i0gsfaffnyla7zw49gbqlqs4kgxj6b5";
   extraLibraries = [ SDL2 ];
   pkgconfigDepends = [ SDL2 ];
   meta = {

pkgs/development/libraries/haskell/shell-conduit/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "shell-conduit";
-  version = "4.2";
-  sha256 = "1ac1imsz1ffm0ldi29ylprgs4zh0qhn52ka17zn8f9301hfx9vhc";
+  version = "4.3";
+  sha256 = "1f82ncdsi4w63r48aj7679hii0hkd46drdz3bdgwxqx2yynjmlj8";
   buildDepends = [
     async conduit conduitExtra controlMonadLoop filepath monadControl
     monadsTf resourcet semigroups split text these transformers

pkgs/development/libraries/haskell/tasty-hspec/default.nix

···
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ ocharles ];
+    broken = true;
   };
 })

pkgs/development/libraries/haskell/tasty-th/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "tasty-th";
-  version = "0.1.2";
-  sha256 = "1x3kixv0hnb7icigz2kfq959pivdc4jaaalvdgn8dlyqzkvfjzx4";
+  version = "0.1.3";
+  sha256 = "1fl5pagm9bdqvp7v54ilkr91m667rxw1jifwfdhrikr938aqrzx3";
   buildDepends = [ languageHaskellExtract tasty ];
   meta = {
     homepage = "http://github.com/bennofs/tasty-th";

pkgs/development/libraries/haskell/template/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "template";
-  version = "0.2.0.9";
-  sha256 = "0i1xq6nj240gddbd8d5m42gzix16k81wqmirpy5a4fssnkpwjqnb";
+  version = "0.2.0.10";
+  sha256 = "10mcnhi2rdflmv79z0359nn5sylifvk9ih38xnjqqby6n4hs7mcg";
   buildDepends = [ mtl text ];
   meta = {
     description = "Simple string substitution";

pkgs/development/libraries/haskell/th-lift-instances/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "th-lift-instances";
-  version = "0.1.3";
-  sha256 = "0snqgcdkskwvrsw239j3xq84mwnf5x79kfsn495kprdc6yh3qdkx";
+  version = "0.1.4";
+  sha256 = "02sf7qn1rs33cdf1dl7vpwkhqzhmj8h3naw0ngh2kz05ymk2qng4";
   buildDepends = [ text thLift vector ];
   testDepends = [ doctest filepath QuickCheck text vector ];
   meta = {

pkgs/development/libraries/haskell/tls/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, asn1Encoding, asn1Types, byteable, cereal, cipherAes
-, cipherDes, cipherRc4, cprngAes, cryptoCipherTypes, cryptohash
-, cryptoNumbers, cryptoPubkey, cryptoPubkeyTypes, cryptoRandom
-, dataDefaultClass, mtl, network, QuickCheck, testFramework
-, testFrameworkQuickcheck2, time, x509, x509Store, x509Validation
+{ cabal, asn1Encoding, asn1Types, async, byteable, cereal
+, cipherAes, cipherDes, cipherRc4, cprngAes, cryptoCipherTypes
+, cryptohash, cryptoNumbers, cryptoPubkey, cryptoPubkeyTypes
+, cryptoRandom, dataDefaultClass, hourglass, mtl, network
+, QuickCheck, tasty, tastyQuickcheck, transformers, x509, x509Store
+, x509Validation
 }:
 
 cabal.mkDerivation (self: {
   pname = "tls";
-  version = "1.2.9";
-  sha256 = "1cwhwxpsxx9x5hv2c66d3yvbs84lrgaxmaz18skidmhqhs4i0sjy";
+  version = "1.2.13";
+  sha256 = "1djjscmyn3wcnlzz1r0clz2nxa2y23rlyjk30xjsdp0m1sq0vdc3";
   buildDepends = [
-    asn1Encoding asn1Types byteable cereal cipherAes cipherDes
+    asn1Encoding asn1Types async byteable cereal cipherAes cipherDes
     cipherRc4 cryptoCipherTypes cryptohash cryptoNumbers cryptoPubkey
-    cryptoPubkeyTypes cryptoRandom dataDefaultClass mtl network x509
-    x509Store x509Validation
+    cryptoPubkeyTypes cryptoRandom dataDefaultClass mtl network
+    transformers x509 x509Store x509Validation
   ];
   testDepends = [
-    cereal cprngAes cryptoPubkey cryptoRandom dataDefaultClass mtl
-    QuickCheck testFramework testFrameworkQuickcheck2 time x509
-    x509Validation
+    cereal cprngAes cryptoPubkey cryptoRandom dataDefaultClass
+    hourglass mtl QuickCheck tasty tastyQuickcheck x509 x509Validation
   ];
   doCheck = false;
   meta = {

pkgs/development/libraries/haskell/vty-ui/default.nix

···
     description = "An interactive terminal user interface library for Vty";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
+    broken = true;
   };
 })

pkgs/development/libraries/haskell/vty/4.7.5.nix

···
-# This file was auto-generated by cabal2nix. Please do NOT edit manually!
-
-{ cabal, Cabal, deepseq, mtl, parallel, parsec, QuickCheck, random
-, stringQq, terminfo, utf8String, vector
-}:
-
-cabal.mkDerivation (self: {
-  pname = "vty";
-  version = "4.7.5";
-  sha256 = "0ahd5qjszfw1xbl5jxhzfw31mny8hp8clw9qciv15xn442prvvpr";
-  isLibrary = true;
-  isExecutable = true;
-  buildDepends = [
-    deepseq mtl parallel parsec stringQq terminfo utf8String vector
-  ];
-  testDepends = [
-    Cabal deepseq mtl parallel parsec QuickCheck random terminfo
-    utf8String vector
-  ];
-  jailbreak = true;
-  doCheck = false;
-  meta = {
-    homepage = "https://github.com/coreyoconnor/vty";
-    description = "A simple terminal UI library";
-    license = self.stdenv.lib.licenses.bsd3;
-    platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-  };
-})

pkgs/development/libraries/haskell/vty/5.2.3.nix pkgs/development/libraries/haskell/vty/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "vty";
-  version = "5.2.3";
-  sha256 = "0afgysliv7bi3x46cj8bcmahfc1lz2niyfmvnzrf9brhxf7l9y76";
+  version = "5.2.4";
+  sha256 = "0dqp54sf6pl7magjhd91k87z50zi83x6w27kmyzp55112aiy7bf6";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/wai-app-static/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wai-app-static";
-  version = "3.0.0.1";
-  sha256 = "1xqw7xvbq38m19337vpalnz5c5mvc57mfp53vqbah3lalxy9mqby";
+  version = "3.0.0.2";
+  sha256 = "1y8x8gb60330mxzp649xp8dhancimmraf2h7py76wjmjp5vc5cx4";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/webkit/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "webkit";
-  version = "0.13.0.2";
-  sha256 = "1dagfc5v5ihg7hm8vkymg1jyhxqhlxb8f4bnbmjcv4sffbm9q14f";
+  version = "0.13.0.3";
+  sha256 = "0l05cg6krafpcfszcka03x7gay8wg1fhd0gpbn2cchfshfkicgxc";
   buildDepends = [ cairo glib gtk mtl pango text ];
   buildTools = [ gtk2hsBuildtools ];
   pkgconfigDepends = [ webkit ];

pkgs/development/libraries/haskell/x509-store/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
 { cabal, asn1Encoding, asn1Types, cryptoPubkeyTypes, filepath, mtl
-, pem, time, x509
+, pem, x509
 }:
 
 cabal.mkDerivation (self: {
   pname = "x509-store";
-  version = "1.4.4";
-  sha256 = "0i3hfrddr0wpfl75a76a1j24az08z4x7ya8l5qcdk7c1lr2c2bw8";
+  version = "1.5.0";
+  sha256 = "1w9sqb007s4avjzvrdwq13a4c528h7h2lg3m8cl31syrgznc9ny5";
   buildDepends = [
-    asn1Encoding asn1Types cryptoPubkeyTypes filepath mtl pem time x509
+    asn1Encoding asn1Types cryptoPubkeyTypes filepath mtl pem x509
   ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-certificate";

pkgs/development/libraries/haskell/x509-system/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, filepath, mtl, pem, time, x509, x509Store }:
+{ cabal, filepath, mtl, pem, x509, x509Store }:
 
 cabal.mkDerivation (self: {
   pname = "x509-system";
-  version = "1.4.6";
-  sha256 = "0h462dgc0jf88yfd4nx9xpqx5kfzc3z6ps8akw13pfy92xdxj28c";
-  buildDepends = [ filepath mtl pem time x509 x509Store ];
+  version = "1.5.0";
+  sha256 = "159zwg35nq42j1rl0p4x00hdf3iy48hd7kavz0rnpwd2p7ljamr3";
+  buildDepends = [ filepath mtl pem x509 x509Store ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-certificate";
     description = "Handle per-operating-system X.509 accessors and storage";

pkgs/development/libraries/haskell/x509-validation/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
 { cabal, asn1Encoding, asn1Types, byteable, cryptohash
-, cryptoPubkey, cryptoPubkeyTypes, dataDefaultClass, filepath, mtl
-, network, pem, time, x509, x509Store
+, cryptoPubkey, cryptoPubkeyTypes, dataDefaultClass, filepath
+, hourglass, mtl, network, pem, x509, x509Store
 }:
 
 cabal.mkDerivation (self: {
   pname = "x509-validation";
-  version = "1.5.0";
-  sha256 = "1xarn00ipi77whly5yjlpqa0xd25lj0jf4xk8ylp4ba58hvcxqrn";
+  version = "1.5.1";
+  sha256 = "19cp187id9hdlzkr7sbv2sdxqxnpjv0db09hwf3zdqqqxr30mn6x";
   buildDepends = [
     asn1Encoding asn1Types byteable cryptohash cryptoPubkey
-    cryptoPubkeyTypes dataDefaultClass filepath mtl network pem time
-    x509 x509Store
+    cryptoPubkeyTypes dataDefaultClass filepath hourglass mtl network
+    pem x509 x509Store
   ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-certificate";

pkgs/development/libraries/haskell/x509/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
 { cabal, asn1Encoding, asn1Parse, asn1Types, cryptohash
-, cryptoPubkeyTypes, filepath, HUnit, mtl, pem, QuickCheck
-, testFramework, testFrameworkHunit, testFrameworkQuickcheck2, time
+, cryptoPubkeyTypes, filepath, hourglass, mtl, pem, tasty
+, tastyQuickcheck
 }:
 
 cabal.mkDerivation (self: {
   pname = "x509";
-  version = "1.4.13";
-  sha256 = "1cl2ygk38jh803aplsg68q6njzb0wcd1syb182amxqn8jlwh8a7c";
+  version = "1.5.0.1";
+  sha256 = "03gj4190f0ql1ghn2mri8901xdydhhnwijyfn8lmpjyn7pgpl3ba";
   buildDepends = [
     asn1Encoding asn1Parse asn1Types cryptohash cryptoPubkeyTypes
-    filepath mtl pem time
+    filepath hourglass mtl pem
   ];
   testDepends = [
-    asn1Types cryptoPubkeyTypes HUnit mtl QuickCheck testFramework
-    testFrameworkHunit testFrameworkQuickcheck2 time
+    asn1Types cryptoPubkeyTypes hourglass mtl tasty tastyQuickcheck
   ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-certificate";

pkgs/development/libraries/haskell/xdot/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "xdot";
-  version = "0.2.4.4";
-  sha256 = "1bv2n1pzn58kqf9k5qbyzlkddhx2v2c9gc50c7q7yd7wxxpml7gi";
+  version = "0.2.4.5";
+  sha256 = "0dv9y5i3707pnx4c0gf9y3zv6p02az4rvspd84hprfvnhd8qfdcp";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ cairo graphviz gtk mtl polyparse text ];

pkgs/development/libraries/haskell/yesod-auth-hashdb/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, cryptohash, persistent, pwstoreFast, text, yesodAuth
-, yesodCore, yesodForm, yesodPersistent
+{ cabal, cryptohash, hspec, persistent, pwstoreFast, text
+, yesodAuth, yesodCore, yesodForm, yesodPersistent
 }:
 
 cabal.mkDerivation (self: {
   pname = "yesod-auth-hashdb";
-  version = "1.4.0";
-  sha256 = "0z6gfm1dk03ap2ra7b9wd2jcsnfazcpk6vxcsx94vmb3a9jqx22l";
+  version = "1.4.1";
+  sha256 = "11biiylg2366vymx37asr7ibw8migwnkf3nj6lx1i94ldvs9kfd4";
   buildDepends = [
     cryptohash persistent pwstoreFast text yesodAuth yesodCore
     yesodForm yesodPersistent
   ];
+  testDepends = [ hspec text ];
   meta = {
-    homepage = "http://www.yesodweb.com/";
+    homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";
     description = "Authentication plugin for Yesod";
     license = self.stdenv.lib.licenses.mit;
     platforms = self.ghc.meta.platforms;

pkgs/development/libraries/haskell/yesod-bin/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-bin";
-  version = "1.4.0.1";
-  sha256 = "062jr3g32rsljscq7bq9bgwwfx7vijx3cmhakwcxw17yh5405ks5";
+  version = "1.4.0.4";
+  sha256 = "1f05y5nh218c2r7d67r3lpxkbf6f6irhy7mg8pvbgy9yz90k0j8b";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/yesod-core/default.nix

···
 , caseInsensitive, cereal, clientsession, conduit, conduitExtra
 , cookie, dataDefault, deepseq, exceptions, fastLogger, hspec
 , httpTypes, HUnit, liftedBase, monadControl, monadLogger, mtl
-, network, parsec, pathPieces, QuickCheck, random, resourcet, safe
-, shakespeare, streamingCommons, text, time, transformers
-, transformersBase, unixCompat, unorderedContainers, vector, wai
-, waiExtra, waiLogger, warp
+, mwcRandom, network, parsec, pathPieces, primitive, QuickCheck
+, random, resourcet, safe, shakespeare, streamingCommons, text
+, time, transformers, transformersBase, unixCompat
+, unorderedContainers, vector, wai, waiExtra, waiLogger, warp
+, word8
 }:
 
 cabal.mkDerivation (self: {
   pname = "yesod-core";
-  version = "1.4.2";
-  sha256 = "0qi1shmbsi8vkxzvyzqzgmdapnbfkkjvhkshkmr7rrdhkdbnkbxl";
+  version = "1.4.3";
+  sha256 = "1mglavffzvav4dzwqq70agz5rd4bdb66p40qa445fq1dxwbwcq6i";
   buildDepends = [
     aeson blazeBuilder blazeHtml blazeMarkup caseInsensitive cereal
     clientsession conduit conduitExtra cookie dataDefault deepseq
     exceptions fastLogger httpTypes liftedBase monadControl monadLogger
-    mtl parsec pathPieces random resourcet safe shakespeare text time
-    transformers transformersBase unixCompat unorderedContainers vector
-    wai waiExtra waiLogger warp
+    mtl mwcRandom parsec pathPieces primitive random resourcet safe
+    shakespeare text time transformers transformersBase unixCompat
+    unorderedContainers vector wai waiExtra waiLogger warp word8
   ];
   testDepends = [
     async blazeBuilder conduit conduitExtra hspec httpTypes HUnit
-    liftedBase network pathPieces QuickCheck random resourcet
+    liftedBase mwcRandom network pathPieces QuickCheck random resourcet
     shakespeare streamingCommons text transformers wai waiExtra
   ];
   jailbreak = true;

pkgs/development/libraries/haskell/yesod-form/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-form";
-  version = "1.4.0.2";
-  sha256 = "1y2585pdph2vl42ig6fvzpyy1p3n4v1i1xqnlkb2cfsyssswh5d4";
+  version = "1.4.1";
+  sha256 = "034bgkr5fmfjbxwy6kkz36als51jyq0ksx8wknwxf7pr07zwbl3x";
   buildDepends = [
     aeson attoparsec blazeBuilder blazeHtml blazeMarkup byteable
     dataDefault emailValidate networkUri persistent resourcet

pkgs/development/libraries/libinput/default.nix

···
+{ stdenv, fetchurl, pkgconfig, mtdev, udev, libevdev }:
+
+stdenv.mkDerivation rec {
+  name = "libinput-0.6.0";
+
+  src = fetchurl {
+    url = "http://www.freedesktop.org/software/libinput/${name}.tar.xz";
+    sha256 = "1g5za42f60vw87982vjh0n6r78qajj34l323p7623fbw3rvmbd9h";
+  };
+
+  buildInputs = [ pkgconfig mtdev udev libevdev ];
+
+  meta = with stdenv.lib; {
+    homepage = http://www.freedesktop.org/wiki/Software/libinput;
+    description = "handles input devices in Wayland compositors and to provide a generic X.Org input driver";
+    platforms = platforms.unix;
+    license = licenses.mit;
+    maintainers = with maintainers; [ wkennington ];
+  };
+}

pkgs/development/libraries/libpcap/default.nix

···
   
   nativeBuildInputs = [ flex bison ];
   
-  # Apparently, 32 bit systems need this forced? Not verified if still needed.
-  configureFlags = stdenv.lib.optionals (stdenv.system == "i686-linux") "--with-pcap=linux";
+  configureFlags = stdenv.lib.optionals stdenv.isLinux "--with-pcap=linux";
 
   preInstall = ''mkdir -p $out/bin'';
   

pkgs/development/libraries/libqb/default.nix

···
 { stdenv, fetchurl, pkgconfig }:
 
 stdenv.mkDerivation rec{
-  name = "libqb-0.16.0";
+  name = "libqb-0.17.1";
 
   src = fetchurl {
     url = "https://fedorahosted.org/releases/q/u/quarterback/${name}.tar.xz";
-    sha256 = "0j3zl5g5nnx98jb16p89q8w61har3gbvnlnmma8yj31xngps3kdq";
+    sha256 = "0a9fy4hb6ixs875fbqw77dfj7519ixg27vg4yajyl87y7gw1a8bs";
   };
 
   buildInputs = [ pkgconfig ];

pkgs/development/libraries/mtdev/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "mtdev-1.1.2";
+  name = "mtdev-1.1.5";
 
   src = fetchurl {
     url = "http://bitmath.org/code/mtdev/${name}.tar.bz2";
-    sha256 = "0c2sfxxymf20ylvblgmdmybqs0cydmphg9fq6fnp6flbl0fd33b9";
+    sha256 = "0zxs7shzgbalkvlaiibi25bd902rbmkv9n1lww6q8j3ri9qdaxv6";
   };
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://bitmath.org/code/mtdev/;
-
     description = "Multitouch Protocol Translation Library";
-
     longDescription = ''
       The mtdev is a stand-alone library which transforms all variants of
       kernel MT events to the slotted type B protocol. The events put into
···
       tracking, type A with contact tracking, or type B with contact tracking.
       See the kernel documentation for further details. 
     '';
-
-    license = stdenv.lib.licenses.mit;
+    license = licenses.mit;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ wkennington ];
   };
 }

pkgs/development/libraries/pangomm/default.nix

···
   meta = with stdenv.lib; {
     description = "C++ interface to the Pango text rendering library";
     homepage    = http://www.pango.org/;
-    # TODO license     = with licenses; [ lgpl2 lgpl21 ];
+    license     = with licenses; [ lgpl2 lgpl21 ];
     maintainers = with maintainers; [ lovek323 raskin ];
     platforms   = platforms.unix;
 

pkgs/development/libraries/sqlite/default.nix

···
 assert readline != null -> ncurses != null;
 
 stdenv.mkDerivation {
-  name = "sqlite-3.8.4.3";
+  name = "sqlite-3.8.6";
 
   src = fetchurl {
-    url = "http://www.sqlite.org/2014/sqlite-autoconf-3080403.tar.gz";
-    sha1 = "zd9nqg1fc41222hvzvmvzr92z80b3wvh";
+    url = "http://www.sqlite.org/2014/sqlite-autoconf-3080600.tar.gz";
+    sha1 = "c4b2911bc4a6e1dc2b411aa21d8c4f524113eb64";
   };
 
   buildInputs = [ readline ncurses ];

pkgs/development/libraries/talloc/default.nix

···
   
   # https://bugzilla.samba.org/show_bug.cgi?id=7000
   postConfigure = if stdenv.isDarwin then ''
-    substituteInPlace "Makefile" --replace "SONAMEFLAG = #" "SONAMEFLAG = -install_name"
+    substituteInPlace "Makefile" --replace "SONAMEFLAG = #" "SONAMEFLAG = -Wl,-install_name,"
   '' else "";
 
   meta = {

pkgs/development/libraries/thrift/default.nix

···
   patches = [ ./yylex.patch ];
 
   # Workaround to make the python wrapper not drop this package:
-  # pythonFullBuildEnv.override { extraLibs = [ thrift ]; }
+  # pythonFull.buildEnv.override { extraLibs = [ thrift ]; }
   pythonPath = [];
 
   buildInputs = [

pkgs/development/libraries/tsocks/default.nix

···
 stdenv.mkDerivation rec {
   name = "tsocks-${version}";
   version = "1.8beta5";
-  
+
   src = fetchurl {
     url = "mirror://sourceforge/tsocks/${name}.tar.gz";
     sha256 = "0ixkymiph771dcdzvssi9dr2pk1bzaw9zv85riv3xl40mzspx7c4";
   };
+
+  patches = [ ./poll.patch ];
 
   preConfigure = ''
-      export configureFlags="$configureFlags --libdir=$out/lib"
+    sed -i -e "s,\\\/usr,"$(echo $out|sed -e "s,\\/,\\\\\\\/,g")",g" tsocks
+    substituteInPlace tsocks --replace /usr $out
+    export configureFlags="$configureFlags --libdir=$out/lib"
   '';
 
   meta = with stdenv.lib; {

pkgs/development/libraries/tsocks/poll.patch

···
+From Ingo Hadan <[e-mail]> Fri, 02 Apr 2010 21:08:50 +0200
+From: Julien Moutinho <[e-mail]>
+Date: Fri, 26 Apr 2013 01:57:26 +0200
+Subject: tsocks fails if socksified application uses poll(2) (e.g. subversion-1.5)
+
+---
+diff --git a/tsocks.c b/tsocks.c
+index 9cfdfff..470babd 100644
+--- a/tsocks.c
++++ b/tsocks.c
+@@ -657,10 +657,11 @@ int poll(POLL_SIGNATURE) {
+              * be ready for writing), otherwise we'll just let the select loop
+              * come around again (since we can't flag it for read, we don't know
+              * if there is any data to be read and can't be bothered checking) */
+-            if (conn->selectevents & WRITE) {
+-               setevents |= POLLOUT; 
++            if (conn->selectevents & POLLOUT) {
++               ufds[i].revents |= POLLOUT; 
+                nevents++;
+             }
++            ufds[i].events = conn->selectevents;
+          }
+       }
+    } while (nevents == 0);
+
+

pkgs/development/libraries/wayland/default.nix

···
 { stdenv, fetchurl, libffi, expat, pkgconfig, libxslt, docbook_xsl, doxygen }:
 
-let version = "1.5.0"; in
+let version = "1.6.0"; in
 
 stdenv.mkDerivation rec {
   name = "wayland-${version}";
 
   src = fetchurl {
     url = "http://wayland.freedesktop.org/releases/${name}.tar.xz";
-    sha256 = "1da179livkkmfsds32yhh4zflxn9qs6av023702kx2w8mzly2s80";
+    sha256 = "0zzwlrmxil10g9rvdgha0y1d8z0x97g65g14kl2qrl2krwni1md7";
   };
 
   buildInputs = [ pkgconfig libffi expat libxslt docbook_xsl doxygen ];

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

···
-{ stdenv, fetchurl, buildPythonPackage, pykickstart, pyparted, pyblock
-, libselinux, cryptsetup, multipath_tools, lsof, utillinux
-, useNixUdev ? true, udev ? null
-# This is only used when useNixUdev is false
-, udevSoMajor ? 1
+{ stdenv, fetchFromGitHub, buildPythonPackage, pykickstart, pyparted, pyblock
+, pyudev, six, libselinux, cryptsetup, multipath_tools, lsof, utillinux
 }:
-
-assert useNixUdev -> udev != null;
 
 let
   pyenable = { enablePython = true; };
···
   cryptsetupWithPython = cryptsetup.override pyenable;
 in buildPythonPackage rec {
   name = "blivet-${version}";
-  version = "0.17-1";
+  version = "0.67";
 
-  src = fetchurl {
-    url = "https://git.fedorahosted.org/cgit/blivet.git/snapshot/"
-        + "${name}.tar.bz2";
-    sha256 = "1k3mws2q0ryb7422mml6idmaasz2i2v6ngyvg6d976dx090qnmci";
+  src = fetchFromGitHub {
+    owner = "dwlehman";
+    repo = "blivet";
+    rev = name;
+    sha256 = "1gk94ghjrxfqnx53hph1j2s7qcv86fjz48is7l099q9c24rjv8ky";
   };
 
   postPatch = ''
-    sed -i -e 's|"multipath"|"${multipath_tools}/sbin/multipath"|' \
-      blivet/devicelibs/mpath.py blivet/devices.py
+    sed -i \
+      -e 's|"multipath"|"${multipath_tools}/sbin/multipath"|' \
+      -e '/^def set_friendly_names/a \    return False' \
+      blivet/devicelibs/mpath.py
     sed -i -e '/"wipefs"/ {
       s|wipefs|${utillinux}/sbin/wipefs|
       s/-f/--force/
     }' blivet/formats/__init__.py
     sed -i -e 's|"lsof"|"${lsof}/bin/lsof"|' blivet/formats/fs.py
     sed -i -r -e 's|"(u?mount)"|"${utillinux}/bin/\1"|' blivet/util.py
-    sed -i '/pvscan/s/, *"--cache"//' blivet/devicelibs/lvm.py
-  '' + (if useNixUdev then ''
-    sed -i -e '/find_library/,/find_library/ {
-      c libudev = "${udev}/lib/libudev.so.1"
-    }' blivet/pyudev.py
-  '' else ''
-    sed -i \
-      -e '/^somajor *=/s/=.*/= ${toString udevSoMajor}/p' \
-      -e 's|common =.*|& + ["/lib/x86_64-linux-gnu", "/lib/i686-linux-gnu"]|' \
-      blivet/pyudev.py
-  '');
+    sed -i -e '/pvscan/s/, *"--cache"//' blivet/devicelibs/lvm.py
+  '';
 
   propagatedBuildInputs = [
-    pykickstart pyparted pyblock selinuxWithPython cryptsetupWithPython
-  ] ++ stdenv.lib.optional useNixUdev udev;
+    pykickstart pyparted pyblock pyudev selinuxWithPython cryptsetupWithPython
+    six
+  ];
 
-  # tests are currently _heavily_ broken upstream
+  # Tests are in <nixos/tests/blivet.nix>.
   doCheck = false;
 
   meta = {

pkgs/development/python-modules/rhpl/builder.sh

···
 source $stdenv/setup
 
-rpm2cpio $src | cpio -idv
+rpmextract $src
 tar xfvj rhpl-*.tar.bz2
 rm rhpl-*.tar.bz2
 cd rhpl-*

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

···
-{stdenv, fetchurl, rpm, cpio, python, wirelesstools, gettext}:
+{stdenv, fetchurl, rpmextract, python, wirelesstools, gettext}:
 
 stdenv.mkDerivation {
   name = "rhpl-0.218";
···
   
   builder = ./builder.sh;
   
-  buildInputs = [ rpm cpio python wirelesstools gettext ];
+  buildInputs = [ rpmextract python wirelesstools gettext ];
 }

pkgs/development/tools/haskell/cabal-db/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "cabal-db";
-  version = "0.1.9";
-  sha256 = "19mw5ycc2y5wkn1h7wkdm2gb29pq2sh0n8z52dbxlkf0rwcgjbfq";
+  version = "0.1.10";
+  sha256 = "0j9xnf23zrpyrfkcx321rqbabzsm4208idpvfy7sdnnvw9a2k5xw";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [
···
   ];
   meta = {
     homepage = "http://github.com/vincenthz/cabal-db";
-    description = "query tools for the local cabal database (revdeps, graph, info, search-by, license, bounds)";
+    description = "query tools for the local cabal database";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    broken = true;
   };
 })

pkgs/development/tools/haskell/graphmod/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "graphmod";
-  version = "1.2.5";
-  sha256 = "1rmrsfvajzrak7jlhwnvhrgszgyg1b6z5wp21k0d7pv2cbfdkp8s";
+  version = "1.2.6";
+  sha256 = "02p1x44ywv2mb4l2dsz9z3ybnvv4nns3882lqm3nc8sw2hkib8z3";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [ dotgen filepath haskellLexer ];

pkgs/development/tools/haskell/hlint/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hlint";
-  version = "1.9.9";
-  sha256 = "193ls1pfycdl8ifq09y2acbhy2hjb2p8f79gjn13ziaycgfz9ygr";
+  version = "1.9.10";
+  sha256 = "08pfc0mhqkhali0hjxpa26hr5ykfdmyldh0r04v1b42a1c60k1id";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/tools/haskell/ihaskell/default.nix

···
   sha256 = "012rmasdc167w6gl18ysr53737j4p4afk0qcsv81hif92vvg5j1c";
   isLibrary = true;
   isExecutable = true;
-  patches = [ (fetchpatch { url = "https://github.com/gibiansky/IHaskell/pull/288.patch"; sha256 = "022zdz4wnyra6cfa7mq0w2ycsb007cvppn2f1360nr3fa5s9wibg"; }) ];
+  patches = [ (fetchpatch { url = "https://github.com/gibiansky/IHaskell/pull/296.patch"; sha256 = "1h9gxq9l3j949prcwqkdkrc3q3sxai4b345hfp5hfi0mhfbysfn6"; }) ];
   prePatch = ''
     tar xvf profile/profile.tar -C profile
     sed -i -e '1iexe = "'$out'/bin/IHaskell".replace(" ", "\\ ")\' profile/ipython_config.py
···
     description = "A Haskell backend kernel for the IPython project";
     license = licenses.mit;
     platforms = self.ghc.meta.platforms;
+    hydraPlatforms = self.stdenv.lib.platforms.none;
     maintainers = with maintainers; [ edwtjo ];
   };
 })

pkgs/development/tools/haskell/ihaskell/wrapper.nix

···
       --set GHC_PACKAGE_PATH "\$GHC_PACKAGE_PATH:" # always end with : to include base packages
   '';
 
-  meta = {
-    description = ihaskell.meta.description;
-  };
-}
+  inherit (ihaskell) meta;
+}

pkgs/development/tools/haskell/keter/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "keter";
-  version = "1.3.4";
-  sha256 = "127sv155kgwz64adylfn2dmpnqh833pa53lnc8ahhwa63xwf9pzk";
+  version = "1.3.5";
+  sha256 = "0jbf9x50gy9qja6gazh0lgyffz46a3wps6hbxppqmcicjhwbpvr5";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "cpphs";
-  version = "1.18.5";
-  sha256 = "0bqfz0wkfnxvv711fgmhmh6rbwffgna1pfqbj7whb6crqji9w7g7";
+  version = "1.18.6";
+  sha256 = "0ds712zabigswf3cljzh7f2ys4rl1fj2cf76lbw856adm8514gxc";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ polyparse ];

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

···
     homepage = http://lttng.org/;
     # liblttvtraceread (ltt/ directory) is distributed under the GNU LGPL v2.1.
     # The rest of the LTTV package is distributed under the GNU GPL v2.
-    # TODO license = with licenses; [ gpl2 lgpl21 ];
+    license = with licenses; [ gpl2 lgpl21 ];
     platforms = platforms.linux;
     maintainers = [ maintainers.bjornfor ];
   };

pkgs/development/tools/quilt/default.nix

···
     '';
 
     license = "GPLv2+";
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/development/web/nodejs/default.nix

···
 
   # !!! Should we also do shared libuv?
   deps = {
-    inherit openssl zlib http-parser;
+    inherit openssl zlib;
     cares = c-ares;
 
     # disabled system v8 because v8 3.14 no longer receives security fixes
     # we fall back to nodejs' internal v8 copy which receives backports for now
     # inherit v8
+  } // stdenv.lib.optionalAttrs (!stdenv.isDarwin) {
+    inherit http-parser;
   };
 
   sharedConfigureFlags = name: [

pkgs/development/web/twitter-bootstrap/default.nix

···
-{ stdenv, fetchgit, lessc, closurecompiler }:
+{ stdenv, fetchFromGitHub, lessc, closurecompiler }:
 
 stdenv.mkDerivation rec {
   name = "twitter-bootstrap-${version}";
   version = "2.3.2";
 
-  src = fetchgit {
-    url = https://github.com/twitter/bootstrap.git;
-    rev = "refs/tags/v${version}";
-    sha256 = "093z4yxqhrr30vna67ksxz3bq146q2xr05hinh78pg2ls88k77la";
+  src = fetchFromGitHub {
+    owner = "twitter";
+    repo = "bootstrap";
+    rev =  "v${version}";
+    sha256 = "0b4dsk9sqlkwwfgqqjlgi6p05qz2jssmmz4adm83f31sx70lgh4g";
   };  
 
   buildInputs = [ lessc closurecompiler ];

pkgs/games/chocolate-doom/default.nix

···
 { stdenv, autoconf, automake, pkgconfig, SDL, SDL_mixer, SDL_net, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "chocolate-doom-2.0.0";
+  name = "chocolate-doom-2.1.0";
   src = fetchurl {
-    url = https://github.com/chocolate-doom/chocolate-doom/archive/chocolate-doom-2.0.0.tar.gz;
-    sha256 = "1n9lkx97h987bq8z586jgissdhs07xyfr0xfdk7m2wpw4yhw10k1";
+    url = "https://github.com/chocolate-doom/chocolate-doom/archive/${name}.tar.gz";
+    sha256 = "1qwnc5j3n99jk35c487mxsij04m4kpkqzkbrb8qwqlsnqllyh1s1";
   };
   buildInputs = [ autoconf automake pkgconfig SDL SDL_mixer SDL_net ];
   patchPhase = ''

pkgs/games/chocolate-doom/master.nix

···
-{ stdenv, autoconf, automake, pkgconfig, SDL, SDL_mixer, SDL_net, git, fetchgit }:
-
-stdenv.mkDerivation rec {
-  name = "chocolate-doom-20141008";
-  src = fetchgit {
-    url = git://github.com/fragglet/chocolate-doom.git;
-    rev = "63e1c884911f9e3382936f84a388e941b29343e6";
-    sha256 = "1855a70widf1ni7lrfvp3hwxs1fhg1v5l738ckai88xpbak8i14m";
-  };
-  buildInputs = [ autoconf automake pkgconfig SDL SDL_mixer SDL_net git ];
-  patchPhase = ''
-    sed -e 's#/games#/bin#g' -i src{,/setup}/Makefile.am
-    ./autogen.sh --prefix=$out
-  '';
-
-  enableParallelBuilding = true;
-
-  meta = {
-    homepage = http://chocolate-doom.org/;
-    description = "A Doom source port that accurately reproduces the experience of Doom as it was played in the 1990s";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [ MP2E ];
-  };
-}

pkgs/misc/emulators/wine/unstable.nix

···
 assert stdenv.gcc.gcc != null;
 
 let
-    version = "1.7.28";
+    version = "1.7.29";
     name = "wine-${version}";
 
     src = fetchurl {
       url = "mirror://sourceforge/wine/${name}.tar.bz2";
-      sha256 = "04r3zk3dz2vzly2a4nqbcvppjs5iy3lq5ibx3wfrf877p5bz3hv7";
+      sha256 = "0qnyp1svzh2yyc3p34dg8hf21lwzxn4xkgpa3s0rfcak6l6ijj5f";
     };
 
     gecko = fetchurl {

pkgs/misc/vim-plugins/default.nix

···
-{ fetchurl, bash, stdenv, python, cmake, vim, perl, ruby, unzip, which, fetchgit, clang }:
+{ fetchurl, bash, stdenv, python, cmake, vim, perl, ruby, unzip, which, fetchgit, fetchzip, clang, zip }:
 
 /*
 About Vim and plugins
···
 of which files belong to what plugin. Now this problem is "fixed" by nix which
 assembles your profile for you.
 
-
 Vim offers the :h rtp setting which works for most plugins. Thus adding adding
 this to your .vimrc should make most plugins work:
 
-  set rtp+=~/.nix-profile/vim-plugins/YouCompleteMe
-  " or for p in ["YouCompleteMe"] | exec 'set rtp+=~/.nix-profile/vim-plugins/'.p | endfor
+  set rtp+=~/.nix-profile/vim-plugins/youcompleteme
+  " or for p in ["youcompleteme"] | exec 'set rtp+=~/.nix-profile/vim-plugins/'.p | endfor
 
 Its what pathogen, vundle, vim-addon-manager (VAM) use.
 
···
 
 So which plugins to add here according to what Marc Weber thinks is best?
 Complicated plugins requiring dependencies, such as YouCompleteMe.
-Then its best to symlink ~/.nix-profile/vim-plugins/YouCompleteMe to
+Then its best to symlink ~/.nix-profile/vim-plugins/youcompleteme to
 ~/.vim/{vim-addons,bundle} or whatever plugin management solution you use.
 
 If you feel differently change the comments and proceed.
···
     }
   '';
 
-  # install a simple standard vim plugin
-  simpleDerivation = a@{name, src, path, buildPhase ? "", ...} : stdenv.mkDerivation (a // {
+  buildVimPlugin = a@{name, namePrefix ? "vimplugin-", src, buildPhase ? "", ...}: stdenv.mkDerivation (a // {
+    name = namePrefix + name;
+
     inherit buildPhase;
 
-    installPhase = ''
+    installPhase = let path = (builtins.parseDrvName name).name; in ''
       target=$out/share/vim-plugins/${path}
       mkdir -p $out/share/vim-plugins
       cp -r . $target
···
 in rec
 
 {
+  a = buildVimPlugin {
+    name = "a-git-2010-11-06";
+    src = fetchgit {
+      url = "https://github.com/vim-scripts/a.vim.git";
+      rev = "2cbe946206ec622d9d8cf2c99317f204c4d41885";
+      sha256 = "ca0982873ed81e7f6545a6623b735104c574fe580d5f21b0aa3dc1557edac240";
+     };
+    meta = {
+      homepage = https://github.com/vim-scripts/a.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-  vimAddonNix = {
-    # github.com/MarcWeber/vim-addon-nix provides some additional support for
-    # editing .nix files
+  alternative = a; # backwards compat, added 2014-10-21
 
-    # This is a placeholder, because I think you always should be using latest
-    # git version. It also depends on some additional plugins (see addon-info.json)
+  airline = buildVimPlugin {
+    name = "airline-git-2014-10-18";
+    src = fetchgit {
+      url = "https://github.com/bling/vim-airline.git";
+      rev = "616daceb735771ed27535abe8a6e4907320f1e82";
+      sha256 = "05ee7f6d58b14c35edda36183745e508bab19d2289b02af73f980062e51316e7";
+     };
+    meta = {
+      homepage = https://github.com/bling/vim-airline; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  YouCompleteMe = stdenv.mkDerivation {
+  align = buildVimPlugin {
+    name = "align-git-2012-08-07";
     src = fetchgit {
-      url = "https://github.com/Valloric/YouCompleteMe.git";
-      rev = "a2cae90f7ba1746bf1209edd6739f87d5914b375";
-      sha256 = "1yxrxskxnr2da5awm59ra4s9wg67rimcbazvln9bayg9saxs540d";
+      url = "https://github.com/vim-scripts/align.git";
+      rev = "787662fe90cd057942bc5b682fd70c87e1a9dd77";
+      sha256 = "f7b5764357370f03546556bd45558837f3790b0e86afadb63cd04d714a668a29";
      };
+    meta = {
+      homepage = https://github.com/vim-scripts/align; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    name = "youcompleteme-20140929";  # commit date
-    buildInputs = [ python cmake clang.clang ];
+  calendar = buildVimPlugin {
+    name = "calendar-git-2014-10-19";
+    src = fetchgit {
+      url = "https://github.com/itchyny/calendar.vim.git";
+      rev = "44890a96d80bcd5fe62307e4bcb4d4085010e324";
+      sha256 = "55f38e3e0af0f95229c654420c332668f93ac941f044c0573c7f1b26030e9202";
+     };
+    meta = {
+      homepage = https://github.com/itchyny/calendar.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    configurePhase = ":";
+  coffee-script = buildVimPlugin {
+    name = "coffee-script-002";
+    src = fetchurl {
+      url = "https://github.com/vim-scripts/vim-coffee-script/archive/v002.tar.gz";
+      sha256 = "1xln6i6jbbihcyp5bsdylr2146y41hmp2xf7wi001g2ymj1zdsc0";
+    };
+  };
 
-    buildPhase = ''
-      patchShebangs .
+  coffeeScript = coffee-script; # backwards compat, added 2014-10-18
 
-      target=$out/share/vim-plugins/YouCompleteMe
-      mkdir -p $target
-      cp -a ./ $target
-
-      mkdir $target/build
-      cd $target/build
-      cmake -G "Unix Makefiles" . $target/third_party/ycmd/cpp -DPYTHON_LIBRARIES:PATH=${python}/lib/libpython2.7.so -DPYTHON_INCLUDE_DIR:PATH=${python}/include/python2.7 -DUSE_CLANG_COMPLETER=ON -DUSE_SYSTEM_LIBCLANG=ON
-      make ycm_support_libs -j''${NIX_BUILD_CORES} -l''${NIX_BUILD_CORES}}
-      ${bash}/bin/bash $target/install.sh --clang-completer --system-libclang
-
-      ${vimHelpTags}
-      vimHelpTags $target
-    '';
-
-    # TODO: implement proper install phase rather than keeping everything in store
-    # TODO: support llvm based C completion, See README of git repository
-    installPhase = ":";
-
-    path = "YouCompleteMe";
-
+  colors-solarized = buildVimPlugin {
+    name = "colors-solarized-git-2011-05-09";
+    src = fetchgit {
+      url = "https://github.com/altercation/vim-colors-solarized.git";
+      rev = "528a59f26d12278698bb946f8fb82a63711eec21";
+      sha256 = "a1b2ef696eee94dafa76431c31ee260acdd13a7cf87939f27eca431d5aa5a315";
+     };
     meta = {
-      description = "fastest non utf-8 aware word and C completion engine for Vim";
-      homepage = http://github.com/Valloric/YouCompleteMe;
-      license = stdenv.lib.licenses.gpl3;
-      maintainers = [stdenv.lib.maintainers.marcweber];
-      platforms = stdenv.lib.platforms.linux;
+      homepage = https://github.com/altercation/vim-colors-solarized; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
   };
 
-  syntastic = simpleDerivation rec {
-    version = "3.4.0";
-    name    = "vim-syntastic-${version}";
+  colorsamplerpack = buildVimPlugin rec {
+    version = "2012.10.28";
+    name    = "colorsamplerpack-${version}";
 
+    setSourceRoot = "sourceRoot=.";
     src = fetchurl {
-      url    = "https://github.com/scrooloose/syntastic/archive/${version}.tar.gz";
-      sha256 = "0h8vfs6icpfwc41qx6n6rc1m35haxp2gaswg9fhcki2w2ikp6knb";
+      url    = "http://www.vim.org/scripts/download_script.php?src_id=18915";
+      name   = "colorsamplerpack.zip";
+      sha256 = "1wsrb3vpqn9fncnalfpvc8r92wk1mcskm4shb3s2h9x5dyihf2rd";
     };
 
-    path = "syntastic";
-  };
-
-  coffeeScript = simpleDerivation {
-    name = "vim-coffee-script-v002";
-    src = fetchurl {
-      url = "https://github.com/vim-scripts/vim-coffee-script/archive/v002.tar.gz";
-      sha256 = "1xln6i6jbbihcyp5bsdylr2146y41hmp2xf7wi001g2ymj1zdsc0";
-    };
-    path = "vim-coffee-script";
+    buildInputs = [ unzip ];
   };
 
-  command_T = simpleDerivation rec {
+  command-t = buildVimPlugin rec {
     version = "1.8";
-    name = "vim-command-t-${version}";
-    src = fetchurl {
+    name = "command-t-${version}";
+    src = fetchzip {
+      inherit name;
       url    = "https://github.com/wincent/Command-T/archive/${version}.tar.gz";
-      sha256 = "ad8664292e6eee40fbe195d856d20d93a8630e8c0149317ad72cc39423630800";
+      sha256 = "186qz1smf7w91r68p724whg6d821f7ph6ks63l2vkhff8f9qqhrc";
     };
-    path = "Command-T";
     buildInputs = [ perl ruby ];
     buildPhase = ''
       pushd ruby/command-t
···
     '';
   };
 
-  eighties = simpleDerivation rec {
+  command_T = command-t; # backwards compat, added 2014-10-18
+
+  commentary = buildVimPlugin {
+    name = "commentary-git-2014-06-27";
+    src = fetchgit {
+      url = "https://github.com/tpope/vim-commentary.git";
+      rev = "8b4df6ca0ba9cd117d97a8fd26b44b2439d5e3f1";
+      sha256 = "5496ed31706552957d4caa76669ecd04e9b2853cf7a7e40bd0164726b21fcca0";
+     };
+    meta = {
+      homepage = https://github.com/tpope/vim-commentary; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
+
+  ctrlp = buildVimPlugin rec {
+    version = "1.79";
+    name    = "ctrlp-${version}";
+
+    setSourceRoot = "sourceRoot=.";
+    src = fetchurl {
+      url    = "http://www.vim.org/scripts/download_script.php?src_id=19448";
+      name   = "ctrlp_180.zip";
+      sha256 = "1x9im8g0g27mxc3c9k7v0jg5bb1dmnbjygmqif5bizab5g69n2mi";
+    };
+
+    buildInputs = [ unzip ];
+  };
+
+  easy-align = buildVimPlugin {
+    name = "easy-align-git-2014-10-03";
+    src = fetchgit {
+      url = "https://github.com/junegunn/vim-easy-align.git";
+      rev = "2595ebf9333f3598502276b29f78ad39965bc595";
+      sha256 = "1223b587c515169d4b735bf56f109f7bfc4f7c1327e76865f498309f7472ef78";
+     };
+    meta = {
+      homepage = https://github.com/junegunn/vim-easy-align; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
+
+  easymotion = buildVimPlugin {
+    name = "easymotion-git-2014-09-29";
+    src = fetchgit {
+      url = "https://github.com/lokaltog/vim-easymotion.git";
+      rev = "868cd71710a48e8ec8acffeabd1eebfb10812c77";
+      sha256 = "13c8b93c257fcbb0f6e0eb197700b4f8cbe4cf4846d29f1aba65f625202b9d77";
+     };
+    meta = {
+      homepage = https://github.com/lokaltog/vim-easymotion; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
+
+  eighties = buildVimPlugin rec {
     version = "1.0.4";
-    name = "vim-eighties-${version}";
+    name = "eighties-${version}";
     src = fetchurl {
       url    = "https://github.com/justincampbell/vim-eighties/archive/${version}.tar.gz";
       sha256 = "0cjd9hbg2qd7jjkvyi15f9ysp7m3aa2sg8nvbf80yb890rfkwaqr";
     };
-    path = "eighties";
     meta = with stdenv.lib; {
       description = "Automatically resizes your windows to 80 characters";
       homepage    = https://github.com/justincampbell/vim-eighties;
···
     };
   };
 
-  golang = simpleDerivation {
-    name = "vim-golang-20131127";
+  extradite = buildVimPlugin {
+    name = "extradite-git-2014-06-18";
     src = fetchgit {
-      url = "https://github.com/jnwhiteh/vim-golang.git";
-      rev = "832d64e5a813511ed52217aa24f0255c49671bab";
-      sha256 = "6858eb674be132477c5dc7f7d3cbe550371f90d1aba480547a614965412a7b3c";
-    };
-    path = "golang";
-    meta = with stdenv.lib; {
-      description = "Vim plugins for Go";
-      homepage    = https://github.com/jnwhiteh/vim-golang;
-      license     = licenses.publicDomain;
-      maintainers = with maintainers; [ lovek323 ];
-      platforms   = platforms.unix;
+      url = "https://github.com/int3/vim-extradite.git";
+      rev = "af4f3a51b6b654d655121b93c0cd9d8fe9a0c85d";
+      sha256 = "d1d29cfbc654134be383747f2cd6b14b7a87de75f997af6a041f14d7ef61ade6";
+     };
+    meta = {
+      homepage = https://github.com/int3/vim-extradite; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
   };
 
-  ipython = simpleDerivation {
-    name = "vim-ipython-ff8f88f3fe518851a91dc88aaa5a75f8f352a960";
-    src = fetchurl {
-      url    = "https://github.com/ivanov/vim-ipython/archive/ff8f88f3fe518851a91dc88aaa5a75f8f352a960.tar.gz";
-      sha256 = "0hlx526dm8amrvh41kwnmgvvdzs6sh5yc5sfq4nk1zjkfcp1ah5j";
-    };
-    path = "ipython";
-    meta = with stdenv.lib; {
-      description = "A two-way integration between vim and iPython";
-      homepage    = https://github.com/ivanov/vim-ipython;
-      repositories.git = https://github.com/ivanov/vim-ipython.git;
-      license     = licenses.publicDomain;
-      maintainers = with maintainers; [ lovek323 ];
-      platforms   = platforms.unix;
+  fugitive = buildVimPlugin {
+    name = "fugitive-git-2014-09-02";
+    src = fetchgit {
+      url = "https://github.com/tpope/vim-fugitive.git";
+      rev = "0374322ba5d85ae44dd9dc44ef31ca015a59097e";
+      sha256 = "3bb09693726c4f9fc1695bc8b40c45d64a6a0f1d9a4243b4a79add841013ad6c";
+     };
+    meta = {
+      homepage = https://github.com/tpope/vim-fugitive; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
   };
 
-  taglist = simpleDerivation {
-    name = "vim-taglist-4.6";
-    meta = with stdenv.lib; {
-      description = "Source code browser plugin";
-      homepage    = "http://www.vim.org/scripts/script.php?script_id=273";
-      license     = licenses.gpl3;
-      maintainers = with maintainers; [ lovek323 ];
-      platforms   = platforms.unix;
+  ghcmod-vim = buildVimPlugin {
+    name = "ghcmod-vim-git-2014-10-19";
+    src = fetchgit {
+      url = "https://github.com/eagletmt/ghcmod-vim.git";
+      rev = "d5c6c7f3c85608b5b76dc3e7e001f60b86c32cb9";
+      sha256 = "ab56d470ea18da3fae021e22bba14460505e61a94f8bf707778dff5eec51cd6d";
+     };
+    meta = {
+      homepage = https://github.com/eagletmt/ghcmod-vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
-    src = fetchurl {
-      url    = "http://www.vim.org/scripts/download_script.php?src_id=19574";
-      name   = "taglist_46.zip";
-      sha256 = "18cbv462vwg7vip2p99qlahm99hswav96cj4ki227kyi05q2lkjj";
+  };
+
+  gist-vim = buildVimPlugin {
+    name = "gist-vim-git-2014-10-19";
+    src = fetchgit {
+      url = "https://github.com/mattn/gist-vim.git";
+      rev = "9265aaa3fb3f090a292c3fb883eab4cea9d2a722";
+      sha256 = "2a1b6c589a60af7acd68f7686d1cbadc60a1da8a407b02d96f86ddfe8bc70c18";
+     };
+    buildInputs = [ zip ];
+    meta = {
+      homepage = https://github.com/mattn/gist-vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
-    setSourceRoot = ''
-      export sourceRoot=taglist
-      mkdir taglist
-      mv doc taglist
-      mv plugin taglist
-    '';
-    buildInputs = [ unzip ];
-    path = "taglist";
   };
 
-  tagbar = simpleDerivation rec {
-    version = "2.6.1";
-    name    = "vim-tagbar-${version}";
+  gitgutter = buildVimPlugin {
+    name = "gitgutter-git-2014-10-17";
+    src = fetchgit {
+      url = "https://github.com/airblade/vim-gitgutter.git";
+      rev = "39f011909620e0c7ae555efdace20c3963ac88af";
+      sha256 = "585c367c8cf72d7ef511b3beca3d1eae1d68bbd61b9a8d4dc7aea6e0caa4813a";
+     };
+    meta = {
+      homepage = https://github.com/airblade/vim-gitgutter; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    meta = with stdenv.lib; {
-      description = "A vim plugin for browsing the tags of source code files";
-      homepage    = https://github.com/majutsushi/tagbar;
-      license     = licenses.gpl3;
-      maintainers = with maintainers; [ lovek323 ];
-      platforms   = platforms.unix;
+  golang = buildVimPlugin {
+    name = "golang-git-2014-08-06";
+    src = fetchgit {
+      url = "https://github.com/jnwhiteh/vim-golang.git";
+      rev = "e6d0c6a72a66af2674b96233c4747661e0f47a8c";
+      sha256 = "1231a2eff780dbff4f885fcb4f656f7dd70597e1037ca800470de03bf0c5e7af";
+     };
+    meta = {
+      homepage = https://github.com/jnwhiteh/vim-golang; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    src = fetchurl {
-      url    = "https://github.com/majutsushi/tagbar/archive/v${version}.tar.gz";
-      sha256 = "c061a7e0a45a166f4558b31e6c47b9fd701f5fa1319527b65a268ea054dea5fb";
+  gundo = buildVimPlugin {
+    name = "gundo-git-2013-08-11";
+    src = fetchgit {
+      url = "https://github.com/vim-scripts/gundo.git";
+      rev = "f443470b96364c24a775629418a6b2562ec9173e";
+      sha256 = "b7a949167e59c936d6eae0d23635b87491b2cd2f46a197683b171d30165a90f9";
+     };
+    meta = {
+      homepage = https://github.com/vim-scripts/gundo; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    path = "tagbar";
+  hardtime = buildVimPlugin {
+    name = "hardtime-git-2014-10-21";
+    src = fetchgit {
+      url = "https://github.com/takac/vim-hardtime.git";
+      rev = "b401c72528d1c23e4cc9bc9585fda4361d0199bf";
+      sha256 = "65e4bda7531076147fc46f496c8e56c740d1fcf8fe85c18cb2d2070d0c3803cd";
+     };
+    meta = {
+      homepage = https://github.com/takac/vim-hardtime; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  xdebug = simpleDerivation {
-    name = "vim-xdebug-a4980fa65f7f159780593ee37c178281691ba2c4";
-    src = fetchurl {
-      url = "https://github.com/joonty/vim-xdebug/archive/a4980fa65f7f159780593ee37c178281691ba2c4.tar.gz";
-      sha256 = "1348gzp0zhc2wifvs5vmf92m9y8ik8ldnvy7bawsxahy8hmhiksk";
+  haskellconceal = buildVimPlugin {
+    name = "haskellconceal-git-2014-08-07";
+    src = fetchgit {
+      url = "https://github.com/twinside/vim-haskellconceal.git";
+      rev = "1d85e8f10b675d38ec117368ec8032f486c27f98";
+      sha256 = "8ae762939ea435333031a094f3c63e6edd534ac849f0008fa0440440f1f2f633";
+     };
+    meta = {
+      homepage = https://github.com/twinside/vim-haskellconceal; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
-    path = "xdebug";
-    postInstall = false;
   };
 
-  vimshell = simpleDerivation rec {
-    version = "9.2";
-    name = "vimshell-${version}";
+  haskellConceal = haskellconceal; # backwards compat, added 2014-10-18
 
-    meta = with stdenv.lib; {
-      description = "An extreme shell that doesn't depend on external shells and is written completely in Vim script";
-      homepage    = https://github.com/Shougo/vimshell.vim;
-      repositories.git = https://github.com/Shougo/vimshell.vim.git;
-      license     = licenses.gpl3;
-      maintainers = with maintainers; [ lovek323 ];
-      platforms   = platforms.unix;
+  hasksyn = buildVimPlugin {
+    name = "hasksyn-git-2014-09-03";
+    src = fetchgit {
+      url = "https://github.com/travitch/hasksyn.git";
+      rev = "c434040bf13a17ca20a551223021b3ace7e453b9";
+      sha256 = "b1a735928aeca7011b83133959d59b9c95ab8535fd00ce9968fae4c3b1381931";
+     };
+    meta = {
+      homepage = https://github.com/travitch/hasksyn; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    src = fetchurl {
-      url    = "https://github.com/Shougo/vimshell.vim/archive/ver.${version}.tar.gz";
-      sha256 = "1pbwxdhpv6pr09b6hwkgy7grpmpwlqpsgsawl38r40q6yib8zb4a";
+  hdevtools = buildVimPlugin {
+    name = "hdevtools-git-2012-12-29";
+    src = fetchgit {
+      url = "https://github.com/bitc/vim-hdevtools.git";
+      rev = "474947c52ff9c93dd36f3c49de90bd9a78f0baa1";
+      sha256 = "bf5f096b665c51ce611c6c1bfddc3267c4b2f94af84b04482b07272a6a5a92f3";
+     };
+    meta = {
+      homepage = https://github.com/bitc/vim-hdevtools; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    buildInputs = [ vimproc ];
+  hier = buildVimPlugin {
+    name = "hier-git-2011-08-27";
+    src = fetchgit {
+      url = "https://github.com/jceb/vim-hier.git";
+      rev = "0b8c365263551a67404ebd7e528c55e17c1d3de7";
+      sha256 = "f62836545abfe379f9c5410da28409947407cd282ef784b2db89aed0756a1785";
+     };
+    buildInputs = [ vim ];
+    meta = {
+      homepage = https://github.com/jceb/vim-hier; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    preBuild = ''
-      sed -ie '1 i\
-      set runtimepath+=${vimproc}/share/vim-plugins/vimproc\
-      ' autoload/vimshell.vim
-    '';
 
-    path = "vimshell";
+  hoogle = buildVimPlugin {
+    name = "hoogle-git-2013-11-26";
+    src = fetchgit {
+      url = "https://github.com/twinside/vim-hoogle.git";
+      rev = "81f28318b0d4174984c33df99db7752891c5c4e9";
+      sha256 = "0f96f3badb6218cac87d0f7027ff032ecc74f08ad3ada542898278ce11cbd5a0";
+     };
+    meta = {
+      homepage = https://github.com/twinside/vim-hoogle; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  vimproc = simpleDerivation rec {
-    version = "21a79bf4edca3ae97555df3fc729d208c7e19b9c";
-    name    = "vimproc-${version}";
+  idris-vim = buildVimPlugin {
+    name = "idris-vim-git-2014-10-14";
+    src = fetchgit {
+      url = "https://github.com/idris-hackers/idris-vim.git";
+      rev = "78730e511cae0a067f79da1168466601553f619b";
+      sha256 = "47638b25fa53203e053e27ec6f135fd63ae640edbe37e62d7450a8c434a4cc6b";
+     };
+    meta = {
+      homepage = https://github.com/idris-hackers/idris-vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    meta = with stdenv.lib; {
-      description = "An asynchronous execution library for Vim";
-      homepage    = https://github.com/Shougo/vimproc.vim;
-      repositories.git = https://github.com/Shougo/vimproc.vim.git;
-      license     = licenses.gpl3;
-      maintainers = with maintainers; [ lovek323 ];
-      platforms   = platforms.unix;
+  ipython = buildVimPlugin {
+    name = "ipython-git-2014-07-17";
+    src = fetchgit {
+      url = "https://github.com/ivanov/vim-ipython.git";
+      rev = "9ce4f201ce26e9f01d56a6040ddf9255aab27272";
+      sha256 = "444dede544f9b519143ecc3a6cdfef0c4c32043fc3cd69f92fdcd86c1010e824";
+     };
+    meta = {
+      homepage = https://github.com/ivanov/vim-ipython; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
+  latex-box = buildVimPlugin {
+    name = "latex-box-git-2014-10-05";
     src = fetchgit {
-      url = "https://github.com/Shougo/vimproc.vim.git";
-      rev = "${version}";
-      sha256 = "16mlrhmd1hq4rgg7bl9gajhb4nmn1x8jxfaxfwiy2bm1phgljgq0";
+      url = "https://github.com/latex-box-team/latex-box.git";
+      rev = "3e000fb161bdf6efe7aef517aef276554aeabb65";
+      sha256 = "462803aceec5904943074e11888482ef6c49c8a5e26d6728ebcb2c4f5dbbb6a4";
      };
+    meta = {
+      homepage = https://github.com/latex-box-team/latex-box; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    buildInputs = [ which ];
+  latex-live-preview = buildVimPlugin {
+    name = "latex-live-preview-git-2013-11-25";
+    src = fetchgit {
+      url = "https://github.com/xuhdev/vim-latex-live-preview.git";
+      rev = "18625ceca4de5984f3df50cdd0202fc13eb9e37c";
+      sha256 = "261852d3830189a50176f997a4c6b4ec7e25893c5b7842a3eb57eb7771158722";
+     };
+    meta = {
+      homepage = https://github.com/xuhdev/vim-latex-live-preview; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    buildPhase = ''
-      sed -i 's/vimproc_mac\.so/vimproc_unix\.so/' autoload/vimproc.vim
-      make -f make_unix.mak
-    '';
+  lushtags = buildVimPlugin {
+    name = "lushtags-git-2013-12-27";
+    src = fetchgit {
+      url = "https://github.com/bitc/lushtags.git";
+      rev = "429fab3b748ae04ee5de0cbf75d947f15441e798";
+      sha256 = "5170019fbe64b15be30a0ba82e6b01364d115ccad6ef690a6df86f73af22a0a7";
+     };
+    meta = {
+      homepage = https://github.com/bitc/lushtags; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    path = "vimproc";
+  neco-ghc = buildVimPlugin {
+    name = "neco-ghc-git-2014-10-17";
+    src = fetchgit {
+      url = "https://github.com/eagletmt/neco-ghc.git";
+      rev = "fffdf57dcb312f874a43a202157b5efecfe3d9de";
+      sha256 = "464b24e3151ebaf0e95c25f09cb047e2542d5dd9100087e538d0a5e46bd0e638";
+     };
+    meta = {
+      homepage = https://github.com/eagletmt/neco-ghc; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  colorsamplerpack = simpleDerivation rec {
-    version = "2012.10.28";
-    name    = "vim-colorsamplerpack-${version}";
+  necoGhc = neco-ghc; # backwards compat, added 2014-10-18
 
-    setSourceRoot = "sourceRoot=.";
-    src = fetchurl {
-      url    = "http://www.vim.org/scripts/download_script.php?src_id=18915";
-      name   = "colorsamplerpack.zip";
-      sha256 = "1wsrb3vpqn9fncnalfpvc8r92wk1mcskm4shb3s2h9x5dyihf2rd";
+  nerdcommenter = buildVimPlugin {
+    name = "nerdcommenter-git-2014-07-08";
+    src = fetchgit {
+      url = "https://github.com/scrooloose/nerdcommenter.git";
+      rev = "6549cfde45339bd4f711504196ff3e8b766ef5e6";
+      sha256 = "ef270ae5617237d68b3d618068e758af8ffd8d3ba27a3799149f7a106cfd178e";
+     };
+    meta = {
+      homepage = https://github.com/scrooloose/nerdcommenter; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    buildInputs = [ unzip ];
+  nerdtree = buildVimPlugin {
+    name = "nerdtree-git-2014-08-06";
+    src = fetchgit {
+      url = "https://github.com/scrooloose/nerdtree.git";
+      rev = "4f1e6ecb057fc0bac189171c1430d71ef25f6bb1";
+      sha256 = "67ff2e7b9a7f39e58e9e334b1b79343a4c11aae10a657ab4fece289d8fe59300";
+     };
+    meta = {
+      homepage = https://github.com/scrooloose/nerdtree; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    path = "colorsamplerpack";
+  pathogen = buildVimPlugin {
+    name = "pathogen-git-2014-07-19";
+    src = fetchgit {
+      url = "https://github.com/tpope/vim-pathogen.git";
+      rev = "91e6378908721d20514bbe5d18d292a0a15faf0c";
+      sha256 = "24c1897d6b58576b2189c90050a7f8ede72a51343c752e9d030e833dbe5cac6f";
+     };
+    meta = {
+      homepage = https://github.com/tpope/vim-pathogen; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  yankring = simpleDerivation rec {
-    version = "18.0";
-    name    = "vim-yankring-${version}";
+  quickfixstatus = buildVimPlugin {
+    name = "quickfixstatus-git-2011-09-02";
+    src = fetchgit {
+      url = "https://github.com/dannyob/quickfixstatus.git";
+      rev = "fd3875b914fc51bbefefa8c4995588c088163053";
+      sha256 = "7b6831d5da1c23d95f3158c67e4376d32c2f62ab2e30d02d3f3e14dcfd867d9b";
+     };
+    meta = {
+      homepage = https://github.com/dannyob/quickfixstatus; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    setSourceRoot = "sourceRoot=.";
-    src = fetchurl {
-      url    = "http://www.vim.org/scripts/download_script.php?src_id=20842";
-      name   = "yankring_180.zip";
-      sha256 = "0bsq4pxagy12jqxzs7gcf25k5ahwif13ayb9k8clyhm0jjdkf0la";
+  quickrun = buildVimPlugin {
+    name = "quickrun-git-2014-10-08";
+    src = fetchgit {
+      url = "https://github.com/thinca/vim-quickrun.git";
+      rev = "ae97cef42ae142306e9431dce9ab97c4353e5254";
+      sha256 = "3219fadb3732c895c82b8bcff1d6e86f0917cd5ac7bf34180c27bb3f75ed1787";
+     };
+    meta = {
+      homepage = https://github.com/thinca/vim-quickrun; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    buildInputs = [ unzip ];
 
-    path = "yankring";
+  rainbow_parentheses = buildVimPlugin {
+    name = "rainbow_parentheses-git-2013-03-04";
+    src = fetchgit {
+      url = "https://github.com/kien/rainbow_parentheses.vim.git";
+      rev = "eb8baa5428bde10ecc1cb14eed1d6e16f5f24695";
+      sha256 = "47975a426d06f41811882691d8a51f32bc72f590477ed52b298660486b2488e3";
+     };
+    meta = {
+      homepage = https://github.com/kien/rainbow_parentheses.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  ctrlp = simpleDerivation rec {
-    version = "1.79";
-    name    = "vim-ctrlp-${version}";
+  rust = buildVimPlugin {
+    name = "rust-git-2014-10-15";
+    src = fetchgit {
+      url = "https://github.com/wting/rust.vim.git";
+      rev = "aaeb7b51f1b188fb1edc29c3a3824053b3e5e265";
+      sha256 = "be858b1e2cb0b37091a3d79a51e264b3101229b007cfc16bcd28c740f3823c01";
+     };
+    meta = {
+      homepage = https://github.com/wting/rust.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
+  };
 
-    setSourceRoot = "sourceRoot=.";
-    src = fetchurl {
-      url    = "http://www.vim.org/scripts/download_script.php?src_id=19448";
-      name   = "ctrlp_180.zip";
-      sha256 = "1x9im8g0g27mxc3c9k7v0jg5bb1dmnbjygmqif5bizab5g69n2mi";
+  shabadou = buildVimPlugin {
+    name = "shabadou-git-2014-07-27";
+    src = fetchgit {
+      url = "https://github.com/osyo-manga/shabadou.vim.git";
+      rev = "c5af30bb0c028d53cfd89e00cab636c844034a9a";
+      sha256 = "392efa8a5e725219e478b571d9a30ddba88d47662467ed3123a168e8b55c4de6";
+     };
+    meta = {
+      homepage = https://github.com/osyo-manga/shabadou.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
+  };
 
-    buildInputs = [ unzip ];
-
-    path = "ctrlp";
+  stylish-haskell = buildVimPlugin {
+    name = "stylish-haskell-git-2014-07-14";
+    src = fetchgit {
+      url = "https://github.com/nbouscal/vim-stylish-haskell.git";
+      rev = "453fd203aee3d7305ea8e4088ff53bd1f5933d75";
+      sha256 = "c0e5010e1e8e56b179ce500387afb569f051c45b37ce92feb4350f293df96a8c";
+     };
+    meta = {
+      homepage = https://github.com/nbouscal/vim-stylish-haskell; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  alternate = stdenv.mkDerivation rec {
-    version = "2.18";
-    name    = "vim-a-${version}";
+  stylishHaskell = stylish-haskell; # backwards compat, added 2014-10-18
 
-    src = fetchurl {
-      url    = "http://www.vim.org/scripts/download_script.php?src_id=7218";
-      name   = "a.vim";
-      sha256 = "1q22vfkv60sshp9yj3mmfc8azavgzz7rpmaf72iznzq4wccy6gac";
+  supertab = buildVimPlugin {
+    name = "supertab-git-2014-10-17";
+    src = fetchgit {
+      url = "https://github.com/ervandew/supertab.git";
+      rev = "fd4e0d06c2b1d9bff2eef1d15e7895b3b4da7cd7";
+      sha256 = "5919521b95519d4baa8ed146c340ca739fa7f31dfd305c74ca0ace324ba93d74";
+     };
+    buildInputs = [ vim ];
+    meta = {
+      homepage = https://github.com/ervandew/supertab; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
     };
-    unpackPhase = ":";
-    installPhase = ''
-      mkdir -p $out/share/vim-plugins/vim-a
-      cp ${src} $out/share/vim-plugins/vim-a/a.vim
-    '';
   };
 
-  vundle = simpleDerivation {
-    name = "vundle-vim-git-0b28e334";
+  surround = buildVimPlugin {
+    name = "surround-git-2014-07-26";
     src = fetchgit {
-      url = "https://github.com/gmarik/Vundle.vim.git";
-      rev = "0b28e334e65b6628b0a61c412fcb45204a2f2bab";
-      sha256 = "9681d471d1391626cb9ad22b2b469003d9980cd23c5c3a8d34666376447e6204";
+      url = "https://github.com/tpope/vim-surround.git";
+      rev = "fa433e0b7330753688f715f3be5d10dc480f20e5";
+      sha256 = "5f01daf72d23fc065f4e4e8eac734275474f32bfa276a9d90ce0d20dfe24058d";
      };
-    path = "vundle";
+    meta = {
+      homepage = https://github.com/tpope/vim-surround; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  tslime = simpleDerivation {
-    name = "tslime-vim-git-e801a32b";
+  signature = buildVimPlugin {
+    name = "signature-git-2014-10-17";
     src = fetchgit {
-      url = "https://github.com/jgdavey/tslime.vim.git";
-      rev = "e801a32b27d83cb5d91afbf7c3d71bb6220f32bd";
-      sha256 = "47fb7165c1dcc444285cdff6fa89bbd4ace82ca79ec14ba0da6091c5f78d1251";
+      url = "https://github.com/kshenoy/vim-signature.git";
+      rev = "f012d6f4d288ef6006f61b06f5240bc461a1f89e";
+      sha256 = "bef5254e343758d609856c745fe9d83639546f3af4ca50542429c1cb91ab577a";
      };
-    path = "tslime";
+    meta = {
+      homepage = https://github.com/kshenoy/vim-signature; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  supertab = simpleDerivation {
-    name = "supertab-git-23db5585";
+  syntastic = buildVimPlugin {
+    name = "syntastic-git-2014-10-17";
     src = fetchgit {
-      url = "https://github.com/ervandew/supertab.git";
-      rev = "23db558596d4a73e4afa8fbedcde23b95bf72251";
-      sha256 = "21fa675969f4cfd2686ab3b63cba632fa55d62481e61d36193403bea9c02ebde";
+      url = "https://github.com/scrooloose/syntastic.git";
+      rev = "77c125170aa6b8c553d58f876021b0cedd8ac820";
+      sha256 = "ec9b1e22134cb16d07bef842be26b4f1f74a9f8b9a0afd9ab771ff79935920af";
      };
-    path = "supertab";
-    buildInputs = [ vim ];
+    meta = {
+      homepage = https://github.com/scrooloose/syntastic; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  fugitive = simpleDerivation {
-    name = "vim-fugitive-git-90ee6fb5";
+  table-mode = buildVimPlugin {
+    name = "table-mode-git-2014-09-17";
     src = fetchgit {
-      url = "https://github.com/tpope/vim-fugitive.git";
-      rev = "90ee6fb5d255d14d9f12f2469f92ee50149f5b44";
-      sha256 = "0297512f7fee62af601a99a68617591ecb2e244475ff0d79ebee9c7e6eff2eaf";
+      url = "https://github.com/dhruvasagar/vim-table-mode.git";
+      rev = "ef0eef0f35f2ca172907f6d696dc8859acd8a0da";
+      sha256 = "0377059972580f621f1bb4b35738e0e00d386b23d839115e8c5fa8fd3acbc98d";
      };
-    path = "fugitive";
+    meta = {
+      homepage = https://github.com/dhruvasagar/vim-table-mode; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  extradite = simpleDerivation {
-    name = "vim-extradite-git-af4f3a51";
+  tabmerge = buildVimPlugin {
+    name = "tabmerge-git-2010-10-17";
     src = fetchgit {
-      url = "https://github.com/int3/vim-extradite.git";
-      rev = "af4f3a51b6b654d655121b93c0cd9d8fe9a0c85d";
-      sha256 = "d1d29cfbc654134be383747f2cd6b14b7a87de75f997af6a041f14d7ef61ade6";
+      url = "https://github.com/vim-scripts/tabmerge.git";
+      rev = "074e5f06f26e7108a0570071a0f938a821768c06";
+      sha256 = "b84501b0fc5cd51bbb58f12f4c2b3a7c97b03fe2a76446b56a2c111bd4f7335f";
      };
-    path = "extradite";
+    meta = {
+      homepage = https://github.com/vim-scripts/tabmerge; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  nerdtree = simpleDerivation {
-    name = "nerdtree-git-4f1e6ecb";
+  tabular = buildVimPlugin {
+    name = "tabular-git-2013-05-16";
     src = fetchgit {
-      url = "https://github.com/scrooloose/nerdtree.git";
-      rev = "4f1e6ecb057fc0bac189171c1430d71ef25f6bb1";
-      sha256 = "67ff2e7b9a7f39e58e9e334b1b79343a4c11aae10a657ab4fece289d8fe59300";
+      url = "https://github.com/godlygeek/tabular.git";
+      rev = "60f25648814f0695eeb6c1040d97adca93c4e0bb";
+      sha256 = "28c860ad621587f2c3213fae47d1a3997746527c17d51e9ab94c209eb7bfeb0f";
      };
-    path = "nerdtree";
+    meta = {
+      homepage = https://github.com/godlygeek/tabular; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  airline = simpleDerivation {
-    name = "vim-airline-git-2114e702";
+  tagbar = buildVimPlugin {
+    name = "tagbar-git-2014-10-14";
     src = fetchgit {
-      url = "https://github.com/bling/vim-airline.git";
-      rev = "2114e7025188a941e5c63b1f942d576adb98d8a4";
-      sha256 = "b6fc4d0545f8b7e107c5f80b94cf536a2b1fdd55d9f2484a29a007911e96130f";
+      url = "https://github.com/majutsushi/tagbar.git";
+      rev = "64e935fe5812d3b7022aba1dee63ec9f7456b02f";
+      sha256 = "2a66b86328e395bd594c8673a6420307a32468e4040dafe2b877ad4afcf6b7f9";
      };
-    path = "airline";
+    meta = {
+      homepage = https://github.com/majutsushi/tagbar; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  ultisnips = simpleDerivation {
-    name = "ultisnips-git-279d6e63";
+  taglist = buildVimPlugin {
+    name = "taglist-4.6";
+    meta = with stdenv.lib; {
+      description = "Source code browser plugin";
+      homepage    = "http://www.vim.org/scripts/script.php?script_id=273";
+      license     = licenses.gpl3;
+      maintainers = with maintainers; [ lovek323 ];
+      platforms   = platforms.unix;
+    };
+    src = fetchurl {
+      url    = "http://www.vim.org/scripts/download_script.php?src_id=19574";
+      name   = "taglist_46.zip";
+      sha256 = "18cbv462vwg7vip2p99qlahm99hswav96cj4ki227kyi05q2lkjj";
+    };
+    setSourceRoot = ''
+      export sourceRoot=taglist
+      mkdir taglist
+      mv doc taglist
+      mv plugin taglist
+    '';
+    buildInputs = [ unzip ];
+  };
+
+  thumbnail = buildVimPlugin {
+    name = "thumbnail-git-2014-07-24";
     src = fetchgit {
-      url = "https://github.com/SirVer/ultisnips.git";
-      rev = "279d6e63c9a8dbaa20ffc43c3c5f057dfc8f1121";
-      sha256 = "f8d93849ef2bce798aa599ba860694ced37d12450010a48dd6bd3004bc52b503";
+      url = "https://github.com/itchyny/thumbnail.vim.git";
+      rev = "e59a1791862ed470510a58456cc001226e177a39";
+      sha256 = "f36d915804e36b5f2dcea7db481da97ec60d0c90df87599a5d5499e649d97f66";
      };
-    path = "ultisnips";
+    meta = {
+      homepage = https://github.com/itchyny/thumbnail.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  align = simpleDerivation {
-    name = "align-git-787662fe";
+  tmux-navigator = buildVimPlugin {
+    name = "tmux-navigator-git-2014-09-09";
     src = fetchgit {
-      url = "https://github.com/vim-scripts/Align.git";
-      rev = "787662fe90cd057942bc5b682fd70c87e1a9dd77";
-      sha256 = "f7b5764357370f03546556bd45558837f3790b0e86afadb63cd04d714a668a29";
+      url = "https://github.com/christoomey/vim-tmux-navigator.git";
+      rev = "195cdf087fea7beaf6274d0a655d157dfab3130c";
+      sha256 = "4235c2bfb64a9094b854cdd7303a64bbb994717f24704911c4b358b2373dfaa9";
      };
-    path = "align";
+    meta = {
+      homepage = https://github.com/christoomey/vim-tmux-navigator; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  gundo = simpleDerivation {
-    name = "gundo-git-f443470b";
+  tmuxNavigator = tmux-navigator; # backwards compat, added 2014-10-18
+
+  tslime = buildVimPlugin {
+    name = "tslime-git-2014-06-12";
     src = fetchgit {
-      url = "https://github.com/vim-scripts/Gundo.git";
-      rev = "f443470b96364c24a775629418a6b2562ec9173e";
-      sha256 = "b7a949167e59c936d6eae0d23635b87491b2cd2f46a197683b171d30165a90f9";
+      url = "https://github.com/jgdavey/tslime.vim.git";
+      rev = "e801a32b27d83cb5d91afbf7c3d71bb6220f32bd";
+      sha256 = "47fb7165c1dcc444285cdff6fa89bbd4ace82ca79ec14ba0da6091c5f78d1251";
      };
-    path = "gundo";
+    meta = {
+      homepage = https://github.com/jgdavey/tslime.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  commentary = simpleDerivation {
-    name = "vim-commentary-git-8b4df6ca";
+  ultisnips = buildVimPlugin {
+    name = "ultisnips-git-2014-10-11";
     src = fetchgit {
-      url = "https://github.com/tpope/vim-commentary.git";
-      rev = "8b4df6ca0ba9cd117d97a8fd26b44b2439d5e3f1";
-      sha256 = "5496ed31706552957d4caa76669ecd04e9b2853cf7a7e40bd0164726b21fcca0";
+      url = "https://github.com/sirver/ultisnips.git";
+      rev = "1ad970379edaec1a386bab5ff26c385b9e89a0ff";
+      sha256 = "5d6858a153d79f596513d01d4ed9cd6dcff853e2c42c4b4546d38bd15423af98";
      };
-    path = "commentary";
+    meta = {
+      homepage = https://github.com/sirver/ultisnips; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  tabular = simpleDerivation {
-    name = "tabular-git-60f25648";
+  undotree = buildVimPlugin {
+    name = "undotree-git-2014-09-17";
     src = fetchgit {
-      url = "https://github.com/godlygeek/tabular.git";
-      rev = "60f25648814f0695eeb6c1040d97adca93c4e0bb";
-      sha256 = "28c860ad621587f2c3213fae47d1a3997746527c17d51e9ab94c209eb7bfeb0f";
+      url = "https://github.com/mbbill/undotree.git";
+      rev = "14655d87774b1f35b5bd23c6de64f535d90ed48d";
+      sha256 = "ad55b88db051f57d0c7ddc226a7b7778daab58fa67dc8ac1d78432c0e7d38520";
      };
-    path = "tabular";
+    meta = {
+      homepage = https://github.com/mbbill/undotree; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  vim2hs = simpleDerivation {
-    name = "vim2hs-git-f2afd557";
+  vim2hs = buildVimPlugin {
+    name = "vim2hs-git-2014-04-16";
     src = fetchgit {
       url = "https://github.com/dag/vim2hs.git";
       rev = "f2afd55704bfe0a2d66e6b270d247e9b8a7b1664";
       sha256 = "485fc58595bb4e50f2239bec5a4cbb0d8f5662aa3f744e42c110cd1d66b7e5b0";
      };
-    path = "vim2hs";
+    meta = {
+      homepage = https://github.com/dag/vim2hs; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  hasksyn = simpleDerivation {
-    name = "hasksyn-git-175cd460";
+  vimoutliner = buildVimPlugin {
+    name = "vimoutliner-git-2014-10-20";
     src = fetchgit {
-      url = "https://github.com/travitch/hasksyn.git";
-      rev = "175cd4605afa5d9b9c75758112c8159fd118c631";
-      sha256 = "3488e38d1f45a9a3363da62c1c946591621151a0a9cdaedd22b3fe8f666bbdb9";
+      url = "https://github.com/vimoutliner/vimoutliner.git";
+      rev = "4e924d9e42b6955a696e087d22795f5fe0e6c857";
+      sha256 = "6a9a27526c51202fb15374b40c5a759df0e10977dbe3045dabef0439c3e62c72";
      };
-    path = "hasksyn";
+    meta = {
+      homepage = https://github.com/vimoutliner/vimoutliner; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  haskellConceal = simpleDerivation {
-    name = "vim-haskellConceal-git-73a8d712";
+  vimproc = buildVimPlugin {
+    name = "vimproc-git-2014-10-03";
     src = fetchgit {
-      url = "https://github.com/begriffs/vim-haskellConceal.git";
-      rev = "73a8d712d3342b2ffdc087b12924f1cf81053860";
-      sha256 = "be60ca030e2d39e972a8c71c0ab3b75b893589d26d5dd78a20cd6779f1f5cfa8";
+      url = "https://github.com/shougo/vimproc.vim.git";
+      rev = "3e055023dfab4f5a4dfa05a834f9d0cb7294a82e";
+      sha256 = "63c2786897e8315eed2473822879b7ceb847e6021695a861892d7b9ab15a69fb";
      };
-    path = "haskellConceal";
-  };
+    buildInputs = [ which ];
+
+    buildPhase = ''
+      sed -i 's/vimproc_mac\.so/vimproc_unix\.so/' autoload/vimproc.vim
+      make -f make_unix.mak
+    '';
 
-  ghcmod = simpleDerivation {
-    name = "ghcmod-vim-git-0c4e9428";
-    src = fetchgit {
-      url = "https://github.com/eagletmt/ghcmod-vim.git";
-      rev = "0c4e94281e57c475752e799adc261f7d5e4ab124";
-      sha256 = "f6a085f7b8198747fae3fff0bc38e4d030e5c97aaeb84958fbf96fa658bbe862";
-     };
-    patches = [ (fetchurl { url = "https://github.com/eagletmt/ghcmod-vim/pull/57.diff"; md5 = "cafbb9f725afbba26b52b6c3344ee89a"; }) ];
-    path = "ghcmod";
+    meta = {
+      homepage = https://github.com/shougo/vimproc.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  necoGhc = simpleDerivation {
-    name = "neco-ghc-git-0311f31b";
-    src = fetchgit {
-      url = "https://github.com/eagletmt/neco-ghc.git";
-      rev = "0311f31b3acaccec5b651ae7089d627a3a49239b";
-      sha256 = "302f29f54c56e9cee647745a8355aeafe323c4efe2f3593d5e4f586acc1c06a5";
-     };
-    path = "neco-ghc";
+  vimshell = buildVimPlugin rec {
+    version = "9.2";
+    name = "vimshell-${version}";
+
+    meta = with stdenv.lib; {
+      description = "An extreme shell that doesn't depend on external shells and is written completely in Vim script";
+      homepage    = https://github.com/Shougo/vimshell.vim;
+      repositories.git = https://github.com/Shougo/vimshell.vim.git;
+      license     = licenses.gpl3;
+      maintainers = with maintainers; [ lovek323 ];
+      platforms   = platforms.unix;
+    };
+
+    src = fetchurl {
+      url    = "https://github.com/Shougo/vimshell.vim/archive/ver.${version}.tar.gz";
+      sha256 = "1pbwxdhpv6pr09b6hwkgy7grpmpwlqpsgsawl38r40q6yib8zb4a";
+    };
+
+    buildInputs = [ vimproc ];
+
+    preBuild = ''
+      sed -ie '1 i\
+      set runtimepath+=${vimproc}/share/vim-plugins/vimproc\
+      ' autoload/vimshell.vim
+    '';
   };
 
-  hoogle = simpleDerivation {
-    name = "vim-hoogle-git-81f28318";
+  vundle = buildVimPlugin {
+    name = "vundle-git-2014-07-18";
     src = fetchgit {
-      url = "https://github.com/Twinside/vim-hoogle.git";
-      rev = "81f28318b0d4174984c33df99db7752891c5c4e9";
-      sha256 = "0f96f3badb6218cac87d0f7027ff032ecc74f08ad3ada542898278ce11cbd5a0";
+      url = "https://github.com/gmarik/vundle.vim.git";
+      rev = "0b28e334e65b6628b0a61c412fcb45204a2f2bab";
+      sha256 = "9681d471d1391626cb9ad22b2b469003d9980cd23c5c3a8d34666376447e6204";
      };
-    path = "hoogle";
+    meta = {
+      homepage = https://github.com/gmarik/vundle.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  hdevtools = simpleDerivation {
-    name = "vim-hdevtools-git-474947c5";
+  watchdogs = buildVimPlugin {
+    name = "watchdogs-git-2014-10-18";
     src = fetchgit {
-      url = "https://github.com/bitc/vim-hdevtools.git";
-      rev = "474947c52ff9c93dd36f3c49de90bd9a78f0baa1";
-      sha256 = "bf5f096b665c51ce611c6c1bfddc3267c4b2f94af84b04482b07272a6a5a92f3";
+      url = "https://github.com/osyo-manga/vim-watchdogs.git";
+      rev = "ad222796eb88b44954340c19c39938046af26e05";
+      sha256 = "4c621ac2834864cf0c46f776029837913e1ba0c725a12d7cb24bf92e04ed1279";
      };
-    path = "hdevtools";
+    meta = {
+      homepage = https://github.com/osyo-manga/vim-watchdogs; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  stylishHaskell = simpleDerivation {
-    name = "vim-stylish-haskell-git-453fd203";
+  webapi-vim = buildVimPlugin {
+    name = "webapi-vim-git-2014-10-19";
     src = fetchgit {
-      url = "https://github.com/nbouscal/vim-stylish-haskell.git";
-      rev = "453fd203aee3d7305ea8e4088ff53bd1f5933d75";
-      sha256 = "c0e5010e1e8e56b179ce500387afb569f051c45b37ce92feb4350f293df96a8c";
+      url = "https://github.com/mattn/webapi-vim.git";
+      rev = "99e11199838ccbeb7213cbc30698200170d355c9";
+      sha256 = "599e282ef45bf6587c34579ab08d4e4a1f2cb54589e1e386c75d701880c90b9e";
      };
-    path = "stylish-haskell";
+    buildInputs = [ zip ];
+    meta = {
+      homepage = https://github.com/mattn/webapi-vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  wombat256 = simpleDerivation {
-    name = "wombat256-vim-git-8734ba45";
+  wombat256 = buildVimPlugin {
+    name = "wombat256-git-2010-10-17";
     src = fetchgit {
       url = "https://github.com/vim-scripts/wombat256.vim.git";
       rev = "8734ba45dcf5e38c4d2686b35c94f9fcb30427e2";
       sha256 = "2feb7d57ab0a9f2ea44ccd606e540db64ab3285956398a50ecc562d7b8dbcd05";
      };
-    path = "wombat256";
+    meta = {
+      homepage = https://github.com/vim-scripts/wombat256.vim; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  tmuxNavigator = simpleDerivation {
-    name = "vim-tmux-navigator-git-3de98bfc";
+  xdebug = buildVimPlugin {
+    name = "xdebug-git-2012-08-15";
     src = fetchgit {
-      url = "https://github.com/christoomey/vim-tmux-navigator.git";
-      rev = "3de98bfcee1289ce8edc6daf9a18f243180c7168";
-      sha256 = "3843f92e0a21fe5ccf613f8a561abd06c822b2ee98bd82c98937548144e4e8df";
+      url = "https://github.com/joonty/vim-xdebug.git";
+      rev = "a4980fa65f7f159780593ee37c178281691ba2c4";
+      sha256 = "1ccb0e63eaf68548feb1c37b09c07c84b6bea9b350c4257549f091aa414601e2";
      };
-    path = "tmux-navigator";
+    postInstall = false;
+    meta = {
+      homepage = https://github.com/joonty/vim-xdebug; 
+      maintainers = [ stdenv.lib.maintainers.jagajaga ];
+    };
   };
 
-  pathogen = simpleDerivation {
-    name = "vim-pathogen-git-3de98bfc";
-    src = fetchgit {
-      url = "https://github.com/tpope/vim-pathogen.git";
-      rev = "91e6378908721d20514bbe5d18d292a0a15faf0c";
-      sha256 = "24c1897d6b58576b2189c90050a7f8ede72a51343c752e9d030e833dbe5cac6f";
-     };
-    path = "pathogen";
+  yankring = buildVimPlugin rec {
+    version = "18.0";
+    name    = "yankring-${version}";
+
+    setSourceRoot = "sourceRoot=.";
+    src = fetchurl {
+      url    = "http://www.vim.org/scripts/download_script.php?src_id=20842";
+      name   = "yankring_180.zip";
+      sha256 = "0bsq4pxagy12jqxzs7gcf25k5ahwif13ayb9k8clyhm0jjdkf0la";
+    };
+
+    buildInputs = [ unzip ];
+  };
+
+  vim-addon-nix = {
+    # github.com/MarcWeber/vim-addon-nix provides some additional support for
+    # editing .nix files
+
+    # This is a placeholder, because I think you always should be using latest
+    # git version. It also depends on some additional plugins (see addon-info.json)
   };
 
-  vimoutliner = simpleDerivation {
-    name = "vimoutliner-git-dce383e7";
+  youcompleteme = stdenv.mkDerivation {
     src = fetchgit {
-      url = "https://github.com/vimoutliner/vimoutliner";
-      rev = "2fc82976683c8770bece157ae3ada55251b6ddeb";
-      sha256 = "dce383e7842c42bcfa8e7c3329fa426cb0fb05786d40a733da705c03aabd196b";
+      url = "https://github.com/Valloric/YouCompleteMe.git";
+      rev = "87b42c689391b69968950ae99c3aaacf2e14c329";
+      sha256 = "1f3pywv8bsqyyakvyarg7z9m73gmvp1lfbfp2f2jj73jmmlzb2kv";
      };
-    path = "vimoutliner";
+
+    name = "vimplugin-youcompleteme-2014-10-06";
+
+    buildInputs = [ python cmake clang.clang ];
+
+    configurePhase = ":";
+
+    buildPhase = ''
+      patchShebangs .
+
+      target=$out/share/vim-plugins/youcompleteme
+      mkdir -p $target
+      cp -a ./ $target
+
+      mkdir $target/build
+      cd $target/build
+      cmake -G "Unix Makefiles" . $target/third_party/ycmd/cpp -DPYTHON_LIBRARIES:PATH=${python}/lib/libpython2.7.so -DPYTHON_INCLUDE_DIR:PATH=${python}/include/python2.7 -DUSE_CLANG_COMPLETER=ON -DUSE_SYSTEM_LIBCLANG=ON
+      make ycm_support_libs -j''${NIX_BUILD_CORES} -l''${NIX_BUILD_CORES}}
+      ${bash}/bin/bash $target/install.sh --clang-completer --system-libclang
+
+      ${vimHelpTags}
+      vimHelpTags $target
+    '';
+
+    # TODO: implement proper install phase rather than keeping everything in store
+    # TODO: support llvm based C completion, See README of git repository
+    installPhase = ":";
+
+    meta = {
+      description = "fastest non utf-8 aware word and C completion engine for Vim";
+      homepage = http://github.com/Valloric/YouCompleteMe;
+      license = stdenv.lib.licenses.gpl3;
+      maintainers = [stdenv.lib.maintainers.marcweber];
+      platforms = stdenv.lib.platforms.linux;
+    };
   };
+
+  YouCompleteMe = youcompleteme; # backwards compat, added 2014-10-18
 
 }

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

···
   meta = with stdenv.lib; {
     description = "Object file displaying tool";
     homepage    = https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/otool.1.html;
-    # TODO license     = with licenses; [ apsl20 gpl2Plus ];
+    license     = with licenses; [ apsl20 gpl2Plus ];
     maintainers = with maintainers; [ lovek323 ];
     platforms   = platforms.darwin;
 

pkgs/os-specific/linux/ati-drivers/builder.sh

···
     cp $BIN/* $out/bin
     for prog in $BIN/*; do
       patchelf --set-interpreter $(echo $glibc/lib/ld-linux*.so.2) $out/bin/$(basename $prog)
-      wrapProgram $out/bin/$(basename $prog) --prefix LD_LIBRARY_PATH : $out/lib:$LD_LIBRARY_PATH
+      wrapProgram $out/bin/$(basename $prog) --prefix LD_LIBRARY_PATH : $out/lib:$gcc/lib:$qt4/lib:$LD_LIBRARY_PATH
     done
   }
 

pkgs/os-specific/linux/ati-drivers/default.nix

···
 , libXxf86vm, xf86vidmodeproto # for fglrx_gamma
 , xorg, makeWrapper, glibc, patchelf
 , unzip
+, qt4 # for amdcccle
 , # Whether to build the libraries only (i.e. not the kernel module or
   # driver utils). Used to support 32-bit binaries on 64-bit
   # Linux.
···
       patchelf
       unzip
       mesa
+      qt4
     ];
 
   inherit libsOnly;
···
   # appear in /run/opengl-driver/lib which get's added to LD_LIBRARY_PATH
   extraDRIlibs = [ xorg.libXext ];
 
-  inherit mesa; # only required to build examples
+  inherit mesa qt4; # only required to build examples and amdcccle
 
   meta = with stdenv.lib; {
     description = "ATI drivers";
     homepage = http://support.amd.com/us/gpudownload/Pages/index.aspx;
     license = licenses.unfree;
-    maintainers = with maintainers; [marcweber offline];
+    maintainers = with maintainers; [ marcweber offline jgeerds ];
     platforms = platforms.linux;
     hydraPlatforms = [];
   };

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

···
-{ fetchurl, stdenv, flex, bison, db, iptables, pkgconfig }:
+{ fetchgit, stdenv, flex, bison, db, iptables, pkgconfig }:
 
 stdenv.mkDerivation rec {
-  name = "iproute2-3.16.0";
+  name = "iproute2-3.17.0";
 
-  src = fetchurl {
-    url = "mirror://kernel/linux/utils/net/iproute2/${name}.tar.xz";
-    sha256 = "0ybv29m88lccpfrh2dgiqash4c3gfvwwpx9kakvnc8c71rn8l2hz";
+  src = fetchgit {
+    url = "git://git.kernel.org/pub/scm/linux/kernel/git/shemminger/iproute2.git";
+    rev = "refs/tags/v3.17.0";
+    sha256 = "113ayyy7cjxn0bf67fh4is4z0jysgif016kv7ig0jp6r68xp2spa";
   };
 
-  patch = [
-    ./vpnc.patch
-    ./device-checking.patch # Remove after 3.16.0
-  ];
+  patch = [ ./vpnc.patch ];
 
-  preConfigure =
-    ''
-      patchShebangs ./configure
-      sed -e '/ARPDDIR/d' -i Makefile
-    '';
+  preConfigure = ''
+    patchShebangs ./configure
+    sed -e '/ARPDDIR/d' -i Makefile
+  '';
 
-  makeFlags = "DESTDIR= LIBDIR=$(out)/lib SBINDIR=$(out)/sbin"
-    + " CONFDIR=$(out)/etc DOCDIR=$(out)/share/doc/${name}"
-    + " MANDIR=$(out)/share/man";
+  makeFlags = [
+    "DESTDIR="
+    "LIBDIR=$(out)/lib"
+    "SBINDIR=$(out)/sbin"
+    "CONFDIR=$(out)/etc"
+    "DOCDIR=$(out)/share/doc/${name}"
+    "MANDIR=$(out)/share/man"
+  ];
 
   buildInputs = [ db iptables ];
   nativeBuildInputs = [ bison flex pkgconfig ];
···
   # Get rid of useless TeX/SGML docs.
   postInstall = "rm -rf $out/share/doc";
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://www.linuxfoundation.org/collaborate/workgroups/networking/iproute2;
     description = "A collection of utilities for controlling TCP/IP networking and traffic control in Linux";
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.eelco ];
+    platforms = platforms.linux;
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ eelco wkennington ];
   };
 }

pkgs/os-specific/linux/iproute/device-checking.patch

···
-From f1b66ff83a0babbe99fef81b3a960d7a4ce8dbc6 Mon Sep 17 00:00:00 2001
-From: vadimk <[e-mail]>
-Date: Sat, 30 Aug 2014 15:06:00 +0300
-Subject: ip link: Remove unnecessary device checking
-
-The real checking is performed later in iplink_modify(..) func which
-checks device existence if NLM_F_CREATE flag is set.
-
-Also it fixes the case when impossible to add veth link which was
-caused by 9a02651a87 (ip: check for missing dev arg when doing VF rate)
-because these devices are not exist yet.
-
-Signed-off-by: Vadim Kochan <[e-mail]>
-Acked-by: Oliver Hartkopp <[e-mail]>
-Signed-off-by: Stephen Hemminger <[e-mail]>
-
-diff --git a/ip/iplink.c b/ip/iplink.c
-index 1a907d9..ea06871 100644
---- a/ip/iplink.c
-+++ b/ip/iplink.c
-@@ -593,8 +593,6 @@ int iplink_parse(int argc, char **argv, struct iplink_req *req,
- 				duparg2("dev", *argv);
- 			*dev = *argv;
- 			dev_index = ll_name_to_index(*dev);
--			if (dev_index == 0)
--				invarg("Unknown device", *argv);
- 		}
- 		argc--; argv++;
- 	}
--- 
-cgit v0.10.1
-

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

···
   TRANSPARENT_HUGEPAGE_ALWAYS? n
   TRANSPARENT_HUGEPAGE_MADVISE? y
 
-  # zram support (e.g for in-memory compressed swap)
+  # zram support (e.g for in-memory compressed swap).
   ${optionalString (versionAtLeast version "3.4") ''
     ZSMALLOC y
   ''}
   ZRAM m
-  
+
   ${optionalString (versionAtLeast version "3.17") "NFC? n"}
+
+  # Enable firmware loading via udev. Only needed for non-declarative
+  # firmware in /root/test-firmware.
+  ${optionalString (versionAtLeast version "3.17") ''
+    FW_LOADER_USER_HELPER_FALLBACK y
+  ''}
 
   ${kernelPlatform.kernelExtraConfig or ""}
   ${extraConfig}

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.10.56";
+  version = "3.10.58";
   extraMeta.branch = "3.10";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "02q0rda1dsapfi2d3nz398fhlk0gvr2q6mj6jcck2izcxzqhsz9a";
+    sha256 = "06wn2ghqjcna517dmqj4yx5c5vl1mnn610xs5wdsyv2ikpr5mzfz";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.12.29";
+  version = "3.12.30";
   extraMeta.branch = "3.12";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1ckzd9s64iahlnv7wh687m827f94q8hw0s4h8s69ijhay6igqqzm";
+    sha256 = "101lcf83y93pwz96glr93gnkkrx4xvwkxrjr1l45didrwnkim514";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.14.20";
+  version = "3.14.22";
   extraMeta.branch = "3.14";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "090i8drjwhxawn7jfg9mrmvqik13j58v0hb272b457k48qyc070y";
+    sha256 = "115hcaxavgqz549y0ly5ijf7cwc0z549wlwwjlm27i0z3fjcg83p";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.16.4";
+  version = "3.16.6";
   extraMeta.branch = "3.16";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "0x8jh9j7kdfbxcf3f69p28j5dwjjdxf92sjnlhk3mp016yv02i99";
+    sha256 = "1wh662krzgcgkhymqrjn8rasv92zsz0nmlwii85h8cwrszzxrs9i";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.17";
-  modDirVersion = "3.17.0";
+  version = "3.17.1";
   extraMeta.branch = "3.17";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "0lb2yyh3j932789jq4gxx9xshgy6rfdnl3lm8yr43kaz7k4kw5gm";
+    sha256 = "1hhxsb4gsaj2mlmshivild7ayagam8f3xfl27n4652b1z4n0171c";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.2.62";
+  version = "3.2.63";
   extraMeta.branch = "3.2";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1yrmar14p5y9xaj9df388xwjmwz8fnsxnid6rkxxk7dni5di8nqf";
+    sha256 = "0fxfk1dppmgv5pwy7jjyih03i9rz5acp0pww4g5sy2d59rzfpbn8";
   };
 
   # We don't provide these patches if grsecurity is enabled, because

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.4.103";
+  version = "3.4.104";
   extraMeta.branch = "3.4";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1ldga9l7dydwv5zvl3xgk8833cjv73yasyy2qmgimkbs03s8q4ig";
+    sha256 = "0xf2w4lccws2pps89hmh7ry8n43wr9p65yvdajba4qfxxy5jvx4b";
   };
 
   kernelPatches = args.kernelPatches ++

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

···
   };
 
   grsecurity_stable = grsecPatch
-    { kversion  = "3.14.20";
-      revision  = "201410062037";
+    { kversion  = "3.14.22";
+      revision  = "201410192047";
       branch    = "stable";
-      sha256    = "0vs5s7xlnsrs5w59vhi57xhsnx3fryqfpvdgsfg2rxqnc1a5b3sp";
+      sha256    = "0f6mdc0m89idlygm75x3z01rqacla4r26cgz1ai1c6sm5vp9yvw1";
     };
 
   grsecurity_unstable = grsecPatch
-    { kversion  = "3.16.4";
-      revision  = "201410062041";
+    { kversion  = "3.17.1";
+      revision  = "201410192051";
       branch    = "test";
-      sha256    = "17g993gwjbj10gp2in534ycsv5hwggi5hrbqrsar1lm95m3d6pbc";
+      sha256    = "1ny8h6dd5mijg7lwi7zwqc6x5n5wkv19avl1d5qx8g2fs6qxbg0m";
     };
 
   grsec_fix_path =

pkgs/os-specific/linux/lttng-modules/default.nix

···
-{ stdenv, fetchgit, kernel }:
+{ stdenv, fetchurl, kernel }:
 
 assert stdenv.lib.versionAtLeast kernel.version "3.4";  # fails on 3.2
+assert builtins.substring 0 4 kernel.version != "3.12";
 
 stdenv.mkDerivation rec {
   pname = "lttng-modules-${version}";
   name = "${pname}-${kernel.version}";
-  # Support for linux 3.16 and 3.17 was added just after the 2.5.0 release
-  version = "2.5.0-58-gbf2ba31"; # "git describe bf2ba318fff"
+  version = "2.6.0-rc1"; # "git describe bf2ba318fff"
 
-  src = fetchgit {
-    url = "https://github.com/lttng/lttng-modules.git";
-    sha256 = "0x70xp463g208rdz5b9b0wdwr2v8px1bwa589knvp4j7zi8d2gj9";
-    rev = "bf2ba318fff";
+  src = fetchurl {
+    url = "https://github.com/lttng/lttng-modules/archive/v${version}.tar.gz";
+    sha256 = "01gha02ybbzr86v6s6bqn649jiw5k89kb363b9s1iv8igrdlzhl1";
   };
 
   preConfigure = ''
···
   meta = with stdenv.lib; {
     description = "Linux kernel modules for LTTng tracing";
     homepage = http://lttng.org/;
-    # TODO license = with licenses; [ lgpl21 gpl2 mit ];
+    license = with licenses; [ lgpl21 gpl2 mit ];
     platforms = platforms.linux;
     maintainers = [ maintainers.bjornfor ];
   };

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

···
 
 stdenv.mkDerivation rec {
   name = "pax-utils-${version}";
-  version = "0.8.1";
+  version = "0.9.1";
 
   src = fetchurl {
     url = "http://dev.gentoo.org/~vapier/dist/${name}.tar.xz";
-    sha256 = "1fgm70s52x48dxjihs0rcwmpfsi2dxbjzcilxy9fzg0i39dz4kw4";
+    sha256 = "034b365il58bd01ld8r5493x7qkxbxzavmgwm916r0rgjpvclg34";
   };
 
   makeFlags = [

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

···
     CC = stdenv.cross.config + "-gcc";
   };
 
+  # Too red
+  configureFlags = [ "--disable-modern-top" ];
+
   meta = {
     homepage = http://sourceforge.net/projects/procps-ng/;
     description = "Utilities that give information about processes using the /proc filesystem";

pkgs/servers/monitoring/zabbix/default.nix

···
 
 let
 
-  version = "1.8.20";
+  version = "1.8.21";
 
   src = fetchurl {
     url = "mirror://sourceforge/zabbix/zabbix-${version}.tar.gz";
-    sha256 = "0psdvzg5c3yhdqqmy5m1b0j3nrvcshjywhl56igy0j8vj16zxi86";
+    sha256 = "1ssqi31blkl1lyv9vjrsrrn494grdng187s8xwfv79adk2w94paw";
   };
 
   preConfigure =

pkgs/servers/mpd/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, systemd
+{ stdenv, fetchurl, pkgconfig, glib, systemd, boost
 , alsaSupport ? true, alsaLib
 , flacSupport ? true, flac
 , vorbisSupport ? true, libvorbis
···
 , mpg123Support ? true, mpg123
 , aacSupport ? true, faad2
 , pulseaudioSupport ? true, pulseaudio
+, icuSupport ? true, icu
 }:
 
 let
-
   opt = stdenv.lib.optional;
-
   mkFlag = c: f: if c then "--enable-${f}" else "--disable-${f}";
+  major = "0.19";
+  minor = "1";
 
 in stdenv.mkDerivation rec {
-  name = "mpd-0.18.16";
+  name = "mpd-${major}.${minor}";
   src = fetchurl {
-    url    = "http://www.musicpd.org/download/mpd/0.18/${name}.tar.gz";
-    sha256 = "0xpmc70ccp0s2s10vsi4hkijiv497dy42a7g225y77axp5ncf364";
+    url    = "http://www.musicpd.org/download/mpd/${major}/${name}.tar.gz";
+    sha256 = "08a8wgr1kp86nnf9xbc71l9py1plslp10xw0ah344imkwyfg0nj8";
   };
 
-  buildInputs = [ pkgconfig glib ]
+  buildInputs = [ pkgconfig glib boost ]
     ++ opt stdenv.isLinux systemd
     ++ opt (stdenv.isLinux && alsaSupport) alsaLib
     ++ opt flacSupport flac
···
     ++ opt mpg123Support mpg123
     ++ opt aacSupport faad2
     ++ opt zipSupport zziplib
-    ++ opt pulseaudioSupport pulseaudio;
+    ++ opt pulseaudioSupport pulseaudio
+    ++ opt icuSupport icu;
 
   configureFlags =
     [ (mkFlag (!stdenv.isDarwin && alsaSupport) "alsa")
···
       (mkFlag aacSupport "aac")
       (mkFlag pulseaudioSupport "pulse")
       (mkFlag stdenv.isDarwin "osx")
+      (mkFlag icuSupport "icu")
       "--enable-debug"
     ]
     ++ opt stdenv.isLinux

pkgs/servers/sql/oracle-xe/default.nix

···
-{ stdenv, makeWrapper, requireFile, patchelf, rpm, cpio, libaio }:
+{ stdenv, makeWrapper, requireFile, patchelf, rpmextract, libaio }:
 
 assert stdenv.system == "x86_64-linux";
 
···
 
   unpackCmd = ''
     (mkdir -p "${name}" && cd "${name}" &&
-      ${rpm}/bin/rpm2cpio "$curSrc" | ${cpio}/bin/cpio -id)
+      ${rpmextract}/bin/rpmextract "$curSrc")
   '';
 
   buildPhase = let

pkgs/tools/X11/xdotool/default.nix

···
-{ stdenv, fetchurl, libX11, perl, libXtst, xextproto, libXi }:
+{ stdenv, fetchurl, libX11, perl, libXtst, xextproto, libXi, libXinerama }:
 
-let version = "2.20101012.3049"; in
+let version = "2.20110530.1"; in
 stdenv.mkDerivation {
   name = "xdotool-${version}";
   src = fetchurl {
     url = "http://semicomplete.googlecode.com/files/xdotool-${version}.tar.gz";
-    sha256 = "0amkb1zvdk0gj7va3rjw9arbyj8pgprkdik05yl6rghq21q076ls";
+    sha256 = "0rxggg1cy7nnkwidx8x2w3c5f3pk6dh2b6q0q7hp069r3n5jrd77";
   };
 
-  buildInputs = [ libX11 perl libXtst xextproto libXi ];
+  buildInputs = [ libX11 perl libXtst xextproto libXi libXinerama ];
 
   configurePhase = ''
     export makeFlags="PREFIX=$out";

pkgs/tools/archivers/rpmextract/default.nix

···
+{ stdenv, fetchurl, rpm, cpio, substituteAll }:
+
+stdenv.mkDerivation rec {
+  name = "rpmextract";
+
+  buildCommand = ''
+    install -Dm755 $script $out/bin/rpmextract
+  '';
+    
+  script = substituteAll {
+    src = ./rpmextract.sh;
+    inherit rpm cpio;
+  };
+
+  meta = with stdenv.lib; {
+    description = "Script to extract RPM archives";
+    platforms = platforms.all;
+    license = licenses.gpl2;
+    maintainers = maintainers.abbradar;
+  };
+}

pkgs/tools/archivers/rpmextract/rpmextract.sh

···
+#!/bin/sh -e
+
+if [ "$1" = "" ]; then
+  echo "usage: rpmextract package_name..." 1>&2
+  exit 1
+fi
+
+for i in "$@"; do
+  @rpm@/bin/rpm2cpio "$i" | @cpio@/bin/cpio -idv
+done

pkgs/tools/audio/gvolicon/default.nix

···
   name = "gvolicon";
   src = fetchgit {
     url = "https://github.com/Unia/gvolicon";
-    rev = "26343415de836e0b05aa0b480c0c69cc2ed9e419";
-    sha256 = "68858840a45b5f74803e85116c6219f805d6d944c00354662889549910856cdd";
+    rev = "c04cafb88124e1e5edc61dd52f76bf13381d5167";
+    sha256 = "31cf770dca0d216e3108b258b4c150cbeb3b127002d53fd6ddddfcf9e3e293aa";
   };
 
   buildInputs = [ pkgconfig makeWrapper alsaLib gnome3.gtk ];
···
     license = stdenv.lib.licenses.gpl3Plus;
     maintainers = [ stdenv.lib.maintainers.bennofs ];
   };
-}
+}

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

···
+{ stdenv, fetchurl, buildPythonPackage, pykickstart, pyparted, pyblock
+, libselinux, cryptsetup, multipath_tools, lsof, utillinux
+, useNixUdev ? true, udev ? null
+# This is only used when useNixUdev is false
+, udevSoMajor ? 1
+}:
+
+assert useNixUdev -> udev != null;
+
+buildPythonPackage rec {
+  name = "blivet-${version}";
+  version = "0.17-1";
+
+  src = fetchurl {
+    url = "https://git.fedorahosted.org/cgit/blivet.git/snapshot/"
+        + "${name}.tar.bz2";
+    sha256 = "1k3mws2q0ryb7422mml6idmaasz2i2v6ngyvg6d976dx090qnmci";
+  };
+
+  postPatch = ''
+    sed -i -e 's|"multipath"|"${multipath_tools}/sbin/multipath"|' \
+      blivet/devicelibs/mpath.py blivet/devices.py
+    sed -i -e '/"wipefs"/ {
+      s|wipefs|${utillinux}/sbin/wipefs|
+      s/-f/--force/
+    }' blivet/formats/__init__.py
+    sed -i -e 's|"lsof"|"${lsof}/bin/lsof"|' blivet/formats/fs.py
+    sed -i -r -e 's|"(u?mount)"|"${utillinux}/bin/\1"|' blivet/util.py
+    sed -i '/pvscan/s/, *"--cache"//' blivet/devicelibs/lvm.py
+  '' + (if useNixUdev then ''
+    sed -i -e '/find_library/,/find_library/ {
+      c libudev = "${udev}/lib/libudev.so.1"
+    }' blivet/pyudev.py
+  '' else ''
+    sed -i \
+      -e '/^somajor *=/s/=.*/= ${toString udevSoMajor}/p' \
+      -e 's|common =.*|& + ["/lib/x86_64-linux-gnu", "/lib/i686-linux-gnu"]|' \
+      blivet/pyudev.py
+  '');
+
+  propagatedBuildInputs = [
+    pykickstart pyparted pyblock libselinux cryptsetup
+  ] ++ stdenv.lib.optional useNixUdev udev;
+
+  # tests are currently _heavily_ broken upstream
+  doCheck = false;
+
+  meta = {
+    homepage = "https://fedoraproject.org/wiki/Blivet";
+    description = "Module for management of a system's storage configuration";
+    license = [ "GPLv2+" "LGPLv2.1+" ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

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

···
+{ stdenv, fetchurl, devicemapper, libgcrypt, libuuid, pkgconfig, popt
+, enablePython ? true, python ? null
+}:
+
+assert enablePython -> python != null;
+
+stdenv.mkDerivation rec {
+  name = "cryptsetup-1.6.3";
+
+  src = fetchurl {
+    url = "http://cryptsetup.googlecode.com/files/${name}.tar.bz2";
+    sha256 = "1n1qk5chyjspbiianrdb55fhb4wl0vfyqz2br05vfb24v4qlgbx2";
+  };
+
+  configureFlags = [ "--enable-cryptsetup-reencrypt" ]
+                ++ stdenv.lib.optional enablePython "--enable-python";
+
+  buildInputs = [ devicemapper libgcrypt libuuid pkgconfig popt ]
+             ++ stdenv.lib.optional enablePython python;
+
+  meta = {
+    homepage = http://code.google.com/p/cryptsetup/;
+    description = "LUKS for dm-crypt";
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = with stdenv.lib.maintainers; [ viric chaoflow ];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

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

···
+{ stdenv, fetchurl, python, buildPythonPackage
+# Propagated to blivet
+, useNixUdev ? true, udevSoMajor ? null
+# Propagated dependencies
+, pkgs, urlgrabber
+}:
+
+let
+  blivet = import ./blivet.nix {
+    inherit stdenv fetchurl buildPythonPackage;
+    inherit pykickstart pyparted pyblock cryptsetup multipath_tools;
+    inherit useNixUdev udevSoMajor;
+    inherit (pkgs) lsof utillinux udev;
+    libselinux = pkgs.libselinux.override { enablePython = true; };
+  };
+
+  cryptsetup = import ./cryptsetup.nix {
+    inherit stdenv fetchurl python;
+    inherit (pkgs) pkgconfig libgcrypt libuuid popt;
+    devicemapper = lvm2;
+  };
+
+  dmraid = import ./dmraid.nix {
+    inherit stdenv fetchurl;
+    devicemapper = lvm2;
+  };
+
+  lvm2 = import ./lvm2.nix {
+    inherit stdenv fetchurl;
+    inherit (pkgs) pkgconfig utillinux udev coreutils;
+  };
+
+  multipath_tools = import ./multipath-tools.nix {
+    inherit stdenv fetchurl lvm2;
+    inherit (pkgs) readline udev libaio gzip;
+  };
+
+  parted = import ./parted.nix {
+    inherit stdenv fetchurl;
+    inherit (pkgs) utillinux readline libuuid gettext check;
+    devicemapper = lvm2;
+  };
+
+  pyblock = import ./pyblock.nix {
+    inherit stdenv fetchurl python lvm2 dmraid;
+  };
+
+  pykickstart = import ./pykickstart.nix {
+    inherit stdenv fetchurl python buildPythonPackage urlgrabber;
+  };
+
+  pyparted = import ./pyparted.nix {
+    inherit stdenv fetchurl python buildPythonPackage parted;
+    inherit (pkgs) pkgconfig e2fsprogs;
+  };
+
+in buildPythonPackage rec {
+  name = "nixpart-${version}";
+  version = "0.4.1";
+
+  src = fetchurl {
+    url = "https://github.com/aszlig/nixpart/archive/v${version}.tar.gz";
+    sha256 = "0avwd8p47xy9cydlbjxk8pj8q75zyl68gw2w6fnkk78dcb1a3swp";
+  };
+
+  propagatedBuildInputs = [ blivet ];
+
+  doCheck = false;
+
+  meta = {
+    description = "NixOS storage manager/partitioner";
+    license = stdenv.lib.licenses.gpl2Plus;
+    maintainers = [ stdenv.lib.maintainers.aszlig ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

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

···
+{ stdenv, fetchurl, devicemapper }:
+
+stdenv.mkDerivation rec {
+  name = "dmraid-1.0.0.rc15";
+
+  src = fetchurl {
+    url = "http://people.redhat.com/~heinzm/sw/dmraid/src/old/${name}.tar.bz2";
+    sha256 = "01bcaq0sc329ghgj7f182xws7jgjpdc41bvris8fsiprnxc7511h";
+  };
+
+  preConfigure = "cd */";
+
+  buildInputs = [ devicemapper ];
+
+  meta = {
+    description = "Old-style RAID configuration utility";
+    longDescritipn = ''
+      Old RAID configuration utility (still under development, though).
+      It is fully compatible with modern kernels and mdadm recognizes
+      its volumes. May be needed for rescuing an older system or nuking
+      the metadata when reformatting.
+    '';
+    maintainers = [ stdenv.lib.maintainers.raskin ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

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

···
+{ stdenv, fetchurl, pkgconfig, udev, utillinux, coreutils }:
+
+let
+  v = "2.02.106";
+in
+
+stdenv.mkDerivation {
+  name = "lvm2-${v}";
+
+  src = fetchurl {
+    url = "ftp://sources.redhat.com/pub/lvm2/releases/LVM2.${v}.tgz";
+    sha256 = "0nr833bl0q4zq52drjxmmpf7bs6kqxwa5kahwwxm9411khkxz0vc";
+  };
+
+  configureFlags =
+    "--disable-readline --enable-udev_rules --enable-udev_sync --enable-pkgconfig --enable-applib";
+
+  buildInputs = [ pkgconfig udev ];
+
+  preConfigure =
+    ''
+      substituteInPlace scripts/lvmdump.sh \
+        --replace /usr/bin/tr ${coreutils}/bin/tr
+      substituteInPlace scripts/lvm2_activation_generator_systemd_red_hat.c \
+        --replace /usr/sbin/lvm $out/sbin/lvm \
+        --replace /usr/bin/udevadm ${udev}/bin/udevadm
+
+      sed -i /DEFAULT_SYS_DIR/d Makefile.in
+      sed -i /DEFAULT_PROFILE_DIR/d conf/Makefile.in
+    '';
+
+  enableParallelBuilding = true;
+
+  #patches = [ ./purity.patch ];
+
+  # To prevent make install from failing.
+  preInstall = "installFlags=\"OWNER= GROUP= confdir=$out/etc\"";
+
+  # Install systemd stuff.
+  #installTargets = "install install_systemd_generators install_systemd_units install_tmpfiles_configuration";
+
+  postInstall =
+    ''
+      substituteInPlace $out/lib/udev/rules.d/13-dm-disk.rules \
+        --replace $out/sbin/blkid ${utillinux}/sbin/blkid
+
+      # Systemd stuff
+      mkdir -p $out/etc/systemd/system $out/lib/systemd/system-generators
+      cp scripts/blk_availability_systemd_red_hat.service $out/etc/systemd/system
+      cp scripts/lvm2_activation_generator_systemd_red_hat $out/lib/systemd/system-generators
+    '';
+
+  meta = {
+    homepage = http://sourceware.org/lvm2/;
+    descriptions = "Tools to support Logical Volume Management (LVM) on Linux";
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/tools/filesystems/nixpart/0.4/multipath-tools.nix

···
+{ stdenv, fetchurl, lvm2, libaio, gzip, readline, udev }:
+
+stdenv.mkDerivation rec {
+  name = "multipath-tools-0.4.9";
+
+  src = fetchurl {
+    url = "http://christophe.varoqui.free.fr/multipath-tools/${name}.tar.bz2";
+    sha256 = "04n7kazp1zrlqfza32phmqla0xkcq4zwn176qff5ida4a60whi4d";
+  };
+
+  sourceRoot = ".";
+
+  buildInputs = [ lvm2 libaio readline ];
+
+  preBuild =
+    ''
+      makeFlagsArray=(GZIP="${gzip}/bin/gzip -9 -c" prefix=$out mandir=$out/share/man/man8 man5dir=$out/share/man/man5 LIB=lib)
+      
+      substituteInPlace multipath/Makefile --replace /etc $out/etc
+      substituteInPlace kpartx/Makefile --replace /etc $out/etc
+      
+      substituteInPlace kpartx/kpartx.rules --replace /sbin/kpartx $out/sbin/kpartx
+      substituteInPlace kpartx/kpartx_id --replace /sbin/dmsetup ${lvm2}/sbin/dmsetup
+
+      substituteInPlace libmultipath/defaults.h --replace /lib/udev/scsi_id ${udev}/lib/udev/scsi_id
+      substituteInPlace libmultipath/hwtable.c --replace /lib/udev/scsi_id ${udev}/lib/udev/scsi_id
+    '';
+
+  meta = {
+    description = "Tools for the Linux multipathing driver";
+    homepage = http://christophe.varoqui.free.fr/;
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

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

···
+{ stdenv, fetchurl, devicemapper, libuuid, gettext, readline
+, utillinux, check, enableStatic ? false, hurd ? null }:
+
+stdenv.mkDerivation rec {
+  name = "parted-3.1";
+
+  src = fetchurl {
+    url = "mirror://gnu/parted/${name}.tar.xz";
+    sha256 = "05fa4m1bky9d13hqv91jlnngzlyn7y4rnnyq6d86w0dg3vww372y";
+  };
+
+  buildInputs = [ libuuid ]
+    ++ stdenv.lib.optional (readline != null) readline
+    ++ stdenv.lib.optional (gettext != null) gettext
+    ++ stdenv.lib.optional (devicemapper != null) devicemapper
+    ++ stdenv.lib.optional (hurd != null) hurd
+    ++ stdenv.lib.optional doCheck check;
+
+  configureFlags =
+       (if (readline != null)
+        then [ "--with-readline" ]
+        else [ "--without-readline" ])
+    ++ stdenv.lib.optional (devicemapper == null) "--disable-device-mapper"
+    ++ stdenv.lib.optional enableStatic "--enable-static";
+
+  doCheck = true;
+
+  preCheck =
+    stdenv.lib.optionalString doCheck
+      # The `t0400-loop-clobber-infloop.sh' test wants `mkswap'.
+      "export PATH=\"${utillinux}/sbin:$PATH\"";
+
+  meta = {
+    description = "Create, destroy, resize, check, and copy partitions";
+
+    longDescription = ''
+      GNU Parted is an industrial-strength package for creating, destroying,
+      resizing, checking and copying partitions, and the file systems on
+      them.  This is useful for creating space for new operating systems,
+      reorganising disk usage, copying data on hard disks and disk imaging.
+
+      It contains a library, libparted, and a command-line frontend, parted,
+      which also serves as a sample implementation and script backend.
+    '';
+
+    homepage = http://www.gnu.org/software/parted/;
+    license = stdenv.lib.licenses.gpl3Plus;
+
+    maintainers = [
+      # Add your name here!
+      stdenv.lib.maintainers.ludo
+    ];
+
+    # GNU Parted requires libuuid, which is part of util-linux-ng.
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

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

···
+{ stdenv, fetchurl, python, lvm2, dmraid }:
+
+stdenv.mkDerivation rec {
+  name = "pyblock-${version}";
+  version = "0.53";
+
+  src = fetchurl rec {
+    url = "http://pkgs.fedoraproject.org/repo/pkgs/python-pyblock/"
+        + "${name}.tar.bz2/${md5}/${name}.tar.bz2";
+    md5 = "f6d33a8362dee358517d0a9e2ebdd044";
+  };
+
+  postPatch = ''
+    sed -i -e 's|/usr/include/python|${python}/include/python|' \
+           -e 's/-Werror *//' -e 's|/usr/|'"$out"'/|' Makefile
+  '';
+
+  buildInputs = [ python lvm2 dmraid ];
+
+  makeFlags = [
+    "USESELINUX=0"
+    "SITELIB=$(out)/lib/${python.libPrefix}/site-packages"
+  ];
+
+  meta = {
+    description = "Interface for working with block devices";
+    license = stdenv.lib.licenses.gpl2Plus;
+  };
+}

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

···
+{ stdenv, python, buildPythonPackage, fetchurl, urlgrabber }:
+
+buildPythonPackage rec {
+  name = "pykickstart-${version}";
+  version = "1.99.39";
+
+  src = fetchurl rec {
+    url = "http://pkgs.fedoraproject.org/repo/pkgs/pykickstart/"
+        + "${name}.tar.gz/${md5}/${name}.tar.gz";
+    md5 = "d249f60aa89b1b4facd63f776925116d";
+  };
+
+  postPatch = ''
+    sed -i -e "s/for tst in tstList/for tst in sorted(tstList, \
+               key=lambda m: m.__name__)/" tests/baseclass.py
+  '';
+
+  propagatedBuildInputs = [ urlgrabber ];
+
+  checkPhase = ''
+    export PYTHONPATH="$PYTHONPATH:."
+    ${python}/bin/${python.executable} tests/baseclass.py -vv
+  '';
+
+  meta = {
+    homepage = "http://fedoraproject.org/wiki/Pykickstart";
+    description = "Read and write Fedora kickstart files";
+    license = stdenv.lib.licenses.gpl2Plus;
+  };
+}

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

···
+{ stdenv, fetchurl, pkgconfig, python, buildPythonPackage, parted, e2fsprogs }:
+
+buildPythonPackage rec {
+  name = "pyparted-${version}";
+  version = "3.10";
+
+  src = fetchurl {
+    url = "https://fedorahosted.org/releases/p/y/pyparted/${name}.tar.gz";
+    sha256 = "17wq4invmv1nfazaksf59ymqyvgv3i8h4q03ry2az0s9lldyg3dv";
+  };
+
+  postPatch = ''
+    sed -i -e 's|/sbin/mke2fs|${e2fsprogs}&|' tests/baseclass.py
+    sed -i -e '
+      s|e\.path\.startswith("/tmp/temp-device-")|"temp-device-" in e.path|
+    ' tests/test__ped_ped.py
+  '' + stdenv.lib.optionalString stdenv.isi686 ''
+    # remove some integers in this test case which overflow on 32bit systems
+    sed -i -r -e '/class *UnitGetSizeTestCase/,/^$/{/[0-9]{11}/d}' \
+      tests/test__ped_ped.py
+  '';
+
+  preConfigure = ''
+    PATH="${parted}/sbin:$PATH"
+  '';
+
+  buildInputs = [ pkgconfig ];
+
+  propagatedBuildInputs = [ parted ];
+
+  checkPhase = ''
+    patchShebangs Makefile
+    make test PYTHON=${python.executable}
+  '';
+
+  meta = {
+    homepage = "https://fedorahosted.org/pyparted/";
+    description = "Python interface for libparted";
+    license = stdenv.lib.licenses.gpl2Plus;
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/tools/filesystems/nixpart/default.nix

···
-{ stdenv, fetchurl, buildPythonPackage, blivet
-# Propagated to blivet
-, useNixUdev ? null, udevSoMajor ? null
-}:
+{ stdenv, fetchurl, buildPythonPackage, blivet }:
 
-let
-  blivetOverrides = stdenv.lib.filterAttrs (k: v: v != null) {
-    inherit useNixUdev udevSoMajor;
-  };
-in buildPythonPackage rec {
+buildPythonPackage rec {
   name = "nixpart-${version}";
-  version = "0.4.1";
+  version = "1.0.0";
 
   src = fetchurl {
     url = "https://github.com/aszlig/nixpart/archive/v${version}.tar.gz";
     sha256 = "0avwd8p47xy9cydlbjxk8pj8q75zyl68gw2w6fnkk78dcb1a3swp";
   };
 
-  propagatedBuildInputs = [ (blivet.override blivetOverrides) ];
-
-  doCheck = false;
+  propagatedBuildInputs = [ blivet ];
 
   meta = {
     description = "NixOS storage manager/partitioner";
     license = stdenv.lib.licenses.gpl2Plus;
     maintainers = [ stdenv.lib.maintainers.aszlig ];
     platforms = stdenv.lib.platforms.linux;
+    broken = true;
   };
 }

pkgs/tools/filesystems/squashfs/default.nix

···
-{ stdenv, fetchurl, zlib, xz }:
+{ stdenv, fetchgit, zlib, xz }:
 
 stdenv.mkDerivation rec {
-  name = "squashfs-4.3";
+  name = "squashfs-4.4dev";
 
-  src = fetchurl {
-    url = mirror://sourceforge/squashfs/squashfs4.3.tar.gz;
-    sha256 = "1xpklm0y43nd9i6jw43y2xh5zvlmj9ar2rvknh0bh7kv8c95aq0d";
+  src = fetchgit {
+    url = https://github.com/plougher/squashfs-tools.git;
+    sha256 = "059pa2shdysr3zfmwrhq28s12zbi5nyzbpzyaf5lmspgfh1493ks";
+    rev = "9c1db6d13a51a2e009f0027ef336ce03624eac0d";
   };
 
   buildInputs = [ zlib xz ];
 
   preBuild = "cd squashfs-tools";
-
+  
   NIX_LDFLAGS = "-lgcc_s"; # for pthread_cancel
 
   installFlags = "INSTALL_DIR=\${out}/bin";
···
   meta = {
     homepage = http://squashfs.sourceforge.net/;
     description = "Tool for creating and unpacking squashfs filesystems";
+    platforms = stdenv.lib.platforms.linux;
   };
 }

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

···
-{ stdenv, fetchurl, writeText, zlib, rpm, cpio, patchelf, which }:
+{ stdenv, fetchurl, writeText, zlib, rpmextract, patchelf, which }:
 
 assert stdenv.isLinux;
 
···
 
     mkdir -pv unpacked
     cd unpacked
-    ${rpm}/bin/rpm2cpio $src | ${cpio}/bin/cpio -imd
+    ${rpmextract}/bin/rpmextract $src
 
     cp -r -t $out/bin usr/bin/*
     cp -r -t $out/share usr/share/*

pkgs/tools/misc/megacli/default.nix

···
-{ stdenv, rpm, cpio, ncurses, patchelf, makeWrapper, requireFile, unzip }:
+{ stdenv, rpmextract, ncurses, patchelf, makeWrapper, requireFile, unzip }:
 
 assert stdenv.system == "x86_64-linux";
 
···
       sha256 = "11jzvh25mlygflazd37gi05xv67im4rgq7sbs5nwgw3gxdh4xfjj";
     };
 
-  buildInputs = [rpm cpio ncurses unzip makeWrapper];
+  buildInputs = [rpmextract ncurses unzip makeWrapper];
   libPath =
     stdenv.lib.makeLibraryPath
        [ stdenv.gcc.gcc stdenv.gcc.libc ncurses ];
···
     mkdir -p $out/bin
     cd $out
     unzip ${src}
-    rpm2cpio linux/MegaCli-8.07.07-1.noarch.rpm | cpio -idmv
+    rpmextract linux/MegaCli-8.07.07-1.noarch.rpm
     ${patchelf}/bin/patchelf --interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" --set-rpath ${libPath}:$out/opt/lsi/3rdpartylibs/x86_64:$out/opt/lsi/3rdpartylibs:${stdenv.gcc.gcc}/lib64:${stdenv.gcc.gcc}/lib opt/MegaRAID/MegaCli/MegaCli64
     wrapProgram $out/opt/MegaRAID/MegaCli/MegaCli64 --set LD_LIBRARY_PATH $out/opt/lsi/3rdpartylibs/x86_64
     ln -s $out/opt/MegaRAID/MegaCli/MegaCli64 $out/bin/MegaCli64

pkgs/tools/misc/parted/default.nix

···
-{ stdenv, fetchurl, devicemapper, libuuid, gettext, readline
+{ stdenv, fetchurl, devicemapper, libuuid, gettext, readline, perl, python
 , utillinux, check, enableStatic ? false, hurd ? null }:
 
 stdenv.mkDerivation rec {
-  name = "parted-3.1";
+  name = "parted-3.2";
 
   src = fetchurl {
     url = "mirror://gnu/parted/${name}.tar.xz";
-    sha256 = "05fa4m1bky9d13hqv91jlnngzlyn7y4rnnyq6d86w0dg3vww372y";
+    sha256 = "1r3qpg3bhz37mgvp9chsaa3k0csby3vayfvz8ggsqz194af5i2w5";
   };
 
+  patches = stdenv.lib.optional doCheck ./gpt-unicode-test-fix.patch;
+
+  postPatch = stdenv.lib.optionalString doCheck ''
+    patchShebangs tests
+  '';
+
   buildInputs = [ libuuid ]
     ++ stdenv.lib.optional (readline != null) readline
     ++ stdenv.lib.optional (gettext != null) gettext
     ++ stdenv.lib.optional (devicemapper != null) devicemapper
     ++ stdenv.lib.optional (hurd != null) hurd
-    ++ stdenv.lib.optional doCheck check;
+    ++ stdenv.lib.optionals doCheck [ check perl python ];
 
   configureFlags =
        (if (readline != null)

pkgs/tools/misc/parted/gpt-unicode-test-fix.patch

···
+From Ludo's suggestion at:
+
+  http://debbugs.gnu.org/cgi/bugreport.cgi?msg=8;bug=18258
+
+diff --git a/tests/.t0251-gpt-unicode.sh.swp b/tests/.t0251-gpt-unicode.sh.swp
+deleted file mode 100644
+index b41c337..0000000
+Binary files a/tests/.t0251-gpt-unicode.sh.swp and /dev/null differ
+diff --git a/tests/t0251-gpt-unicode.sh b/tests/t0251-gpt-unicode.sh
+index c845950..fa63a72 100755
+--- a/tests/t0251-gpt-unicode.sh
++++ b/tests/t0251-gpt-unicode.sh
+@@ -22,7 +22,24 @@ dev=loop-file
+ # create zeroed device
+ truncate -s 10m $dev || fail=1
+ 
+-export LC_ALL=C.UTF-8
++found_locale=no
++for locale in en_US de_DE fr_FR es_ES
++do
++  LC_ALL="$locale.UTF-8"
++  export LC_ALL
++
++  # In a UTF-8 locale, the string below prints as 4 characters.
++  if [ `printf 'foo\341\264\244' | wc -m` -eq 4 ]; then
++    found_locale=yes
++    break
++  fi
++done
++
++if [ "$found_locale" != "yes" ]; then
++  echo "no valid UTF-8 locale found; skipping" >&2
++  exit 77
++fi
++
+ # create gpt label with named partition
+ part_name=$(printf 'foo\341\264\244')
+ parted -s $dev mklabel gpt mkpart primary ext2 1MiB 2MiB name 1 $part_name > empty 2>&1 || fail=1

pkgs/tools/misc/pipelight/default.nix

···
+{ stdenv, fetchurl, fetchgit, autoconf, automake, wineUnstable, perl, xlibs
+  , gnupg, gcc48_multi, mesa, curl, bash, cacert, cabextract, utillinux, attr
+  }:
+
+let
+  wine_patches_version = "1.7.28";
+  wine_hash = "04r3zk3dz2vzly2a4nqbcvppjs5iy3lq5ibx3wfrf877p5bz3hv7";
+
+  wine_patches = fetchgit {
+    url = "git://github.com/compholio/wine-compholio.git";
+    rev = "refs/tags/v${wine_patches_version}";
+    sha256 = "17f1wmxbx6ly1ws4p528ijf9b4yvmnmap5k7npw9icvkyaky5xi9";
+  };
+
+  wine_custom =
+    stdenv.lib.overrideDerivation wineUnstable (args: rec {
+      name = "wine-${wine_patches_version}";
+      version = "${wine_patches_version}";
+      src = null;
+      srcs = [
+	      (fetchurl {
+                url = "mirror://sourceforge/wine/${name}.tar.bz2";
+                sha256 = wine_hash;
+	      })
+	      wine_patches ];
+      sourceRoot = "./${name}";
+      buildInputs = args.buildInputs ++ [ 
+        autoconf perl utillinux automake attr 
+      ];
+      nativeBuildInputs = args.nativeBuildInputs ++ [ 
+        autoconf perl utillinux automake attr 
+      ];
+      postPatch = ''
+        export wineDir=$(pwd)
+        patchShebangs $wineDir/tools/
+	chmod u+w $wineDir/../git-export/debian/tools/
+        patchShebangs $wineDir/../git-export/debian/tools/
+        chmod -R +rwx ../git-export/
+        make -C ../git-export/patches DESTDIR=$wineDir install
+      '';
+    });
+
+  mozillaPluginPath = "/lib/mozilla/plugins";
+
+
+in stdenv.mkDerivation rec {
+
+  version = "0.2.7.2";
+
+  name = "pipelight-${version}";
+
+  src = fetchurl {
+    url = "https://bitbucket.org/mmueller2012/pipelight/get/v${version}.tar.gz";
+    sha256 = "02132151091f1f62d7409a537649efc86deb0eb4a323fd66907fc22947e2cfbd";
+  };
+
+  buildInputs = [ wine_custom xlibs.libX11 gcc48_multi mesa curl ];
+  propagatedbuildInputs = [ curl cabextract ];
+
+  patches = [ ./pipelight.patch ];
+
+  configurePhase = ''
+    patchShebangs . 
+    ./configure \
+      --prefix=$out \
+      --moz-plugin-path=$out/${mozillaPluginPath} \
+      --wine-path=${wine_custom} \
+      --gpg-exec=${gnupg}/bin/gpg2 \
+      --bash-interp=${bash}/bin/bash \
+      --downloader=${curl}/bin/curl
+      $configureFlags
+  '';
+
+  passthru = {
+    mozillaPlugin = mozillaPluginPath;
+    wine = wine_custom;
+  };
+
+  postInstall = ''
+    $out/bin/pipelight-plugin --create-mozilla-plugins
+  '';
+
+  preFixup = ''
+    substituteInPlace $out/share/pipelight/install-dependency \
+      --replace cabextract ${cabextract}/bin/cabextract
+  '';
+
+  enableParallelBuilding = true;
+
+  meta = {
+    homepage = "http://pipelight.net/";
+    licenses = with stdenv.lib.licenses; [ mpl11 gpl2 lgpl21 ];
+    description = "A wrapper for using Windows plugins in Linux browsers";
+    maintainers = with stdenv.lib.maintainers; [skeidel];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

pkgs/tools/misc/pipelight/pipelight.patch

···
+diff -urN pipelight.old/bin/pipelight-plugin.in pipelight.new/bin/pipelight-plugin.in
+--- pipelight.old/bin/pipelight-plugin.in	2014-07-19 22:53:02.000000000 +0200
++++ pipelight.new/bin/pipelight-plugin.in	2014-07-27 00:02:39.275834030 +0200
+@@ -92,7 +92,7 @@
+	PLUGIN_PATH=$(realpath "$PLUGIN_PATH")
+
+	# Global installation
+-	if [ $(/usr/bin/id -u) -eq 0 ]; then
++	if [ $(id -u) -eq 0 ]; then
+		INSTALLDIR="$PLUGIN_PATH"
+
+	# Use environment variable (only if it doesn't point to the global directory)
+@@ -594,7 +594,7 @@
+	fi
+
+	# Ensure the signature is valid, extract the content
+-	if ! @@GPG@@ --batch --no-default-keyring --keyring "$PIPELIGHT_SHARE_PATH/sig-install-dependency.gpg" --decrypt "$tmpfile" > "$decfile"; then
++	if ! @@GPG@@ --homedir /tmp --batch --no-default-keyring --keyring "$PIPELIGHT_SHARE_PATH/sig-install-dependency.gpg" --decrypt "$tmpfile" > "$decfile"; then
+		rm "$tmpfile"
+		rm "$decfile"
+		echo ""
+@@ -630,24 +630,10 @@
+	return 0
+ }
+
+-# Use fetch on FreeBSD if wget is not available
+-if command -v wget >/dev/null 2>&1; then
+-	download_file()
+-	{
+-		wget -O "$1" "$2"
+-	}
+-elif command -v fetch >/dev/null 2>&1; then
+-	download_file()
+-	{
+-		fetch -o "$1" "$2"
+-	}
+-else
+-	download_file()
+-	{
+-		echo "ERROR: Could neither find wget nor fetch. Unable to download file!" >&2
+-		return 1
+-	}
+-fi
++download_file()
++{
++	curl --cacert /etc/ssl/certs/ca-bundle.crt -o "$1" "$2"
++}
+
+ # Use shasum instead of sha256sum on MacOS / *BSD
+ if ! command -v sha256sum >/dev/null 2>&1 && command -v shasum >/dev/null 2>&1; then
+diff -urN pipelight.old/configure pipelight.new/configure
+--- pipelight.old/configure	2014-07-19 22:53:02.000000000 +0200
++++ pipelight.new/configure	2014-07-26 23:52:13.690881447 +0200
+@@ -66,12 +66,8 @@
+ datadir=""
+ libdir=""
+ mandir=""
+-bash_interp="$(which bash)"
+-if which gpg &> /dev/null; then
+-	gpg_exec="$(which gpg)"
+-else
+-	gpg_exec="/usr/bin/gpg"
+-fi
++bash_interp=bash
++gpg_exec=gpg2
+ moz_plugin_path=""
+ gcc_runtime_dlls=""
+ so_mode="0644"
+diff -urN pipelight.old/Makefile pipelight.new/Makefile
+--- pipelight.old/Makefile	2014-07-19 22:53:02.000000000 +0200
++++ pipelight.new/Makefile	2014-07-26 23:25:22.020707765 +0200
+@@ -29,7 +29,7 @@
+			-e 's|@@BINDIR@@|$(bindir)|g' \
+			-e 's|@@DATADIR@@|$(datadir)|g' \
+			-e 's|@@GCC_RUNTIME_DLLS@@|$(gcc_runtime_dlls)|g' \
+-			-e 's|@@GPG@@|$(gpgexec)|g' \
++			-e 's|@@GPG@@|$(gpg_exec)|g' \
+			-e 's|@@LIBDIR@@|$(libdir)|g' \
+			-e 's|@@MANDIR@@|$(mandir)|g' \
+			-e 's|@@MOZ_PLUGIN_PATH@@|$(moz_plugin_path)|g' \
+@@ -69,12 +69,12 @@
+
+ .PHONY: prebuilt32
+ prebuilt32: config.make pluginloader-$(git_commit).tar.gz pluginloader-$(git_commit).tar.gz.sig
+-	$(gpgexec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"
++	$(gpg_exec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"
+	tar -xvf "pluginloader-$(git_commit).tar.gz" src/windows/pluginloader.exe src/winecheck/winecheck.exe
+
+ .PHONY: prebuilt64
+ prebuilt64: config.make pluginloader-$(git_commit).tar.gz pluginloader-$(git_commit).tar.gz.sig
+-	$(gpgexec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"
++	$(gpg_exec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"
+	tar -xvf "pluginloader-$(git_commit).tar.gz" src/windows/pluginloader64.exe src/winecheck/winecheck64.exe
+
+ .PHONY: pluginloader32
+diff -urN pipelight.old/share/install-dependency pipelight.new/share/install-dependency
+--- pipelight.old/share/install-dependency	2014-07-19 22:53:02.000000000 +0200
++++ pipelight.new/share/install-dependency	2014-07-26 23:26:18.431938546 +0200
+@@ -734,42 +734,14 @@
+	return 0
+ }
+
+-# Use fetch on FreeBSD if wget is not available
+-if command -v wget >/dev/null 2>&1; then
+-	download_file()
+-	{
+-		wget -O "$1" "$2"
+-	}
+-	get_download_size()
+-	{
+-		local filesize="$(wget -O- "$1" --spider --server-response 2>&1 | sed -ne '/Content-Length/{s/.*: //;p}')"
+-		local re='^[0-9]+$'
+-		if [[ "$filesize" -ne "0" ]] && [[ "$filesize" =~ $re ]]; then
+-			echo "$(($filesize/(1024*1024)))"
+-		else
+-			echo "N/A"
+-		fi
+-	}
+-elif command -v fetch >/dev/null 2>&1; then
+-	download_file()
+-	{
+-		fetch -o "$1" "$2"
+-	}
+-	get_download_size()
+-	{
+-		echo "N/A"
+-	}
+-else
+-	download_file()
+-	{
+-		echo "ERROR: Could neither find wget nor fetch. Unable to download file!" >&2
+-		return 1
+-	}
+-	get_download_size()
+-	{
+-		echo "N/A"
+-	}
+-fi
++download_file()
++{
++	curl --cacert /etc/ssl/certs/ca-bundle.crt -o "$1" "$2"
++}
++get_download_size()
++{
++	echo "N/A"
++}
+
+ # Use shasum instead of sha256sum on MacOS / *BSD
+ if ! command -v sha256sum >/dev/null 2>&1 && command -v shasum >/dev/null 2>&1; then

pkgs/tools/misc/tmux/default.nix

···
-{stdenv, fetchurl, ncurses, libevent, pkgconfig, makeWrapper}:
+{stdenv, fetchurl, ncurses, libevent, pkgconfig}:
 
 stdenv.mkDerivation rec {
   pname = "tmux";
···
 
   nativeBuildInputs = [ pkgconfig ];
 
-  buildInputs = [ ncurses libevent makeWrapper ];
+  buildInputs = [ ncurses libevent ];
 
   postInstall =
     ''
       mkdir -p $out/etc/bash_completion.d
       cp -v examples/bash_completion_tmux.sh $out/etc/bash_completion.d/tmux
-      wrapProgram $out/bin/tmux --prefix TERMINFO : $out/share/terminfo
     '';
 
   meta = {
···
           * Interactive menus to select windows, sessions or clients.
           * Change the current window by searching for text in the target.
           * Terminal locking, manually or after a timeout.
-          * A clean, easily extended, BSD-licensed codebase, under active development. 
+          * A clean, easily extended, BSD-licensed codebase, under active development.
       '';
 
     license = stdenv.lib.licenses.bsd3;

pkgs/tools/misc/youtube-dl/default.nix

···
     homepage = "http://rg3.github.com/youtube-dl/";
     repositories.git = https://github.com/rg3/youtube-dl.git;
     description = "Command-line tool to download videos from YouTube.com and other sites";
+    license = stdenv.lib.licenses.unlicense;
 
     platforms = with stdenv.lib.platforms; linux ++ darwin;
     maintainers = with stdenv.lib.maintainers; [ bluescreen303 simons phreedom ];

pkgs/tools/networking/cadaver/default.nix

···
-{ stdenv, fetchurl }:
+{ stdenv, fetchurl, openssl }:
 
 stdenv.mkDerivation rec {
   name = "cadaver-0.23.3";
···
     url = "http://www.webdav.org/cadaver/${name}.tar.gz";
     sha256 = "1jizq69ifrjbjvz5y79wh1ny94gsdby4gdxwjad4bfih6a5fck7x";
   };
+
+  buildInputs = [openssl];
+  configureFlags = ["--with-ssl"];
 
   meta = with stdenv.lib; {
     description = "A command-line WebDAV client for Unix";

pkgs/tools/networking/cjdns/default.nix

···
-{ stdenv, fetchgit, nodejs, which, python27 }:
+{ stdenv, fetchFromGitHub, nodejs, which, python27 }:
 
 let
-  date = "20140922";
-  rev = "5ebca772b0582173127e8c1e61ee235c5ab3fb50";
+  date = "20140928";
+  rev = "e2b673698e471dbc82b4e9dbc04cb9e16f1f06a6";
 in
 stdenv.mkDerivation {
   name = "cjdns-${date}-${stdenv.lib.strings.substring 0 7 rev}";
 
-  src = fetchgit {
-    url = "https://github.com/cjdelisle/cjdns.git";
+  src = fetchFromGitHub {
+    owner = "cjdelisle";
+    repo = "cjdns";
     inherit rev;
-    sha256 = "04abf73f4aede12c35b70ae09a367b3d6352a63f818185f788ed13356d06197a";
+    sha256 = "0ql51845rni6678dda03zr18ary7xlqcs3khva9x80x815h1sy8v";
   };
 
-  buildInputs = [ which python27 nodejs];
+  patches = [ ./rfc5952.patch ];
 
-  patches = [ ./makekey.patch ];
+  buildInputs = [ which python27 nodejs];
 
   buildPhase = "bash do";
-  installPhase = "installBin cjdroute makekey";
+  installPhase = "installBin cjdroute makekeys privatetopublic publictoip6";
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = https://github.com/cjdelisle/cjdns;
     description = "Encrypted networking for regular people";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [ viric emery ];
-    platforms = stdenv.lib.platforms.linux;
+    license = licenses.gpl3;
+    maintainers = with maintainers; [ viric emery ];
+    platforms = platforms.unix;
   };
 }

pkgs/tools/networking/cjdns/makekey.patch

···
-diff --git a/contrib/c/makekey.c b/contrib/c/makekey.c
-new file mode 100644
-index 0000000..c7184e5
---- /dev/null
-+++ b/contrib/c/makekey.c
-@@ -0,0 +1,46 @@
-+/* vim: set expandtab ts=4 sw=4: */
-+/*
-+ * You may redistribute this program and/or modify it under the terms of
-+ * the GNU General Public License as published by the Free Software Foundation,
-+ * either version 3 of the License, or (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
-+ */
-+#include "crypto/random/Random.h"
-+#include "memory/MallocAllocator.h"
-+#include "crypto/AddressCalc.h"
-+#include "util/AddrTools.h"
-+#include "util/Hex.h"
-+
-+#include "crypto_scalarmult_curve25519.h"
-+
-+#include <stdio.h>
-+
-+int main(int argc, char** argv)
-+{
-+    struct Allocator* alloc = MallocAllocator_new(1<<22);
-+    struct Random* rand = Random_new(alloc, NULL, NULL);
-+
-+    uint8_t privateKey[32];
-+    uint8_t publicKey[32];
-+    uint8_t ip[16];
-+    uint8_t hexPrivateKey[65];
-+
-+    for (;;) {
-+        Random_bytes(rand, privateKey, 32);
-+        crypto_scalarmult_curve25519_base(publicKey, privateKey);
-+        if (AddressCalc_addressForPublicKey(ip, publicKey)) {
-+            Hex_encode(hexPrivateKey, 65, privateKey, 32);
-+            printf(hexPrivateKey);
-+            return 0;
-+        }
-+    }
-+    return 0;
-+}
-+
-diff --git a/node_build/make.js b/node_build/make.js
-index 5e51645..11465e3 100644
---- a/node_build/make.js
-+++ b/node_build/make.js
-@@ -339,6 +339,7 @@ Builder.configure({
-     builder.buildExecutable('contrib/c/privatetopublic.c');
-     builder.buildExecutable('contrib/c/sybilsim.c');
-     builder.buildExecutable('contrib/c/makekeys.c');
-+    builder.buildExecutable('contrib/c/makekey.c');
- 
-     builder.buildExecutable('crypto/random/randombytes.c');
- 

pkgs/tools/networking/cjdns/rfc5952.patch

···
+diff --git a/admin/angel/cjdroute2.c b/admin/angel/cjdroute2.c
+index dfce6c6..77954a7 100644
+--- a/admin/angel/cjdroute2.c
++++ b/admin/angel/cjdroute2.c
+@@ -80,7 +80,7 @@ static int genAddress(uint8_t addressOut[40],
+         if (AddressCalc_addressForPublicKey(address.ip6.bytes, address.key)) {
+             Hex_encode(privateKeyHexOut, 65, privateKey, 32);
+             Base32_encode(publicKeyBase32Out, 53, address.key, 32);
+-            Address_printIp(addressOut, &address);
++            Address_printShortIp(addressOut, &address);
+             return 0;
+         }
+     }
+diff --git a/contrib/c/makekeys.c b/contrib/c/makekeys.c
+index 3727fff..29582f1 100644
+--- a/contrib/c/makekeys.c
++++ b/contrib/c/makekeys.c
+@@ -41,7 +41,7 @@ int main(int argc, char** argv)
+         if (AddressCalc_addressForPublicKey(ip, publicKey)) {
+             Hex_encode(hexPrivateKey, 65, privateKey, 32);
+             Base32_encode(publicKeyBase32, 53, publicKey, 32);
+-            AddrTools_printIp(printedIp, ip);
++            AddrTools_printShortIp(printedIp, ip);
+             printf("%s %s %s.k\n", hexPrivateKey, printedIp, publicKeyBase32);
+         }
+     }
+diff --git a/contrib/c/privatetopublic.c b/contrib/c/privatetopublic.c
+index 7f5f967..dc98f1c 100644
+--- a/contrib/c/privatetopublic.c
++++ b/contrib/c/privatetopublic.c
+@@ -73,7 +73,7 @@ int main(int argc, char** argv)
+     AddressCalc_addressForPublicKey(address.ip6.bytes, address.key);
+     if (address.ip6.bytes[0] == 0xFC) {
+         Base32_encode(publicKeyBase32Out, 53, address.key, 32);
+-        Address_printIp(addressOut, &address);
++        Address_printShortIp(addressOut, &address);
+         printf(    "Input privkey: %s\n"
+             "Matching pubkey: %s.k\n"
+             "Resulting address: %s\n"
+diff --git a/contrib/c/publictoip6.c b/contrib/c/publictoip6.c
+index fc92f7e..99afc4c 100644
+--- a/contrib/c/publictoip6.c
++++ b/contrib/c/publictoip6.c
+@@ -48,7 +48,7 @@ int main(int argc, char** argv)
+     }
+ 
+     uint8_t output[40] = {0};
+-    AddrTools_printIp(output, ip6Bytes);
++    AddrTools_printShortIp(output, ip6Bytes);
+     printf("%s\n", output);
+     return 0;
+ }
+diff --git a/dht/Address.c b/dht/Address.c
+index e4c2dba..ba77cad 100644
+--- a/dht/Address.c
++++ b/dht/Address.c
+@@ -102,6 +102,12 @@ void Address_printIp(uint8_t output[40], struct Address* addr)
+     AddrTools_printIp(output, addr->ip6.bytes);
+ }
+ 
++void Address_printShortIp(uint8_t output[40], struct Address* addr)
++{
++    Address_getPrefix(addr);
++    AddrTools_printShortIp(output, addr->ip6.bytes);
++}
++
+ void Address_print(uint8_t output[60], struct Address* addr)
+ {
+     Address_printIp(output, addr);
+diff --git a/dht/Address.h b/dht/Address.h
+index 43c6f05..f200b40 100644
+--- a/dht/Address.h
++++ b/dht/Address.h
+@@ -94,6 +94,8 @@ void Address_forKey(struct Address* out, const uint8_t key[Address_KEY_SIZE]);
+ 
+ void Address_printIp(uint8_t output[40], struct Address* addr);
+ 
++void Address_printShortIp(uint8_t output[40], struct Address* addr);
++
+ void Address_print(uint8_t output[60], struct Address* addr);
+ 
+ String* Address_toString(struct Address* addr, struct Allocator* alloc);
+diff --git a/net/Ducttape.c b/net/Ducttape.c
+index 84597d0..1813f3f 100644
+--- a/net/Ducttape.c
++++ b/net/Ducttape.c
+@@ -227,7 +227,7 @@ static inline bool isRouterTraffic(struct Message* message, struct Headers_IP6He
+ #define debugHandles(logger, session, message, ...) \
+     do {                                                                               \
+         uint8_t ip[40];                                                                \
+-        AddrTools_printIp(ip, session->ip6);                                           \
++        AddrTools_printIp(ip, session->ip6);                                      \
+         Log_debug(logger, "ver[%u] send[%d] recv[%u] ip[%s] " message,                 \
+                   session->version,                                                    \
+                   Endian_hostToBigEndian32(session->sendHandle_be),                    \
+@@ -271,10 +271,10 @@ static inline uint8_t incomingForMe(struct Message* message,
+     if (Bits_memcmp(addr.ip6.bytes, dtHeader->ip6Header->sourceAddr, 16)) {
+         #ifdef Log_DEBUG
+             uint8_t keyAddr[40];
+-            Address_printIp(keyAddr, &addr);
++            Address_printShortIp(keyAddr, &addr);
+             Bits_memcpyConst(addr.ip6.bytes, dtHeader->ip6Header->sourceAddr, 16);
+             uint8_t srcAddr[40];
+-            Address_printIp(srcAddr, &addr);
++            Address_printShortIp(srcAddr, &addr);
+             Log_debug(context->logger,
+                        "DROP packet because source address is not same as key.\n"
+                        "    %s source addr\n"
+@@ -292,7 +292,7 @@ static inline uint8_t incomingForMe(struct Message* message,
+         if (Checksum_udpIp6(dtHeader->ip6Header->sourceAddr, (uint8_t*)uh, message->length)) {
+             #ifdef Log_DEBUG
+                 uint8_t keyAddr[40];
+-                Address_printIp(keyAddr, &addr);
++                Address_printShortIp(keyAddr, &addr);
+                 Log_debug(context->logger,
+                           "DROP Router packet with incorrect checksum, from [%s]", keyAddr);
+             #endif
+@@ -708,7 +708,7 @@ static inline int core(struct Message* message,
+                     struct Address destination;
+                     Bits_memcpyConst(destination.ip6.bytes, ip6Header->destinationAddr, 16);
+                     uint8_t ipAddr[40];
+-                    Address_printIp(ipAddr, &destination);
++                    Address_printShortIp(ipAddr, &destination);
+                     Log_debug(context->logger, "Forwarding data to %s via %s\n", ipAddr, nhAddr);
+                 #endif */
+             } else {
+@@ -723,7 +723,7 @@ static inline int core(struct Message* message,
+         struct Address destination;
+         Bits_memcpyConst(destination.ip6.bytes, ip6Header->destinationAddr, 16);
+         uint8_t ipAddr[40];
+-        Address_printIp(ipAddr, &destination);
++        Address_printShortIp(ipAddr, &destination);
+         Log_info(context->logger, "DROP message because this node is the closest known "
+                                    "node to the destination %s.", ipAddr);
+     #endif
+diff --git a/test/printIp_test.c b/test/printIp_test.c
+new file mode 100644
+index 0000000..75d7427
+--- /dev/null
++++ b/test/printIp_test.c
+@@ -0,0 +1,54 @@
++/* vim: set expandtab ts=4 sw=4: */
++/*
++ * You may redistribute this program and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation,
++ * either version 3 of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "crypto/random/Random.h"
++#include "memory/MallocAllocator.h"
++#include "util/AddrTools.h"
++#include "util/Assert.h"
++
++#include <stdio.h>
++
++int main()
++{
++    struct Allocator* alloc = MallocAllocator_new(1<<22);
++    struct Random* rand = Random_new(alloc, NULL, NULL);
++
++    uint8_t ip[16];
++    uint8_t printedIp[40];
++    uint8_t printedShortIp[40];
++    uint8_t ipFromFull[16];
++    uint8_t ipFromShort[16];
++
++    for (int i = 0; i < 1024; ++i) {
++        Random_bytes(rand, ip, 16);
++
++        for (int j = 0; j < 16; j++) {
++            // make the random result have lots of zeros since that's what we're looking for.
++            ip[j] = (ip[j] % 2) ? 0 : ip[j];
++        }
++
++        AddrTools_printIp(printedIp, ip);
++        AddrTools_printShortIp(printedShortIp, ip);
++        //printf("%s\n%s\n\n", printedIp, printedShortIp);
++
++        AddrTools_parseIp(ipFromFull, printedIp);
++        AddrTools_parseIp(ipFromShort, printedShortIp);
++
++        Assert_true(0 == Bits_memcmp(ip, ipFromFull, 16));
++        Assert_true(0 == Bits_memcmp(ipFromFull, ipFromShort, 16));
++    }
++
++    return 0;
++}
+diff --git a/util/AddrTools.h b/util/AddrTools.h
+index 858ced4..d59544d 100644
+--- a/util/AddrTools.h
++++ b/util/AddrTools.h
+@@ -143,6 +143,44 @@ static inline void AddrTools_printIp(uint8_t output[40], const uint8_t binIp[16]
+     output[39] = '\0';
+ }
+ 
++static inline void AddrTools_printShortIp(uint8_t output[40], const uint8_t binIp[16])
++{
++    /* The chances of hitting :0:0: and breaking
++     * RFC5952 are 1 in (1 / (2^16))^2 * 6.
++     * E. Siler
++     */
++
++    char *p = output;
++    int i = 0;
++    for (; i < 16;) {
++        if ((size_t)p != (size_t)output) {
++            *p++= ':';
++        }
++
++        if (binIp[i] > 0x0F) {
++            Hex_encode(p, 2, &binIp[i++], 1);
++            p += 2;
++        } else if (binIp[i] > 0x00) {
++            *p++ = Hex_encodeLowNibble(binIp[i++]);
++        } else {
++            ++i;
++            if (binIp[i] > 0x0F) {
++                Hex_encode(p, 2, &binIp[i++], 1);
++                p += 2;
++            } else {
++                *p++ = Hex_encodeLowNibble(binIp[i++]);
++            }
++            continue;
++        }
++        Hex_encode(p, 2, &binIp[i++], 1);
++        p += 2;
++    }
++    *p = '\0';
++
++    Assert_true((size_t)p <= ((size_t)output + 40));
++    Assert_true(i <= 16);
++}
++
+ /**
+  * Parse out an address.
+  *
+diff --git a/util/Hex.c b/util/Hex.c
+index e3e3c4d..b9bce57 100644
+--- a/util/Hex.c
++++ b/util/Hex.c
+@@ -29,6 +29,8 @@ static const uint8_t numForAscii[] =
+     99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,
+ };
+ 
++static const char* hexEntities = "0123456789abcdef";
++
+ int Hex_encode(uint8_t* output,
+                const uint32_t outputLength,
+                const uint8_t* in,
+@@ -40,8 +42,6 @@ int Hex_encode(uint8_t* output,
+         output[inputLength * 2] = '\0';
+     }
+ 
+-    static const char* hexEntities = "0123456789abcdef";
+-
+     for (uint32_t i = 0; i < inputLength; i++) {
+         output[i * 2] = hexEntities[in[i] >> 4];
+         output[i * 2 + 1] = hexEntities[in[i] & 15];
+@@ -88,3 +88,8 @@ int Hex_decode(uint8_t* output,
+ 
+     return length / 2;
+ }
++
++uint8_t Hex_encodeLowNibble(const uint8_t nibble)
++{
++    return hexEntities[nibble & 15];
++}
+diff --git a/util/Hex.h b/util/Hex.h
+index 4570c3e..a12e402 100644
+--- a/util/Hex.h
++++ b/util/Hex.h
+@@ -41,4 +41,6 @@ bool Hex_isHexEntity(const uint8_t character);
+ 
+ int Hex_decodeByte(const uint8_t highNibble, const uint8_t lowNibble);
+ 
++uint8_t Hex_encodeLowNibble(const uint8_t nibble);
++
+ #endif

pkgs/tools/networking/dhcpcd/default.nix

···
 { stdenv, fetchurl, pkgconfig, udev }:
 
 stdenv.mkDerivation rec {
-  name = "dhcpcd-6.4.7";
+  name = "dhcpcd-6.5.1";
 
   src = fetchurl {
     url = "http://roy.marples.name/downloads/dhcpcd/${name}.tar.bz2";
-    sha256 = "11z14nxk91g232zk4j17b822b7lvrzaa9kaxz0n6nhvihsb8025v";
+    sha256 = "0y0falxxlahr2i630ydraq4ldr7d5mg8ar0s5np5ddl76w58dlrp";
   };
 
   patches = [ /* ./lxc_ro_promote_secondaries.patch */ ];

pkgs/tools/networking/p2p/tahoe-lafs/default.nix

···
     '';
 
     homepage = http://allmydata.org/;
-
-    # TODO license = [ lib.licenses.gpl2Plus /* or */ "TGPPLv1+" ];
-
+    license = [ lib.licenses.gpl2Plus /* or */ "TGPPLv1+" ];
     maintainers = [ lib.maintainers.simons  ];
     platforms = lib.platforms.gnu;  # arbitrary choice
   };

pkgs/tools/networking/radvd/default.nix

···
 { stdenv, fetchurl, pkgconfig, libdaemon, bison, flex, check }:
 
 stdenv.mkDerivation rec {
-  name = "radvd-2.7";
+  name = "radvd-2.8";
   
   src = fetchurl {
     url = "http://www.litech.org/radvd/dist/${name}.tar.xz";
-    sha256 = "09rzw96cjkzywadxmhbhaw52ahawzjp3pv7pblcsnb0mrwaawny0";
+    sha256 = "1y8d8k457apc5wrzc80sdkbvwynvvax31z5rh9ca9bsd0jr4240a";
   };
 
   buildInputs = [ pkgconfig libdaemon bison flex check ];

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

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "nix-1.8pre3843_3f8576";
+  name = "nix-1.8pre3861_bca6d35";
 
   src = fetchurl {
-    url = "http://hydra.nixos.org/build/15588665/download/4/${name}.tar.xz";
-    sha256 = "23befe1b5ecff38cc1088b98f221893f87d47e3335b381090ce13e9dd6c6eb87";
+    url = http://hydra.nixos.org/build/15940830/download/4/nix-1.8pre3861_bca6d35.tar.xz;
+    sha256 = "f2c5d2669c69a23fc8510d08beb48210da72cb4ec8fe334eff476b93f76d744f";
   };
 
   nativeBuildInputs = [ perl pkgconfig ];

pkgs/tools/system/safe-rm/default.nix

···
+{ stdenv, fetchgit, perl, coreutils }:
+
+stdenv.mkDerivation rec {
+  name = "safe-rm-${version}";
+  version = "0.11";
+
+  src = fetchgit {
+    url = "https://gitorious.org/safe-rm/mainline.git";
+    rev = "refs/tags/${name}";
+    sha256 = "1csnqq22pfbg9dwhv13x60jih0gn07bn5rwg2nhi0dsslzk4l496";
+  };
+
+  propagatedBuildInputs = [ perl coreutils ];
+
+  postFixup = ''
+    sed -e 's@/bin/rm@${coreutils}/bin/rm@' -i $out/bin/safe-rm
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp safe-rm $out/bin
+
+    mkdir -p $out/share/man/man1
+    pod2man safe-rm > $out/share/man/man1/safe-rm.1
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Tool intended to prevent the accidental deletion of important files.";
+    homepage = https://launchpad.net/safe-rm;
+    license = licenses.gpl3;
+    platforms = platforms.all;
+    maintainers = [ maintainers.koral ];
+  };
+}

pkgs/top-level/all-packages.nix

···
     inherit stdenv;
   };
 
+  substituteAllFiles = import ../build-support/substitute-files/substitute-all-files.nix {
+    inherit stdenv;
+  };
+
   replaceDependency = import ../build-support/replace-dependency.nix {
     inherit runCommand nix lib;
   };
···
 
   bitbucket-cli = pythonPackages.bitbucket-cli;
 
+  blink = callPackage ../applications/networking/instant-messengers/blink { };
+
   blockdiag = pythonPackages.blockdiag;
 
   bmon = callPackage ../tools/misc/bmon { };
···
   chkrootkit = callPackage ../tools/security/chkrootkit { };
 
   chocolateDoom = callPackage ../games/chocolate-doom { };
-  # master is here because chocolateDoom v2.0 has broken netplay
-  chocolateDoomMaster = callPackage ../games/chocolate-doom/master.nix { };
 
   chrony = callPackage ../tools/networking/chrony { };
 
···
 
   jwhois = callPackage ../tools/networking/jwhois { };
 
+  k2pdfopt = callPackage ../applications/misc/k2pdfopt { };
+
   kazam = callPackage ../applications/video/kazam { };
 
   kalibrate-rtl = callPackage ../tools/misc/kalibrate-rtl { };
···
   openobex = callPackage ../tools/bluetooth/openobex { };
 
   openopc = callPackage ../tools/misc/openopc {
-    pythonFull = python27FullBuildEnv.override {
+    pythonFull = python27.buildEnv.override {
       extraLibs = [ python27Packages.pyro3 ];
     };
   };
···
   prey-bash-client = callPackage ../tools/security/prey { };
 
   projectm = callPackage ../applications/audio/projectm { };
+
+  proot = callPackage ../tools/system/proot { };
 
   proxychains = callPackage ../tools/networking/proxychains { };
 
···
 
   rpm = callPackage ../tools/package-management/rpm { };
 
+  rpmextract = callPackage ../tools/archivers/rpmextract { };
+
   rrdtool = callPackage ../tools/misc/rrdtool { };
 
   rtorrent = callPackage ../tools/networking/p2p/rtorrent { };
···
   sablotron = callPackage ../tools/text/xml/sablotron { };
 
   safecopy = callPackage ../tools/system/safecopy { };
+
+  safe-rm = callPackage ../tools/system/safe-rm { };
 
   salut_a_toi = callPackage ../applications/networking/instant-messengers/salut-a-toi {};
 
···
     llvm = llvm_34;
     openblas = openblas_0_2_10;
   };
-  julia = julia030;
+  julia031 = let
+    liblapack = liblapack_3_5_0.override {shared = true;};
+  in callPackage ../development/compilers/julia/0.3.1.nix {
+    inherit liblapack;
+    suitesparse = suitesparse.override {
+      inherit liblapack;
+    };
+    llvm = llvm_34;
+    openblas = openblas_0_2_10;
+  };
+  julia = julia031;
 
   lazarus = builderDefsPackage (import ../development/compilers/fpc/lazarus.nix) {
     inherit makeWrapper gtk glib pango atk gdk_pixbuf;
···
 
   roadsend = callPackage ../development/compilers/roadsend { };
 
-  rustc       = callPackage ../development/compilers/rustc/0.11.nix {};
+  rustc       = callPackage ../development/compilers/rustc/0.12.nix {};
   rustcMaster = callPackage ../development/compilers/rustc/head.nix {};
 
   rust = rustc;
···
   clisp = callPackage ../development/interpreters/clisp { };
 
   # compatibility issues in 2.47 - at list 2.44.1 is known good
-  # for sbcl bootstrap
+  # for sbcl bootstrap.
+  # SBCL page recommends 2.33.2, though. Not sure when was it last tested
   clisp_2_44_1 = callPackage ../development/interpreters/clisp/2.44.1.nix {
     libsigsegv = libsigsegv_25;
   };
···
   python2Packages = python27Packages;
   python3Packages = python34Packages;
 
-  python26 = callPackage ../development/interpreters/python/2.6 { db = db47; };
-  python27 = callPackage ../development/interpreters/python/2.7 { };
-  python32 = callPackage ../development/interpreters/python/3.2 { };
-  python33 = callPackage ../development/interpreters/python/3.3 { };
-  python34 = hiPrio (callPackage ../development/interpreters/python/3.4 { });
-
-  pypy = callPackage ../development/interpreters/pypy/2.4 { };
+  python26 = callPackage ../development/interpreters/python/2.6 {
+    db = db47;
+    self = python26;
+  };
+  python27 = callPackage ../development/interpreters/python/2.7 {
+    self = python27;
+  };
+  python32 = callPackage ../development/interpreters/python/3.2 {
+    self = python32;
+  };
+  python33 = callPackage ../development/interpreters/python/3.3 {
+    self = python33;
+  };
+  python34 = hiPrio (callPackage ../development/interpreters/python/3.4 {
+    self = python34;
+  });
+  pypy = callPackage ../development/interpreters/pypy/2.4 {
+    self = pypy;
+  };
 
   pythonFull = python2Full;
   python2Full = python27Full;
   python26Full = python26.override {
     includeModules = true;
+    self = python26Full;
   };
   python27Full = python27.override {
     includeModules = true;
-  };
-  python26FullBuildEnv = callPackage ../development/interpreters/python/wrapper.nix {
-    python = python26Full;
-    inherit (python26Packages) recursivePthLoader;
-  };
-  python27FullBuildEnv = callPackage ../development/interpreters/python/wrapper.nix {
-    python = python27Full;
-    inherit (python27Packages) recursivePthLoader;
+    self = python27Full;
   };
-  pythonFullBuildEnv = python2FullBuildEnv;
-  python2FullBuildEnv = python27FullBuildEnv;
 
   python2nix = callPackage ../tools/package-management/python2nix { };
 
···
   tcl = callPackage ../development/interpreters/tcl { };
 
   xulrunner = callPackage ../development/interpreters/xulrunner {
+    stdenv = if stdenv.isLinux then useGoldLinker stdenv else stdenv;
     inherit (gnome) libIDL;
     inherit (pythonPackages) pysqlite;
   };
···
     inherit (gnome) gtkdoc;
   };
 
+  libinput = callPackage ../development/libraries/libinput { };
+
   libiptcdata = callPackage ../development/libraries/libiptcdata { };
 
   libjpeg_original = callPackage ../development/libraries/libjpeg { };
···
 
   physfs = callPackage ../development/libraries/physfs { };
 
+  pipelight = callPackage ../tools/misc/pipelight { };
+
   pkcs11helper = callPackage ../development/libraries/pkcs11helper { };
 
   plib = callPackage ../development/libraries/plib { };
···
       stdenv = stdenv_32bit;
       inherit (gnome) libIDL;
       enableExtensionPack = config.virtualbox.enableExtensionPack or false;
+      pulseSupport = config.pulseaudio or false;
     };
 
     virtualboxGuestAdditions = callPackage ../applications/virtualization/virtualbox/guest-additions { };
···
     libXaw = xlibs.libXaw;
     Xaw3d = null;
     gconf = null;
-    librsvg = null;
     alsaLib = null;
     imagemagick = null;
   };
···
     graphvizDot = callPackage ../applications/editors/emacs-modes/graphviz-dot { };
 
     gist = callPackage ../applications/editors/emacs-modes/gist { };
+
+    gitModes = callPackage ../applications/editors/emacs-modes/git-modes { };
 
     haskellMode = callPackage ../applications/editors/emacs-modes/haskell { };
 
···
     stratego = callPackage ../applications/editors/emacs-modes/stratego { };
 
     structuredHaskellMode = callPackage ../applications/editors/emacs-modes/structured-haskell-mode {
-      inherit (haskellPackages) cabal haskellSrcExts;
+      inherit (haskellPackages) cabal ;
+      haskellSrcExts = haskellPackages.haskellSrcExts_1_15_0_1;
     };
 
     sunriseCommander = callPackage ../applications/editors/emacs-modes/sunrise-commander { };
···
   firefox13Wrapper = wrapFirefox { browser = firefox13Pkgs.firefox; };
 
   firefox = callPackage ../applications/networking/browsers/firefox {
+    stdenv = if stdenv.isLinux then useGoldLinker stdenv else stdenv;
     inherit (gnome) libIDL;
     inherit (pythonPackages) pysqlite;
   };
···
 
   ncmpcpp = callPackage ../applications/audio/ncmpcpp { };
 
+  ncmpcppBeta = callPackage ../applications/audio/ncmpcpp/beta.nix { };
+
   normalize = callPackage ../applications/audio/normalize { };
 
   mplayer = callPackage ../applications/video/mplayer {
···
                                     })
                                  );
 
-  sxiv = callPackage ../applications/graphics/sxiv { };
+  sxiv = callPackage ../applications/graphics/sxiv {
+    giflib = giflib_5_0;
+  };
 
   bittorrentSync = callPackage ../applications/networking/bittorrentsync { };
 
···
 
   vim = callPackage ../applications/editors/vim { };
 
-  macvim = callPackage ../applications/editors/vim/macvim.nix { };
+  macvim = callPackage ../applications/editors/vim/macvim.nix { stdenv = clangStdenv; };
 
   vimHugeX = vim_configurable;
 
···
   };
 
   vimNox = lowPrio (vim_configurable.override { source = "vim-nox"; });
+
+  qpdfview = callPackage ../applications/misc/qpdfview {};
 
   qvim = lowPrio (callPackage ../applications/editors/vim/qvim.nix {
     inherit (pkgs) fetchgit stdenv ncurses pkgconfig gettext
···
 
   weechatDevel = lowPrio (callPackage ../applications/networking/irc/weechat/devel.nix { });
 
-  weston = callPackage ../applications/window-managers/weston { };
+  westonLite = callPackage ../applications/window-managers/weston {
+    pango = null;
+    freerdp = null;
+    libunwind = null;
+    vaapi = null;
+    libva = null;
+    libwebp = null;
+  };
+
+  weston = callPackage ../applications/window-managers/weston {
+    freerdp = freerdpUnstable;
+  };
 
   windowmaker = callPackage ../applications/window-managers/windowmaker { };
 
···
     coqExtLib = callPackage ../development/coq-modules/coq-ext-lib {};
 
     domains = callPackage ../development/coq-modules/domains {};
+
+    flocq = callPackage ../development/coq-modules/flocq {};
 
     heq = callPackage ../development/coq-modules/heq {};
 

pkgs/top-level/haskell-defaults.nix

···
     cabalInstall_1_20_0_3 = super.cabalInstall_1_20_0_3.override { Cabal = self.Cabal_1_20_0_2; };
     codex = super.codex.override { hackageDb = super.hackageDb.override { Cabal = self.Cabal_1_20_0_2; }; };
     MonadRandom = self.MonadRandom_0_1_13; # requires transformers >= 0.4.x
-    mtl = self.mtl_2_1_2;
+    mtl = self.mtl_2_1_3_1;
   };
 
   ghc763Prefs = self : super : ghc783Prefs self super // {
···
         vectorBinaryInstances = self.vectorBinaryInstances.override { binary = self.binary_0_7_2_2; };
       };
     };
-    Elm = super.Elm.override { pandoc = self.pandoc.override { zipArchive = self.zipArchive.override { binary = self.binary_0_7_2_2; }; }; };
     gloss = null;                       # requires base >= 4.7
     haddock = self.haddock_2_13_2;
     modularArithmetic = null;           # requires base >= 4.7

pkgs/top-level/haskell-packages.nix

···
 
   aeson_0_7_0_4 = callPackage ../development/libraries/haskell/aeson/0.7.0.4.nix { blazeBuilder = null; };
   aeson_0_7_0_6 = callPackage ../development/libraries/haskell/aeson/0.7.0.6.nix { blazeBuilder = null; };
-  aeson_0_8_0_1 = callPackage ../development/libraries/haskell/aeson/0.8.0.1.nix { blazeBuilder = null; };
-  aeson = self.aeson_0_8_0_1;
+  aeson_0_8_0_2 = callPackage ../development/libraries/haskell/aeson/0.8.0.2.nix { blazeBuilder = null; };
+  aeson = self.aeson_0_8_0_2;
 
   aesonPretty = callPackage ../development/libraries/haskell/aeson-pretty {};
 
···
 
   charset = callPackage ../development/libraries/haskell/charset {};
 
+  charsetdetectAe = callPackage ../development/libraries/haskell/charsetdetect-ae {};
+
   Chart = callPackage ../development/libraries/haskell/Chart {};
   ChartCairo = callPackage ../development/libraries/haskell/Chart-cairo {};
   ChartDiagrams = callPackage ../development/libraries/haskell/Chart-diagrams {};
···
 
   dbus = callPackage ../development/libraries/haskell/dbus {};
 
+  Decimal = callPackage ../development/libraries/haskell/Decimal {};
+
   deepseq_1_1_0_0 = callPackage ../development/libraries/haskell/deepseq/1.1.0.0.nix {};
   deepseq_1_1_0_2 = callPackage ../development/libraries/haskell/deepseq/1.1.0.2.nix {};
   deepseq_1_2_0_1 = callPackage ../development/libraries/haskell/deepseq/1.2.0.1.nix {};
···
 
   executablePath = callPackage ../development/libraries/haskell/executable-path {};
 
-  Extra = callPackage ../development/libraries/haskell/Extra {};
+  Extra = callPackage ../development/libraries/haskell/Extra-lib {};
 
   fay = callPackage ../development/libraries/haskell/fay {};
 
···
   extensibleExceptions_0_1_1_3 = callPackage ../development/libraries/haskell/extensible-exceptions/0.1.1.3.nix {};
   extensibleExceptions_0_1_1_4 = callPackage ../development/libraries/haskell/extensible-exceptions/0.1.1.4.nix {};
   extensibleExceptions = self.extensibleExceptions_0_1_1_4;
+
+  extra = callPackage ../development/libraries/haskell/extra {};
 
   failure = callPackage ../development/libraries/haskell/failure {};
 
···
 
   groupoids = callPackage ../development/libraries/haskell/groupoids {};
 
-  hakyll = callPackage ../development/libraries/haskell/hakyll {};
+  hakyll = callPackage ../development/libraries/haskell/hakyll {
+    pandocCiteproc = self.pandocCiteproc_0_4;
+  };
 
   hamlet = callPackage ../development/libraries/haskell/hamlet {};
 
···
 
   hi = callPackage ../development/libraries/haskell/hi {};
 
-  hindent = callPackage ../development/libraries/haskell/hindent {};
+  hindent = callPackage ../development/libraries/haskell/hindent {
+    haskellSrcExts = self.haskellSrcExts_1_15_0_1;
+  };
 
   hint = callPackage ../development/libraries/haskell/hint {};
 
···
 
   hoodleTypes = callPackage ../development/libraries/haskell/hoodle-types {};
 
-  hoogle = callPackage ../development/libraries/haskell/hoogle {};
+  hoogle_4_2_34 = callPackage ../development/libraries/haskell/hoogle/4.2.34.nix { haskellSrcExts = self.haskellSrcExts_1_15_0_1; };
+  hoogle_4_2_36 = callPackage ../development/libraries/haskell/hoogle/4.2.36.nix {};
+  hoogle = self.hoogle_4_2_36;
+
   hoogleLocal = callPackage ../development/libraries/haskell/hoogle/local.nix {};
 
   hopenssl = callPackage ../development/libraries/haskell/hopenssl {};
···
   hspecExpectationsLens = callPackage ../development/libraries/haskell/hspec-expectations-lens {};
 
   hspecMeta = callPackage ../development/libraries/haskell/hspec-meta {};
+
+  hspecCheckers = callPackage ../development/libraries/haskell/hspec-checkers {};
 
   hstatsd = callPackage ../development/libraries/haskell/hstatsd {};
 
···
 
   languageHaskellExtract = callPackage ../development/libraries/haskell/language-haskell-extract {};
 
-  lambdabot = callPackage ../development/libraries/haskell/lambdabot {};
+  lambdabot = callPackage ../development/libraries/haskell/lambdabot {
+    haskellSrcExts = self.haskellSrcExts_1_15_0_1;
+    hoogle = self.hoogle_4_2_34.override {
+      haskellSrcExts = self.haskellSrcExts_1_15_0_1;
+    };
+  };
 
   lambdabotWrapper = callPackage ../development/libraries/haskell/lambdabot/wrapper.nix {
     mueval = self.muevalWrapper.override {
···
   mtl_2_0_1_0 = callPackage ../development/libraries/haskell/mtl/2.0.1.0.nix {};
   mtl_2_1_1 = callPackage ../development/libraries/haskell/mtl/2.1.1.nix {};
   mtl_2_1_2 = callPackage ../development/libraries/haskell/mtl/2.1.2.nix {};
+  mtl_2_1_3_1 = callPackage ../development/libraries/haskell/mtl/2.1.3.1.nix {};
   mtl_2_2_1 = callPackage ../development/libraries/haskell/mtl/2.2.1.nix {};
   mtl = null; # tightly coupled with 'transformers' which is a core package
 
···
 
   pandoc = callPackage ../development/libraries/haskell/pandoc {};
 
-  pandocCiteproc = callPackage ../development/libraries/haskell/pandoc-citeproc {};
+  pandocCiteproc_0_4 = callPackage ../development/libraries/haskell/pandoc-citeproc/0.4.nix {};
+  pandocCiteproc_0_5 = callPackage ../development/libraries/haskell/pandoc-citeproc/0.5.nix {};
+  pandocCiteproc_0_6 = callPackage ../development/libraries/haskell/pandoc-citeproc/0.6.nix {};
+  pandocCiteproc = self.pandocCiteproc_0_6;
 
   pandocTypes = callPackage ../development/libraries/haskell/pandoc-types {};
 
···
 
   void = callPackage ../development/libraries/haskell/void {};
 
-  vty_4_7_5 = callPackage ../development/libraries/haskell/vty/4.7.5.nix {};
-  vty_5_2_3 = callPackage ../development/libraries/haskell/vty/5.2.3.nix {};
-  vty = self.vty_5_2_3;
+  vty = callPackage ../development/libraries/haskell/vty {};
 
-  vtyUi = callPackage ../development/libraries/haskell/vty-ui {
-    vty = self.vty_4_7_5;
-  };
+  vtyUi = callPackage ../development/libraries/haskell/vty-ui {};
 
   wai = callPackage ../development/libraries/haskell/wai {};
 
···
 
   wordTrie = callPackage ../development/libraries/haskell/word-trie {};
 
-  # You should prefer ‘yiCustom’ over ‘yi’ unless you never plan to
-  # use any external libraries in your config.
+  # This is an unwrapped version of Yi, it will not behave well (no
+  # M-x or reload). Use ‘yiCustom’ instead.
   yi = callPackage ../applications/editors/yi/yi.nix { };
 
   yiContrib = callPackage ../development/libraries/haskell/yi-contrib {};
 
   yiCustom = callPackage ../applications/editors/yi/yi-custom.nix {
-    extraPackages = [];
+    extraPackages = pkgs: [];
   };
 
   yiLanguage = callPackage ../development/libraries/haskell/yi-language {};
···
 
       buildCommand = ''
       export HOME="$TMPDIR"
-      ${nativePkgs.haskellPackages.cabal2nix}/bin/cabal2nix ${src + "/${name}.cabal"} --sha256=FILTERME \
-          | grep -v FILTERME | sed \
-            -e 's/licenses.proprietary/licenses.unfree/' \
-            -e 's/{ cabal/{ cabal, cabalInstall, cabalDrvArgs ? {}, src/' \
-            -e 's/cabal.mkDerivation (self: {/cabal.mkDerivation (self: cabalDrvArgs \/\/ {/' \
-            -e 's/buildDepends = \[/buildDepends = \[ cabalInstall/' \
-            -e 's/pname = \([^\n]*\)/pname = \1\n  inherit src;\n/'  > $out
+      ${nativePkgs.haskellPackages.cabal2nix}/bin/cabal2nix ${src} \
+          | sed -e 's/licenses.proprietary/licenses.unfree/' > $out
       '';
 
     } // pkgs.lib.optionalAttrs nativePkgs.stdenv.isLinux {
       LANG = "en_US.UTF-8";
       LOCALE_ARCHIVE = "${nativePkgs.glibcLocales}/lib/locale/locale-archive";
     });
-  in callPackage cabalExpr ({ inherit src cabalDrvArgs; } // args);
+  in callPackage cabalExpr {
+    cabal = self.cabal.override {
+      extension = eself: esuper: {
+        buildDepends = [ self.cabalInstall ] ++ esuper.buildDepends;
+      } // cabalDrvArgs;
+    };
+  };
 
   buildLocalCabal = src: name: self.buildLocalCabalWithArgs { inherit src name; };
 

pkgs/top-level/node-packages-generated.nix

···
     ];
     passthru.names = [ "accepts" ];
   };
-  by-spec."accepts"."~1.1.0" =
-    self.by-version."accepts"."1.1.1";
-  by-version."accepts"."1.1.1" = lib.makeOverridable self.buildNodePackage {
-    name = "accepts-1.1.1";
+  by-spec."accepts"."~1.1.2" =
+    self.by-version."accepts"."1.1.2";
+  by-version."accepts"."1.1.2" = lib.makeOverridable self.buildNodePackage {
+    name = "accepts-1.1.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/accepts/-/accepts-1.1.1.tgz";
-        name = "accepts-1.1.1.tgz";
-        sha1 = "3b40bf6abc3fe3bc004534f4672ae1efd0063a96";
+        url = "http://registry.npmjs.org/accepts/-/accepts-1.1.2.tgz";
+        name = "accepts-1.1.2.tgz";
+        sha1 = "8469a0a0a215b50cb0d156d351662f8978b00876";
       })
     ];
     buildInputs =
       (self.nativeDeps."accepts" or []);
     deps = {
       "mime-types-2.0.2" = self.by-version."mime-types"."2.0.2";
-      "negotiator-0.4.8" = self.by-version."negotiator"."0.4.8";
+      "negotiator-0.4.9" = self.by-version."negotiator"."0.4.9";
     };
     peerDependencies = [
     ];
···
       "glob-3.2.11" = self.by-version."glob"."3.2.11";
       "lazystream-0.1.0" = self.by-version."lazystream"."0.1.0";
       "lodash-2.4.1" = self.by-version."lodash"."2.4.1";
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
       "tar-stream-0.4.7" = self.by-version."tar-stream"."0.4.7";
       "zip-stream-0.4.1" = self.by-version."zip-stream"."0.4.1";
     };
···
     ];
     passthru.names = [ "archiver" ];
   };
-  by-spec."archy"."0" =
+  by-spec."archy"."0.0.2" =
     self.by-version."archy"."0.0.2";
   by-version."archy"."0.0.2" = lib.makeOverridable self.buildNodePackage {
     name = "archy-0.0.2";
···
     ];
     passthru.names = [ "archy" ];
   };
-  by-spec."archy"."0.0.2" =
-    self.by-version."archy"."0.0.2";
   by-spec."archy"."^0.0.2" =
     self.by-version."archy"."0.0.2";
+  by-spec."archy"."~1.0.0" =
+    self.by-version."archy"."1.0.0";
+  by-version."archy"."1.0.0" = lib.makeOverridable self.buildNodePackage {
+    name = "archy-1.0.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/archy/-/archy-1.0.0.tgz";
+        name = "archy-1.0.0.tgz";
+        sha1 = "f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."archy" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "archy" ];
+  };
   by-spec."argparse"."0.1.15" =
     self.by-version."argparse"."0.1.15";
   by-version."argparse"."0.1.15" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "asap" ];
   };
+  by-spec."asap"."~1.0.0" =
+    self.by-version."asap"."1.0.0";
   by-spec."ascii-json"."~0.2" =
     self.by-version."ascii-json"."0.2.0";
   by-version."ascii-json"."0.2.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "async-some" ];
   };
   by-spec."aws-sdk"."*" =
-    self.by-version."aws-sdk"."2.0.18";
-  by-version."aws-sdk"."2.0.18" = lib.makeOverridable self.buildNodePackage {
-    name = "aws-sdk-2.0.18";
+    self.by-version."aws-sdk"."2.0.21";
+  by-version."aws-sdk"."2.0.21" = lib.makeOverridable self.buildNodePackage {
+    name = "aws-sdk-2.0.21";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.18.tgz";
-        name = "aws-sdk-2.0.18.tgz";
-        sha1 = "aea83ffff08de9dd167f785d04b463025078c790";
+        url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.21.tgz";
+        name = "aws-sdk-2.0.21.tgz";
+        sha1 = "aece051188e5d4a13f2432eb1d00f9dd9a81ef54";
       })
     ];
     buildInputs =
       (self.nativeDeps."aws-sdk" or []);
     deps = {
-      "aws-sdk-apis-3.1.9" = self.by-version."aws-sdk-apis"."3.1.9";
       "xml2js-0.2.6" = self.by-version."xml2js"."0.2.6";
       "xmlbuilder-0.4.2" = self.by-version."xmlbuilder"."0.4.2";
     };
···
     ];
     passthru.names = [ "aws-sdk" ];
   };
-  "aws-sdk" = self.by-version."aws-sdk"."2.0.18";
+  "aws-sdk" = self.by-version."aws-sdk"."2.0.21";
   by-spec."aws-sdk".">=1.2.0 <2" =
     self.by-version."aws-sdk"."1.18.0";
   by-version."aws-sdk"."1.18.0" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "aws-sdk" ];
   };
-  by-spec."aws-sdk-apis".">=3.1.0 <4.0.0" =
-    self.by-version."aws-sdk-apis"."3.1.9";
-  by-version."aws-sdk-apis"."3.1.9" = lib.makeOverridable self.buildNodePackage {
-    name = "aws-sdk-apis-3.1.9";
-    bin = false;
-    src = [
-      (fetchurl {
-        url = "http://registry.npmjs.org/aws-sdk-apis/-/aws-sdk-apis-3.1.9.tgz";
-        name = "aws-sdk-apis-3.1.9.tgz";
-        sha1 = "abd017548bb9eab0472d3c729d512aba3fc16a67";
-      })
-    ];
-    buildInputs =
-      (self.nativeDeps."aws-sdk-apis" or []);
-    deps = {
-    };
-    peerDependencies = [
-    ];
-    passthru.names = [ "aws-sdk-apis" ];
-  };
   by-spec."aws-sign"."~0.2.0" =
     self.by-version."aws-sign"."0.2.0";
   by-version."aws-sign"."0.2.0" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."bl" or []);
     deps = {
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
     };
     peerDependencies = [
     ];
···
   by-spec."block-stream"."0.0.7" =
     self.by-version."block-stream"."0.0.7";
   by-spec."bluebird".">= 1.2.1" =
-    self.by-version."bluebird"."2.3.5";
-  by-version."bluebird"."2.3.5" = lib.makeOverridable self.buildNodePackage {
-    name = "bluebird-2.3.5";
+    self.by-version."bluebird"."2.3.6";
+  by-version."bluebird"."2.3.6" = lib.makeOverridable self.buildNodePackage {
+    name = "bluebird-2.3.6";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/bluebird/-/bluebird-2.3.5.tgz";
-        name = "bluebird-2.3.5.tgz";
-        sha1 = "551366d041fdd09030109c2cab990ec444bf78b6";
+        url = "http://registry.npmjs.org/bluebird/-/bluebird-2.3.6.tgz";
+        name = "bluebird-2.3.6.tgz";
+        sha1 = "aa090a29c1bfbc01089609358f4b1c37683515f9";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "body-parser" ];
   };
-  by-spec."body-parser"."~1.8.4" =
-    self.by-version."body-parser"."1.8.4";
-  by-version."body-parser"."1.8.4" = lib.makeOverridable self.buildNodePackage {
-    name = "body-parser-1.8.4";
+  by-spec."body-parser"."~1.9.0" =
+    self.by-version."body-parser"."1.9.0";
+  by-version."body-parser"."1.9.0" = lib.makeOverridable self.buildNodePackage {
+    name = "body-parser-1.9.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/body-parser/-/body-parser-1.8.4.tgz";
-        name = "body-parser-1.8.4.tgz";
-        sha1 = "d497e04bc13b3f9a8bd8c70bb0cdc16f2e028898";
+        url = "http://registry.npmjs.org/body-parser/-/body-parser-1.9.0.tgz";
+        name = "body-parser-1.9.0.tgz";
+        sha1 = "95d72943b1a4f67f56bbac9e0dcc837b68703605";
       })
     ];
     buildInputs =
       (self.nativeDeps."body-parser" or []);
     deps = {
       "bytes-1.0.0" = self.by-version."bytes"."1.0.0";
-      "depd-0.4.5" = self.by-version."depd"."0.4.5";
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
       "iconv-lite-0.4.4" = self.by-version."iconv-lite"."0.4.4";
       "media-typer-0.3.0" = self.by-version."media-typer"."0.3.0";
       "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";
···
       "fstream-1.0.2" = self.by-version."fstream"."1.0.2";
       "fstream-ignore-1.0.1" = self.by-version."fstream-ignore"."1.0.1";
       "glob-4.0.6" = self.by-version."glob"."4.0.6";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "handlebars-2.0.0" = self.by-version."handlebars"."2.0.0";
       "inquirer-0.7.1" = self.by-version."inquirer"."0.7.1";
       "insight-0.4.3" = self.by-version."insight"."0.4.3";
···
       (self.nativeDeps."browserchannel" or []);
     deps = {
       "hat-0.0.3" = self.by-version."hat"."0.0.3";
-      "connect-2.26.4" = self.by-version."connect"."2.26.4";
+      "connect-2.27.0" = self.by-version."connect"."2.27.0";
       "request-2.45.0" = self.by-version."request"."2.45.0";
       "ascii-json-0.2.0" = self.by-version."ascii-json"."0.2.0";
     };
···
   };
   "browserchannel" = self.by-version."browserchannel"."2.0.0";
   by-spec."browserify"."*" =
-    self.by-version."browserify"."6.0.2";
-  by-version."browserify"."6.0.2" = lib.makeOverridable self.buildNodePackage {
-    name = "browserify-6.0.2";
+    self.by-version."browserify"."6.1.0";
+  by-version."browserify"."6.1.0" = lib.makeOverridable self.buildNodePackage {
+    name = "browserify-6.1.0";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/browserify/-/browserify-6.0.2.tgz";
-        name = "browserify-6.0.2.tgz";
-        sha1 = "d6dd7a9f9e909f2e84163e544a9d1f358ddd9d58";
+        url = "http://registry.npmjs.org/browserify/-/browserify-6.1.0.tgz";
+        name = "browserify-6.1.0.tgz";
+        sha1 = "8da16d98a0be638b5e53d1cd560f7f344d238cdb";
       })
     ];
     buildInputs =
···
       "concat-stream-1.4.6" = self.by-version."concat-stream"."1.4.6";
       "console-browserify-1.1.0" = self.by-version."console-browserify"."1.1.0";
       "constants-browserify-0.0.1" = self.by-version."constants-browserify"."0.0.1";
-      "crypto-browserify-3.2.6" = self.by-version."crypto-browserify"."3.2.6";
+      "crypto-browserify-3.2.8" = self.by-version."crypto-browserify"."3.2.8";
       "deep-equal-0.2.1" = self.by-version."deep-equal"."0.2.1";
       "defined-0.0.0" = self.by-version."defined"."0.0.0";
       "deps-sort-1.3.5" = self.by-version."deps-sort"."1.3.5";
-      "domain-browser-1.1.2" = self.by-version."domain-browser"."1.1.2";
+      "domain-browser-1.1.3" = self.by-version."domain-browser"."1.1.3";
       "duplexer2-0.0.2" = self.by-version."duplexer2"."0.0.2";
       "events-1.0.2" = self.by-version."events"."1.0.2";
       "glob-4.0.6" = self.by-version."glob"."4.0.6";
···
       "path-browserify-0.0.0" = self.by-version."path-browserify"."0.0.0";
       "process-0.8.0" = self.by-version."process"."0.8.0";
       "punycode-1.2.4" = self.by-version."punycode"."1.2.4";
-      "querystring-es3-0.2.1-0" = self.by-version."querystring-es3"."0.2.1-0";
+      "querystring-es3-0.2.1" = self.by-version."querystring-es3"."0.2.1";
       "readable-stream-1.1.13" = self.by-version."readable-stream"."1.1.13";
       "resolve-0.7.4" = self.by-version."resolve"."0.7.4";
       "shallow-copy-0.0.1" = self.by-version."shallow-copy"."0.0.1";
···
     ];
     passthru.names = [ "browserify" ];
   };
-  "browserify" = self.by-version."browserify"."6.0.2";
+  "browserify" = self.by-version."browserify"."6.1.0";
   by-spec."browserify-zlib"."^0.1.4" =
     self.by-version."browserify-zlib"."0.1.4";
   by-version."browserify-zlib"."0.1.4" = lib.makeOverridable self.buildNodePackage {
···
   by-spec."chmodr"."~0.1.0" =
     self.by-version."chmodr"."0.1.0";
   by-spec."chokidar".">=0.8.2" =
-    self.by-version."chokidar"."0.9.0";
-  by-version."chokidar"."0.9.0" = lib.makeOverridable self.buildNodePackage {
-    name = "chokidar-0.9.0";
+    self.by-version."chokidar"."0.10.1";
+  by-version."chokidar"."0.10.1" = lib.makeOverridable self.buildNodePackage {
+    name = "chokidar-0.10.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/chokidar/-/chokidar-0.9.0.tgz";
-        name = "chokidar-0.9.0.tgz";
-        sha1 = "c1ae41561dbdb89dd5fac615453d20b48a946c2f";
+        url = "http://registry.npmjs.org/chokidar/-/chokidar-0.10.1.tgz";
+        name = "chokidar-0.10.1.tgz";
+        sha1 = "ec2b4e9910c75a2b2e09ff5fdf283029b73af199";
       })
     ];
     buildInputs =
       (self.nativeDeps."chokidar" or []);
     deps = {
       "fsevents-0.3.0" = self.by-version."fsevents"."0.3.0";
-      "recursive-readdir-0.0.2" = self.by-version."recursive-readdir"."0.0.2";
+      "readdirp-1.1.0" = self.by-version."readdirp"."1.1.0";
     };
     peerDependencies = [
     ];
···
   by-spec."clean-css"."~2.2.0" =
     self.by-version."clean-css"."2.2.16";
   by-spec."cli"."0.6.x" =
-    self.by-version."cli"."0.6.4";
-  by-version."cli"."0.6.4" = lib.makeOverridable self.buildNodePackage {
-    name = "cli-0.6.4";
+    self.by-version."cli"."0.6.5";
+  by-version."cli"."0.6.5" = lib.makeOverridable self.buildNodePackage {
+    name = "cli-0.6.5";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/cli/-/cli-0.6.4.tgz";
-        name = "cli-0.6.4.tgz";
-        sha1 = "105c4e9b29ecdbc1ee0c8e418276f62d8351f88e";
+        url = "http://registry.npmjs.org/cli/-/cli-0.6.5.tgz";
+        name = "cli-0.6.5.tgz";
+        sha1 = "f4edda12dfa8d56d726b43b0b558e089b0d2a85c";
       })
     ];
     buildInputs =
···
     deps = {
       "d-0.1.1" = self.by-version."d"."0.1.1";
       "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";
-      "memoizee-0.3.7" = self.by-version."memoizee"."0.3.7";
+      "memoizee-0.3.8" = self.by-version."memoizee"."0.3.8";
       "timers-ext-0.1.0" = self.by-version."timers-ext"."0.1.0";
     };
     peerDependencies = [
···
     deps = {
       "colors-0.6.2" = self.by-version."colors"."0.6.2";
       "eyes-0.1.8" = self.by-version."eyes"."0.1.8";
-      "winston-0.8.0" = self.by-version."winston"."0.8.0";
+      "winston-0.8.1" = self.by-version."winston"."0.8.1";
     };
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."cmd-shim" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
     };
     peerDependencies = [
···
     passthru.names = [ "collections" ];
   };
   by-spec."color"."~0.7.1" =
-    self.by-version."color"."0.7.1";
-  by-version."color"."0.7.1" = lib.makeOverridable self.buildNodePackage {
-    name = "color-0.7.1";
+    self.by-version."color"."0.7.3";
+  by-version."color"."0.7.3" = lib.makeOverridable self.buildNodePackage {
+    name = "color-0.7.3";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/color/-/color-0.7.1.tgz";
-        name = "color-0.7.1.tgz";
-        sha1 = "a2676f19c6ccb708b7586dc98b5c6e37dc9a199c";
+        url = "http://registry.npmjs.org/color/-/color-0.7.3.tgz";
+        name = "color-0.7.3.tgz";
+        sha1 = "ab3ae4bc6cb8cfadb5d749c40f34aea088104f89";
       })
     ];
     buildInputs =
       (self.nativeDeps."color" or []);
     deps = {
-      "color-convert-0.5.0" = self.by-version."color-convert"."0.5.0";
+      "color-convert-0.5.2" = self.by-version."color-convert"."0.5.2";
       "color-string-0.2.1" = self.by-version."color-string"."0.2.1";
     };
     peerDependencies = [
···
     passthru.names = [ "color" ];
   };
   by-spec."color-convert"."0.5.x" =
-    self.by-version."color-convert"."0.5.0";
-  by-version."color-convert"."0.5.0" = lib.makeOverridable self.buildNodePackage {
-    name = "color-convert-0.5.0";
+    self.by-version."color-convert"."0.5.2";
+  by-version."color-convert"."0.5.2" = lib.makeOverridable self.buildNodePackage {
+    name = "color-convert-0.5.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/color-convert/-/color-convert-0.5.0.tgz";
-        name = "color-convert-0.5.0.tgz";
-        sha1 = "4032cab2128c81670c7b394d77b6783f49caaaf7";
+        url = "http://registry.npmjs.org/color-convert/-/color-convert-0.5.2.tgz";
+        name = "color-convert-0.5.2.tgz";
+        sha1 = "febd9efc33674df3374ff8eeaec3bc56c79a9b35";
       })
     ];
     buildInputs =
···
     buildInputs =
       (self.nativeDeps."color-string" or []);
     deps = {
-      "color-convert-0.5.0" = self.by-version."color-convert"."0.5.0";
+      "color-convert-0.5.2" = self.by-version."color-convert"."0.5.2";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "commander" ];
   };
-  by-spec."commander"."2.x" =
+  by-spec."commander"."2.3.0" =
     self.by-version."commander"."2.3.0";
   by-version."commander"."2.3.0" = lib.makeOverridable self.buildNodePackage {
     name = "commander-2.3.0";
···
         url = "http://registry.npmjs.org/commander/-/commander-2.3.0.tgz";
         name = "commander-2.3.0.tgz";
         sha1 = "fd430e889832ec353b9acd1de217c11cb3eef873";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."commander" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "commander" ];
+  };
+  by-spec."commander"."2.x" =
+    self.by-version."commander"."2.4.0";
+  by-version."commander"."2.4.0" = lib.makeOverridable self.buildNodePackage {
+    name = "commander-2.4.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/commander/-/commander-2.4.0.tgz";
+        name = "commander-2.4.0.tgz";
+        sha1 = "fad884ce8f09509b10a5ec931332cb97786e2fd6";
       })
     ];
     buildInputs =
···
     deps = {
       "buffer-crc32-0.2.3" = self.by-version."buffer-crc32"."0.2.3";
       "crc32-stream-0.3.1" = self.by-version."crc32-stream"."0.3.1";
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
     };
     peerDependencies = [
     ];
     passthru.names = [ "compress-commons" ];
   };
-  by-spec."compressible"."~2.0.0" =
+  by-spec."compressible"."~2.0.1" =
     self.by-version."compressible"."2.0.1";
   by-version."compressible"."2.0.1" = lib.makeOverridable self.buildNodePackage {
     name = "compressible-2.0.1";
···
     buildInputs =
       (self.nativeDeps."compressible" or []);
     deps = {
-      "mime-db-1.1.0" = self.by-version."mime-db"."1.1.0";
+      "mime-db-1.1.1" = self.by-version."mime-db"."1.1.1";
     };
     peerDependencies = [
     ];
     passthru.names = [ "compressible" ];
   };
-  by-spec."compression"."~1.1.0" =
-    self.by-version."compression"."1.1.0";
-  by-version."compression"."1.1.0" = lib.makeOverridable self.buildNodePackage {
-    name = "compression-1.1.0";
+  by-spec."compression"."~1.2.0" =
+    self.by-version."compression"."1.2.0";
+  by-version."compression"."1.2.0" = lib.makeOverridable self.buildNodePackage {
+    name = "compression-1.2.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/compression/-/compression-1.1.0.tgz";
-        name = "compression-1.1.0.tgz";
-        sha1 = "58243eded272fc531d7c744d8e8daa7cc0b99215";
+        url = "http://registry.npmjs.org/compression/-/compression-1.2.0.tgz";
+        name = "compression-1.2.0.tgz";
+        sha1 = "c6951ca9ad90588ada7617da693c6bbbe8736866";
       })
     ];
     buildInputs =
       (self.nativeDeps."compression" or []);
     deps = {
-      "accepts-1.1.1" = self.by-version."accepts"."1.1.1";
+      "accepts-1.1.2" = self.by-version."accepts"."1.1.2";
       "bytes-1.0.0" = self.by-version."bytes"."1.0.0";
       "compressible-2.0.1" = self.by-version."compressible"."2.0.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";
       "vary-1.0.0" = self.by-version."vary"."1.0.0";
     };
···
     buildInputs =
       (self.nativeDeps."configstore" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "js-yaml-3.0.2" = self.by-version."js-yaml"."3.0.2";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "object-assign-0.3.1" = self.by-version."object-assign"."0.3.1";
···
       "fresh-0.2.0" = self.by-version."fresh"."0.2.0";
       "pause-0.0.1" = self.by-version."pause"."0.0.1";
       "uid2-0.0.3" = self.by-version."uid2"."0.0.3";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "methods-0.0.1" = self.by-version."methods"."0.0.1";
       "raw-body-0.0.3" = self.by-version."raw-body"."0.0.3";
       "negotiator-0.3.0" = self.by-version."negotiator"."0.3.0";
···
     ];
     passthru.names = [ "connect" ];
   };
-  by-spec."connect"."2.26.4" =
-    self.by-version."connect"."2.26.4";
-  by-version."connect"."2.26.4" = lib.makeOverridable self.buildNodePackage {
-    name = "connect-2.26.4";
+  by-spec."connect"."2.27.0" =
+    self.by-version."connect"."2.27.0";
+  by-version."connect"."2.27.0" = lib.makeOverridable self.buildNodePackage {
+    name = "connect-2.27.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/connect/-/connect-2.26.4.tgz";
-        name = "connect-2.26.4.tgz";
-        sha1 = "1ad3477cb90e590f1778ac17b51475af376bece0";
+        url = "http://registry.npmjs.org/connect/-/connect-2.27.0.tgz";
+        name = "connect-2.27.0.tgz";
+        sha1 = "04a2922c7cbe12455c9466f93bd719c37c433dfa";
       })
     ];
     buildInputs =
       (self.nativeDeps."connect" or []);
     deps = {
       "basic-auth-connect-1.0.0" = self.by-version."basic-auth-connect"."1.0.0";
-      "body-parser-1.8.4" = self.by-version."body-parser"."1.8.4";
+      "body-parser-1.9.0" = self.by-version."body-parser"."1.9.0";
       "bytes-1.0.0" = self.by-version."bytes"."1.0.0";
       "cookie-0.1.2" = self.by-version."cookie"."0.1.2";
       "cookie-parser-1.3.3" = self.by-version."cookie-parser"."1.3.3";
       "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";
-      "compression-1.1.0" = self.by-version."compression"."1.1.0";
-      "connect-timeout-1.3.0" = self.by-version."connect-timeout"."1.3.0";
-      "csurf-1.6.1" = self.by-version."csurf"."1.6.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
-      "depd-0.4.5" = self.by-version."depd"."0.4.5";
-      "errorhandler-1.2.0" = self.by-version."errorhandler"."1.2.0";
-      "express-session-1.8.2" = self.by-version."express-session"."1.8.2";
-      "finalhandler-0.2.0" = self.by-version."finalhandler"."0.2.0";
+      "compression-1.2.0" = self.by-version."compression"."1.2.0";
+      "connect-timeout-1.4.0" = self.by-version."connect-timeout"."1.4.0";
+      "csurf-1.6.2" = self.by-version."csurf"."1.6.2";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
+      "errorhandler-1.2.2" = self.by-version."errorhandler"."1.2.2";
+      "express-session-1.9.0" = self.by-version."express-session"."1.9.0";
+      "finalhandler-0.3.1" = self.by-version."finalhandler"."0.3.1";
       "fresh-0.2.4" = self.by-version."fresh"."0.2.4";
+      "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";
       "media-typer-0.3.0" = self.by-version."media-typer"."0.3.0";
-      "method-override-2.2.0" = self.by-version."method-override"."2.2.0";
-      "morgan-1.3.2" = self.by-version."morgan"."1.3.2";
+      "method-override-2.3.0" = self.by-version."method-override"."2.3.0";
+      "morgan-1.4.0" = self.by-version."morgan"."1.4.0";
       "multiparty-3.3.2" = self.by-version."multiparty"."3.3.2";
       "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";
       "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";
       "qs-2.2.4" = self.by-version."qs"."2.2.4";
-      "response-time-2.0.1" = self.by-version."response-time"."2.0.1";
-      "serve-favicon-2.1.5" = self.by-version."serve-favicon"."2.1.5";
-      "serve-index-1.2.1" = self.by-version."serve-index"."1.2.1";
-      "serve-static-1.6.3" = self.by-version."serve-static"."1.6.3";
+      "response-time-2.2.0" = self.by-version."response-time"."2.2.0";
+      "serve-favicon-2.1.6" = self.by-version."serve-favicon"."2.1.6";
+      "serve-index-1.5.0" = self.by-version."serve-index"."1.5.0";
+      "serve-static-1.7.0" = self.by-version."serve-static"."1.7.0";
       "type-is-1.5.2" = self.by-version."type-is"."1.5.2";
+      "utils-merge-1.0.0" = self.by-version."utils-merge"."1.0.0";
       "vhost-3.0.0" = self.by-version."vhost"."3.0.0";
       "pause-0.0.1" = self.by-version."pause"."0.0.1";
     };
···
       "bytes-0.1.0" = self.by-version."bytes"."0.1.0";
       "send-0.0.3" = self.by-version."send"."0.0.3";
       "fresh-0.1.0" = self.by-version."fresh"."0.1.0";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
     };
     peerDependencies = [
     ];
···
       "bytes-0.2.0" = self.by-version."bytes"."0.2.0";
       "fresh-0.1.0" = self.by-version."fresh"."0.1.0";
       "pause-0.0.1" = self.by-version."pause"."0.0.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
     };
     peerDependencies = [
     ];
···
       "bytes-0.2.0" = self.by-version."bytes"."0.2.0";
       "fresh-0.1.0" = self.by-version."fresh"."0.1.0";
       "pause-0.0.1" = self.by-version."pause"."0.0.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
     };
     peerDependencies = [
     ];
     passthru.names = [ "connect" ];
   };
   by-spec."connect"."~2" =
-    self.by-version."connect"."2.26.4";
+    self.by-version."connect"."2.27.0";
   by-spec."connect"."~2.12.0" =
     self.by-version."connect"."2.12.0";
   by-version."connect"."2.12.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "connect-mongo" ];
   };
   "connect-mongo" = self.by-version."connect-mongo"."0.4.1";
-  by-spec."connect-timeout"."~1.3.0" =
-    self.by-version."connect-timeout"."1.3.0";
-  by-version."connect-timeout"."1.3.0" = lib.makeOverridable self.buildNodePackage {
-    name = "connect-timeout-1.3.0";
+  by-spec."connect-timeout"."~1.4.0" =
+    self.by-version."connect-timeout"."1.4.0";
+  by-version."connect-timeout"."1.4.0" = lib.makeOverridable self.buildNodePackage {
+    name = "connect-timeout-1.4.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/connect-timeout/-/connect-timeout-1.3.0.tgz";
-        name = "connect-timeout-1.3.0.tgz";
-        sha1 = "d9d1d2df2900d490ed54190809f37e6b4508a1ec";
+        url = "http://registry.npmjs.org/connect-timeout/-/connect-timeout-1.4.0.tgz";
+        name = "connect-timeout-1.4.0.tgz";
+        sha1 = "b8003ea155abd18bbdd8a19c91e5284ddc2e465e";
       })
     ];
     buildInputs =
       (self.nativeDeps."connect-timeout" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";
       "ms-0.6.2" = self.by-version."ms"."0.6.2";
       "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";
     };
···
     ];
     passthru.names = [ "constants-browserify" ];
   };
+  by-spec."content-disposition"."0.5.0" =
+    self.by-version."content-disposition"."0.5.0";
+  by-version."content-disposition"."0.5.0" = lib.makeOverridable self.buildNodePackage {
+    name = "content-disposition-0.5.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/content-disposition/-/content-disposition-0.5.0.tgz";
+        name = "content-disposition-0.5.0.tgz";
+        sha1 = "4284fe6ae0630874639e44e80a418c2934135e9e";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."content-disposition" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "content-disposition" ];
+  };
   by-spec."convert-source-map"."~0.3.0" =
     self.by-version."convert-source-map"."0.3.5";
   by-version."convert-source-map"."0.3.5" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."crc32-stream" or []);
     deps = {
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
       "buffer-crc32-0.2.3" = self.by-version."buffer-crc32"."0.2.3";
     };
     peerDependencies = [
···
     passthru.names = [ "crypto" ];
   };
   by-spec."crypto-browserify"."^3.0.0" =
-    self.by-version."crypto-browserify"."3.2.6";
-  by-version."crypto-browserify"."3.2.6" = lib.makeOverridable self.buildNodePackage {
-    name = "crypto-browserify-3.2.6";
+    self.by-version."crypto-browserify"."3.2.8";
+  by-version."crypto-browserify"."3.2.8" = lib.makeOverridable self.buildNodePackage {
+    name = "crypto-browserify-3.2.8";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.2.6.tgz";
-        name = "crypto-browserify-3.2.6.tgz";
-        sha1 = "e65a44893ad85138dbf0eaf515675adfd917cdb4";
+        url = "http://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.2.8.tgz";
+        name = "crypto-browserify-3.2.8.tgz";
+        sha1 = "b9b11dbe6d9651dd882a01e6cc467df718ecf189";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "css-stringify" ];
   };
-  by-spec."csurf"."~1.6.1" =
-    self.by-version."csurf"."1.6.1";
-  by-version."csurf"."1.6.1" = lib.makeOverridable self.buildNodePackage {
-    name = "csurf-1.6.1";
+  by-spec."csurf"."~1.6.2" =
+    self.by-version."csurf"."1.6.2";
+  by-version."csurf"."1.6.2" = lib.makeOverridable self.buildNodePackage {
+    name = "csurf-1.6.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/csurf/-/csurf-1.6.1.tgz";
-        name = "csurf-1.6.1.tgz";
-        sha1 = "78da376f016bcaa48275d553d133585e478f4054";
+        url = "http://registry.npmjs.org/csurf/-/csurf-1.6.2.tgz";
+        name = "csurf-1.6.2.tgz";
+        sha1 = "e732b7478b4bef654337fd8bb363d0422a71d9f1";
       })
     ];
     buildInputs =
···
       "cookie-0.1.2" = self.by-version."cookie"."0.1.2";
       "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";
       "csrf-2.0.1" = self.by-version."csrf"."2.0.1";
+      "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";
     };
     peerDependencies = [
     ];
···
   by-spec."dateformat"."~1.0.6" =
     self.by-version."dateformat"."1.0.8";
   by-spec."debug"."*" =
-    self.by-version."debug"."2.0.0";
-  by-version."debug"."2.0.0" = lib.makeOverridable self.buildNodePackage {
-    name = "debug-2.0.0";
+    self.by-version."debug"."2.1.0";
+  by-version."debug"."2.1.0" = lib.makeOverridable self.buildNodePackage {
+    name = "debug-2.1.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/debug/-/debug-2.0.0.tgz";
-        name = "debug-2.0.0.tgz";
-        sha1 = "89bd9df6732b51256bc6705342bba02ed12131ef";
+        url = "http://registry.npmjs.org/debug/-/debug-2.1.0.tgz";
+        name = "debug-2.1.0.tgz";
+        sha1 = "33ab915659d8c2cc8a41443d94d6ebd37697ed21";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "debug" ];
   };
+  by-spec."debug"."2.0.0" =
+    self.by-version."debug"."2.0.0";
+  by-version."debug"."2.0.0" = lib.makeOverridable self.buildNodePackage {
+    name = "debug-2.0.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/debug/-/debug-2.0.0.tgz";
+        name = "debug-2.0.0.tgz";
+        sha1 = "89bd9df6732b51256bc6705342bba02ed12131ef";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."debug" or []);
+    deps = {
+      "ms-0.6.2" = self.by-version."ms"."0.6.2";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "debug" ];
+  };
   by-spec."debug".">= 0.7.3 < 1" =
     self.by-version."debug"."0.8.1";
   by-version."debug"."0.8.1" = lib.makeOverridable self.buildNodePackage {
···
     self.by-version."debug"."1.0.4";
   by-spec."debug"."~2.0.0" =
     self.by-version."debug"."2.0.0";
+  by-spec."debug"."~2.1.0" =
+    self.by-version."debug"."2.1.0";
   by-spec."debuglog"."^1.0.1" =
     self.by-version."debuglog"."1.0.1";
   by-version."debuglog"."1.0.1" = lib.makeOverridable self.buildNodePackage {
···
       "touch-0.0.2" = self.by-version."touch"."0.0.2";
       "readable-stream-1.1.13" = self.by-version."readable-stream"."1.1.13";
       "nopt-2.2.1" = self.by-version."nopt"."2.2.1";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "depd" ];
   };
+  by-spec."depd"."~1.0.0" =
+    self.by-version."depd"."1.0.0";
+  by-version."depd"."1.0.0" = lib.makeOverridable self.buildNodePackage {
+    name = "depd-1.0.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/depd/-/depd-1.0.0.tgz";
+        name = "depd-1.0.0.tgz";
+        sha1 = "2fda0d00e98aae2845d4991ab1bf1f2a199073d5";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."depd" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "depd" ];
+  };
   by-spec."deprecated"."^0.0.1" =
     self.by-version."deprecated"."0.0.1";
   by-version."deprecated"."0.0.1" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "diff" ];
   };
-  by-spec."diff"."~1.0.3" =
+  by-spec."diff"."1.0.8" =
     self.by-version."diff"."1.0.8";
   by-version."diff"."1.0.8" = lib.makeOverridable self.buildNodePackage {
     name = "diff-1.0.8";
···
     ];
     passthru.names = [ "diff" ];
   };
+  by-spec."diff"."~1.0.3" =
+    self.by-version."diff"."1.0.8";
   by-spec."diff"."~1.0.7" =
     self.by-version."diff"."1.0.8";
   by-spec."director"."1.1.10" =
···
     passthru.names = [ "dkim-signer" ];
   };
   by-spec."domain-browser"."~1.1.0" =
-    self.by-version."domain-browser"."1.1.2";
-  by-version."domain-browser"."1.1.2" = lib.makeOverridable self.buildNodePackage {
-    name = "domain-browser-1.1.2";
+    self.by-version."domain-browser"."1.1.3";
+  by-version."domain-browser"."1.1.3" = lib.makeOverridable self.buildNodePackage {
+    name = "domain-browser-1.1.3";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/domain-browser/-/domain-browser-1.1.2.tgz";
-        name = "domain-browser-1.1.2.tgz";
-        sha1 = "5a21f30a29a9891533915061426974dc2f14e56b";
+        url = "http://registry.npmjs.org/domain-browser/-/domain-browser-1.1.3.tgz";
+        name = "domain-browser-1.1.3.tgz";
+        sha1 = "ee8b336f1c53dc990b302eac12b4c7fee24923c1";
       })
     ];
     buildInputs =
···
     passthru.names = [ "emitter-component" ];
   };
   by-spec."encoding"."~0.1.7" =
-    self.by-version."encoding"."0.1.8";
-  by-version."encoding"."0.1.8" = lib.makeOverridable self.buildNodePackage {
-    name = "encoding-0.1.8";
+    self.by-version."encoding"."0.1.10";
+  by-version."encoding"."0.1.10" = lib.makeOverridable self.buildNodePackage {
+    name = "encoding-0.1.10";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/encoding/-/encoding-0.1.8.tgz";
-        name = "encoding-0.1.8.tgz";
-        sha1 = "3c48d355f6f4da0545de88c6f2673ccf70df11e7";
+        url = "http://registry.npmjs.org/encoding/-/encoding-0.1.10.tgz";
+        name = "encoding-0.1.10.tgz";
+        sha1 = "4463122033a7e3fdae4e81bf306f675dd8e4612c";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "entities" ];
   };
-  by-spec."envify"."^2.0.0" =
-    self.by-version."envify"."2.0.1";
-  by-version."envify"."2.0.1" = lib.makeOverridable self.buildNodePackage {
-    name = "envify-2.0.1";
+  by-spec."envify"."^3.0.0" =
+    self.by-version."envify"."3.0.0";
+  by-version."envify"."3.0.0" = lib.makeOverridable self.buildNodePackage {
+    name = "envify-3.0.0";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/envify/-/envify-2.0.1.tgz";
-        name = "envify-2.0.1.tgz";
-        sha1 = "abab827e063efd8e6f4d485aa82b66688dd056b2";
+        url = "http://registry.npmjs.org/envify/-/envify-3.0.0.tgz";
+        name = "envify-3.0.0.tgz";
+        sha1 = "af81202306f69df13845d0bfcb25a19abcb5f510";
       })
     ];
     buildInputs =
···
     deps = {
       "xtend-2.1.2" = self.by-version."xtend"."2.1.2";
       "through-2.3.6" = self.by-version."through"."2.3.6";
-      "esprima-fb-3001.1.0-dev-harmony-fb" = self.by-version."esprima-fb"."3001.1.0-dev-harmony-fb";
-      "jstransform-3.0.0" = self.by-version."jstransform"."3.0.0";
+      "esprima-fb-4001.3001.0-dev-harmony-fb" = self.by-version."esprima-fb"."4001.3001.0-dev-harmony-fb";
+      "jstransform-6.3.2" = self.by-version."jstransform"."6.3.2";
     };
     peerDependencies = [
     ];
     passthru.names = [ "envify" ];
   };
-  by-spec."errorhandler"."~1.2.0" =
-    self.by-version."errorhandler"."1.2.0";
-  by-version."errorhandler"."1.2.0" = lib.makeOverridable self.buildNodePackage {
-    name = "errorhandler-1.2.0";
+  by-spec."errorhandler"."~1.2.2" =
+    self.by-version."errorhandler"."1.2.2";
+  by-version."errorhandler"."1.2.2" = lib.makeOverridable self.buildNodePackage {
+    name = "errorhandler-1.2.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/errorhandler/-/errorhandler-1.2.0.tgz";
-        name = "errorhandler-1.2.0.tgz";
-        sha1 = "2f89db72c150580c65e8dd5180504f5b8a398bd9";
+        url = "http://registry.npmjs.org/errorhandler/-/errorhandler-1.2.2.tgz";
+        name = "errorhandler-1.2.2.tgz";
+        sha1 = "be0249eee868cf21649648e346da8899d0195984";
       })
     ];
     buildInputs =
       (self.nativeDeps."errorhandler" or []);
     deps = {
-      "accepts-1.1.1" = self.by-version."accepts"."1.1.1";
+      "accepts-1.1.2" = self.by-version."accepts"."1.1.2";
       "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";
     };
     peerDependencies = [
···
       (self.nativeDeps."es5-ext" or []);
     deps = {
       "es6-iterator-0.1.1" = self.by-version."es6-iterator"."0.1.1";
-      "es6-symbol-0.1.0" = self.by-version."es6-symbol"."0.1.0";
+      "es6-symbol-0.1.1" = self.by-version."es6-symbol"."0.1.1";
     };
     peerDependencies = [
     ];
···
     deps = {
       "d-0.1.1" = self.by-version."d"."0.1.1";
       "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";
-      "es6-symbol-0.1.0" = self.by-version."es6-symbol"."0.1.0";
+      "es6-symbol-0.1.1" = self.by-version."es6-symbol"."0.1.1";
     };
     peerDependencies = [
     ];
     passthru.names = [ "es6-iterator" ];
   };
   by-spec."es6-symbol"."0.1.x" =
-    self.by-version."es6-symbol"."0.1.0";
-  by-version."es6-symbol"."0.1.0" = lib.makeOverridable self.buildNodePackage {
-    name = "es6-symbol-0.1.0";
+    self.by-version."es6-symbol"."0.1.1";
+  by-version."es6-symbol"."0.1.1" = lib.makeOverridable self.buildNodePackage {
+    name = "es6-symbol-0.1.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/es6-symbol/-/es6-symbol-0.1.0.tgz";
-        name = "es6-symbol-0.1.0.tgz";
-        sha1 = "ba5878f37a652f6c713244716fc7b24d61d2dc39";
+        url = "http://registry.npmjs.org/es6-symbol/-/es6-symbol-0.1.1.tgz";
+        name = "es6-symbol-0.1.1.tgz";
+        sha1 = "9cf7fab2edaff1b1da8fe8e68bfe3f5aca6ca218";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "es6-symbol" ];
   };
+  by-spec."es6-weak-map"."~0.1.2" =
+    self.by-version."es6-weak-map"."0.1.2";
+  by-version."es6-weak-map"."0.1.2" = lib.makeOverridable self.buildNodePackage {
+    name = "es6-weak-map-0.1.2";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/es6-weak-map/-/es6-weak-map-0.1.2.tgz";
+        name = "es6-weak-map-0.1.2.tgz";
+        sha1 = "bc5b5fab73f68f6f77a6b39c481fce3d7856d385";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."es6-weak-map" or []);
+    deps = {
+      "d-0.1.1" = self.by-version."d"."0.1.1";
+      "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";
+      "es6-iterator-0.1.1" = self.by-version."es6-iterator"."0.1.1";
+      "es6-symbol-0.1.1" = self.by-version."es6-symbol"."0.1.1";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "es6-weak-map" ];
+  };
   by-spec."escape-html"."*" =
     self.by-version."escape-html"."1.0.1";
   by-version."escape-html"."1.0.1" = lib.makeOverridable self.buildNodePackage {
···
   "escape-html" = self.by-version."escape-html"."1.0.1";
   by-spec."escape-html"."1.0.1" =
     self.by-version."escape-html"."1.0.1";
-  by-spec."escape-string-regexp"."^1.0.0" =
+  by-spec."escape-string-regexp"."1.0.2" =
     self.by-version."escape-string-regexp"."1.0.2";
   by-version."escape-string-regexp"."1.0.2" = lib.makeOverridable self.buildNodePackage {
     name = "escape-string-regexp-1.0.2";
···
     ];
     passthru.names = [ "escape-string-regexp" ];
   };
+  by-spec."escape-string-regexp"."^1.0.0" =
+    self.by-version."escape-string-regexp"."1.0.2";
   by-spec."escodegen"."1.3.x" =
     self.by-version."escodegen"."1.3.3";
   by-version."escodegen"."1.3.3" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."escope" or []);
     deps = {
-      "estraverse-1.5.1" = self.by-version."estraverse"."1.5.1";
+      "estraverse-1.7.0" = self.by-version."estraverse"."1.7.0";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "esprima-fb" ];
   };
-  by-spec."esprima-fb"."~3001.1.0-dev-harmony-fb" =
-    self.by-version."esprima-fb"."3001.1.0-dev-harmony-fb";
+  by-spec."esprima-fb"."^4001.3001.0-dev-harmony-fb" =
+    self.by-version."esprima-fb"."4001.3001.0-dev-harmony-fb";
+  by-version."esprima-fb"."4001.3001.0-dev-harmony-fb" = lib.makeOverridable self.buildNodePackage {
+    name = "esprima-fb-4001.3001.0-dev-harmony-fb";
+    bin = true;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/esprima-fb/-/esprima-fb-4001.3001.0-dev-harmony-fb.tgz";
+        name = "esprima-fb-4001.3001.0-dev-harmony-fb.tgz";
+        sha1 = "659f1f5dc87f2f474db234a7db2a1b6c3e40af14";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."esprima-fb" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "esprima-fb" ];
+  };
+  by-spec."esprima-fb"."~6001.1.0-dev-harmony-fb" =
+    self.by-version."esprima-fb"."6001.1.0-dev-harmony-fb";
+  by-version."esprima-fb"."6001.1.0-dev-harmony-fb" = lib.makeOverridable self.buildNodePackage {
+    name = "esprima-fb-6001.1.0-dev-harmony-fb";
+    bin = true;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/esprima-fb/-/esprima-fb-6001.1.0-dev-harmony-fb.tgz";
+        name = "esprima-fb-6001.1.0-dev-harmony-fb.tgz";
+        sha1 = "72705de7030b45ca41bbf16400a3636ffa0ca4eb";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."esprima-fb" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "esprima-fb" ];
+  };
   by-spec."esshorten"."~ 0.0.2" =
     self.by-version."esshorten"."0.0.2";
   by-version."esshorten"."0.0.2" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "esshorten" ];
   };
   by-spec."estraverse".">= 0.0.2" =
-    self.by-version."estraverse"."1.5.1";
-  by-version."estraverse"."1.5.1" = lib.makeOverridable self.buildNodePackage {
-    name = "estraverse-1.5.1";
+    self.by-version."estraverse"."1.7.0";
+  by-version."estraverse"."1.7.0" = lib.makeOverridable self.buildNodePackage {
+    name = "estraverse-1.7.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/estraverse/-/estraverse-1.5.1.tgz";
-        name = "estraverse-1.5.1.tgz";
-        sha1 = "867a3e8e58a9f84618afb6c2ddbcd916b7cbaf71";
+        url = "http://registry.npmjs.org/estraverse/-/estraverse-1.7.0.tgz";
+        name = "estraverse-1.7.0.tgz";
+        sha1 = "05dbae27f44ee7cd795e16d118ceff05f1b6a413";
       })
     ];
     buildInputs =
···
     self.by-version."estraverse"."1.3.2";
   by-spec."estraverse"."~1.5.0" =
     self.by-version."estraverse"."1.5.1";
+  by-version."estraverse"."1.5.1" = lib.makeOverridable self.buildNodePackage {
+    name = "estraverse-1.5.1";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/estraverse/-/estraverse-1.5.1.tgz";
+        name = "estraverse-1.5.1.tgz";
+        sha1 = "867a3e8e58a9f84618afb6c2ddbcd916b7cbaf71";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."estraverse" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "estraverse" ];
+  };
   by-spec."esutils"."~1.0.0" =
     self.by-version."esutils"."1.0.0";
   by-version."esutils"."1.0.0" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "etag" ];
   };
+  by-spec."etag"."~1.5.0" =
+    self.by-version."etag"."1.5.0";
+  by-version."etag"."1.5.0" = lib.makeOverridable self.buildNodePackage {
+    name = "etag-1.5.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/etag/-/etag-1.5.0.tgz";
+        name = "etag-1.5.0.tgz";
+        sha1 = "8ca0f7a30b4b7305f034e8902fb8ec3c321491e4";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."etag" or []);
+    deps = {
+      "crc-3.0.0" = self.by-version."crc"."3.0.0";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "etag" ];
+  };
   by-spec."event-emitter"."~0.3.1" =
     self.by-version."event-emitter"."0.3.1";
   by-version."event-emitter"."0.3.1" = lib.makeOverridable self.buildNodePackage {
···
       "node-swt-0.1.1" = self.by-version."node-swt"."0.1.1";
       "node-wsfederation-0.1.1" = self.by-version."node-wsfederation"."0.1.1";
       "debug-0.5.0" = self.by-version."debug"."0.5.0";
-      "express-3.17.6" = self.by-version."express"."3.17.6";
+      "express-3.18.0" = self.by-version."express"."3.18.0";
     };
     peerDependencies = [
     ];
···
   by-spec."exit"."~0.1.1" =
     self.by-version."exit"."0.1.2";
   by-spec."express"."*" =
-    self.by-version."express"."4.9.5";
-  by-version."express"."4.9.5" = lib.makeOverridable self.buildNodePackage {
-    name = "express-4.9.5";
+    self.by-version."express"."4.9.8";
+  by-version."express"."4.9.8" = lib.makeOverridable self.buildNodePackage {
+    name = "express-4.9.8";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/express/-/express-4.9.5.tgz";
-        name = "express-4.9.5.tgz";
-        sha1 = "7f62aa84ac8f5e96acfb98e2944dde0bf1cf8688";
+        url = "http://registry.npmjs.org/express/-/express-4.9.8.tgz";
+        name = "express-4.9.8.tgz";
+        sha1 = "f360f596baeabbd0e5223b603d6eb578d9d2d10d";
       })
     ];
     buildInputs =
       (self.nativeDeps."express" or []);
     deps = {
-      "accepts-1.1.1" = self.by-version."accepts"."1.1.1";
+      "accepts-1.1.2" = self.by-version."accepts"."1.1.2";
       "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";
       "debug-2.0.0" = self.by-version."debug"."2.0.0";
       "depd-0.4.5" = self.by-version."depd"."0.4.5";
···
       "qs-2.2.4" = self.by-version."qs"."2.2.4";
       "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";
       "send-0.9.3" = self.by-version."send"."0.9.3";
-      "serve-static-1.6.3" = self.by-version."serve-static"."1.6.3";
+      "serve-static-1.6.4" = self.by-version."serve-static"."1.6.4";
       "type-is-1.5.2" = self.by-version."type-is"."1.5.2";
       "vary-1.0.0" = self.by-version."vary"."1.0.0";
       "cookie-0.1.2" = self.by-version."cookie"."0.1.2";
···
     ];
     passthru.names = [ "express" ];
   };
-  "express" = self.by-version."express"."4.9.5";
+  "express" = self.by-version."express"."4.9.8";
   by-spec."express"."2.5.11" =
     self.by-version."express"."2.5.11";
   by-version."express"."2.5.11" = lib.makeOverridable self.buildNodePackage {
···
       "methods-0.0.1" = self.by-version."methods"."0.0.1";
       "send-0.1.0" = self.by-version."send"."0.1.0";
       "cookie-signature-1.0.1" = self.by-version."cookie-signature"."1.0.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
     };
     peerDependencies = [
     ];
···
       "methods-0.1.0" = self.by-version."methods"."0.1.0";
       "send-0.1.4" = self.by-version."send"."0.1.4";
       "cookie-signature-1.0.1" = self.by-version."cookie-signature"."1.0.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
     };
     peerDependencies = [
     ];
     passthru.names = [ "express" ];
   };
   by-spec."express"."3.x" =
-    self.by-version."express"."3.17.6";
-  by-version."express"."3.17.6" = lib.makeOverridable self.buildNodePackage {
-    name = "express-3.17.6";
+    self.by-version."express"."3.18.0";
+  by-version."express"."3.18.0" = lib.makeOverridable self.buildNodePackage {
+    name = "express-3.18.0";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/express/-/express-3.17.6.tgz";
-        name = "express-3.17.6.tgz";
-        sha1 = "e2f9a6a48b85233afc4f7b6c5cd6799c53f5f46f";
+        url = "http://registry.npmjs.org/express/-/express-3.18.0.tgz";
+        name = "express-3.18.0.tgz";
+        sha1 = "ff1f4ee689ba6e622a087e397994f7c2115c5c57";
       })
     ];
     buildInputs =
       (self.nativeDeps."express" or []);
     deps = {
       "basic-auth-1.0.0" = self.by-version."basic-auth"."1.0.0";
-      "connect-2.26.4" = self.by-version."connect"."2.26.4";
+      "connect-2.27.0" = self.by-version."connect"."2.27.0";
+      "content-disposition-0.5.0" = self.by-version."content-disposition"."0.5.0";
       "commander-1.3.2" = self.by-version."commander"."1.3.2";
       "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";
-      "crc-3.0.0" = self.by-version."crc"."3.0.0";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
-      "depd-0.4.5" = self.by-version."depd"."0.4.5";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
       "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";
+      "etag-1.5.0" = self.by-version."etag"."1.5.0";
       "fresh-0.2.4" = self.by-version."fresh"."0.2.4";
       "media-typer-0.3.0" = self.by-version."media-typer"."0.3.0";
       "methods-1.1.0" = self.by-version."methods"."1.1.0";
···
       "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";
       "proxy-addr-1.0.3" = self.by-version."proxy-addr"."1.0.3";
       "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";
-      "send-0.9.3" = self.by-version."send"."0.9.3";
+      "send-0.10.0" = self.by-version."send"."0.10.0";
       "vary-1.0.0" = self.by-version."vary"."1.0.0";
       "cookie-0.1.2" = self.by-version."cookie"."0.1.2";
       "merge-descriptors-0.0.2" = self.by-version."merge-descriptors"."0.0.2";
···
     passthru.names = [ "express" ];
   };
   by-spec."express".">=3.0.0" =
-    self.by-version."express"."4.9.5";
+    self.by-version."express"."4.9.8";
   by-spec."express"."~3.1.1" =
     self.by-version."express"."3.1.2";
   by-version."express"."3.1.2" = lib.makeOverridable self.buildNodePackage {
···
       "methods-0.0.1" = self.by-version."methods"."0.0.1";
       "send-0.1.0" = self.by-version."send"."0.1.0";
       "cookie-signature-1.0.0" = self.by-version."cookie-signature"."1.0.0";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
     };
     peerDependencies = [
     ];
···
       "async-0.7.0" = self.by-version."async"."0.7.0";
     };
     peerDependencies = [
-      self.by-version."express"."4.9.5"
+      self.by-version."express"."4.9.8"
     ];
     passthru.names = [ "express-form" ];
   };
···
     ];
     passthru.names = [ "express-session" ];
   };
-  by-spec."express-session"."~1.8.2" =
-    self.by-version."express-session"."1.8.2";
-  by-version."express-session"."1.8.2" = lib.makeOverridable self.buildNodePackage {
-    name = "express-session-1.8.2";
+  by-spec."express-session"."~1.9.0" =
+    self.by-version."express-session"."1.9.0";
+  by-version."express-session"."1.9.0" = lib.makeOverridable self.buildNodePackage {
+    name = "express-session-1.9.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/express-session/-/express-session-1.8.2.tgz";
-        name = "express-session-1.8.2.tgz";
-        sha1 = "c4011e728a2349b3c18f117a5409908985e83483";
+        url = "http://registry.npmjs.org/express-session/-/express-session-1.9.0.tgz";
+        name = "express-session-1.9.0.tgz";
+        sha1 = "75ceb80194e5f3d0c71922e4affb90bc40c119f1";
       })
     ];
     buildInputs =
···
       "cookie-0.1.2" = self.by-version."cookie"."0.1.2";
       "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";
       "crc-3.0.0" = self.by-version."crc"."3.0.0";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
-      "depd-0.4.5" = self.by-version."depd"."0.4.5";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
       "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";
       "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";
       "uid-safe-1.0.1" = self.by-version."uid-safe"."1.0.1";
···
     passthru.names = [ "fetch-bower" ];
   };
   by-spec."fields"."~0.1.11" =
-    self.by-version."fields"."0.1.16";
-  by-version."fields"."0.1.16" = lib.makeOverridable self.buildNodePackage {
-    name = "fields-0.1.16";
+    self.by-version."fields"."0.1.17";
+  by-version."fields"."0.1.17" = lib.makeOverridable self.buildNodePackage {
+    name = "fields-0.1.17";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/fields/-/fields-0.1.16.tgz";
-        name = "fields-0.1.16.tgz";
-        sha1 = "a6d127f93636050c7407bd7a5e26265f82f58c22";
+        url = "http://registry.npmjs.org/fields/-/fields-0.1.17.tgz";
+        name = "fields-0.1.17.tgz";
+        sha1 = "4d5d87d68f7e6f5b46098546821aa939a248cdbf";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "finalhandler" ];
   };
+  by-spec."finalhandler"."0.3.1" =
+    self.by-version."finalhandler"."0.3.1";
+  by-version."finalhandler"."0.3.1" = lib.makeOverridable self.buildNodePackage {
+    name = "finalhandler-0.3.1";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/finalhandler/-/finalhandler-0.3.1.tgz";
+        name = "finalhandler-0.3.1.tgz";
+        sha1 = "ffda7643228678c6b088c89421a8381663961808";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."finalhandler" or []);
+    deps = {
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";
+      "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "finalhandler" ];
+  };
   by-spec."findit".">=1.1.0 <2.0.0" =
     self.by-version."findit"."1.2.0";
   by-version."findit"."1.2.0" = lib.makeOverridable self.buildNodePackage {
···
     peerDependencies = [
     ];
     passthru.names = [ "first-chunk-stream" ];
+  };
+  by-spec."flagged-respawn"."~0.3.0" =
+    self.by-version."flagged-respawn"."0.3.1";
+  by-version."flagged-respawn"."0.3.1" = lib.makeOverridable self.buildNodePackage {
+    name = "flagged-respawn-0.3.1";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/flagged-respawn/-/flagged-respawn-0.3.1.tgz";
+        name = "flagged-respawn-0.3.1.tgz";
+        sha1 = "397700925df6e12452202a71e89d89545fbbbe9d";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."flagged-respawn" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "flagged-respawn" ];
   };
   by-spec."flatiron"."*" =
     self.by-version."flatiron"."0.4.2";
···
     buildInputs =
       (self.nativeDeps."fs-vacuum" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
     };
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."fs-write-stream-atomic" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
     };
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."fstream" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "inherits-2.0.1" = self.by-version."inherits"."2.0.1";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
···
     buildInputs =
       (self.nativeDeps."fstream" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "inherits-2.0.1" = self.by-version."inherits"."2.0.1";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
···
   by-spec."fstream-ignore"."~1.0.1" =
     self.by-version."fstream-ignore"."1.0.1";
   by-spec."fstream-npm"."~1.0.0" =
-    self.by-version."fstream-npm"."1.0.0";
-  by-version."fstream-npm"."1.0.0" = lib.makeOverridable self.buildNodePackage {
-    name = "fstream-npm-1.0.0";
+    self.by-version."fstream-npm"."1.0.1";
+  by-version."fstream-npm"."1.0.1" = lib.makeOverridable self.buildNodePackage {
+    name = "fstream-npm-1.0.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/fstream-npm/-/fstream-npm-1.0.0.tgz";
-        name = "fstream-npm-1.0.0.tgz";
-        sha1 = "0262c95c771d393e7cf59fcfeabce621703f3d27";
+        url = "http://registry.npmjs.org/fstream-npm/-/fstream-npm-1.0.1.tgz";
+        name = "fstream-npm-1.0.1.tgz";
+        sha1 = "1e35c77f0fa24f5d6367e6d447ae7d6ddb482db2";
       })
     ];
     buildInputs =
···
     buildInputs =
       (self.nativeDeps."glob" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "inherits-2.0.1" = self.by-version."inherits"."2.0.1";
       "minimatch-1.0.0" = self.by-version."minimatch"."1.0.0";
       "once-1.3.1" = self.by-version."once"."1.3.1";
···
     self.by-version."glob"."3.2.11";
   by-spec."glob"."~4.0.2" =
     self.by-version."glob"."4.0.6";
-  by-spec."glob"."~4.0.5" =
+  by-spec."glob"."~4.0.6" =
     self.by-version."glob"."4.0.6";
   by-spec."glob-stream"."^3.1.5" =
     self.by-version."glob-stream"."3.1.15";
···
       "ordered-read-streams-0.0.8" = self.by-version."ordered-read-streams"."0.0.8";
       "glob2base-0.0.11" = self.by-version."glob2base"."0.0.11";
       "unique-stream-1.0.0" = self.by-version."unique-stream"."1.0.0";
-      "through2-0.6.2" = self.by-version."through2"."0.6.2";
+      "through2-0.6.3" = self.by-version."through2"."0.6.3";
     };
     peerDependencies = [
     ];
···
     passthru.names = [ "got" ];
   };
   by-spec."graceful-fs"."2 || 3" =
-    self.by-version."graceful-fs"."3.0.3";
-  by-version."graceful-fs"."3.0.3" = lib.makeOverridable self.buildNodePackage {
-    name = "graceful-fs-3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
+  by-version."graceful-fs"."3.0.4" = lib.makeOverridable self.buildNodePackage {
+    name = "graceful-fs-3.0.4";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.3.tgz";
-        name = "graceful-fs-3.0.3.tgz";
-        sha1 = "277141085e739ae7d54361119a62797b08a1d8c0";
+        url = "http://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.4.tgz";
+        name = "graceful-fs-3.0.4.tgz";
+        sha1 = "a0306d9b0940e0fc512d33b5df1014e88e0637a3";
       })
     ];
     buildInputs =
···
     passthru.names = [ "graceful-fs" ];
   };
   by-spec."graceful-fs"."3" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."graceful-fs".">3.0.1 <4.0.0-0" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."graceful-fs"."^3.0.0" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."graceful-fs"."^3.0.2" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."graceful-fs"."~1" =
     self.by-version."graceful-fs"."1.2.3";
   by-version."graceful-fs"."1.2.3" = lib.makeOverridable self.buildNodePackage {
···
   by-spec."graceful-fs"."~2.0.1" =
     self.by-version."graceful-fs"."2.0.3";
   by-spec."graceful-fs"."~3.0.0" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."graceful-fs"."~3.0.1" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."graceful-fs"."~3.0.2" =
-    self.by-version."graceful-fs"."3.0.3";
+    self.by-version."graceful-fs"."3.0.4";
+  by-spec."graceful-fs"."~3.0.4" =
+    self.by-version."graceful-fs"."3.0.4";
   by-spec."gridfs-stream"."*" =
     self.by-version."gridfs-stream"."0.5.1";
   by-version."gridfs-stream"."0.5.1" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "growl" ];
   };
-  by-spec."growl"."1.8.x" =
+  by-spec."growl"."1.8.1" =
     self.by-version."growl"."1.8.1";
   by-version."growl"."1.8.1" = lib.makeOverridable self.buildNodePackage {
     name = "growl-1.8.1";
···
   };
   "guifi-earth" = self.by-version."guifi-earth"."0.2.1";
   by-spec."gulp"."*" =
-    self.by-version."gulp"."3.8.8";
-  by-version."gulp"."3.8.8" = lib.makeOverridable self.buildNodePackage {
-    name = "gulp-3.8.8";
+    self.by-version."gulp"."3.8.9";
+  by-version."gulp"."3.8.9" = lib.makeOverridable self.buildNodePackage {
+    name = "gulp-3.8.9";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/gulp/-/gulp-3.8.8.tgz";
-        name = "gulp-3.8.8.tgz";
-        sha1 = "0b0473e7cdfd04c785184513938397d4552cfe96";
+        url = "http://registry.npmjs.org/gulp/-/gulp-3.8.9.tgz";
+        name = "gulp-3.8.9.tgz";
+        sha1 = "90773dc79cb0b3087e5443c695b0f5a21548ccce";
       })
     ];
     buildInputs =
···
       "deprecated-0.0.1" = self.by-version."deprecated"."0.0.1";
       "gulp-util-3.0.1" = self.by-version."gulp-util"."3.0.1";
       "interpret-0.3.7" = self.by-version."interpret"."0.3.7";
-      "liftoff-0.12.1" = self.by-version."liftoff"."0.12.1";
+      "liftoff-0.13.5" = self.by-version."liftoff"."0.13.5";
       "minimist-1.1.0" = self.by-version."minimist"."1.1.0";
       "orchestrator-0.3.7" = self.by-version."orchestrator"."0.3.7";
       "pretty-hrtime-0.2.2" = self.by-version."pretty-hrtime"."0.2.2";
       "semver-3.0.1" = self.by-version."semver"."3.0.1";
       "tildify-1.0.0" = self.by-version."tildify"."1.0.0";
-      "vinyl-fs-0.3.8" = self.by-version."vinyl-fs"."0.3.8";
+      "v8flags-1.0.1" = self.by-version."v8flags"."1.0.1";
+      "vinyl-fs-0.3.10" = self.by-version."vinyl-fs"."0.3.10";
     };
     peerDependencies = [
     ];
     passthru.names = [ "gulp" ];
   };
-  "gulp" = self.by-version."gulp"."3.8.8";
+  "gulp" = self.by-version."gulp"."3.8.9";
   by-spec."gulp-util"."^3.0.0" =
     self.by-version."gulp-util"."3.0.1";
   by-version."gulp-util"."3.0.1" = lib.makeOverridable self.buildNodePackage {
···
       "lodash.template-2.4.1" = self.by-version."lodash.template"."2.4.1";
       "minimist-1.1.0" = self.by-version."minimist"."1.1.0";
       "multipipe-0.1.1" = self.by-version."multipipe"."0.1.1";
-      "through2-0.6.2" = self.by-version."through2"."0.6.2";
+      "through2-0.6.3" = self.by-version."through2"."0.6.3";
       "vinyl-0.4.3" = self.by-version."vinyl"."0.4.3";
     };
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."gzippo" or []);
     deps = {
-      "send-0.9.3" = self.by-version."send"."0.9.3";
+      "send-0.10.0" = self.by-version."send"."0.10.0";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "http-browserify" ];
   };
+  by-spec."http-errors"."~1.2.6" =
+    self.by-version."http-errors"."1.2.7";
+  by-version."http-errors"."1.2.7" = lib.makeOverridable self.buildNodePackage {
+    name = "http-errors-1.2.7";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/http-errors/-/http-errors-1.2.7.tgz";
+        name = "http-errors-1.2.7.tgz";
+        sha1 = "b881fa12c59b0079fd4ced456bf8dbc9610d3b78";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."http-errors" or []);
+    deps = {
+      "inherits-2.0.1" = self.by-version."inherits"."2.0.1";
+      "statuses-1.2.0" = self.by-version."statuses"."1.2.0";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "http-errors" ];
+  };
+  by-spec."http-errors"."~1.2.7" =
+    self.by-version."http-errors"."1.2.7";
   by-spec."http-proxy"."1.0.2" =
     self.by-version."http-proxy"."1.0.2";
   by-version."http-proxy"."1.0.2" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "iconv-lite" ];
   };
-  by-spec."iconv-lite"."~0.4.3" =
+  by-spec."iconv-lite"."~0.4.4" =
     self.by-version."iconv-lite"."0.4.4";
   by-spec."ieee754"."^1.1.4" =
     self.by-version."ieee754"."1.1.4";
···
     ];
     passthru.names = [ "indexof" ];
   };
-  by-spec."inflight"."~1.0.3" =
+  by-spec."inflight"."~1.0.4" =
     self.by-version."inflight"."1.0.4";
   by-version."inflight"."1.0.4" = lib.makeOverridable self.buildNodePackage {
     name = "inflight-1.0.4";
···
     ];
     passthru.names = [ "ini" ];
   };
-  by-spec."ini"."~1.2.0" =
-    self.by-version."ini"."1.2.1";
-  by-version."ini"."1.2.1" = lib.makeOverridable self.buildNodePackage {
-    name = "ini-1.2.1";
-    bin = false;
-    src = [
-      (fetchurl {
-        url = "http://registry.npmjs.org/ini/-/ini-1.2.1.tgz";
-        name = "ini-1.2.1.tgz";
-        sha1 = "7f774e2f22752cd1dacbf9c63323df2a164ebca3";
-      })
-    ];
-    buildInputs =
-      (self.nativeDeps."ini" or []);
-    deps = {
-    };
-    peerDependencies = [
-    ];
-    passthru.names = [ "ini" ];
-  };
+  by-spec."ini"."~1.3.0" =
+    self.by-version."ini"."1.3.0";
   by-spec."init-package-json"."~1.1.0" =
     self.by-version."init-package-json"."1.1.0";
   by-version."init-package-json"."1.1.0" = lib.makeOverridable self.buildNodePackage {
···
       "promzard-0.2.2" = self.by-version."promzard"."0.2.2";
       "read-1.0.5" = self.by-version."read"."1.0.5";
       "read-package-json-1.2.7" = self.by-version."read-package-json"."1.2.7";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
     };
     peerDependencies = [
     ];
···
       "lodash-2.4.1" = self.by-version."lodash"."2.4.1";
       "mute-stream-0.0.4" = self.by-version."mute-stream"."0.0.4";
       "readline2-0.1.0" = self.by-version."readline2"."0.1.0";
-      "rx-2.3.12" = self.by-version."rx"."2.3.12";
+      "rx-2.3.13" = self.by-version."rx"."2.3.13";
       "through-2.3.6" = self.by-version."through"."2.3.6";
     };
     peerDependencies = [
···
       "lodash-2.4.1" = self.by-version."lodash"."2.4.1";
       "mute-stream-0.0.4" = self.by-version."mute-stream"."0.0.4";
       "readline2-0.1.0" = self.by-version."readline2"."0.1.0";
-      "rx-2.3.12" = self.by-version."rx"."2.3.12";
+      "rx-2.3.13" = self.by-version."rx"."2.3.13";
       "through-2.3.6" = self.by-version."through"."2.3.6";
     };
     peerDependencies = [
···
       (self.nativeDeps."ironhorse" or []);
     deps = {
       "underscore-1.5.2" = self.by-version."underscore"."1.5.2";
-      "winston-0.8.0" = self.by-version."winston"."0.8.0";
+      "winston-0.8.1" = self.by-version."winston"."0.8.1";
       "nconf-0.6.9" = self.by-version."nconf"."0.6.9";
       "fs-walk-0.0.1" = self.by-version."fs-walk"."0.0.1";
       "async-0.9.0" = self.by-version."async"."0.9.0";
-      "express-4.9.5" = self.by-version."express"."4.9.5";
+      "express-4.9.8" = self.by-version."express"."4.9.8";
       "jade-1.7.0" = self.by-version."jade"."1.7.0";
       "passport-0.2.1" = self.by-version."passport"."0.2.1";
       "passport-http-0.2.2" = self.by-version."passport-http"."0.2.2";
···
     deps = {
       "shelljs-0.3.0" = self.by-version."shelljs"."0.3.0";
       "underscore-1.6.0" = self.by-version."underscore"."1.6.0";
-      "cli-0.6.4" = self.by-version."cli"."0.6.4";
+      "cli-0.6.5" = self.by-version."cli"."0.6.5";
       "minimatch-1.0.0" = self.by-version."minimatch"."1.0.0";
       "htmlparser2-3.7.3" = self.by-version."htmlparser2"."3.7.3";
       "console-browserify-1.1.0" = self.by-version."console-browserify"."1.1.0";
       "exit-0.1.2" = self.by-version."exit"."0.1.2";
-      "strip-json-comments-1.0.1" = self.by-version."strip-json-comments"."1.0.1";
+      "strip-json-comments-1.0.2" = self.by-version."strip-json-comments"."1.0.2";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "jsprim" ];
   };
-  by-spec."jstransform"."~3.0.0" =
-    self.by-version."jstransform"."3.0.0";
-  by-version."jstransform"."3.0.0" = lib.makeOverridable self.buildNodePackage {
-    name = "jstransform-3.0.0";
+  by-spec."jstransform"."^6.1.0" =
+    self.by-version."jstransform"."6.3.2";
+  by-version."jstransform"."6.3.2" = lib.makeOverridable self.buildNodePackage {
+    name = "jstransform-6.3.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/jstransform/-/jstransform-3.0.0.tgz";
-        name = "jstransform-3.0.0.tgz";
-        sha1 = "a2591ab6cee8d97bf3be830dbfa2313b87cd640b";
+        url = "http://registry.npmjs.org/jstransform/-/jstransform-6.3.2.tgz";
+        name = "jstransform-6.3.2.tgz";
+        sha1 = "1e7a99ca7540b26676d972ab75f1d2e74e6b23a9";
       })
     ];
     buildInputs =
       (self.nativeDeps."jstransform" or []);
     deps = {
       "base62-0.1.1" = self.by-version."base62"."0.1.1";
-      "esprima-fb-3001.1.0-dev-harmony-fb" = self.by-version."esprima-fb"."3001.1.0-dev-harmony-fb";
+      "esprima-fb-6001.1.0-dev-harmony-fb" = self.by-version."esprima-fb"."6001.1.0-dev-harmony-fb";
       "source-map-0.1.31" = self.by-version."source-map"."0.1.31";
     };
     peerDependencies = [
···
     deps = {
       "di-0.0.1" = self.by-version."di"."0.0.1";
       "socket.io-0.9.17" = self.by-version."socket.io"."0.9.17";
-      "chokidar-0.9.0" = self.by-version."chokidar"."0.9.0";
+      "chokidar-0.10.1" = self.by-version."chokidar"."0.10.1";
       "glob-3.2.11" = self.by-version."glob"."3.2.11";
       "minimatch-0.2.14" = self.by-version."minimatch"."0.2.14";
       "http-proxy-0.10.4" = self.by-version."http-proxy"."0.10.4";
···
     };
     peerDependencies = [
       self.by-version."karma"."0.12.24"
-      self.by-version."mocha"."1.21.4"
+      self.by-version."mocha"."2.0.0"
     ];
     passthru.names = [ "karma-mocha" ];
   };
···
     buildInputs =
       (self.nativeDeps."karma-sauce-launcher" or []);
     deps = {
-      "wd-0.3.8" = self.by-version."wd"."0.3.8";
+      "wd-0.3.9" = self.by-version."wd"."0.3.9";
       "sauce-connect-launcher-0.6.1" = self.by-version."sauce-connect-launcher"."0.6.1";
       "q-0.9.7" = self.by-version."q"."0.9.7";
       "saucelabs-0.1.1" = self.by-version."saucelabs"."0.1.1";
···
     buildInputs =
       (self.nativeDeps."lazystream" or []);
     deps = {
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
     };
     peerDependencies = [
     ];
···
     deps = {
       "through2-0.5.1" = self.by-version."through2"."0.5.1";
       "vinyl-0.2.3" = self.by-version."vinyl"."0.2.3";
-      "vinyl-fs-0.3.8" = self.by-version."vinyl-fs"."0.3.8";
+      "vinyl-fs-0.3.10" = self.by-version."vinyl-fs"."0.3.10";
     };
     peerDependencies = [
     ];
···
   };
   "lcov-result-merger" = self.by-version."lcov-result-merger"."1.0.0";
   by-spec."less"."*" =
+    self.by-version."less"."2.0.0-b1";
+  by-version."less"."2.0.0-b1" = lib.makeOverridable self.buildNodePackage {
+    name = "less-2.0.0-b1";
+    bin = true;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/less/-/less-2.0.0-b1.tgz";
+        name = "less-2.0.0-b1.tgz";
+        sha1 = "3dcb5815b2052c89435c00def2aeb58ddb321b6a";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."less" or []);
+    deps = {
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
+      "mime-1.2.11" = self.by-version."mime"."1.2.11";
+      "request-2.45.0" = self.by-version."request"."2.45.0";
+      "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
+      "source-map-0.1.40" = self.by-version."source-map"."0.1.40";
+      "promise-6.0.1" = self.by-version."promise"."6.0.1";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "less" ];
+  };
+  "less" = self.by-version."less"."2.0.0-b1";
+  by-spec."less"."^1.7.2" =
     self.by-version."less"."1.7.5";
   by-version."less"."1.7.5" = lib.makeOverridable self.buildNodePackage {
     name = "less-1.7.5";
···
     buildInputs =
       (self.nativeDeps."less" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "mime-1.2.11" = self.by-version."mime"."1.2.11";
       "request-2.40.0" = self.by-version."request"."2.40.0";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
···
     ];
     passthru.names = [ "less" ];
   };
-  "less" = self.by-version."less"."1.7.5";
-  by-spec."less"."^1.7.2" =
-    self.by-version."less"."1.7.5";
   by-spec."lexical-scope"."~1.1.0" =
     self.by-version."lexical-scope"."1.1.0";
   by-version."lexical-scope"."1.1.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "libyaml" ];
   };
   "libyaml" = self.by-version."libyaml"."0.2.5";
-  by-spec."liftoff"."^0.12.0" =
-    self.by-version."liftoff"."0.12.1";
-  by-version."liftoff"."0.12.1" = lib.makeOverridable self.buildNodePackage {
-    name = "liftoff-0.12.1";
+  by-spec."liftoff"."^0.13.2" =
+    self.by-version."liftoff"."0.13.5";
+  by-version."liftoff"."0.13.5" = lib.makeOverridable self.buildNodePackage {
+    name = "liftoff-0.13.5";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/liftoff/-/liftoff-0.12.1.tgz";
-        name = "liftoff-0.12.1.tgz";
-        sha1 = "bcaa49759c68396b83b984ad0b2d8cc226f9526d";
+        url = "http://registry.npmjs.org/liftoff/-/liftoff-0.13.5.tgz";
+        name = "liftoff-0.13.5.tgz";
+        sha1 = "fb603b0ba34e9ab77a3737529f452d344562386c";
       })
     ];
     buildInputs =
       (self.nativeDeps."liftoff" or []);
     deps = {
       "findup-sync-0.1.3" = self.by-version."findup-sync"."0.1.3";
-      "resolve-0.7.4" = self.by-version."resolve"."0.7.4";
-      "minimist-0.2.0" = self.by-version."minimist"."0.2.0";
+      "resolve-1.0.0" = self.by-version."resolve"."1.0.0";
+      "minimist-1.1.0" = self.by-version."minimist"."1.1.0";
       "extend-1.3.0" = self.by-version."extend"."1.3.0";
+      "flagged-respawn-0.3.1" = self.by-version."flagged-respawn"."0.3.1";
     };
     peerDependencies = [
     ];
···
       (self.nativeDeps."log4js" or []);
     deps = {
       "async-0.2.10" = self.by-version."async"."0.2.10";
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
       "semver-1.1.4" = self.by-version."semver"."1.1.4";
     };
     peerDependencies = [
···
   };
   by-spec."lru-cache"."~2.5.0" =
     self.by-version."lru-cache"."2.5.0";
-  by-spec."lru-queue"."0.1.x" =
+  by-spec."lru-queue"."0.1" =
     self.by-version."lru-queue"."0.1.0";
   by-version."lru-queue"."0.1.0" = lib.makeOverridable self.buildNodePackage {
     name = "lru-queue-0.1.0";
···
     passthru.names = [ "media-typer" ];
   };
   by-spec."memoizee"."0.3.x" =
-    self.by-version."memoizee"."0.3.7";
-  by-version."memoizee"."0.3.7" = lib.makeOverridable self.buildNodePackage {
-    name = "memoizee-0.3.7";
+    self.by-version."memoizee"."0.3.8";
+  by-version."memoizee"."0.3.8" = lib.makeOverridable self.buildNodePackage {
+    name = "memoizee-0.3.8";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/memoizee/-/memoizee-0.3.7.tgz";
-        name = "memoizee-0.3.7.tgz";
-        sha1 = "13ccfdd580e56cf7c10f4b6342a6800ef87e975b";
+        url = "http://registry.npmjs.org/memoizee/-/memoizee-0.3.8.tgz";
+        name = "memoizee-0.3.8.tgz";
+        sha1 = "b5faf419f02fafe3c2cc1cf5d3907c210fc7efdc";
       })
     ];
     buildInputs =
···
     deps = {
       "d-0.1.1" = self.by-version."d"."0.1.1";
       "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";
+      "es6-weak-map-0.1.2" = self.by-version."es6-weak-map"."0.1.2";
       "event-emitter-0.3.1" = self.by-version."event-emitter"."0.3.1";
       "lru-queue-0.1.0" = self.by-version."lru-queue"."0.1.0";
       "next-tick-0.2.2" = self.by-version."next-tick"."0.2.2";
···
     ];
     passthru.names = [ "merge-descriptors" ];
   };
-  by-spec."method-override"."~2.2.0" =
-    self.by-version."method-override"."2.2.0";
-  by-version."method-override"."2.2.0" = lib.makeOverridable self.buildNodePackage {
-    name = "method-override-2.2.0";
+  by-spec."method-override"."~2.3.0" =
+    self.by-version."method-override"."2.3.0";
+  by-version."method-override"."2.3.0" = lib.makeOverridable self.buildNodePackage {
+    name = "method-override-2.3.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/method-override/-/method-override-2.2.0.tgz";
-        name = "method-override-2.2.0.tgz";
-        sha1 = "177e852b6add3b4f9177033a9446b01e7801a0c0";
+        url = "http://registry.npmjs.org/method-override/-/method-override-2.3.0.tgz";
+        name = "method-override-2.3.0.tgz";
+        sha1 = "fe820769594247ede8a6ca87b8eaa413084e595e";
       })
     ];
     buildInputs =
       (self.nativeDeps."method-override" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "methods-1.1.0" = self.by-version."methods"."1.1.0";
       "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";
       "vary-1.0.0" = self.by-version."vary"."1.0.0";
···
   by-spec."mime"."~1.2.9" =
     self.by-version."mime"."1.2.11";
   by-spec."mime-db"."1.x" =
-    self.by-version."mime-db"."1.1.0";
-  by-version."mime-db"."1.1.0" = lib.makeOverridable self.buildNodePackage {
-    name = "mime-db-1.1.0";
+    self.by-version."mime-db"."1.1.1";
+  by-version."mime-db"."1.1.1" = lib.makeOverridable self.buildNodePackage {
+    name = "mime-db-1.1.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mime-db/-/mime-db-1.1.0.tgz";
-        name = "mime-db-1.1.0.tgz";
-        sha1 = "4613f418ab995450bf4bda240cd0ab38016a07a9";
+        url = "http://registry.npmjs.org/mime-db/-/mime-db-1.1.1.tgz";
+        name = "mime-db-1.1.1.tgz";
+        sha1 = "0fc890cda05d0edadefde73d241ef7e28d110a98";
       })
     ];
     buildInputs =
···
     passthru.names = [ "mime-db" ];
   };
   by-spec."mime-db"."~1.1.0" =
-    self.by-version."mime-db"."1.1.0";
+    self.by-version."mime-db"."1.1.1";
   by-spec."mime-types"."~1.0.0" =
     self.by-version."mime-types"."1.0.2";
   by-version."mime-types"."1.0.2" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."mime-types" or []);
     deps = {
-      "mime-db-1.1.0" = self.by-version."mime-db"."1.1.0";
+      "mime-db-1.1.1" = self.by-version."mime-db"."1.1.1";
     };
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."mimelib" or []);
     deps = {
-      "encoding-0.1.8" = self.by-version."encoding"."0.1.8";
+      "encoding-0.1.10" = self.by-version."encoding"."0.1.10";
       "addressparser-0.2.1" = self.by-version."addressparser"."0.2.1";
     };
     peerDependencies = [
···
     ];
     passthru.names = [ "minimist" ];
   };
+  by-spec."minimist"."~1.1.0" =
+    self.by-version."minimist"."1.1.0";
   by-spec."ministyle"."~0.1.3" =
     self.by-version."ministyle"."0.1.4";
   by-version."ministyle"."0.1.4" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "mkpath" ];
   };
   by-spec."mocha"."*" =
-    self.by-version."mocha"."1.21.4";
-  by-version."mocha"."1.21.4" = lib.makeOverridable self.buildNodePackage {
-    name = "mocha-1.21.4";
+    self.by-version."mocha"."2.0.0";
+  by-version."mocha"."2.0.0" = lib.makeOverridable self.buildNodePackage {
+    name = "mocha-2.0.0";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mocha/-/mocha-1.21.4.tgz";
-        name = "mocha-1.21.4.tgz";
-        sha1 = "e77d69c3773ba3e2b4fe6b628c28b5dd43880adc";
+        url = "http://registry.npmjs.org/mocha/-/mocha-2.0.0.tgz";
+        name = "mocha-2.0.0.tgz";
+        sha1 = "4f737685475046533432494b76c3e81cb5005c54";
       })
     ];
     buildInputs =
       (self.nativeDeps."mocha" or []);
     deps = {
-      "commander-2.0.0" = self.by-version."commander"."2.0.0";
-      "growl-1.8.1" = self.by-version."growl"."1.8.1";
-      "jade-0.26.3" = self.by-version."jade"."0.26.3";
-      "diff-1.0.7" = self.by-version."diff"."1.0.7";
+      "commander-2.3.0" = self.by-version."commander"."2.3.0";
       "debug-2.0.0" = self.by-version."debug"."2.0.0";
-      "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";
+      "diff-1.0.8" = self.by-version."diff"."1.0.8";
+      "escape-string-regexp-1.0.2" = self.by-version."escape-string-regexp"."1.0.2";
       "glob-3.2.3" = self.by-version."glob"."3.2.3";
+      "growl-1.8.1" = self.by-version."growl"."1.8.1";
+      "jade-0.26.3" = self.by-version."jade"."0.26.3";
+      "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
     };
     peerDependencies = [
     ];
     passthru.names = [ "mocha" ];
   };
-  "mocha" = self.by-version."mocha"."1.21.4";
+  "mocha" = self.by-version."mocha"."2.0.0";
   by-spec."mocha"."~1.20.1" =
     self.by-version."mocha"."1.20.1";
   by-version."mocha"."1.20.1" = lib.makeOverridable self.buildNodePackage {
···
       "growl-1.7.0" = self.by-version."growl"."1.7.0";
       "jade-0.26.3" = self.by-version."jade"."0.26.3";
       "diff-1.0.7" = self.by-version."diff"."1.0.7";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";
       "glob-3.2.3" = self.by-version."glob"."3.2.3";
     };
···
     passthru.names = [ "mocha" ];
   };
   by-spec."mocha-phantomjs"."*" =
-    self.by-version."mocha-phantomjs"."3.5.0";
-  by-version."mocha-phantomjs"."3.5.0" = lib.makeOverridable self.buildNodePackage {
-    name = "mocha-phantomjs-3.5.0";
+    self.by-version."mocha-phantomjs"."3.5.1";
+  by-version."mocha-phantomjs"."3.5.1" = lib.makeOverridable self.buildNodePackage {
+    name = "mocha-phantomjs-3.5.1";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mocha-phantomjs/-/mocha-phantomjs-3.5.0.tgz";
-        name = "mocha-phantomjs-3.5.0.tgz";
-        sha1 = "56fb4072122b4061b21e9c3901e35f4a7c58a93e";
+        url = "http://registry.npmjs.org/mocha-phantomjs/-/mocha-phantomjs-3.5.1.tgz";
+        name = "mocha-phantomjs-3.5.1.tgz";
+        sha1 = "e5460eff3e859b98be73a743f11cb5cae3c58d00";
       })
     ];
     buildInputs =
···
       "commander-2.0.0" = self.by-version."commander"."2.0.0";
     };
     peerDependencies = [
-      self.by-version."phantomjs"."1.9.10"
+      self.by-version."phantomjs"."1.9.11"
     ];
     passthru.names = [ "mocha-phantomjs" ];
   };
-  "mocha-phantomjs" = self.by-version."mocha-phantomjs"."3.5.0";
+  "mocha-phantomjs" = self.by-version."mocha-phantomjs"."3.5.1";
   by-spec."mocha-unfunk-reporter"."*" =
     self.by-version."mocha-unfunk-reporter"."0.4.0";
   by-version."mocha-unfunk-reporter"."0.4.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "moment" ];
   };
   by-spec."mongodb"."*" =
-    self.by-version."mongodb"."2.0.0-alpha2";
-  by-version."mongodb"."2.0.0-alpha2" = lib.makeOverridable self.buildNodePackage {
-    name = "mongodb-2.0.0-alpha2";
+    self.by-version."mongodb"."2.0.3";
+  by-version."mongodb"."2.0.3" = lib.makeOverridable self.buildNodePackage {
+    name = "mongodb-2.0.3";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mongodb/-/mongodb-2.0.0-alpha2.tgz";
-        name = "mongodb-2.0.0-alpha2.tgz";
-        sha1 = "04541787b29a7db6a03ca4e44e593dd726d03d91";
+        url = "http://registry.npmjs.org/mongodb/-/mongodb-2.0.3.tgz";
+        name = "mongodb-2.0.3.tgz";
+        sha1 = "78dd12c11aaa8cf8666c16128fd19f55a8f9b313";
       })
     ];
     buildInputs =
       (self.nativeDeps."mongodb" or []);
     deps = {
-      "mongodb-core-1.0.0-alpha9" = self.by-version."mongodb-core"."1.0.0-alpha9";
+      "mongodb-core-1.0.3" = self.by-version."mongodb-core"."1.0.3";
       "readable-stream-1.0.31" = self.by-version."readable-stream"."1.0.31";
     };
     peerDependencies = [
     ];
     passthru.names = [ "mongodb" ];
   };
-  "mongodb" = self.by-version."mongodb"."2.0.0-alpha2";
+  "mongodb" = self.by-version."mongodb"."2.0.3";
   by-spec."mongodb"."1.2.14" =
     self.by-version."mongodb"."1.2.14";
   by-version."mongodb"."1.2.14" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "mongodb" ];
   };
   by-spec."mongodb-core"."~1.0" =
-    self.by-version."mongodb-core"."1.0.0-alpha9";
-  by-version."mongodb-core"."1.0.0-alpha9" = lib.makeOverridable self.buildNodePackage {
-    name = "mongodb-core-1.0.0-alpha9";
+    self.by-version."mongodb-core"."1.0.3";
+  by-version."mongodb-core"."1.0.3" = lib.makeOverridable self.buildNodePackage {
+    name = "mongodb-core-1.0.3";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mongodb-core/-/mongodb-core-1.0.0-alpha9.tgz";
-        name = "mongodb-core-1.0.0-alpha9.tgz";
-        sha1 = "895cf88ad00d20462c417cc2f59d261ec15f0c23";
+        url = "http://registry.npmjs.org/mongodb-core/-/mongodb-core-1.0.3.tgz";
+        name = "mongodb-core-1.0.3.tgz";
+        sha1 = "387649e432368dcd02c983f39454700d6958619a";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "monocle" ];
   };
-  by-spec."morgan"."~1.3.2" =
-    self.by-version."morgan"."1.3.2";
-  by-version."morgan"."1.3.2" = lib.makeOverridable self.buildNodePackage {
-    name = "morgan-1.3.2";
+  by-spec."morgan"."~1.4.0" =
+    self.by-version."morgan"."1.4.0";
+  by-version."morgan"."1.4.0" = lib.makeOverridable self.buildNodePackage {
+    name = "morgan-1.4.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/morgan/-/morgan-1.3.2.tgz";
-        name = "morgan-1.3.2.tgz";
-        sha1 = "ac41aa15221ee4e5f2ac843896b6918139a18efd";
+        url = "http://registry.npmjs.org/morgan/-/morgan-1.4.0.tgz";
+        name = "morgan-1.4.0.tgz";
+        sha1 = "ce3c6ee28f794f85f59165476575b70ed386eb3d";
       })
     ];
     buildInputs =
       (self.nativeDeps."morgan" or []);
     deps = {
       "basic-auth-1.0.0" = self.by-version."basic-auth"."1.0.0";
-      "depd-0.4.5" = self.by-version."depd"."0.4.5";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
       "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";
     };
     peerDependencies = [
···
     passthru.names = [ "mv" ];
   };
   by-spec."mz"."1" =
-    self.by-version."mz"."1.0.1";
-  by-version."mz"."1.0.1" = lib.makeOverridable self.buildNodePackage {
-    name = "mz-1.0.1";
+    self.by-version."mz"."1.0.2";
+  by-version."mz"."1.0.2" = lib.makeOverridable self.buildNodePackage {
+    name = "mz-1.0.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mz/-/mz-1.0.1.tgz";
-        name = "mz-1.0.1.tgz";
-        sha1 = "5ce1d3fe5cb3267c9c3141fb6a070f8d17f215d8";
+        url = "http://registry.npmjs.org/mz/-/mz-1.0.2.tgz";
+        name = "mz-1.0.2.tgz";
+        sha1 = "1c861e902ed75527399ca0d95152b9726aea73ac";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "negotiator" ];
   };
-  by-spec."negotiator"."0.4.8" =
-    self.by-version."negotiator"."0.4.8";
-  by-version."negotiator"."0.4.8" = lib.makeOverridable self.buildNodePackage {
-    name = "negotiator-0.4.8";
+  by-spec."negotiator"."0.4.9" =
+    self.by-version."negotiator"."0.4.9";
+  by-version."negotiator"."0.4.9" = lib.makeOverridable self.buildNodePackage {
+    name = "negotiator-0.4.9";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/negotiator/-/negotiator-0.4.8.tgz";
-        name = "negotiator-0.4.8.tgz";
-        sha1 = "96010b23b63c387f47a4bed96762a831cda39eab";
+        url = "http://registry.npmjs.org/negotiator/-/negotiator-0.4.9.tgz";
+        name = "negotiator-0.4.9.tgz";
+        sha1 = "92e46b6db53c7e421ed64a2bc94f08be7630df3f";
       })
     ];
     buildInputs =
···
     passthru.names = [ "nib" ];
   };
   by-spec."nijs"."*" =
-    self.by-version."nijs"."0.0.18";
-  by-version."nijs"."0.0.18" = lib.makeOverridable self.buildNodePackage {
-    name = "nijs-0.0.18";
+    self.by-version."nijs"."0.0.20";
+  by-version."nijs"."0.0.20" = lib.makeOverridable self.buildNodePackage {
+    name = "nijs-0.0.20";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/nijs/-/nijs-0.0.18.tgz";
-        name = "nijs-0.0.18.tgz";
-        sha1 = "bfdf140350d2bb3edae6b094dbc31035d6c7bec8";
+        url = "http://registry.npmjs.org/nijs/-/nijs-0.0.20.tgz";
+        name = "nijs-0.0.20.tgz";
+        sha1 = "db193f4ed5fc9571ee6fb58542778e96e38f0f7e";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "nijs" ];
   };
-  "nijs" = self.by-version."nijs"."0.0.18";
+  "nijs" = self.by-version."nijs"."0.0.20";
   by-spec."node-appc"."0.2.14" =
     self.by-version."node-appc"."0.2.14";
   by-version."node-appc"."0.2.14" = lib.makeOverridable self.buildNodePackage {
···
     deps = {
       "fstream-1.0.2" = self.by-version."fstream"."1.0.2";
       "glob-4.0.6" = self.by-version."glob"."4.0.6";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "minimatch-1.0.0" = self.by-version."minimatch"."1.0.0";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "nopt-3.0.1" = self.by-version."nopt"."3.0.1";
···
       "osenv-0.1.0" = self.by-version."osenv"."0.1.0";
       "request-2.45.0" = self.by-version."request"."2.45.0";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
       "tar-1.0.1" = self.by-version."tar"."1.0.1";
       "which-1.0.5" = self.by-version."which"."1.0.5";
     };
···
   };
   "node-inspector" = self.by-version."node-inspector"."0.7.4";
   by-spec."node-protobuf"."*" =
-    self.by-version."node-protobuf"."1.2.1";
-  by-version."node-protobuf"."1.2.1" = lib.makeOverridable self.buildNodePackage {
-    name = "node-protobuf-1.2.1";
+    self.by-version."node-protobuf"."1.2.2";
+  by-version."node-protobuf"."1.2.2" = lib.makeOverridable self.buildNodePackage {
+    name = "node-protobuf-1.2.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/node-protobuf/-/node-protobuf-1.2.1.tgz";
-        name = "node-protobuf-1.2.1.tgz";
-        sha1 = "d517eb4cdcfac002390ace6b8f0b865322eef049";
+        url = "http://registry.npmjs.org/node-protobuf/-/node-protobuf-1.2.2.tgz";
+        name = "node-protobuf-1.2.2.tgz";
+        sha1 = "8d512499fe012358c1fd89d6b4d84ad80317acb3";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "node-protobuf" ];
   };
-  "node-protobuf" = self.by-version."node-protobuf"."1.2.1";
+  "node-protobuf" = self.by-version."node-protobuf"."1.2.2";
   by-spec."node-swt".">=0.1.1" =
     self.by-version."node-swt"."0.1.1";
   by-version."node-swt"."0.1.1" = lib.makeOverridable self.buildNodePackage {
···
     deps = {
       "github-url-from-git-1.4.0" = self.by-version."github-url-from-git"."1.4.0";
       "github-url-from-username-repo-1.0.2" = self.by-version."github-url-from-username-repo"."1.0.2";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
     };
     peerDependencies = [
     ];
···
   by-spec."normalize-package-data"."~1.0.3" =
     self.by-version."normalize-package-data"."1.0.3";
   by-spec."npm"."*" =
-    self.by-version."npm"."2.1.3";
-  by-version."npm"."2.1.3" = lib.makeOverridable self.buildNodePackage {
-    name = "npm-2.1.3";
+    self.by-version."npm"."2.1.5";
+  by-version."npm"."2.1.5" = lib.makeOverridable self.buildNodePackage {
+    name = "npm-2.1.5";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/npm/-/npm-2.1.3.tgz";
-        name = "npm-2.1.3.tgz";
-        sha1 = "f6dfc9d4bdaefe712a50bb75ae5c8bbdf2cd3a3b";
+        url = "http://registry.npmjs.org/npm/-/npm-2.1.5.tgz";
+        name = "npm-2.1.5.tgz";
+        sha1 = "ce343163a56f1ff14ffa295c140d99833b9764cb";
       })
     ];
     buildInputs =
···
       "ansi-0.3.0" = self.by-version."ansi"."0.3.0";
       "ansicolors-0.3.2" = self.by-version."ansicolors"."0.3.2";
       "ansistyles-0.1.3" = self.by-version."ansistyles"."0.1.3";
-      "archy-0.0.2" = self.by-version."archy"."0.0.2";
+      "archy-1.0.0" = self.by-version."archy"."1.0.0";
       "async-some-1.0.1" = self.by-version."async-some"."1.0.1";
       "block-stream-0.0.7" = self.by-version."block-stream"."0.0.7";
       "char-spinner-1.0.1" = self.by-version."char-spinner"."1.0.1";
···
       "chownr-0.0.1" = self.by-version."chownr"."0.0.1";
       "cmd-shim-2.0.1" = self.by-version."cmd-shim"."2.0.1";
       "columnify-1.2.1" = self.by-version."columnify"."1.2.1";
+      "config-chain-1.1.8" = self.by-version."config-chain"."1.1.8";
       "dezalgo-1.0.1" = self.by-version."dezalgo"."1.0.1";
       "editor-0.1.0" = self.by-version."editor"."0.1.0";
       "fs-vacuum-1.2.1" = self.by-version."fs-vacuum"."1.2.1";
       "fs-write-stream-atomic-1.0.2" = self.by-version."fs-write-stream-atomic"."1.0.2";
       "fstream-1.0.2" = self.by-version."fstream"."1.0.2";
-      "fstream-npm-1.0.0" = self.by-version."fstream-npm"."1.0.0";
+      "fstream-npm-1.0.1" = self.by-version."fstream-npm"."1.0.1";
       "github-url-from-git-1.4.0" = self.by-version."github-url-from-git"."1.4.0";
       "github-url-from-username-repo-1.0.2" = self.by-version."github-url-from-username-repo"."1.0.2";
       "glob-4.0.6" = self.by-version."glob"."4.0.6";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "inflight-1.0.4" = self.by-version."inflight"."1.0.4";
       "inherits-2.0.1" = self.by-version."inherits"."2.0.1";
-      "ini-1.2.1" = self.by-version."ini"."1.2.1";
+      "ini-1.3.0" = self.by-version."ini"."1.3.0";
       "init-package-json-1.1.0" = self.by-version."init-package-json"."1.1.0";
       "lockfile-1.0.0" = self.by-version."lockfile"."1.0.0";
       "lru-cache-2.5.0" = self.by-version."lru-cache"."2.5.0";
···
       "npm-cache-filename-1.0.1" = self.by-version."npm-cache-filename"."1.0.1";
       "npm-install-checks-1.0.4" = self.by-version."npm-install-checks"."1.0.4";
       "npm-package-arg-2.1.3" = self.by-version."npm-package-arg"."2.1.3";
-      "npm-registry-client-3.2.2" = self.by-version."npm-registry-client"."3.2.2";
-      "npm-user-validate-0.1.0" = self.by-version."npm-user-validate"."0.1.0";
-      "npmconf-2.1.0" = self.by-version."npmconf"."2.1.0";
+      "npm-registry-client-3.2.4" = self.by-version."npm-registry-client"."3.2.4";
+      "npm-user-validate-0.1.1" = self.by-version."npm-user-validate"."0.1.1";
       "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";
       "once-1.3.1" = self.by-version."once"."1.3.1";
-      "opener-1.3.0" = self.by-version."opener"."1.3.0";
+      "opener-1.4.0" = self.by-version."opener"."1.4.0";
       "osenv-0.1.0" = self.by-version."osenv"."0.1.0";
       "path-is-inside-1.0.1" = self.by-version."path-is-inside"."1.0.1";
       "read-1.0.5" = self.by-version."read"."1.0.5";
       "read-installed-3.1.3" = self.by-version."read-installed"."3.1.3";
       "read-package-json-1.2.7" = self.by-version."read-package-json"."1.2.7";
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
-      "realize-package-specifier-1.1.0" = self.by-version."realize-package-specifier"."1.1.0";
-      "request-2.44.0" = self.by-version."request"."2.44.0";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
+      "realize-package-specifier-1.2.0" = self.by-version."realize-package-specifier"."1.2.0";
+      "request-2.45.0" = self.by-version."request"."2.45.0";
       "retry-0.6.1" = self.by-version."retry"."0.6.1";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
-      "sha-1.2.4" = self.by-version."sha"."1.2.4";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
+      "sha-1.3.0" = self.by-version."sha"."1.3.0";
       "slide-1.1.6" = self.by-version."slide"."1.1.6";
       "sorted-object-1.0.0" = self.by-version."sorted-object"."1.0.0";
       "tar-1.0.1" = self.by-version."tar"."1.0.1";
···
     ];
     passthru.names = [ "npm" ];
   };
-  "npm" = self.by-version."npm"."2.1.3";
+  "npm" = self.by-version."npm"."2.1.5";
   by-spec."npm-cache-filename"."^1.0.0" =
     self.by-version."npm-cache-filename"."1.0.1";
   by-version."npm-cache-filename"."1.0.1" = lib.makeOverridable self.buildNodePackage {
···
       (self.nativeDeps."npm-install-checks" or []);
     deps = {
       "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
     };
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."npm-package-arg" or []);
     deps = {
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
     };
     peerDependencies = [
     ];
···
       (self.nativeDeps."npm-registry-client" or []);
     deps = {
       "chownr-0.0.1" = self.by-version."chownr"."0.0.1";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "normalize-package-data-1.0.3" = self.by-version."normalize-package-data"."1.0.3";
       "npm-cache-filename-1.0.1" = self.by-version."npm-cache-filename"."1.0.1";
···
       "request-2.45.0" = self.by-version."request"."2.45.0";
       "retry-0.6.0" = self.by-version."retry"."0.6.0";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
       "slide-1.1.6" = self.by-version."slide"."1.1.6";
       "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";
     };
···
     ];
     passthru.names = [ "npm-registry-client" ];
   };
-  by-spec."npm-registry-client"."~3.2.2" =
-    self.by-version."npm-registry-client"."3.2.2";
-  by-version."npm-registry-client"."3.2.2" = lib.makeOverridable self.buildNodePackage {
-    name = "npm-registry-client-3.2.2";
+  by-spec."npm-registry-client"."~3.2.4" =
+    self.by-version."npm-registry-client"."3.2.4";
+  by-version."npm-registry-client"."3.2.4" = lib.makeOverridable self.buildNodePackage {
+    name = "npm-registry-client-3.2.4";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/npm-registry-client/-/npm-registry-client-3.2.2.tgz";
-        name = "npm-registry-client-3.2.2.tgz";
-        sha1 = "7c4ef979cf61b411d15421a24ac2b3b846f8bd53";
+        url = "http://registry.npmjs.org/npm-registry-client/-/npm-registry-client-3.2.4.tgz";
+        name = "npm-registry-client-3.2.4.tgz";
+        sha1 = "8659b3449e1c9a9f8181dad142cadb048bfe521f";
       })
     ];
     buildInputs =
       (self.nativeDeps."npm-registry-client" or []);
     deps = {
       "chownr-0.0.1" = self.by-version."chownr"."0.0.1";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "normalize-package-data-1.0.3" = self.by-version."normalize-package-data"."1.0.3";
       "npm-cache-filename-1.0.1" = self.by-version."npm-cache-filename"."1.0.1";
       "once-1.3.1" = self.by-version."once"."1.3.1";
       "request-2.45.0" = self.by-version."request"."2.45.0";
-      "retry-0.6.0" = self.by-version."retry"."0.6.0";
+      "retry-0.6.1" = self.by-version."retry"."0.6.1";
       "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
       "slide-1.1.6" = self.by-version."slide"."1.1.6";
       "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";
     };
     peerDependencies = [
-      self.by-version."npmconf"."2.1.0"
     ];
     passthru.names = [ "npm-registry-client" ];
   };
-  by-spec."npm-user-validate"."~0.1.0" =
-    self.by-version."npm-user-validate"."0.1.0";
-  by-version."npm-user-validate"."0.1.0" = lib.makeOverridable self.buildNodePackage {
-    name = "npm-user-validate-0.1.0";
+  by-spec."npm-user-validate"."~0.1.1" =
+    self.by-version."npm-user-validate"."0.1.1";
+  by-version."npm-user-validate"."0.1.1" = lib.makeOverridable self.buildNodePackage {
+    name = "npm-user-validate-0.1.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/npm-user-validate/-/npm-user-validate-0.1.0.tgz";
-        name = "npm-user-validate-0.1.0.tgz";
-        sha1 = "358a5b5148ed3f79771d980388c6e34c4a61f638";
+        url = "http://registry.npmjs.org/npm-user-validate/-/npm-user-validate-0.1.1.tgz";
+        name = "npm-user-validate-0.1.1.tgz";
+        sha1 = "ea7774636c3c8fe6d01e174bd9f2ee0e22eeed57";
       })
     ];
     buildInputs =
···
       "nopt-3.0.1" = self.by-version."nopt"."3.0.1";
       "once-1.3.1" = self.by-version."once"."1.3.1";
       "osenv-0.1.0" = self.by-version."osenv"."0.1.0";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
       "uid-number-0.0.5" = self.by-version."uid-number"."0.0.5";
     };
     peerDependencies = [
     ];
     passthru.names = [ "npmconf" ];
   };
-  by-spec."npmconf".">=2.1.0-0 >=2.1.0-0 <2.2.0-0" =
-    self.by-version."npmconf"."2.1.0";
-  by-version."npmconf"."2.1.0" = lib.makeOverridable self.buildNodePackage {
-    name = "npmconf-2.1.0";
+  by-spec."npmconf"."^2.0.1" =
+    self.by-version."npmconf"."2.1.1";
+  by-version."npmconf"."2.1.1" = lib.makeOverridable self.buildNodePackage {
+    name = "npmconf-2.1.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/npmconf/-/npmconf-2.1.0.tgz";
-        name = "npmconf-2.1.0.tgz";
-        sha1 = "6dcdbd1fe3d7373b78ec74ab69e919d4954f76b0";
+        url = "http://registry.npmjs.org/npmconf/-/npmconf-2.1.1.tgz";
+        name = "npmconf-2.1.1.tgz";
+        sha1 = "a266c7e5c56695eb7f55caf3a5a7328f24510dae";
       })
     ];
     buildInputs =
···
       "nopt-3.0.1" = self.by-version."nopt"."3.0.1";
       "once-1.3.1" = self.by-version."once"."1.3.1";
       "osenv-0.1.0" = self.by-version."osenv"."0.1.0";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
       "uid-number-0.0.5" = self.by-version."uid-number"."0.0.5";
     };
     peerDependencies = [
     ];
     passthru.names = [ "npmconf" ];
   };
-  by-spec."npmconf"."^2.0.1" =
-    self.by-version."npmconf"."2.1.0";
-  by-spec."npmconf"."^2.1.0" =
-    self.by-version."npmconf"."2.1.0";
   by-spec."npmconf"."~0.1.2" =
     self.by-version."npmconf"."0.1.16";
   by-version."npmconf"."0.1.16" = lib.makeOverridable self.buildNodePackage {
···
   };
   by-spec."npmconf"."~2.0.5" =
     self.by-version."npmconf"."2.0.9";
-  by-spec."npmconf"."~2.1.0" =
-    self.by-version."npmconf"."2.1.0";
   by-spec."npmlog"."*" =
     self.by-version."npmlog"."0.1.1";
   by-version."npmlog"."0.1.1" = lib.makeOverridable self.buildNodePackage {
···
       (fetchurl {
         url = "https://github.com/ciaranj/node-oauth/tarball/master";
         name = "oauth-0.9.11.tgz";
-        sha256 = "81deda1451b8103f278cbede8aab0a929a63882dbc604214fd7690d72390d083";
+        sha256 = "783dead39b8df22dfff8961fcfb3e65622375d4308c12c1fbce2ae2e4da20184";
       })
     ];
     buildInputs =
···
   };
   by-spec."once"."~1.3.0" =
     self.by-version."once"."1.3.1";
+  by-spec."once"."~1.3.1" =
+    self.by-version."once"."1.3.1";
   by-spec."open"."0.0.2" =
     self.by-version."open"."0.0.2";
   by-version."open"."0.0.2" = lib.makeOverridable self.buildNodePackage {
···
         url = "http://registry.npmjs.org/opener/-/opener-1.3.0.tgz";
         name = "opener-1.3.0.tgz";
         sha1 = "130ba662213fa842edb4cd0361d31a15301a43e2";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."opener" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "opener" ];
+  };
+  by-spec."opener"."~1.4.0" =
+    self.by-version."opener"."1.4.0";
+  by-version."opener"."1.4.0" = lib.makeOverridable self.buildNodePackage {
+    name = "opener-1.4.0";
+    bin = true;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/opener/-/opener-1.4.0.tgz";
+        name = "opener-1.4.0.tgz";
+        sha1 = "d11f86eeeb076883735c9d509f538fe82d10b941";
       })
     ];
     buildInputs =
···
     passthru.names = [ "pbkdf2-compat" ];
   };
   by-spec."phantomjs"."*" =
-    self.by-version."phantomjs"."1.9.10";
-  by-version."phantomjs"."1.9.10" = lib.makeOverridable self.buildNodePackage {
-    name = "phantomjs-1.9.10";
+    self.by-version."phantomjs"."1.9.11";
+  by-version."phantomjs"."1.9.11" = lib.makeOverridable self.buildNodePackage {
+    name = "phantomjs-1.9.11";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/phantomjs/-/phantomjs-1.9.10.tgz";
-        name = "phantomjs-1.9.10.tgz";
-        sha1 = "be174e20b03f42c39beaaf84cc153fb65b225a4a";
+        url = "http://registry.npmjs.org/phantomjs/-/phantomjs-1.9.11.tgz";
+        name = "phantomjs-1.9.11.tgz";
+        sha1 = "de822affca7858382b6ab9c931ba4541e5b8a0ae";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "phantomjs" ];
   };
-  "phantomjs" = self.by-version."phantomjs"."1.9.10";
+  "phantomjs" = self.by-version."phantomjs"."1.9.11";
   by-spec."phantomjs"."~1.9.1" =
-    self.by-version."phantomjs"."1.9.10";
+    self.by-version."phantomjs"."1.9.11";
   by-spec."phantomjs"."~1.9.10" =
-    self.by-version."phantomjs"."1.9.10";
+    self.by-version."phantomjs"."1.9.11";
   by-spec."pkginfo"."0.2.x" =
     self.by-version."pkginfo"."0.2.3";
   by-version."pkginfo"."0.2.3" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "promise" ];
   };
+  by-spec."promise"."~6.0.1" =
+    self.by-version."promise"."6.0.1";
+  by-version."promise"."6.0.1" = lib.makeOverridable self.buildNodePackage {
+    name = "promise-6.0.1";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/promise/-/promise-6.0.1.tgz";
+        name = "promise-6.0.1.tgz";
+        sha1 = "d475cff81c083a27fe87ae19952b72c1a6936237";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."promise" or []);
+    deps = {
+      "asap-1.0.0" = self.by-version."asap"."1.0.0";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "promise" ];
+  };
   by-spec."prompt"."0.2.11" =
     self.by-version."prompt"."0.2.11";
   by-version."prompt"."0.2.11" = lib.makeOverridable self.buildNodePackage {
···
       "read-1.0.5" = self.by-version."read"."1.0.5";
       "revalidator-0.1.8" = self.by-version."revalidator"."0.1.8";
       "utile-0.2.1" = self.by-version."utile"."0.2.1";
-      "winston-0.8.0" = self.by-version."winston"."0.8.0";
+      "winston-0.8.1" = self.by-version."winston"."0.8.1";
     };
     peerDependencies = [
     ];
···
     passthru.names = [ "punycode" ];
   };
   by-spec."punycode".">=0.2.0" =
-    self.by-version."punycode"."1.3.1";
-  by-version."punycode"."1.3.1" = lib.makeOverridable self.buildNodePackage {
-    name = "punycode-1.3.1";
+    self.by-version."punycode"."1.3.2";
+  by-version."punycode"."1.3.2" = lib.makeOverridable self.buildNodePackage {
+    name = "punycode-1.3.2";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/punycode/-/punycode-1.3.1.tgz";
-        name = "punycode-1.3.1.tgz";
-        sha1 = "710afe5123c20a1530b712e3e682b9118fe8058e";
+        url = "http://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz";
+        name = "punycode-1.3.2.tgz";
+        sha1 = "9653a036fb7c1ee42342f2325cceefea3926c48d";
       })
     ];
     buildInputs =
···
     passthru.names = [ "qs" ];
   };
   by-spec."querystring-es3"."~0.2.0" =
-    self.by-version."querystring-es3"."0.2.1-0";
-  by-version."querystring-es3"."0.2.1-0" = lib.makeOverridable self.buildNodePackage {
-    name = "querystring-es3-0.2.1-0";
+    self.by-version."querystring-es3"."0.2.1";
+  by-version."querystring-es3"."0.2.1" = lib.makeOverridable self.buildNodePackage {
+    name = "querystring-es3-0.2.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1-0.tgz";
-        name = "querystring-es3-0.2.1-0.tgz";
-        sha1 = "bd38cbd701040e7ef66c94a93db4a5b45be39565";
+        url = "http://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz";
+        name = "querystring-es3-0.2.1.tgz";
+        sha1 = "9ec61f79049875707d69414596fd907a4d711e73";
       })
     ];
     buildInputs =
···
     passthru.names = [ "rc" ];
   };
   by-spec."react"."*" =
-    self.by-version."react"."0.11.2";
-  by-version."react"."0.11.2" = lib.makeOverridable self.buildNodePackage {
-    name = "react-0.11.2";
+    self.by-version."react"."0.12.0-rc1";
+  by-version."react"."0.12.0-rc1" = lib.makeOverridable self.buildNodePackage {
+    name = "react-0.12.0-rc1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/react/-/react-0.11.2.tgz";
-        name = "react-0.11.2.tgz";
-        sha1 = "eaeb787e9b1e266a3540c07c06f4ea80fe1e3766";
+        url = "http://registry.npmjs.org/react/-/react-0.12.0-rc1.tgz";
+        name = "react-0.12.0-rc1.tgz";
+        sha1 = "de56afc07e834fdf2f988a9c1026c25b93a61636";
       })
     ];
     buildInputs =
       (self.nativeDeps."react" or []);
     deps = {
-      "envify-2.0.1" = self.by-version."envify"."2.0.1";
+      "envify-3.0.0" = self.by-version."envify"."3.0.0";
     };
     peerDependencies = [
     ];
     passthru.names = [ "react" ];
   };
-  "react" = self.by-version."react"."0.11.2";
+  "react" = self.by-version."react"."0.12.0-rc1";
   by-spec."read"."1" =
     self.by-version."read"."1.0.5";
   by-version."read"."1.0.5" = lib.makeOverridable self.buildNodePackage {
···
       "debuglog-1.0.1" = self.by-version."debuglog"."1.0.1";
       "read-package-json-1.2.7" = self.by-version."read-package-json"."1.2.7";
       "readdir-scoped-modules-1.0.0" = self.by-version."readdir-scoped-modules"."1.0.0";
-      "semver-4.0.3" = self.by-version."semver"."4.0.3";
+      "semver-4.1.0" = self.by-version."semver"."4.1.0";
       "slide-1.1.6" = self.by-version."slide"."1.1.6";
       "util-extend-1.0.1" = self.by-version."util-extend"."1.0.1";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
     };
     peerDependencies = [
     ];
···
       "glob-4.0.6" = self.by-version."glob"."4.0.6";
       "lru-cache-2.5.0" = self.by-version."lru-cache"."2.5.0";
       "normalize-package-data-1.0.3" = self.by-version."normalize-package-data"."1.0.3";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "readable-stream" ];
   };
-  by-spec."readable-stream"."1.0" =
-    self.by-version."readable-stream"."1.0.32";
-  by-version."readable-stream"."1.0.32" = lib.makeOverridable self.buildNodePackage {
-    name = "readable-stream-1.0.32";
+  by-spec."readable-stream"."1.0.27-1" =
+    self.by-version."readable-stream"."1.0.27-1";
+  by-version."readable-stream"."1.0.27-1" = lib.makeOverridable self.buildNodePackage {
+    name = "readable-stream-1.0.27-1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.32.tgz";
-        name = "readable-stream-1.0.32.tgz";
-        sha1 = "6b44a88ba984cd0ec0834ae7d59a47c39aef48ec";
+        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.27-1.tgz";
+        name = "readable-stream-1.0.27-1.tgz";
+        sha1 = "6b67983c20357cefd07f0165001a16d710d91078";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "readable-stream" ];
   };
-  by-spec."readable-stream"."1.0.27-1" =
-    self.by-version."readable-stream"."1.0.27-1";
-  by-version."readable-stream"."1.0.27-1" = lib.makeOverridable self.buildNodePackage {
-    name = "readable-stream-1.0.27-1";
+  by-spec."readable-stream"."1.0.31" =
+    self.by-version."readable-stream"."1.0.31";
+  by-version."readable-stream"."1.0.31" = lib.makeOverridable self.buildNodePackage {
+    name = "readable-stream-1.0.31";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.27-1.tgz";
-        name = "readable-stream-1.0.27-1.tgz";
-        sha1 = "6b67983c20357cefd07f0165001a16d710d91078";
+        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.31.tgz";
+        name = "readable-stream-1.0.31.tgz";
+        sha1 = "8f2502e0bc9e3b0da1b94520aabb4e2603ecafae";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "readable-stream" ];
   };
-  by-spec."readable-stream"."1.0.31" =
-    self.by-version."readable-stream"."1.0.31";
-  by-version."readable-stream"."1.0.31" = lib.makeOverridable self.buildNodePackage {
-    name = "readable-stream-1.0.31";
+  by-spec."readable-stream"."1.1" =
+    self.by-version."readable-stream"."1.1.13";
+  by-spec."readable-stream".">=1.0.33-1 <1.1.0-0" =
+    self.by-version."readable-stream"."1.0.33-1";
+  by-version."readable-stream"."1.0.33-1" = lib.makeOverridable self.buildNodePackage {
+    name = "readable-stream-1.0.33-1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.31.tgz";
-        name = "readable-stream-1.0.31.tgz";
-        sha1 = "8f2502e0bc9e3b0da1b94520aabb4e2603ecafae";
+        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.33-1.tgz";
+        name = "readable-stream-1.0.33-1.tgz";
+        sha1 = "40d0d91338691291a9117c05d78adb5497c37810";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "readable-stream" ];
   };
-  by-spec."readable-stream"."1.1" =
-    self.by-version."readable-stream"."1.1.13";
-  by-spec."readable-stream".">=1.0.28 <1.1.0-0" =
-    self.by-version."readable-stream"."1.0.32";
   by-spec."readable-stream".">=1.1.13-1 <1.2.0-0" =
     self.by-version."readable-stream"."1.1.13";
   by-spec."readable-stream"."^1.0.27-1" =
···
   by-spec."readable-stream"."^1.1.13-1" =
     self.by-version."readable-stream"."1.1.13";
   by-spec."readable-stream"."~1.0.17" =
-    self.by-version."readable-stream"."1.0.32";
+    self.by-version."readable-stream"."1.0.33-1";
   by-spec."readable-stream"."~1.0.2" =
-    self.by-version."readable-stream"."1.0.32";
+    self.by-version."readable-stream"."1.0.33-1";
   by-spec."readable-stream"."~1.0.24" =
-    self.by-version."readable-stream"."1.0.32";
+    self.by-version."readable-stream"."1.0.33-1";
   by-spec."readable-stream"."~1.0.26" =
-    self.by-version."readable-stream"."1.0.32";
+    self.by-version."readable-stream"."1.0.33-1";
+  by-spec."readable-stream"."~1.0.26-2" =
+    self.by-version."readable-stream"."1.0.33-1";
   by-spec."readable-stream"."~1.0.32" =
-    self.by-version."readable-stream"."1.0.32";
+    self.by-version."readable-stream"."1.0.33-1";
+  by-spec."readable-stream"."~1.1" =
+    self.by-version."readable-stream"."1.1.13";
   by-spec."readable-stream"."~1.1.8" =
     self.by-version."readable-stream"."1.1.13";
   by-spec."readable-stream"."~1.1.9" =
···
     ];
     passthru.names = [ "readdirp" ];
   };
+  by-spec."readdirp"."~1.1.0" =
+    self.by-version."readdirp"."1.1.0";
+  by-version."readdirp"."1.1.0" = lib.makeOverridable self.buildNodePackage {
+    name = "readdirp-1.1.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/readdirp/-/readdirp-1.1.0.tgz";
+        name = "readdirp-1.1.0.tgz";
+        sha1 = "6506f9d5d8bb2edc19c855a60bb92feca5fae39c";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."readdirp" or []);
+    deps = {
+      "graceful-fs-2.0.3" = self.by-version."graceful-fs"."2.0.3";
+      "minimatch-0.2.14" = self.by-version."minimatch"."0.2.14";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "readdirp" ];
+  };
   by-spec."readline2"."~0.1.0" =
     self.by-version."readline2"."0.1.0";
   by-version."readline2"."0.1.0" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "readline2" ];
   };
-  by-spec."realize-package-specifier"."~1.1.0" =
-    self.by-version."realize-package-specifier"."1.1.0";
-  by-version."realize-package-specifier"."1.1.0" = lib.makeOverridable self.buildNodePackage {
-    name = "realize-package-specifier-1.1.0";
+  by-spec."realize-package-specifier"."~1.2.0" =
+    self.by-version."realize-package-specifier"."1.2.0";
+  by-version."realize-package-specifier"."1.2.0" = lib.makeOverridable self.buildNodePackage {
+    name = "realize-package-specifier-1.2.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/realize-package-specifier/-/realize-package-specifier-1.1.0.tgz";
-        name = "realize-package-specifier-1.1.0.tgz";
-        sha1 = "b6922638b7224186ae9278bdebbb63cba23a0160";
+        url = "http://registry.npmjs.org/realize-package-specifier/-/realize-package-specifier-1.2.0.tgz";
+        name = "realize-package-specifier-1.2.0.tgz";
+        sha1 = "93364e40dee38369f92e9b0c76124500342132f2";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "realize-package-specifier" ];
   };
-  by-spec."recursive-readdir"."0.0.2" =
-    self.by-version."recursive-readdir"."0.0.2";
-  by-version."recursive-readdir"."0.0.2" = lib.makeOverridable self.buildNodePackage {
-    name = "recursive-readdir-0.0.2";
-    bin = false;
-    src = [
-      (fetchurl {
-        url = "http://registry.npmjs.org/recursive-readdir/-/recursive-readdir-0.0.2.tgz";
-        name = "recursive-readdir-0.0.2.tgz";
-        sha1 = "0bc47dc4838e646dccfba0507b5e57ffbff35f7c";
-      })
-    ];
-    buildInputs =
-      (self.nativeDeps."recursive-readdir" or []);
-    deps = {
-    };
-    peerDependencies = [
-    ];
-    passthru.names = [ "recursive-readdir" ];
-  };
   by-spec."redeyed"."~0.4.0" =
     self.by-version."redeyed"."0.4.4";
   by-version."redeyed"."0.4.4" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."registry-url" or []);
     deps = {
-      "npmconf-2.1.0" = self.by-version."npmconf"."2.1.0";
+      "npmconf-2.1.1" = self.by-version."npmconf"."2.1.1";
     };
     peerDependencies = [
     ];
···
     self.by-version."request"."2.40.0";
   by-spec."request"."~2.42.0" =
     self.by-version."request"."2.42.0";
-  by-spec."request"."~2.44.0" =
-    self.by-version."request"."2.44.0";
-  by-version."request"."2.44.0" = lib.makeOverridable self.buildNodePackage {
-    name = "request-2.44.0";
-    bin = false;
-    src = [
-      (fetchurl {
-        url = "http://registry.npmjs.org/request/-/request-2.44.0.tgz";
-        name = "request-2.44.0.tgz";
-        sha1 = "78d62454d68853cadfb07ad31f58b9ec98072ea8";
-      })
-    ];
-    buildInputs =
-      (self.nativeDeps."request" or []);
-    deps = {
-      "bl-0.9.3" = self.by-version."bl"."0.9.3";
-      "caseless-0.6.0" = self.by-version."caseless"."0.6.0";
-      "forever-agent-0.5.2" = self.by-version."forever-agent"."0.5.2";
-      "qs-1.2.2" = self.by-version."qs"."1.2.2";
-      "json-stringify-safe-5.0.0" = self.by-version."json-stringify-safe"."5.0.0";
-      "mime-types-1.0.2" = self.by-version."mime-types"."1.0.2";
-      "node-uuid-1.4.1" = self.by-version."node-uuid"."1.4.1";
-      "tunnel-agent-0.4.0" = self.by-version."tunnel-agent"."0.4.0";
-      "tough-cookie-0.12.1" = self.by-version."tough-cookie"."0.12.1";
-      "form-data-0.1.4" = self.by-version."form-data"."0.1.4";
-      "http-signature-0.10.0" = self.by-version."http-signature"."0.10.0";
-      "oauth-sign-0.4.0" = self.by-version."oauth-sign"."0.4.0";
-      "hawk-1.1.1" = self.by-version."hawk"."1.1.1";
-      "aws-sign2-0.5.0" = self.by-version."aws-sign2"."0.5.0";
-      "stringstream-0.0.4" = self.by-version."stringstream"."0.0.4";
-    };
-    peerDependencies = [
-    ];
-    passthru.names = [ "request" ];
-  };
+  by-spec."request"."~2.45.0" =
+    self.by-version."request"."2.45.0";
   by-spec."request-progress"."0.3.0" =
     self.by-version."request-progress"."0.3.0";
   by-version."request-progress"."0.3.0" = lib.makeOverridable self.buildNodePackage {
···
   };
   by-spec."resolve"."~0.3.1" =
     self.by-version."resolve"."0.3.1";
-  by-spec."resolve"."~0.7.0" =
-    self.by-version."resolve"."0.7.4";
   by-spec."resolve"."~0.7.1" =
     self.by-version."resolve"."0.7.4";
   by-spec."resolve"."~0.7.2" =
     self.by-version."resolve"."0.7.4";
-  by-spec."response-time"."~2.0.1" =
-    self.by-version."response-time"."2.0.1";
-  by-version."response-time"."2.0.1" = lib.makeOverridable self.buildNodePackage {
-    name = "response-time-2.0.1";
+  by-spec."resolve"."~1.0.0" =
+    self.by-version."resolve"."1.0.0";
+  by-version."resolve"."1.0.0" = lib.makeOverridable self.buildNodePackage {
+    name = "resolve-1.0.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/response-time/-/response-time-2.0.1.tgz";
-        name = "response-time-2.0.1.tgz";
-        sha1 = "c6d2cbadeac4cb251b21016fe182640c02aff343";
+        url = "http://registry.npmjs.org/resolve/-/resolve-1.0.0.tgz";
+        name = "resolve-1.0.0.tgz";
+        sha1 = "2a6e3b314dcd57c6519e8e2282af8687e8de61c6";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."resolve" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "resolve" ];
+  };
+  by-spec."response-time"."~2.2.0" =
+    self.by-version."response-time"."2.2.0";
+  by-version."response-time"."2.2.0" = lib.makeOverridable self.buildNodePackage {
+    name = "response-time-2.2.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/response-time/-/response-time-2.2.0.tgz";
+        name = "response-time-2.2.0.tgz";
+        sha1 = "77ab4688cbf030e9c5f82dc1eac7fe5226d3c8eb";
       })
     ];
     buildInputs =
       (self.nativeDeps."response-time" or []);
     deps = {
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
       "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";
     };
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."rethinkdb" or []);
     deps = {
-      "bluebird-2.3.5" = self.by-version."bluebird"."2.3.5";
+      "bluebird-2.3.6" = self.by-version."bluebird"."2.3.6";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "retry" ];
   };
-  by-spec."retry"."~0.6.0" =
+  by-spec."retry"."^0.6.1" =
     self.by-version."retry"."0.6.1";
   by-version."retry"."0.6.1" = lib.makeOverridable self.buildNodePackage {
     name = "retry-0.6.1";
···
     ];
     passthru.names = [ "retry" ];
   };
+  by-spec."retry"."~0.6.0" =
+    self.by-version."retry"."0.6.1";
+  by-spec."retry"."~0.6.1" =
+    self.by-version."retry"."0.6.1";
   by-spec."revalidator"."0.1.x" =
     self.by-version."revalidator"."0.1.8";
   by-version."revalidator"."0.1.8" = lib.makeOverridable self.buildNodePackage {
···
   };
   by-spec."rimraf"."~2.2.0" =
     self.by-version."rimraf"."2.2.8";
-  by-spec."rimraf"."~2.2.2" =
-    self.by-version."rimraf"."2.2.8";
   by-spec."rimraf"."~2.2.5" =
     self.by-version."rimraf"."2.2.8";
   by-spec."rimraf"."~2.2.6" =
···
     passthru.names = [ "ruglify" ];
   };
   by-spec."rx"."^2.2.27" =
-    self.by-version."rx"."2.3.12";
-  by-version."rx"."2.3.12" = lib.makeOverridable self.buildNodePackage {
-    name = "rx-2.3.12";
+    self.by-version."rx"."2.3.13";
+  by-version."rx"."2.3.13" = lib.makeOverridable self.buildNodePackage {
+    name = "rx-2.3.13";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/rx/-/rx-2.3.12.tgz";
-        name = "rx-2.3.12.tgz";
-        sha1 = "9bdc2c8e12cb0a62e528947de458277849f0c2f4";
+        url = "http://registry.npmjs.org/rx/-/rx-2.3.13.tgz";
+        name = "rx-2.3.13.tgz";
+        sha1 = "8a42c6079e4bf7a712c17780ed17c408633a6cbc";
       })
     ];
     buildInputs =
···
     passthru.names = [ "sax" ];
   };
   by-spec."sax"."0.6.x" =
-    self.by-version."sax"."0.6.0";
-  by-version."sax"."0.6.0" = lib.makeOverridable self.buildNodePackage {
-    name = "sax-0.6.0";
+    self.by-version."sax"."0.6.1";
+  by-version."sax"."0.6.1" = lib.makeOverridable self.buildNodePackage {
+    name = "sax-0.6.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/sax/-/sax-0.6.0.tgz";
-        name = "sax-0.6.0.tgz";
-        sha1 = "7a155519b712e3ec56f102ab984f15e15d3859f0";
+        url = "http://registry.npmjs.org/sax/-/sax-0.6.1.tgz";
+        name = "sax-0.6.1.tgz";
+        sha1 = "563b19c7c1de892e09bfc4f2fc30e3c27f0952b9";
       })
     ];
     buildInputs =
···
     passthru.names = [ "sax" ];
   };
   by-spec."sax".">=0.4.2" =
-    self.by-version."sax"."0.6.0";
+    self.by-version."sax"."0.6.1";
   by-spec."scmp"."0.0.3" =
     self.by-version."scmp"."0.0.3";
   by-version."scmp"."0.0.3" = lib.makeOverridable self.buildNodePackage {
···
   };
   "selenium-webdriver" = self.by-version."selenium-webdriver"."2.43.5";
   by-spec."semver"."*" =
-    self.by-version."semver"."4.0.3";
-  by-version."semver"."4.0.3" = lib.makeOverridable self.buildNodePackage {
-    name = "semver-4.0.3";
+    self.by-version."semver"."4.1.0";
+  by-version."semver"."4.1.0" = lib.makeOverridable self.buildNodePackage {
+    name = "semver-4.1.0";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/semver/-/semver-4.0.3.tgz";
-        name = "semver-4.0.3.tgz";
-        sha1 = "f79c9ba670efccc029d98a5017def64b0ce1644e";
+        url = "http://registry.npmjs.org/semver/-/semver-4.1.0.tgz";
+        name = "semver-4.1.0.tgz";
+        sha1 = "bc80a9ff68532814362cc3cfda3c7b75ed9c321c";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "semver" ];
   };
-  "semver" = self.by-version."semver"."4.0.3";
+  "semver" = self.by-version."semver"."4.1.0";
   by-spec."semver"."1.1.0" =
     self.by-version."semver"."1.1.0";
   by-version."semver"."1.1.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "semver" ];
   };
   by-spec."semver"."2 >=2.2.1 || 3.x || 4" =
-    self.by-version."semver"."4.0.3";
+    self.by-version."semver"."4.1.0";
   by-spec."semver"."2 || 3 || 4" =
-    self.by-version."semver"."4.0.3";
+    self.by-version."semver"."4.1.0";
   by-spec."semver"."2.x" =
     self.by-version."semver"."2.3.2";
   by-spec."semver"."2.x || 3.x || 4" =
-    self.by-version."semver"."4.0.3";
+    self.by-version."semver"."4.1.0";
   by-spec."semver"."4" =
-    self.by-version."semver"."4.0.3";
+    self.by-version."semver"."4.1.0";
   by-spec."semver".">=2.0.10 <3.0.0" =
     self.by-version."semver"."2.3.2";
   by-spec."semver".">=2.2.1 <3" =
···
   by-spec."semver"."^2.3.0" =
     self.by-version."semver"."2.3.2";
   by-spec."semver"."^2.3.0 || 3.x || 4" =
-    self.by-version."semver"."4.0.3";
+    self.by-version."semver"."4.1.0";
   by-spec."semver"."^3.0.1" =
     self.by-version."semver"."3.0.1";
   by-version."semver"."3.0.1" = lib.makeOverridable self.buildNodePackage {
···
     self.by-version."semver"."2.3.2";
   by-spec."semver"."~3.0.1" =
     self.by-version."semver"."3.0.1";
-  by-spec."semver"."~4.0.0" =
-    self.by-version."semver"."4.0.3";
+  by-spec."semver"."~4.1.0" =
+    self.by-version."semver"."4.1.0";
   by-spec."semver-diff"."^0.1.0" =
     self.by-version."semver-diff"."0.1.0";
   by-version."semver-diff"."0.1.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "semver-diff" ];
   };
   by-spec."send"."*" =
-    self.by-version."send"."0.9.3";
-  by-version."send"."0.9.3" = lib.makeOverridable self.buildNodePackage {
-    name = "send-0.9.3";
+    self.by-version."send"."0.10.0";
+  by-version."send"."0.10.0" = lib.makeOverridable self.buildNodePackage {
+    name = "send-0.10.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/send/-/send-0.9.3.tgz";
-        name = "send-0.9.3.tgz";
-        sha1 = "b43a7414cd089b7fbec9b755246f7c37b7b85cc0";
+        url = "http://registry.npmjs.org/send/-/send-0.10.0.tgz";
+        name = "send-0.10.0.tgz";
+        sha1 = "2f984b703934c628b72b72d70557b75ca906ea6c";
       })
     ];
     buildInputs =
       (self.nativeDeps."send" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
-      "depd-0.4.5" = self.by-version."depd"."0.4.5";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "depd-1.0.0" = self.by-version."depd"."1.0.0";
       "destroy-1.0.3" = self.by-version."destroy"."1.0.3";
       "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";
-      "etag-1.4.0" = self.by-version."etag"."1.4.0";
+      "etag-1.5.0" = self.by-version."etag"."1.5.0";
       "fresh-0.2.4" = self.by-version."fresh"."0.2.4";
       "mime-1.2.11" = self.by-version."mime"."1.2.11";
       "ms-0.6.2" = self.by-version."ms"."0.6.2";
···
     buildInputs =
       (self.nativeDeps."send" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "mime-1.2.6" = self.by-version."mime"."1.2.6";
       "fresh-0.1.0" = self.by-version."fresh"."0.1.0";
       "range-parser-0.0.4" = self.by-version."range-parser"."0.0.4";
···
     buildInputs =
       (self.nativeDeps."send" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "mime-1.2.6" = self.by-version."mime"."1.2.6";
       "fresh-0.1.0" = self.by-version."fresh"."0.1.0";
       "range-parser-0.0.4" = self.by-version."range-parser"."0.0.4";
···
     buildInputs =
       (self.nativeDeps."send" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "mime-1.2.11" = self.by-version."mime"."1.2.11";
       "fresh-0.2.0" = self.by-version."fresh"."0.2.0";
       "range-parser-0.0.4" = self.by-version."range-parser"."0.0.4";
···
     ];
     passthru.names = [ "send" ];
   };
+  by-spec."send"."0.10.0" =
+    self.by-version."send"."0.10.0";
   by-spec."send"."0.2.0" =
     self.by-version."send"."0.2.0";
   by-version."send"."0.2.0" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."send" or []);
     deps = {
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "mime-1.2.11" = self.by-version."mime"."1.2.11";
       "fresh-0.2.4" = self.by-version."fresh"."0.2.4";
       "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";
···
   };
   by-spec."send"."0.9.3" =
     self.by-version."send"."0.9.3";
+  by-version."send"."0.9.3" = lib.makeOverridable self.buildNodePackage {
+    name = "send-0.9.3";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/send/-/send-0.9.3.tgz";
+        name = "send-0.9.3.tgz";
+        sha1 = "b43a7414cd089b7fbec9b755246f7c37b7b85cc0";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."send" or []);
+    deps = {
+      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "depd-0.4.5" = self.by-version."depd"."0.4.5";
+      "destroy-1.0.3" = self.by-version."destroy"."1.0.3";
+      "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";
+      "etag-1.4.0" = self.by-version."etag"."1.4.0";
+      "fresh-0.2.4" = self.by-version."fresh"."0.2.4";
+      "mime-1.2.11" = self.by-version."mime"."1.2.11";
+      "ms-0.6.2" = self.by-version."ms"."0.6.2";
+      "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";
+      "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "send" ];
+  };
   by-spec."sequence"."2.2.1" =
     self.by-version."sequence"."2.2.1";
   by-version."sequence"."2.2.1" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "sequencify" ];
   };
-  by-spec."serve-favicon"."~2.1.5" =
-    self.by-version."serve-favicon"."2.1.5";
-  by-version."serve-favicon"."2.1.5" = lib.makeOverridable self.buildNodePackage {
-    name = "serve-favicon-2.1.5";
+  by-spec."serve-favicon"."~2.1.6" =
+    self.by-version."serve-favicon"."2.1.6";
+  by-version."serve-favicon"."2.1.6" = lib.makeOverridable self.buildNodePackage {
+    name = "serve-favicon-2.1.6";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/serve-favicon/-/serve-favicon-2.1.5.tgz";
-        name = "serve-favicon-2.1.5.tgz";
-        sha1 = "8eba1830890bddbbf042e8d5c6456c7d004f6175";
+        url = "http://registry.npmjs.org/serve-favicon/-/serve-favicon-2.1.6.tgz";
+        name = "serve-favicon-2.1.6.tgz";
+        sha1 = "46326a9eb64a0fa5cf012a4f85efe9fda95820e5";
       })
     ];
     buildInputs =
       (self.nativeDeps."serve-favicon" or []);
     deps = {
-      "etag-1.4.0" = self.by-version."etag"."1.4.0";
+      "etag-1.5.0" = self.by-version."etag"."1.5.0";
       "fresh-0.2.4" = self.by-version."fresh"."0.2.4";
       "ms-0.6.2" = self.by-version."ms"."0.6.2";
     };
···
     ];
     passthru.names = [ "serve-favicon" ];
   };
-  by-spec."serve-index"."~1.2.1" =
-    self.by-version."serve-index"."1.2.1";
-  by-version."serve-index"."1.2.1" = lib.makeOverridable self.buildNodePackage {
-    name = "serve-index-1.2.1";
+  by-spec."serve-index"."~1.5.0" =
+    self.by-version."serve-index"."1.5.0";
+  by-version."serve-index"."1.5.0" = lib.makeOverridable self.buildNodePackage {
+    name = "serve-index-1.5.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/serve-index/-/serve-index-1.2.1.tgz";
-        name = "serve-index-1.2.1.tgz";
-        sha1 = "854daef00ac9ff2f5bfda1c019b78fb0ed6d2e6f";
+        url = "http://registry.npmjs.org/serve-index/-/serve-index-1.5.0.tgz";
+        name = "serve-index-1.5.0.tgz";
+        sha1 = "066a35ff1564146cceb2105014a5b070af68707e";
       })
     ];
     buildInputs =
       (self.nativeDeps."serve-index" or []);
     deps = {
-      "accepts-1.1.1" = self.by-version."accepts"."1.1.1";
+      "accepts-1.1.2" = self.by-version."accepts"."1.1.2";
       "batch-0.5.1" = self.by-version."batch"."0.5.1";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
+      "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";
+      "mime-types-2.0.2" = self.by-version."mime-types"."2.0.2";
       "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";
     };
     peerDependencies = [
···
   };
   by-spec."serve-static"."~1.5.4" =
     self.by-version."serve-static"."1.5.4";
-  by-spec."serve-static"."~1.6.3" =
-    self.by-version."serve-static"."1.6.3";
-  by-version."serve-static"."1.6.3" = lib.makeOverridable self.buildNodePackage {
-    name = "serve-static-1.6.3";
+  by-spec."serve-static"."~1.6.4" =
+    self.by-version."serve-static"."1.6.4";
+  by-version."serve-static"."1.6.4" = lib.makeOverridable self.buildNodePackage {
+    name = "serve-static-1.6.4";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/serve-static/-/serve-static-1.6.3.tgz";
-        name = "serve-static-1.6.3.tgz";
-        sha1 = "b214235d4d4516db050ea9f7b429b46212e79132";
+        url = "http://registry.npmjs.org/serve-static/-/serve-static-1.6.4.tgz";
+        name = "serve-static-1.6.4.tgz";
+        sha1 = "c512e4188d7a9366672db24e40d294f0c6212367";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "serve-static" ];
   };
-  by-spec."sha"."~1.2.1" =
-    self.by-version."sha"."1.2.4";
-  by-version."sha"."1.2.4" = lib.makeOverridable self.buildNodePackage {
-    name = "sha-1.2.4";
+  by-spec."serve-static"."~1.7.0" =
+    self.by-version."serve-static"."1.7.0";
+  by-version."serve-static"."1.7.0" = lib.makeOverridable self.buildNodePackage {
+    name = "serve-static-1.7.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/sha/-/sha-1.2.4.tgz";
-        name = "sha-1.2.4.tgz";
-        sha1 = "1f9a377f27b6fdee409b9b858e43da702be48a4d";
+        url = "http://registry.npmjs.org/serve-static/-/serve-static-1.7.0.tgz";
+        name = "serve-static-1.7.0.tgz";
+        sha1 = "af2ad4e619fa2d46dcd19dd59e3b034c92510e4d";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."serve-static" or []);
+    deps = {
+      "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";
+      "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";
+      "send-0.10.0" = self.by-version."send"."0.10.0";
+      "utils-merge-1.0.0" = self.by-version."utils-merge"."1.0.0";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "serve-static" ];
+  };
+  by-spec."sha"."~1.3.0" =
+    self.by-version."sha"."1.3.0";
+  by-version."sha"."1.3.0" = lib.makeOverridable self.buildNodePackage {
+    name = "sha-1.3.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/sha/-/sha-1.3.0.tgz";
+        name = "sha-1.3.0.tgz";
+        sha1 = "79f4787045d0ede7327d702c25c443460dbc6764";
       })
     ];
     buildInputs =
       (self.nativeDeps."sha" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
+      "readable-stream-1.1.13" = self.by-version."readable-stream"."1.1.13";
     };
     peerDependencies = [
     ];
···
   by-spec."shelljs"."0.3.x" =
     self.by-version."shelljs"."0.3.0";
   by-spec."should"."*" =
-    self.by-version."should"."4.0.4";
-  by-version."should"."4.0.4" = lib.makeOverridable self.buildNodePackage {
-    name = "should-4.0.4";
+    self.by-version."should"."4.1.0";
+  by-version."should"."4.1.0" = lib.makeOverridable self.buildNodePackage {
+    name = "should-4.1.0";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/should/-/should-4.0.4.tgz";
-        name = "should-4.0.4.tgz";
-        sha1 = "8efaa304f1f148cf3d2e955862990f9ab9ea628f";
+        url = "http://registry.npmjs.org/should/-/should-4.1.0.tgz";
+        name = "should-4.1.0.tgz";
+        sha1 = "ae3335655a1fdbb156e0b338bf191106f59dab21";
       })
     ];
     buildInputs =
       (self.nativeDeps."should" or []);
     deps = {
+      "should-equal-0.0.1" = self.by-version."should-equal"."0.0.1";
     };
     peerDependencies = [
     ];
     passthru.names = [ "should" ];
   };
-  "should" = self.by-version."should"."4.0.4";
+  "should" = self.by-version."should"."4.1.0";
+  by-spec."should-equal"."0.0.1" =
+    self.by-version."should-equal"."0.0.1";
+  by-version."should-equal"."0.0.1" = lib.makeOverridable self.buildNodePackage {
+    name = "should-equal-0.0.1";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/should-equal/-/should-equal-0.0.1.tgz";
+        name = "should-equal-0.0.1.tgz";
+        sha1 = "55066653a9f03211da695a2fea768b19956a9c0b";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."should-equal" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "should-equal" ];
+  };
   by-spec."sigmund"."~1.0.0" =
     self.by-version."sigmund"."1.0.0";
   by-version."sigmund"."1.0.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "statsd-librato-backend" ];
   };
   "statsd-librato-backend" = self.by-version."statsd-librato-backend"."0.1.3";
+  by-spec."statuses"."1" =
+    self.by-version."statuses"."1.2.0";
+  by-version."statuses"."1.2.0" = lib.makeOverridable self.buildNodePackage {
+    name = "statuses-1.2.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/statuses/-/statuses-1.2.0.tgz";
+        name = "statuses-1.2.0.tgz";
+        sha1 = "4445790d65bec29184f50d54810f67e290c1679e";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."statuses" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "statuses" ];
+  };
   by-spec."stream-browserify"."^1.0.0" =
     self.by-version."stream-browserify"."1.0.0";
   by-version."stream-browserify"."1.0.0" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "strip-json-comments" ];
   };
   by-spec."strip-json-comments"."1.0.x" =
-    self.by-version."strip-json-comments"."1.0.1";
-  by-version."strip-json-comments"."1.0.1" = lib.makeOverridable self.buildNodePackage {
-    name = "strip-json-comments-1.0.1";
+    self.by-version."strip-json-comments"."1.0.2";
+  by-version."strip-json-comments"."1.0.2" = lib.makeOverridable self.buildNodePackage {
+    name = "strip-json-comments-1.0.2";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/strip-json-comments/-/strip-json-comments-1.0.1.tgz";
-        name = "strip-json-comments-1.0.1.tgz";
-        sha1 = "a91252d95ddee4ff38a66135cd6c78de5709f374";
+        url = "http://registry.npmjs.org/strip-json-comments/-/strip-json-comments-1.0.2.tgz";
+        name = "strip-json-comments-1.0.2.tgz";
+        sha1 = "5a48ab96023dbac1b7b8d0ffabf6f63f1677be9f";
       })
     ];
     buildInputs =
···
     buildInputs =
       (self.nativeDeps."strong-data-uri" or []);
     deps = {
-      "truncate-1.0.2" = self.by-version."truncate"."1.0.2";
+      "truncate-1.0.4" = self.by-version."truncate"."1.0.4";
     };
     peerDependencies = [
     ];
     passthru.names = [ "strong-data-uri" ];
   };
   by-spec."stylus"."*" =
-    self.by-version."stylus"."0.49.1";
-  by-version."stylus"."0.49.1" = lib.makeOverridable self.buildNodePackage {
-    name = "stylus-0.49.1";
+    self.by-version."stylus"."0.49.2";
+  by-version."stylus"."0.49.2" = lib.makeOverridable self.buildNodePackage {
+    name = "stylus-0.49.2";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/stylus/-/stylus-0.49.1.tgz";
-        name = "stylus-0.49.1.tgz";
-        sha1 = "c915495675ca77847a7d4285dd6d6572bae34448";
+        url = "http://registry.npmjs.org/stylus/-/stylus-0.49.2.tgz";
+        name = "stylus-0.49.2.tgz";
+        sha1 = "c72a9ea9d904d24bb07c8fd609e6abc28620000a";
       })
     ];
     buildInputs =
···
     deps = {
       "css-parse-1.7.0" = self.by-version."css-parse"."1.7.0";
       "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "sax-0.5.8" = self.by-version."sax"."0.5.8";
       "glob-3.2.11" = self.by-version."glob"."3.2.11";
       "source-map-0.1.40" = self.by-version."source-map"."0.1.40";
···
     ];
     passthru.names = [ "stylus" ];
   };
-  "stylus" = self.by-version."stylus"."0.49.1";
+  "stylus" = self.by-version."stylus"."0.49.2";
   by-spec."stylus"."0.42.2" =
     self.by-version."stylus"."0.42.2";
   by-version."stylus"."0.42.2" = lib.makeOverridable self.buildNodePackage {
···
     deps = {
       "css-parse-1.7.0" = self.by-version."css-parse"."1.7.0";
       "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";
-      "debug-2.0.0" = self.by-version."debug"."2.0.0";
+      "debug-2.1.0" = self.by-version."debug"."2.1.0";
       "sax-0.5.8" = self.by-version."sax"."0.5.8";
       "glob-3.2.11" = self.by-version."glob"."3.2.11";
     };
···
     buildInputs =
       (self.nativeDeps."through2" or []);
     deps = {
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
       "xtend-3.0.0" = self.by-version."xtend"."3.0.0";
     };
     peerDependencies = [
···
     passthru.names = [ "through2" ];
   };
   by-spec."through2"."^0.6.1" =
-    self.by-version."through2"."0.6.2";
-  by-version."through2"."0.6.2" = lib.makeOverridable self.buildNodePackage {
-    name = "through2-0.6.2";
+    self.by-version."through2"."0.6.3";
+  by-version."through2"."0.6.3" = lib.makeOverridable self.buildNodePackage {
+    name = "through2-0.6.3";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/through2/-/through2-0.6.2.tgz";
-        name = "through2-0.6.2.tgz";
-        sha1 = "53265824c555e7fcdc4111dcdc52c7de64636c75";
+        url = "http://registry.npmjs.org/through2/-/through2-0.6.3.tgz";
+        name = "through2-0.6.3.tgz";
+        sha1 = "795292fde9f254c2a368b38f9cc5d1bd4663afb6";
       })
     ];
     buildInputs =
       (self.nativeDeps."through2" or []);
     deps = {
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
       "xtend-4.0.0" = self.by-version."xtend"."4.0.0";
     };
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."through2" or []);
     deps = {
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
       "xtend-2.1.2" = self.by-version."xtend"."2.1.2";
     };
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."tildify" or []);
     deps = {
-      "user-home-1.0.0" = self.by-version."user-home"."1.0.0";
+      "user-home-1.1.0" = self.by-version."user-home"."1.1.0";
     };
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "timers-browserify" ];
   };
-  by-spec."timers-ext"."0.1.x" =
+  by-spec."timers-ext"."0.1" =
     self.by-version."timers-ext"."0.1.0";
   by-version."timers-ext"."0.1.0" = lib.makeOverridable self.buildNodePackage {
     name = "timers-ext-0.1.0";
···
     ];
     passthru.names = [ "timers-ext" ];
   };
+  by-spec."timers-ext"."0.1.x" =
+    self.by-version."timers-ext"."0.1.0";
   by-spec."timespan"."~2.3.0" =
     self.by-version."timespan"."2.3.0";
   by-version."timespan"."2.3.0" = lib.makeOverridable self.buildNodePackage {
···
     deps = {
       "async-0.2.10" = self.by-version."async"."0.2.10";
       "colors-0.6.2" = self.by-version."colors"."0.6.2";
-      "fields-0.1.16" = self.by-version."fields"."0.1.16";
+      "fields-0.1.17" = self.by-version."fields"."0.1.17";
       "humanize-0.0.9" = self.by-version."humanize"."0.0.9";
       "jade-0.35.0" = self.by-version."jade"."0.35.0";
       "longjohn-0.2.4" = self.by-version."longjohn"."0.2.4";
···
     buildInputs =
       (self.nativeDeps."tough-cookie" or []);
     deps = {
-      "punycode-1.3.1" = self.by-version."punycode"."1.3.1";
+      "punycode-1.3.2" = self.by-version."punycode"."1.3.2";
     };
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."traceur" or []);
     deps = {
-      "commander-2.3.0" = self.by-version."commander"."2.3.0";
+      "commander-2.4.0" = self.by-version."commander"."2.4.0";
       "glob-4.0.6" = self.by-version."glob"."4.0.6";
       "semver-2.3.2" = self.by-version."semver"."2.3.2";
     };
···
     passthru.names = [ "traverse" ];
   };
   by-spec."truncate"."~1.0.2" =
-    self.by-version."truncate"."1.0.2";
-  by-version."truncate"."1.0.2" = lib.makeOverridable self.buildNodePackage {
-    name = "truncate-1.0.2";
+    self.by-version."truncate"."1.0.4";
+  by-version."truncate"."1.0.4" = lib.makeOverridable self.buildNodePackage {
+    name = "truncate-1.0.4";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/truncate/-/truncate-1.0.2.tgz";
-        name = "truncate-1.0.2.tgz";
-        sha1 = "3221c41f6e747f83e8613f5466c8bfb596226a66";
+        url = "http://registry.npmjs.org/truncate/-/truncate-1.0.4.tgz";
+        name = "truncate-1.0.4.tgz";
+        sha1 = "2bcfbbff4a97b9089b693c1ae37c5105ec8775aa";
       })
     ];
     buildInputs =
···
     buildInputs =
       (self.nativeDeps."uid-safe" or []);
     deps = {
-      "mz-1.0.1" = self.by-version."mz"."1.0.1";
+      "mz-1.0.2" = self.by-version."mz"."1.0.2";
       "base64-url-1.0.0" = self.by-version."base64-url"."1.0.0";
     };
     peerDependencies = [
···
       "signals-1.0.0" = self.by-version."signals"."1.0.0";
       "hasher-1.2.0" = self.by-version."hasher"."1.2.0";
       "blueimp-md5-1.1.0" = self.by-version."blueimp-md5"."1.1.0";
-      "color-0.7.1" = self.by-version."color"."0.7.1";
+      "color-0.7.3" = self.by-version."color"."0.7.3";
       "keen.io-0.1.2" = self.by-version."keen.io"."0.1.2";
       "getmac-1.0.6" = self.by-version."getmac"."1.0.6";
       "deep-extend-0.2.11" = self.by-version."deep-extend"."0.2.11";
···
     passthru.names = [ "url" ];
   };
   by-spec."user-home"."^1.0.0" =
-    self.by-version."user-home"."1.0.0";
-  by-version."user-home"."1.0.0" = lib.makeOverridable self.buildNodePackage {
-    name = "user-home-1.0.0";
+    self.by-version."user-home"."1.1.0";
+  by-version."user-home"."1.1.0" = lib.makeOverridable self.buildNodePackage {
+    name = "user-home-1.1.0";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/user-home/-/user-home-1.0.0.tgz";
-        name = "user-home-1.0.0.tgz";
-        sha1 = "54ecb631e0fa420e9b0a6b946b158d137825b38b";
+        url = "http://registry.npmjs.org/user-home/-/user-home-1.1.0.tgz";
+        name = "user-home-1.1.0.tgz";
+        sha1 = "1f4e6bce5458aeec4ac80ebcdcc66119c1070cdf";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "uuid" ];
   };
+  by-spec."v8flags"."^1.0.1" =
+    self.by-version."v8flags"."1.0.1";
+  by-version."v8flags"."1.0.1" = lib.makeOverridable self.buildNodePackage {
+    name = "v8flags-1.0.1";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/v8flags/-/v8flags-1.0.1.tgz";
+        name = "v8flags-1.0.1.tgz";
+        sha1 = "a35328d86fd040ef9cdeed5387a8e5bcb25216ec";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."v8flags" or []);
+    deps = {
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "v8flags" ];
+  };
   by-spec."validator"."0.4.x" =
     self.by-version."validator"."0.4.28";
   by-version."validator"."0.4.28" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "vinyl" ];
   };
   by-spec."vinyl-fs"."^0.3.0" =
-    self.by-version."vinyl-fs"."0.3.8";
-  by-version."vinyl-fs"."0.3.8" = lib.makeOverridable self.buildNodePackage {
-    name = "vinyl-fs-0.3.8";
+    self.by-version."vinyl-fs"."0.3.10";
+  by-version."vinyl-fs"."0.3.10" = lib.makeOverridable self.buildNodePackage {
+    name = "vinyl-fs-0.3.10";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/vinyl-fs/-/vinyl-fs-0.3.8.tgz";
-        name = "vinyl-fs-0.3.8.tgz";
-        sha1 = "bea09db28e558e5e903a51a5363fcdb59e5aabe4";
+        url = "http://registry.npmjs.org/vinyl-fs/-/vinyl-fs-0.3.10.tgz";
+        name = "vinyl-fs-0.3.10.tgz";
+        sha1 = "f59ac977cb040e95df865ad34cdeb00f57f31f47";
       })
     ];
     buildInputs =
···
     deps = {
       "glob-stream-3.1.15" = self.by-version."glob-stream"."3.1.15";
       "glob-watcher-0.0.6" = self.by-version."glob-watcher"."0.0.6";
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "lodash-2.4.1" = self.by-version."lodash"."2.4.1";
       "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";
       "strip-bom-1.0.0" = self.by-version."strip-bom"."1.0.0";
-      "through2-0.6.2" = self.by-version."through2"."0.6.2";
+      "through2-0.6.3" = self.by-version."through2"."0.6.3";
       "vinyl-0.4.3" = self.by-version."vinyl"."0.4.3";
     };
     peerDependencies = [
···
     passthru.names = [ "vinyl-fs" ];
   };
   by-spec."vinyl-fs"."^0.3.3" =
-    self.by-version."vinyl-fs"."0.3.8";
+    self.by-version."vinyl-fs"."0.3.10";
   by-spec."vm-browserify"."~0.0.1" =
     self.by-version."vm-browserify"."0.0.4";
   by-version."vm-browserify"."0.0.4" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "wcwidth" ];
   };
   by-spec."wd"."~0.3.4" =
-    self.by-version."wd"."0.3.8";
-  by-version."wd"."0.3.8" = lib.makeOverridable self.buildNodePackage {
-    name = "wd-0.3.8";
+    self.by-version."wd"."0.3.9";
+  by-version."wd"."0.3.9" = lib.makeOverridable self.buildNodePackage {
+    name = "wd-0.3.9";
     bin = true;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/wd/-/wd-0.3.8.tgz";
-        name = "wd-0.3.8.tgz";
-        sha1 = "68c4371561ac32b986dd93f42f89072746c09c84";
+        url = "http://registry.npmjs.org/wd/-/wd-0.3.9.tgz";
+        name = "wd-0.3.9.tgz";
+        sha1 = "857130517e5976203653dd325edc4bdc2dbd946f";
       })
     ];
     buildInputs =
···
     deps = {
       "archiver-0.11.0" = self.by-version."archiver"."0.11.0";
       "async-0.9.0" = self.by-version."async"."0.9.0";
-      "colors-0.6.2" = self.by-version."colors"."0.6.2";
       "lodash-2.4.1" = self.by-version."lodash"."2.4.1";
       "q-1.0.1" = self.by-version."q"."1.0.1";
-      "request-2.42.0" = self.by-version."request"."2.42.0";
+      "request-2.45.0" = self.by-version."request"."2.45.0";
       "underscore.string-2.3.3" = self.by-version."underscore.string"."2.3.3";
       "vargs-0.1.0" = self.by-version."vargs"."0.1.0";
     };
···
       "kew-0.1.7" = self.by-version."kew"."0.1.7";
       "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";
       "npmconf-0.1.16" = self.by-version."npmconf"."0.1.16";
-      "phantomjs-1.9.10" = self.by-version."phantomjs"."1.9.10";
+      "phantomjs-1.9.11" = self.by-version."phantomjs"."1.9.11";
       "tmp-0.0.24" = self.by-version."tmp"."0.0.24";
       "follow-redirects-0.0.3" = self.by-version."follow-redirects"."0.0.3";
     };
···
     passthru.names = [ "winser" ];
   };
   by-spec."winston"."*" =
-    self.by-version."winston"."0.8.0";
-  by-version."winston"."0.8.0" = lib.makeOverridable self.buildNodePackage {
-    name = "winston-0.8.0";
+    self.by-version."winston"."0.8.1";
+  by-version."winston"."0.8.1" = lib.makeOverridable self.buildNodePackage {
+    name = "winston-0.8.1";
     bin = false;
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/winston/-/winston-0.8.0.tgz";
-        name = "winston-0.8.0.tgz";
-        sha1 = "61d0830fa699706212206b0a2b5ca69a93043668";
+        url = "http://registry.npmjs.org/winston/-/winston-0.8.1.tgz";
+        name = "winston-0.8.1.tgz";
+        sha1 = "86bc9ec6c02aefe5c6dfdb88f3aff1b19d629216";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "winston" ];
   };
-  "winston" = self.by-version."winston"."0.8.0";
+  "winston" = self.by-version."winston"."0.8.1";
   by-spec."winston"."0.6.2" =
     self.by-version."winston"."0.6.2";
   by-version."winston"."0.6.2" = lib.makeOverridable self.buildNodePackage {
···
   };
   by-spec."winston"."0.8.0" =
     self.by-version."winston"."0.8.0";
+  by-version."winston"."0.8.0" = lib.makeOverridable self.buildNodePackage {
+    name = "winston-0.8.0";
+    bin = false;
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/winston/-/winston-0.8.0.tgz";
+        name = "winston-0.8.0.tgz";
+        sha1 = "61d0830fa699706212206b0a2b5ca69a93043668";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."winston" or []);
+    deps = {
+      "async-0.2.10" = self.by-version."async"."0.2.10";
+      "colors-0.6.2" = self.by-version."colors"."0.6.2";
+      "cycle-1.0.3" = self.by-version."cycle"."1.0.3";
+      "eyes-0.1.8" = self.by-version."eyes"."0.1.8";
+      "pkginfo-0.3.0" = self.by-version."pkginfo"."0.3.0";
+      "stack-trace-0.0.9" = self.by-version."stack-trace"."0.0.9";
+    };
+    peerDependencies = [
+    ];
+    passthru.names = [ "winston" ];
+  };
   by-spec."winston"."0.8.x" =
-    self.by-version."winston"."0.8.0";
+    self.by-version."winston"."0.8.1";
   by-spec."winston"."~0.7.2" =
     self.by-version."winston"."0.7.3";
   by-version."winston"."0.7.3" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."write-file-atomic" or []);
     deps = {
-      "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";
+      "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";
       "slide-1.1.6" = self.by-version."slide"."1.1.6";
     };
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."xml2js" or []);
     deps = {
-      "sax-0.6.0" = self.by-version."sax"."0.6.0";
+      "sax-0.6.1" = self.by-version."sax"."0.6.1";
     };
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."xml2js" or []);
     deps = {
-      "sax-0.6.0" = self.by-version."sax"."0.6.0";
+      "sax-0.6.1" = self.by-version."sax"."0.6.1";
       "xmlbuilder-2.4.4" = self.by-version."xmlbuilder"."2.4.4";
     };
     peerDependencies = [
···
     deps = {
       "compress-commons-0.1.6" = self.by-version."compress-commons"."0.1.6";
       "lodash-2.4.1" = self.by-version."lodash"."2.4.1";
-      "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";
+      "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";
     };
     peerDependencies = [
     ];

pkgs/top-level/perl-packages.nix

···
   };
 
   CatalystModelDBICSchema = buildPerlPackage {
-    name = "Catalyst-Model-DBIC-Schema-0.60";
+    name = "Catalyst-Model-DBIC-Schema-0.65";
     src = fetchurl {
-      url = mirror://cpan/authors/id/R/RK/RKITOVER/Catalyst-Model-DBIC-Schema-0.60.tar.gz;
-      sha256 = "176jqvrmhp0wng446m0qlmh1kgqj4z1czg6s418ffr4a7c3jqyld";
+      url = mirror://cpan/authors/id/G/GB/GBJK/Catalyst-Model-DBIC-Schema-0.65.tar.gz;
+      sha256 = "26a911ef5ef7ffc81b6ce65c3156f71fb35083c456ad27e6d82d2dc02493eeea";
     };
     buildInputs = [ DBDSQLite TestException TestRequires ];
-    propagatedBuildInputs = [ CarpClan CatalystComponentInstancePerContext CatalystDevel CatalystRuntime CatalystXComponentTraits DBIxClass DBIxClassCursorCached DBIxClassSchemaLoader HashMerge ListMoreUtils Moose MooseXMarkAsMethods MooseXNonMoose MooseXTypes namespaceautoclean namespaceclean TieIxHash TryTiny ];
+    propagatedBuildInputs = [ CarpClan CatalystComponentInstancePerContext CatalystRuntime CatalystXComponentTraits DBIxClass DBIxClassSchemaLoader HashMerge ListMoreUtils ModuleRuntime Moose MooseXMarkAsMethods MooseXNonMoose MooseXTypes MooseXTypesLoadableClass TieIxHash TryTiny namespaceautoclean namespaceclean ];
     meta = {
       description = "DBIx::Class::Schema Model Class";
       license = "perl";
···
   };
 
   CatalystRuntime = buildPerlPackage {
-    name = "Catalyst-Runtime-5.90030";
+    name = "Catalyst-Runtime-5.90075";
     src = fetchurl {
-      url = mirror://cpan/authors/id/J/JJ/JJNAPIORK/Catalyst-Runtime-5.90030.tar.gz;
-      sha256 = "c27357f744fa0d2f9b2682c5f86723d90de43f30cd50089306dd13eb8849eb0c";
+      url = mirror://cpan/authors/id/J/JJ/JJNAPIORK/Catalyst-Runtime-5.90075.tar.gz;
+      sha256 = "a80ed1b1600a8ababda34bc024756a6fb0275b0fff3fa1bb17104813e3ce8752";
     };
-    buildInputs = [ ClassDataInheritable DataDump HTTPMessage TestException ];
-    propagatedBuildInputs = [ CGISimple CatalystDispatchTypeRegex ClassC3AdoptNEXT ClassLoad DataDump DataOptList HTMLParser HTTPBody HTTPMessage HTTPRequestAsCGI LWP ListMoreUtils MROCompat Moose MooseXEmulateClassAccessorFast MooseXGetopt MooseXMethodAttributes MooseXRoleWithOverloading PathClass Plack PlackMiddlewareReverseProxy PlackTestExternalServer SafeIsa StringRewritePrefix SubExporter TaskWeaken TextSimpleTable TreeSimple TreeSimpleVisitorFactory TryTiny URI namespaceautoclean namespaceclean ];
+    buildInputs = [ DataDump HTTPMessage IOstringy JSONMaybeXS TestFatal ];
+    propagatedBuildInputs = [ CGISimple CGIStruct ClassC3AdoptNEXT ClassDataInheritable ClassLoad DataDump DataOptList Encode HTMLParser HTTPBody HTTPMessage HTTPRequestAsCGI HashMultiValue JSONMaybeXS LWP ListMoreUtils MROCompat ModulePluggable Moose MooseXEmulateClassAccessorFast MooseXGetopt MooseXMethodAttributes MooseXRoleWithOverloading PathClass Plack PlackMiddlewareFixMissingBodyInRedirect PlackMiddlewareMethodOverride PlackMiddlewareRemoveRedundantBody PlackMiddlewareReverseProxy PlackTestExternalServer SafeIsa StreamBuffered StringRewritePrefix SubExporter TaskWeaken TextSimpleTable TreeSimple TreeSimpleVisitorFactory TryTiny URI namespaceautoclean namespaceclean ];
     meta = {
       homepage = http://dev.catalyst.perl.org/;
       description = "The Catalyst Framework Runtime";
···
       sha256 = "0hqvckaw91q5yc25a33bp0d4qqxlgkp7rxlvi8n8svxd1406r55s";
     };
     propagatedBuildInputs = [ CatalystRuntime DateTime Moose namespaceautoclean ];
+    doCheck = false;
     meta = {
       description = "Request logging from within Catalyst";
       license = "perl";
···
     };
   };
 
+  CGIStruct = buildPerlPackage {
+    name = "CGI-Struct-1.21";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FU/FULLERMD/CGI-Struct-1.21.tar.gz;
+      sha256 = "d13d8da7fdcd6d906054e4760fc28a718aec91bd3cf067a58927fb7cb1c09d6c";
+    };
+    buildInputs = [ TestDeep ];
+    meta = {
+      description = "Build structures from CGI data";
+      license = "bsd";
+    };
+  };
+
   ClassAccessor = buildPerlPackage {
     name = "Class-Accessor-0.34";
     src = fetchurl {
···
   };
 
   ClassAccessorGrouped = buildPerlPackage {
-    name = "Class-Accessor-Grouped-0.10010";
+    name = "Class-Accessor-Grouped-0.10012";
     src = fetchurl {
-      url = mirror://cpan/authors/id/R/RI/RIBASUSHI/Class-Accessor-Grouped-0.10010.tar.gz;
-      sha256 = "1hlfjfhagsksskv01viq1z14wlr0i4xl3nvznvq1qrnqwqxs4qi1";
+      url = mirror://cpan/authors/id/R/RI/RIBASUSHI/Class-Accessor-Grouped-0.10012.tar.gz;
+      sha256 = "c4613ee3307939f47a9afd40e8b173f3a22f501c3b139799aa030f01b627e7fe";
     };
-    buildInputs = [ TestException ];
-    propagatedBuildInputs = [ ClassXSAccessor ModuleRuntime SubName ];
+    buildInputs = [ ClassXSAccessor DevelHide PackageStash SubName TestException ];
+    propagatedBuildInputs = [ ModuleRuntime ];
     meta = {
       description = "Lets you build groups of accessors";
       license = "perl";
···
   };
 
   CPANMeta = buildPerlPackage {
-    name = "CPAN-Meta-2.120921";
+    name = "CPAN-Meta-2.142690";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-2.120921.tar.gz;
-      sha256 = "12cprk636jaklc97vdh55yjvzcr13h3csdnv3dgna84r2jijka79";
+      url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-2.142690.tar.gz;
+      sha256 = "495770e22e91e3d2bd04dc364f05061cabacfdce35baa3868bc0c05733d145db";
     };
-    propagatedBuildInputs = [ ParseCPANMeta CPANMetaYAML CPANMetaRequirements ];
+    propagatedBuildInputs = [ ParseCPANMeta CPANMetaYAML CPANMetaRequirements JSONPP ];
     meta = {
-      homepage = https://github.com/dagolden/cpan-meta;
+      homepage = https://github.com/Perl-Toolchain-Gang/CPAN-Meta;
       description = "The distribution metadata for a CPAN dist";
-      license = "perl5";
+      license = "perl";
     };
   };
 
   CPANMetaCheck = buildPerlPackage {
-    name = "CPAN-Meta-Check-0.004";
+    name = "CPAN-Meta-Check-0.009";
     src = fetchurl {
-      url = mirror://cpan/authors/id/L/LE/LEONT/CPAN-Meta-Check-0.004.tar.gz;
-      sha256 = "0ccybgfc0p41shmc6nmbg20xljq2ygfjcxmyaf6y07yk6wdcyf7s";
+      url = mirror://cpan/authors/id/L/LE/LEONT/CPAN-Meta-Check-0.009.tar.gz;
+      sha256 = "eb2d43afd1da276e4acdebd24937f5171d0aaca8d19a5ef0c3e834b8792b7361";
     };
-    buildInputs = [ TestDifferences ];
+    buildInputs = [ TestDeep ];
     propagatedBuildInputs = [ CPANMeta CPANMetaRequirements ];
     meta = {
-      homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;
       description = "Verify requirements in a CPAN::Meta object";
-      license = "perl5";
+      license = "perl";
     };
   };
 
   CPANMetaRequirements = buildPerlPackage {
-    name = "CPAN-Meta-Requirements-2.125";
+    name = "CPAN-Meta-Requirements-2.128";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-Requirements-2.125.tar.gz;
-      sha256 = "1d6sryjkk52n4m8h7l0jc4hr9xrq2d02l8clzm48rq1h6j6q49hq";
+      url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-Requirements-2.128.tar.gz;
+      sha256 = "ff0ae309ed76d8c7381fdb8436659a594e6884eeac1c9a742ba9aa7ee2a1d52d";
     };
-    buildInputs = [ TestMore ];
     meta = {
-      homepage = https://github.com/dagolden/cpan-meta-requirements;
+      homepage = https://github.com/dagolden/CPAN-Meta-Requirements;
       description = "A set of version requirements for a CPAN dist";
-      license = "perl5";
+      license = "perl";
     };
   };
 
···
   };
 
   DBIxClass = buildPerlPackage {
-    name = "DBIx-Class-0.08250";
+    name = "DBIx-Class-0.082801";
     src = fetchurl {
-      url = mirror://cpan/authors/id/R/RI/RIBASUSHI/DBIx-Class-0.08250.tar.gz;
-      sha256 = "0nsqvj34klc9pf4l5kj3nqkq7agbsn11ys4115100awf7gxjbad6";
+      url = mirror://cpan/authors/id/R/RI/RIBASUSHI/DBIx-Class-0.082801.tar.gz;
+      sha256 = "889d6f9139d8e73f5524dfa211019126042e84cb7a0ec30cd2ed7d315d73484b";
     };
-    patches = [ ../development/perl-modules/dbix-class-fix-tests.patch ];
-    buildInputs = [ DBDSQLite PackageStash TestException TestWarn TestDeep ];
-    propagatedBuildInputs = [ ClassAccessorGrouped ClassC3Componentised ClassInspector ClassMethodModifiers ConfigAny ContextPreserve DataCompare DataDumperConcise DataPage DBI DevelGlobalDestruction HashMerge ModuleFind Moo MROCompat namespaceclean PathClass ScopeGuard SQLAbstract strictures SubName TryTiny ];
+    buildInputs = [ DBDSQLite PackageStash TestDeep TestException TestWarn ];
+    propagatedBuildInputs = [ ClassAccessorGrouped ClassC3Componentised ClassInspector ConfigAny ContextPreserve DBI DataDumperConcise DataPage DevelGlobalDestruction HashMerge MROCompat ModuleFind Moo PathClass SQLAbstract ScopeGuard SubName TryTiny namespaceclean ];
     meta = {
       homepage = http://www.dbix-class.org/;
       description = "Extensible and flexible object <-> relational mapper";
···
   };
 
   DevelStackTrace = buildPerlPackage {
-    name = "Devel-StackTrace-1.31";
+    name = "Devel-StackTrace-1.34";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DR/DROLSKY/Devel-StackTrace-1.31.tar.gz;
-      sha256 = "0djvqfbq9ag1bpw0bcksidfy13n91xbl53py3d7w0y2323hjc957";
+      url = mirror://cpan/authors/id/D/DR/DROLSKY/Devel-StackTrace-1.34.tar.gz;
+      sha256 = "e882ccd7f4cbab0d0cdad53897f3f3bf29bdcf47d2bdfde1ac07f1bc7d7ebd16";
     };
     meta = {
-      homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;
+      homepage = http://metacpan.org/release/Devel-StackTrace;
       description = "An object representing a stack trace";
       license = "artistic_2";
     };
···
     };
   };
 
-  "if" = buildPerlPackage {
-    name = "if-0.01000001";
+  if_ = buildPerlPackage {
+    name = "if-0.0601";
     src = fetchurl {
-      url = mirror://cpan/authors/id/I/IL/ILYAZ/modules/if-0.01000001.tar.gz;
-      sha256 = "0vb40cb20b22layp5v9xa30hmcnhxidwjkfwcrxwhrvwypy2cmgw";
-    };
-    meta = {
+      url = mirror://cpan/authors/id/I/IL/ILYAZ/modules/if-0.0601.tar.gz;
+      sha256 = "fb2b7329aa111a673cd22dc2889167e52058aead0de2fe0855b32dd658d5c1b7";
     };
   };
 
···
     propagatedBuildInputs = [ JSON ];
     meta = {
       description = "Wrapper Class for the various JSON classes";
+      license = "perl";
+    };
+  };
+
+  JSONMaybeXS = buildPerlPackage {
+    name = "JSON-MaybeXS-1.002005";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/E/ET/ETHER/JSON-MaybeXS-1.002005.tar.gz;
+      sha256 = "f576caf2b10bf3a8eedaf05c0d65e7d3deb52f9c5e1894579ff9ffe71207157f";
+    };
+    buildInputs = [ TestWithoutModule ];
+    propagatedBuildInputs = [ JSONPP ];
+    meta = {
+      description = "Use L<Cpanel::JSON::XS> with a fallback to L<JSON::XS> and L<JSON::PP>";
       license = "perl";
     };
   };
···
   };
 
   ModuleBuildTiny = buildPerlModule {
-    name = "Module-Build-Tiny-0.026";
+    name = "Module-Build-Tiny-0.039";
     src = fetchurl {
-      url = mirror://cpan/authors/id/L/LE/LEONT/Module-Build-Tiny-0.026.tar.gz;
-      sha256 = "9a1860325404c4ea20e2a79e7236c5ad9203ab71bacab9667044e3fad1eb31ad";
+      url = mirror://cpan/authors/id/L/LE/LEONT/Module-Build-Tiny-0.039.tar.gz;
+      sha256 = "7d580ff6ace0cbe555bf36b86dc8ea232581530cbeaaea09bccb57b55797f11c";
     };
-    buildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP perl ];
-    propagatedBuildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP ];
+    buildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP TestHarness perl ];
+    propagatedBuildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP TestHarness ];
     meta = {
       description = "A tiny replacement for Module::Build";
       license = "perl";
···
     };
   };
 
+  ModuleRuntimeConflicts = buildPerlPackage {
+    name = "Module-Runtime-Conflicts-0.001";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/E/ET/ETHER/Module-Runtime-Conflicts-0.001.tar.gz;
+      sha256 = "0f73d03846575dd1492d3760deeb9627afaa1f8b04d4d526b1775174201be25f";
+    };
+    buildInputs = [ ModuleBuildTiny ];
+    propagatedBuildInputs = [ DistCheckConflicts ModuleRuntime ];
+    meta = {
+      homepage = https://github.com/karenetheridge/Module-Runtime-Conflicts;
+      description = "Provide information on conflicts for Module::Runtime";
+      license = "perl";
+    };
+  };
+
   ModuleScanDeps = buildPerlPackage {
     name = "Module-ScanDeps-1.10";
     src = fetchurl {
···
   };
 
   Moose = buildPerlPackage {
-    name = "Moose-2.0604";
+    name = "Moose-2.1213";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DO/DOY/Moose-2.0604.tar.gz;
-      sha256 = "0nwvklb8dwf8lskwxik3gi9gsqzrix2jhc56zvfzlf1q5q1s07qj";
+      url = mirror://cpan/authors/id/E/ET/ETHER/Moose-2.1213.tar.gz;
+      sha256 = "0f3b196ae67dc1daaa43c44ae7703f27c4f92c391ad3e252a90e90c50c851e03";
     };
-    buildInputs = [ DistCheckConflicts TestFatal TestRequires ];
-    propagatedBuildInputs = [ ClassLoad ClassLoadXS DataOptList DevelGlobalDestruction DistCheckConflicts EvalClosure ListMoreUtils MROCompat PackageDeprecationManager PackageStash PackageStashXS ParamsUtil SubExporter SubName TaskWeaken TryTiny ];
+    buildInputs = [ CPANMetaCheck CPANMetaRequirements DistCheckConflicts TestCleanNamespaces TestFatal TestRequires ];
+    propagatedBuildInputs = [ ClassLoad ClassLoadXS DataOptList DevelGlobalDestruction DevelStackTrace DistCheckConflicts EvalClosure ListMoreUtils MROCompat ModuleRuntime ModuleRuntimeConflicts PackageDeprecationManager PackageStash PackageStashXS ParamsUtil SubExporter SubName TaskWeaken TryTiny ];
     meta = {
-      homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;
+      homepage = http://moose.perl.org/;
       description = "A postmodern object system for Perl 5";
-      license = "perl5";
+      license = "perl";
+      maintainers = [ maintainers.eelco ];
+      platforms   = stdenv.lib.platforms.linux;
     };
   };
 
···
   };
 
   MooseXGetopt = buildPerlPackage {
-    name = "MooseX-Getopt-0.50";
+    name = "MooseX-Getopt-0.65";
     src = fetchurl {
-      url = mirror://cpan/authors/id/E/ET/ETHER/MooseX-Getopt-0.50.tar.gz;
-      sha256 = "0fwm5vb8z8q4b6fmf7gz4xzw5z713mmfnxzjph6vfyyymlr5bll9";
+      url = mirror://cpan/authors/id/E/ET/ETHER/MooseX-Getopt-0.65.tar.gz;
+      sha256 = "c07c2b7312c471bf2d331025c0ad6cc02068633eda1e208cbdb5511ef5da7fda";
     };
-    buildInputs = [ PathClass TestCheckDeps TestFatal TestMoose TestNoWarnings TestRequires TestTrap TestWarn ];
-    propagatedBuildInputs = [ GetoptLongDescriptive Moose MooseXRoleParameterized ];
+    buildInputs = [ CPANMeta ModuleBuildTiny ModuleRuntime Moose PathTiny TestDeep TestFatal TestRequires TestTrap TestWarnings if_ ];
+    propagatedBuildInputs = [ GetoptLongDescriptive Moose MooseXRoleParameterized TryTiny namespaceautoclean ];
     meta = {
-      homepage = http://metacpan.org/release/MooseX-Getopt;
+      homepage = https://github.com/moose/MooseX-Getopt;
       description = "A Moose role for processing command line options";
-      license = "perl5";
+      license = "perl";
     };
   };
 
···
     };
   };
 
-  MooseXTypesLoadableClass = buildPerlPackage rec {
-    name = "MooseX-Types-LoadableClass-0.008";
+  MooseXTypesLoadableClass = buildPerlPackage {
+    name = "MooseX-Types-LoadableClass-0.012";
     src = fetchurl {
-      url = mirror://cpan/authors/id/B/BO/BOBTFISH/MooseX-Types-LoadableClass-0.008.tar.gz;
-      sha256 = "0wh4zxknqv98nrmsp6yg6mazjyl3vacrgywarzjg5gks78c84i8g";
+      url = mirror://cpan/authors/id/E/ET/ETHER/MooseX-Types-LoadableClass-0.012.tar.gz;
+      sha256 = "a1d2b186c2b69f416bb0c9271dc8692c2287c2f6ce144cc3b9b2c922427060df";
     };
-    propagatedBuildInputs = [ ClassLoad Moose MooseXTypes namespaceclean ];
+    buildInputs = [ ModuleBuildTiny Moose TestFatal ];
+    propagatedBuildInputs = [ ClassLoad ModuleRuntime Moose MooseXTypes namespaceautoclean ];
     meta = {
       maintainers = with maintainers; [ ocharles ];
       platforms   = stdenv.lib.platforms.unix;
+      homepage = https://github.com/moose/MooseX-Types-LoadableClass;
+      description = "ClassName type constraint with coercion to load the class";
+      license = "perl";
     };
   };
 
···
     doCheck = false; # Test performs network access.
   };
 
-  namespaceautoclean = buildPerlPackage rec {
-    name = "namespace-autoclean-0.13";
+  namespaceautoclean = buildPerlPackage {
+    name = "namespace-autoclean-0.20";
     src = fetchurl {
-      url = mirror://cpan/authors/id/B/BO/BOBTFISH/namespace-autoclean-0.13.tar.gz;
-      sha256 = "1w53k9f9zla90qdn7cyc9dx8zcv26gwy2y87gcazqsq1aj371m04";
+      url = mirror://cpan/authors/id/E/ET/ETHER/namespace-autoclean-0.20.tar.gz;
+      sha256 = "42a199314d07b7a29044d6072529ca53037c75a43550193b1586bd19c690a05f";
     };
-    buildInputs = [ Moose SubName ];
-    propagatedBuildInputs = [ BHooksEndOfScope ClassMOP namespaceclean ];
+    buildInputs = [ ModuleBuildTiny TestRequires ];
+    propagatedBuildInputs = [ BHooksEndOfScope SubIdentify namespaceclean ];
     meta = {
-      homepage = http://metacpan.org/release/namespace-autoclean;
+      homepage = https://github.com/moose/namespace-autoclean;
       description = "Keep imports out of your namespace";
-      license = "perl5";
+      license = "perl";
     };
   };
 
···
   };
 
   NetAmazonS3 = buildPerlPackage {
-    name = "Net-Amazon-S3-0.59";
+    name = "Net-Amazon-S3-0.60";
     src = fetchurl {
-      url = mirror://cpan/authors/id/P/PF/PFIG/Net-Amazon-S3-0.59.tar.gz;
-      sha256 = "94f2bd6b317a9142e400d7d17bd573dc9d22284c3ceaa4864474ba674e0e2e9f";
+      url = mirror://cpan/authors/id/P/PF/PFIG/Net-Amazon-S3-0.60.tar.gz;
+      sha256 = "628937132268e501fb82410f96636e01b183423ea133b6c362894da109d6ac81";
     };
     buildInputs = [ LWP TestException ];
     propagatedBuildInputs = [ DataStreamBulk DateTimeFormatHTTP DigestHMAC DigestMD5File FileFindRule HTTPDate HTTPMessage LWPUserAgentDetermined MIMETypes Moose MooseXStrictConstructor MooseXTypesDateTimeMoreCoercions PathClass RegexpCommon TermEncoding TermProgressBarSimple URI XMLLibXML JSON ];
···
   };
 
   PackageStash = buildPerlPackage {
-    name = "Package-Stash-0.34";
+    name = "Package-Stash-0.37";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DO/DOY/Package-Stash-0.34.tar.gz;
-      sha256 = "1674zs96ndq3czs6v8xkdqqz4fnka0i2835nnns9zbw2q01yirj6";
+      url = mirror://cpan/authors/id/D/DO/DOY/Package-Stash-0.37.tar.gz;
+      sha256 = "06ab05388f9130cd377c0e1d3e3bafeed6ef6a1e22104571a9e1d7bfac787b2c";
     };
     buildInputs = [ DistCheckConflicts TestFatal TestRequires ];
-    propagatedBuildInputs = [ DistCheckConflicts ModuleImplementation PackageDeprecationManager ];
+    propagatedBuildInputs = [ DistCheckConflicts ModuleImplementation ];
     meta = {
       homepage = http://metacpan.org/release/Package-Stash;
       description = "Routines for manipulating stashes";
-      license = "perl5";
+      license = "perl";
     };
   };
 
···
     };
   };
 
+  PlackMiddlewareFixMissingBodyInRedirect = buildPerlPackage {
+    name = "Plack-Middleware-FixMissingBodyInRedirect-0.11";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SW/SWEETKID/Plack-Middleware-FixMissingBodyInRedirect-0.11.tar.gz;
+      sha256 = "eb4d4232344e7da3217347b847736ea55df962d11b870a225315d9241e8fbefb";
+    };
+    buildInputs = [ HTTPMessage Plack ];
+    propagatedBuildInputs = [ HTMLParser Plack ];
+    meta = {
+      homepage = https://github.com/Sweet-kid/Plack-Middleware-FixMissingBodyInRedirect;
+      description = "Plack::Middleware which sets body for redirect response, if it's not already set";
+      license = "perl";
+    };
+  };
+
+  PlackMiddlewareMethodOverride = buildPerlModule {
+    name = "Plack-Middleware-MethodOverride-0.10";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DW/DWHEELER/Plack-Middleware-MethodOverride-0.10.tar.gz;
+      sha256 = "f8d6a33b56d69dddd5db289f855e100d86ff39099abe31ef40e2672d0dc5568d";
+    };
+    propagatedBuildInputs = [ Plack URI ];
+    meta = {
+      homepage = http://search.cpan.org/dist/Plack-Middleware-MethodOverride/;
+      description = "Override REST methods to Plack apps via POST";
+      license = "perl";
+    };
+  };
+
+  PlackMiddlewareRemoveRedundantBody = buildPerlPackage {
+    name = "Plack-Middleware-RemoveRedundantBody-0.05";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SW/SWEETKID/Plack-Middleware-RemoveRedundantBody-0.05.tar.gz;
+      sha256 = "a0676e1c792bea7f25f1d901bee59054d35012d5ea8cd42529d336143fa87cd8";
+    };
+    buildInputs = [ HTTPMessage Plack ];
+    propagatedBuildInputs = [ Plack ];
+    meta = {
+      homepage = https://github.com/Sweet-kid/Plack-Middleware-RemoveRedundantBody;
+      description = "Plack::Middleware which sets removes body for HTTP response if it's not required";
+      license = "perl";
+    };
+  };
+
   PlackMiddlewareReverseProxy = buildPerlPackage {
     name = "Plack-Middleware-ReverseProxy-0.15";
     src = fetchurl {
···
   };
 
   SQLAbstract = buildPerlPackage {
-    name = "SQL-Abstract-1.73";
+    name = "SQL-Abstract-1.80";
     src = fetchurl {
-      url = mirror://cpan/authors/id/F/FR/FREW/SQL-Abstract-1.73.tar.gz;
-      sha256 = "081ppyvsc66yshmfr9q9v7hp9g58725nnibd771i9g153vzs49kb";
+      url = mirror://cpan/authors/id/R/RI/RIBASUSHI/SQL-Abstract-1.80.tar.gz;
+      sha256 = "de4d0507fca0c6340c17867abca0632017bd56594443e67ea6ace826ba9a07a2";
     };
-    buildInputs = [ TestException TestWarn ];
-    propagatedBuildInputs = [ ClassAccessorGrouped GetoptLongDescriptive HashMerge ];
+    buildInputs = [ TestDeep TestException TestWarn ];
+    propagatedBuildInputs = [ HashMerge MROCompat Moo ];
     meta = {
       description = "Generate SQL from Perl data structures";
       license = "perl";
···
     };
   };
 
+  TestCleanNamespaces = buildPerlPackage {
+    name = "Test-CleanNamespaces-0.16";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/E/ET/ETHER/Test-CleanNamespaces-0.16.tar.gz;
+      sha256 = "9779378394b9be32cf04129fafe2d40d74f6f200f593f1494998bd128a6ed9fa";
+    };
+    buildInputs = [ ModuleRuntime TestDeep TestRequires TestTester TestWarnings if_ ];
+    propagatedBuildInputs = [ FileFindRule FileFindRulePerl ModuleRuntime PackageStash SubExporter SubIdentify namespaceclean ];
+    meta = {
+      homepage = https://github.com/karenetheridge/Test-CleanNamespaces;
+      description = "Check for uncleaned imports";
+      license = "perl";
+    };
+  };
+
   TestCPANMeta = buildPerlPackage {
     name = "Test-CPAN-Meta-0.23";
     src = fetchurl {
···
     };
   };
 
-  TestHarness = buildPerlPackage rec {
-    name = "Test-Harness-3.17";
+  TestHarness = buildPerlPackage {
+    name = "Test-Harness-3.33";
     src = fetchurl {
-      url = "mirror://cpan/authors/id/A/AN/ANDYA/${name}.tar.gz";
-      sha256 = "0j390xx6an88gh49n7zz8mj1s3z0xsxc8dynfq71xf7ba7i1afhr";
+      url = mirror://cpan/authors/id/L/LE/LEONT/Test-Harness-3.33.tar.gz;
+      sha256 = "c22e36287d5cee3c28fd2006e3c8b6e7cc76c6fc39d79c7ab74f1936d35e8fe2";
+    };
+    doCheck = false; # makes assumptions about path to Perl
+    meta = {
+      homepage = http://testanything.org/;
+      description = "Run Perl standard test scripts with statistics";
+      license = "perl";
     };
   };
 
···
     propagatedBuildInputs = [TestException UNIVERSALisa UNIVERSALcan];
   };
 
-  TestMoose = buildPerlPackage {
-    name = "Test-Moose-2.0604";
-    src = fetchurl {
-      url = mirror://cpan/authors/id/D/DO/DOY/Moose-2.0604.tar.gz;
-      sha256 = "0nwvklb8dwf8lskwxik3gi9gsqzrix2jhc56zvfzlf1q5q1s07qj";
-    };
-    buildInputs = [ DistCheckConflicts TestFatal TestRequires ];
-    propagatedBuildInputs = [ ClassLoad ClassLoadXS DataOptList DevelGlobalDestruction DistCheckConflicts EvalClosure ListMoreUtils MROCompat PackageDeprecationManager PackageStash PackageStashXS ParamsUtil SubExporter SubName TaskWeaken TryTiny ];
-    meta = {
-      homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;
-      description = "A postmodern object system for Perl 5";
-      license = "perl5";
-    };
-  };
+  TestMoose = Moose;
 
   TestMockTime = buildPerlPackage rec {
     name = "Test-MockTime-0.12";
···
     };
   };
 
-  TestWarnings = buildPerlModule {
-    name = "Test-Warnings-0.008";
+  TestWarnings = buildPerlPackage {
+    name = "Test-Warnings-0.016";
     src = fetchurl {
-      url = mirror://cpan/authors/id/E/ET/ETHER/Test-Warnings-0.008.tar.gz;
-      sha256 = "119f2a279fe7d0681dcf4517f1bcb056e4596cfbae7b9ee447118f036cf089e4";
+      url = mirror://cpan/authors/id/E/ET/ETHER/Test-Warnings-0.016.tar.gz;
+      sha256 = "09ebc9afa29eb4d1d44fbd974dfcd52e0a2d9ce7ec3e3ee7602394157831aba9";
     };
-    buildInputs = [ CaptureTiny ModuleBuildTiny TestCheckDeps TestDeep TestTester pkgs.perlPackages."if" ];
+    buildInputs = [ TestTester if_ ];
     meta = {
       homepage = https://github.com/karenetheridge/Test-Warnings;
       description = "Test for warnings and the lack of them";
···
       url = mirror://cpan/authors/id/L/LB/LBROCARD/Test-WWW-Mechanize-PSGI-0.35.tar.gz;
       sha256 = "1hih8s49zf38bisvhnhzrrj0zwyiivkrbs7nmmdqm1qqy27wv7pc";
     };
+    buildInputs = [ TestPod ];
     propagatedBuildInputs = [ Plack TestWWWMechanize TryTiny ];
     meta = {
       description = "Test PSGI programs using WWW::Mechanize";
···
   };
 
   TryTiny = buildPerlPackage {
-    name = "Try-Tiny-0.12";
+    name = "Try-Tiny-0.22";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DO/DOY/Try-Tiny-0.12.tar.gz;
-      sha256 = "0awv2w33jb1xw3bsrfwsz53dgwm8s8vnpk4ssxxp3n89i7116p2g";
+      url = mirror://cpan/authors/id/D/DO/DOY/Try-Tiny-0.22.tar.gz;
+      sha256 = "60fba46f4693d33d54539104f9001df008dabb400b6837e9605c39a6ee6a1b19";
     };
+    buildInputs = [ if_ ];
     meta = {
-      homepage = https://github.com/doy/try-tiny.git;
+      homepage = http://metacpan.org/release/Try-Tiny;
+      description = "Minimal try/catch with proper preservation of $@";
+      license = "mit";
     };
   };
 

pkgs/top-level/python-packages.nix

···
   };
 
   ipython = callPackage ../shells/ipython {
+    inherit pythonPackages;
+
     qtconsoleSupport = !pkgs.stdenv.isDarwin; # qt is not supported on darwin
     pylabQtSupport = !pkgs.stdenv.isDarwin;
     pylabSupport = !pkgs.stdenv.isDarwin; # cups is not supported on darwin
···
 
   # This is used for NixOps to make sure we won't break it with the next major
   # version of nixpart.
-  nixpart0 = self.nixpart;
+  nixpart0 = callPackage ../tools/filesystems/nixpart/0.4 { };
 
   pitz = callPackage ../applications/misc/pitz { };
 
···
     meta = {
       homepage = http://code.google.com/p/py-amqplib/;
       description = "Python client for the Advanced Message Queuing Procotol (AMQP)";
+    };
+  };
+
+
+  application = buildPythonPackage rec {
+    name = "python-application-${version}";
+    version = "1.4.1";
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/python-application/${name}.tar.gz";
+      sha256 = "3ae188e9dfd4bd63c9b43aebbf1d9de5df03fb5ac01e72f3bff5b41007570275";
     };
   };
 
···
   });
 
 
+  cjson = buildPythonPackage rec {
+    name = "python-cjson-${version}";
+    version = "1.1.0";
+    disabled = isPy3k || isPyPy;
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/python-cjson/${name}.tar.gz";
+      sha256 = "a01fabb7593728c3d851e1cd9a3efbd18f72650a31a5aa8a74018640da3de8b3";
+    };
+
+    meta = with stdenv.lib; {
+      description = "This module implements a very fast JSON encoder/decoder for Python.";
+      homepage    = "http://ag-projects.com/";
+      license     = licenses.lgpl2;
+      platforms   = platforms.all;
+    };
+  };
+
+
   click = buildPythonPackage {
     name = "click-2.1";
     src = pkgs.fetchurl {
···
     };
   };
 
+  dns = buildPythonPackage rec {
+    name = "dnspython-${version}";
+    version = "1.12.0";
+
+    src = pkgs.fetchurl {
+      url = "http://www.dnspython.org/kits/1.12.0/dnspython-1.12.0.tar.gz";
+      sha256 = "0kvjlkp96qzh3j31szpjlzqbp02brixh4j4clnpw80b0hspq5yq3";
+    };
+  };
+
   docker = buildPythonPackage rec {
     name = "docker-py-0.4.0";
 
···
   };
 
 
+  eventlib = buildPythonPackage rec {
+    name = "python-eventlib-${version}";
+    version = "0.2.0";
+
+    src = pkgs.fetchurl {
+      url = "http://download.ag-projects.com/SipClient/${name}.tar.gz";
+      sha256 = "0fld5lb85ql4a5bgc38sdxi5pgzqljysp1p8f7abxnd6vymh4rgi";
+    };
+
+    propagatedBuildInputs = with self; [ greenlet ];
+
+    meta = with stdenv.lib; {
+      description = "Eventlib bindings for python.";
+      homepage    = "http://ag-projects.com/";
+      license     = licenses.lgpl2;
+      platforms   = platforms.all;
+    };
+  };
+
+
   eyeD3 = buildPythonPackage rec {
     version = "0.7.4";
     name    = "eyeD3-${version}";
···
     '';
 
     propagatedBuildInputs = with self; [ gflags iso8601_0_1_4 ipaddr httplib2 google_apputils google_api_python_client ];
+  };
+
+  gnutls = buildPythonPackage rec {
+    name = "python-gnutls";
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/python-gnutls/python-gnutls-2.0.1.tar.gz";
+      sha256 = "d8fb368c6a4dd58bc6cd5e61d4a12d119c4506fd344a371b3429b3ac2623b9ac";
+    };
+
+    propagatedBuildInputs = with self; [ pkgs.gnutls ];
   };
 
   gitdb = buildPythonPackage rec {
···
     };
   };
 
+
   greenlet = buildPythonPackage rec {
-    name = "greenlet-0.4.3";
+    name = "greenlet-${version}";
+    version = "0.4.4";
     disabled = isPyPy;  # builtin for pypy
 
     src = pkgs.fetchurl {
-      url = "http://pypi.python.org/packages/source/g/greenlet/${name}.zip";
-      md5 = "a5e467a5876c415cd357c1ab9027e06c";
+      url = "https://pypi.python.org/packages/source/g/greenlet/${name}.zip";
+      sha256 = "935a76b7ad3c41846af26e136e2fd8ec763794cbc5b5fbc4b7b09d9a8de1d056";
     };
 
-    meta = {
+    meta = with stdenv.lib; {
       homepage = http://pypi.python.org/pypi/greenlet;
       description = "Module for lightweight in-process concurrent programming";
+      license     = licenses.lgpl2;
+      platforms   = platforms.all;
     };
   };
 
···
   };
 
 
+  msrplib = buildPythonPackage rec {
+    name = "python-msrplib-${version}";
+    version = "0.15.0";
+
+    src = pkgs.fetchurl {
+      url = "http://download.ag-projects.com/SipClient/${name}.tar.gz";
+      sha256 = "1sm03jcz663xkbhfmrk7rr5l3wlkydn8xs56fvqjxyapx0m5sw6f";
+    };
+
+    propagatedBuildInputs = with self; [ eventlib application gnutls ];
+  };
+
+
   munkres = buildPythonPackage rec {
     name = "munkres-1.0.6";
 
···
 
   });
 
+  pagerduty = buildPythonPackage rec {
+    name = "pagerduty-${version}";
+    version = "0.2.1";
+    disabled = isPy3k;
+
+    src = pkgs.fetchurl {
+        url = "https://pypi.python.org/packages/source/p/pagerduty/pagerduty-${version}.tar.gz";
+        md5 = "8109a330d16751a7f4041c0ccedec787";
+    };
+  };
+
   pandas = buildPythonPackage rec {
     name = "pandas-0.14.0";
 
···
       md5 = "56b6614499aacb7d6b5983c4914daea7";
     };
 
-    buildInputs = with self; [ pkgs.freetype pkgs.libjpeg pkgs.zlib pkgs.libtiff pkgs.libwebp ];
+    buildInputs = with self; [ pkgs.freetype pkgs.libjpeg pkgs.zlib pkgs.libtiff pkgs.libwebp pkgs.tcl ];
 
     # NOTE: we use LCMS_ROOT as WEBP root since there is not other setting for webp.
     preConfigure = ''
···
               s|^JPEG_ROOT =.*$|JPEG_ROOT = _lib_include("${pkgs.libjpeg}")|g ;
               s|^ZLIB_ROOT =.*$|ZLIB_ROOT = _lib_include("${pkgs.zlib}")|g ;
               s|^LCMS_ROOT =.*$|LCMS_ROOT = _lib_include("${pkgs.libwebp}")|g ;
-              s|^TIFF_ROOT =.*$|TIFF_ROOT = _lib_include("${pkgs.libtiff}")|g ;'
+              s|^TIFF_ROOT =.*$|TIFF_ROOT = _lib_include("${pkgs.libtiff}")|g ;
+              s|^TCL_ROOT=.*$|TCL_ROOT = _lib_include("${pkgs.tcl}")|g ;'
     '';
 
-
-
     meta = {
       homepage = http://python-imaging.github.com/Pillow;
 
···
       license = stdenv.lib.licenses.gpl2Plus;
     };
   };
+
 
   pycapnp = buildPythonPackage rec {
     name = "pycapnp-0.4.4";
···
       sha256 = "17wq4invmv1nfazaksf59ymqyvgv3i8h4q03ry2az0s9lldyg3dv";
     };
 
+    patches = singleton (pkgs.fetchurl {
+      url = "https://www.redhat.com/archives/pyparted-devel/"
+          + "2014-April/msg00000.html";
+      postFetch = ''
+        sed -i -ne '/<!--X-Body-of-Message-->/,/<!--X-Body-of-Message-End-->/ {
+          s/^<[^>]*>//; /^$/!p
+        }' "$downloadedFile"
+      '';
+      sha256 = "1lakhz3nvx0qacn90bj1nq13zqxphiw4d9dsc44gwa8nj24j2zws";
+    });
+
     postPatch = ''
       sed -i -e 's|/sbin/mke2fs|${pkgs.e2fsprogs}&|' tests/baseclass.py
       sed -i -e '
···
     propagatedBuildInputs = with self; [ kitchen requests bunch paver ];
     doCheck = false;
   });
+
+  python_simple_hipchat = buildPythonPackage rec {
+    name = "python-simple-hipchat-${version}";
+    version = "0.1";
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/python-simple-hipchat/python-simple-hipchat-${version}.zip";
+      md5 = "3806b3729a021511bac065360832f197";
+    };
+
+    buildInputs = [ pkgs.unzip ];
+  };
 
   python_keyczar = buildPythonPackage rec {
     name = "python-keyczar-0.71c";
···
   };
 
 
+  scapy = buildPythonPackage rec {
+    name = "scapy-2.2.0";
+
+    disabled = isPy3k || isPyPy;
+
+    src = pkgs.fetchurl {
+      url = "http://www.secdev.org/projects/scapy/files/${name}.tar.gz";
+      sha256 = "1bqmp0xglkndrqgmybpwmzkv462mir8qlkfwsxwbvvzh9li3ndn5";
+    };
+
+    propagatedBuildInputs = [ modules.readline ];
+
+    meta = with stdenv.lib; {
+      description = "Powerful interactive network packet manipulation program";
+      homepage = http://www.secdev.org/projects/scapy/;
+      license = licenses.gpl2;
+      platforms = platforms.linux;
+      maintainers = [ maintainers.bjornfor ];
+    };
+  };
+
+
   scipy = buildPythonPackage rec {
     name = "scipy-0.14.0";
 
···
       sha256 = "bec9269cbfa58de4f0849ec79bb7d54eeeed9df8b5fbfa1637fbc68062822847";
     };
 
-    buildInputs = with self; [ pbr pip ];
+    buildInputs = with self; [ pbr pip ] ++ optional isPy26 argparse;
 
     propagatedBuildInputs = with self; [ setuptools ];
 
···
   };
 
 
+  sipsimple = buildPythonPackage rec {
+    name = "sipsimple-${version}";
+    version = "1.4.2";
+    disabled = isPy3k;
+
+    configurePhase = "find -name 'configure' -exec chmod a+x {} \\; ; find -name 'aconfigure' -exec chmod a+x {} \\; ; ${python}/bin/${python.executable} setup.py build_ext --pjsip-clean-compile";
+
+    src = pkgs.fetchurl {
+      url = "http://download.ag-projects.com/SipClient/python-${name}.tar.gz";
+      sha256 = "f6e6de7ab5f20e8ae08966b8811462e4271833db4f7fbab58ffba4e5c07ab114";
+    };
+
+    propagatedBuildInputs = with self; [ cython pkgs.openssl dns dateutil xcaplib msrplib];
+
+    buildInputs = with self; [ pkgs.alsaLib ];
+
+    installPhase = "${python}/bin/${python.executable} setup.py install --prefix=$out";
+
+    doCheck = false;
+  };
+
+
   six = buildPythonPackage rec {
-    name = "six-1.7.3";
+    name = "six-1.8.0";
 
     src = pkgs.fetchurl {
       url = "http://pypi.python.org/packages/source/s/six/${name}.tar.gz";
-      md5 = "784c6e5541c3c4952de9c0a966a0a80b";
+      md5 = "1626eb24cc889110c38f7e786ec69885";
     };
 
     # error: invalid command 'test'
···
 
   wxPython30 = callPackage ../development/python-modules/wxPython/3.0.nix {
     wxGTK = pkgs.wxGTK30;
+  };
+
+  xcaplib = buildPythonPackage rec {
+    name = "python-xcaplib-${version}";
+    version = "1.0.17";
+
+    src = pkgs.fetchurl {
+      url = "http://download.ag-projects.com/SipClient/${name}.tar.gz";
+      sha256 = "1bf8n9ghmgxz8kjgnwy4y7ajijy5hi7viabgh0pvzkhz9gfvck86";
+    };
+
+    propagatedBuildInputs = with self; [ eventlib application ];
   };
 
   xe = buildPythonPackage rec {
···
     };
   };
 
+  graphite_pager = buildPythonPackage rec {
+    name = "graphite-pager-${version}";
+    version = "2bbfe91220ec1e0ca1cdf4b5564386482a44ed7d";
+
+    src = pkgs.fetchgit {
+      url = "https://github.com/offlinehacker/graphite-pager.git";
+      sha256 = "aa932f941efe4ed89971fe7572218b020d1a144259739ef78db6397b968eef62";
+      rev = version;
+    };
+
+    buildInputs = with self; [ nose mock ];
+    propagatedBuildInputs = with self; [
+      jinja2 pyyaml redis requests pagerduty 
+      python_simple_hipchat pushbullet
+    ];
+
+    patchPhase = "> requirements.txt";
+    checkPhase = "nosetests";
+
+    meta = {
+      description = "A simple alerting application for Graphite metrics";
+      homepage = https://github.com/seatgeek/graphite-pager;
+      maintainers = [ maintainers.offline ];
+      license = licenses.bsd2;
+    };
+  };
+
 
   pyspotify = buildPythonPackage rec {
     name = "pyspotify-${version}";
···
     };
   };
 
+
   grequests = buildPythonPackage rec {
     name = "grequests-0.2.0";
 
···
       license = "bsd";
       maintainers = [ stdenv.lib.maintainers.matejc ];
     };
+  };
+
+  pushbullet = buildPythonPackage rec {
+    name = "pushbullet.py-${version}";
+    version = "0.5.0";
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/pushbullet.py/pushbullet.py-0.5.0.tar.gz";
+      md5 = "36c83ba5f7d5208bb86c00eba633f921";
+    };
+
+    propagatedBuildInputs = with self; [requests websocket_client python_magic ];
   };
 
   power = buildPythonPackage rec {

pkgs/top-level/release.nix

···
 { nixpkgs ? { outPath = (import ./all-packages.nix {}).lib.cleanSource ../..; revCount = 1234; shortRev = "abcdef"; }
 , officialRelease ? false
 , # The platforms for which we build Nixpkgs.
-  supportedSystems ? [ "x86_64-linux" "i686-linux" "x86_64-darwin" ]
+  supportedSystems ? [ "x86_64-linux" "i686-linux" /* "x86_64-darwin" */ ]
 }:
 
 with import ./release-lib.nix { inherit supportedSystems; };