Merge master into stdenv-updates

Conflicts (simple):
pkgs/development/compilers/gcc/4.8/default.nix
pkgs/development/compilers/llvm/default.nix
pkgs/development/libraries/gmp/5.1.1.nix
pkgs/development/libraries/gmp/5.1.3.nix
pkgs/development/libraries/gmp/5.1.x.nix
pkgs/top-level/all-packages.nix

doc/language-support.xml

···
 
 buildPerlPackage rec {
   name = "BerkeleyDB-0.36";
-  
+
   src = fetchurl {
     url = "mirror://cpan/authors/id/P/PM/PMQS/${name}.tar.gz";
     sha256 = "07xf50riarb60l1h6m2dqmql8q5dij619712fsgw7ach04d8g3z1";
···
     echo "INCLUDE = ${db4}/include" >> config.in
   '';
 }
-</programlisting>  
+</programlisting>
 
 </para>
 
···
 </section>
 
 
-<section><title>Java</title>
+<section xml:id="ssec-language-java"><title>Java</title>
+
+<para>Ant-based Java packages are typically built from source as follows:
+
+<programlisting>
+stdenv.mkDerivation {
+  name = "...";
+  src = fetchurl { ... };
+
+  buildInputs = [ jdk ant ];
+
+  buildPhase = "ant";
+}
+</programlisting>
+
+Note that <varname>jdk</varname> is an alias for the OpenJDK.</para>
+
+<para>JAR files that are intended to be used by other packages should
+be installed in <filename>$out/share/java</filename>.  The OpenJDK has
+a stdenv setup hook that adds any JARs in the
+<filename>share/java</filename> directories of the build inputs to the
+<envar>CLASSPATH</envar> environment variable.  For instance, if the
+package <literal>libfoo</literal> installs a JAR named
+<filename>foo.jar</filename> in its <filename>share/java</filename>
+directory, and another package declares the attribute
+
+<programlisting>
+buildInputs = [ jdk libfoo ];
+</programlisting>
+
+then <envar>CLASSPATH</envar> will be set to
+<filename>/nix/store/...-libfoo/share/java/foo.jar</filename>.</para>
+
+<para>Private JARs
+should be installed in a location like
+<filename>$out/share/<replaceable>package-name</replaceable></filename>.</para>
+
+<para>If your Java package provides a program, you need to generate a
+wrapper script to run it using the OpenJRE.  You can use
+<literal>makeWrapper</literal> for this:
+
+<programlisting>
+buildInputs = [ makeWrapper ];
+
+installPhase =
+  ''
+    mkdir -p $out/bin
+    makeWrapper ${jre}/bin/java $out/bin/foo \
+      --add-flags "-cp $out/share/java/foo.jar org.foo.Main"
+  '';
+</programlisting>
+
+Note the use of <literal>jre</literal>, which is the part of the
+OpenJDK package that contains the Java Runtime Environment.  By using
+<literal>${jre}/bin/java</literal> instead of
+<literal>${jdk}/bin/java</literal>, you prevent your package from
+depending on the JDK at runtime.</para>
+
+<para>It is possible to use a different Java compiler than
+<command>javac</command> from the OpenJDK.  For instance, to use the
+Eclipse Java Compiler:
+
+<programlisting>
+buildInputs = [ jre ant ecj ];
+</programlisting>
+
+(Note that here you don’t need the full JDK as an input, but just the
+JRE.)  The ECJ has a stdenv setup hook that sets some environment
+variables to cause Ant to use ECJ, but this doesn’t work with all Ant
+files.  Similarly, you can use the GNU Java Compiler:
+
+<programlisting>
+buildInputs = [ gcj ant ];
+</programlisting>
 
-<para>Java packages should install JAR files in
-<filename>$out/lib/java</filename>.</para>
+Here, Ant will automatically use <command>gij</command> (the GNU Java
+Runtime) instead of the OpenJRE.</para>
 
 </section>
 

nixos/modules/config/timezone.nix

···
   config = {
 
     environment.variables.TZDIR = "/etc/zoneinfo";
-    environment.variables.TZ = config.time.timeZone;
 
-    environment.etc.localtime.source = "${pkgs.tzdata}/share/zoneinfo/${config.time.timeZone}";
+    environment.etc.localtime =
+      { source = "${pkgs.tzdata}/share/zoneinfo/${config.time.timeZone}";
+        mode = "direct-symlink";
+      };
 
     environment.etc.zoneinfo.source = "${pkgs.tzdata}/share/zoneinfo";
 

nixos/modules/misc/ids.nix

···
       mongodb = 98;
       openldap = 99;
       memcached = 100;
+      cgminer = 101;
 
       # When adding a uid, make sure it doesn't match an existing gid.
 

nixos/modules/module-list.nix

···
   ./services/networking/ifplugd.nix
   ./services/networking/iodined.nix
   ./services/networking/ircd-hybrid/default.nix
+  ./services/networking/kippo.nix
   ./services/networking/minidlna.nix
   ./services/networking/nat.nix
   ./services/networking/networkmanager.nix
···
   ./services/torrent/transmission.nix
   ./services/ttys/gpm.nix
   ./services/ttys/agetty.nix
+  ./services/ttys/kmscon.nix
   ./services/web-servers/apache-httpd/default.nix
   ./services/web-servers/jboss/default.nix
   ./services/web-servers/lighttpd/default.nix
···
   ./services/x11/hardware/multitouch.nix
   ./services/x11/hardware/synaptics.nix
   ./services/x11/hardware/wacom.nix
+  ./services/x11/mesa.nix
   ./services/x11/window-managers/awesome.nix
   #./services/x11/window-managers/compiz.nix
   ./services/x11/window-managers/default.nix

nixos/modules/rename.nix

···
 # !!! this hardcodes bash, could we detect from config which shell is actually used?
 ++ obsolete [ "environment" "promptInit" ] [ "programs" "bash" "promptInit" ]
 
+++ obsolete [ "services" "xserver" "driSupport" ] [ "services" "mesa" "driSupport" ]
+++ obsolete [ "services" "xserver" "driSupport32Bit" ] [ "services" "mesa" "driSupport32Bit" ]
+++ obsolete [ "services" "xserver" "s3tcSupport" ] [ "services" "mesa" "s3tcSupport" ]
+++ obsolete [ "services" "xserver" "videoDrivers" ] [ "services" "mesa" "videoDrivers" ]
+
 # Options that are obsolete and have no replacement.
 ++ obsolete' [ "boot" "loader" "grub" "bootDevice" ]
 ++ obsolete' [ "boot" "initrd" "luks" "enable" ]

nixos/modules/services/misc/cgminer.nix

···
 
   config = mkIf config.services.cgminer.enable {
 
-    users.extraUsers = singleton
-      { name = cfg.user;
+    users.extraUsers = optionalAttrs (cfg.user == "cgminer") (singleton
+      { name = "cgminer";
+        uid = config.ids.uids.cgminer;
         description = "Cgminer user";
-      };
+      });
 
     environment.systemPackages = [ cfg.package ];
 
     systemd.services.cgminer = {
       path = [ pkgs.cgminer ];
 
-      after = [ "display-manager.target" "network.target" ];
+      after = [ "network.target" "display-manager.service" ];
       wantedBy = [ "multi-user.target" ];
 
-      environment = { 
+      environment = {
         LD_LIBRARY_PATH = ''/run/opengl-driver/lib:/run/opengl-driver-32/lib'';
         DISPLAY = ":0";
         GPU_MAX_ALLOC_PERCENT = "100";
···
       };
 
       serviceConfig = {
-        ExecStart = "${pkgs.cgminer}/bin/cgminer -T -c ${cgminerConfig}";
+        ExecStart = "${pkgs.cgminer}/bin/cgminer --syslog --text-only --config ${cgminerConfig}";
         User = cfg.user;
-        RestartSec = 10;
+        RestartSec = "30s";
+        Restart = "always";
+        StartLimitInterval = "1m";
       };
     };
 

nixos/modules/services/networking/kippo.nix

···
+# NixOS module for kippo honeypot ssh server
+# See all the options for configuration details.
+#
+# Default port is 2222. Recommend using something like this for port redirection to default SSH port:
+# networking.firewall.extraCommands = ''
+#      iptables -t nat -A PREROUTING -i IN_IFACE -p tcp --dport 22 -j REDIRECT --to-port 2222'';
+#
+# Lastly: use this service at your own risk. I am working on a way to run this inside a VM.
+{ pkgs, config, ... }:
+with pkgs.lib;
+let
+  cfg = config.services.kippo;
+in
+rec {
+  options = {
+    services.kippo = {
+      enable = mkOption {
+        default = false;
+        type = types.uniq types.bool;
+        description = ''Enable the kippo honeypot ssh server.'';
+      };
+      port = mkOption {
+        default = 2222;
+        type = types.uniq types.int;
+        description = ''TCP port number for kippo to bind to.'';
+      };
+      hostname = mkOption {
+        default = "nas3";
+        type = types.string;
+        description = ''Hostname for kippo to present to SSH login'';
+      };
+      varPath = mkOption {
+        default = "/var/lib/kippo";
+        type = types.string;
+        description = ''Path of read/write files needed for operation and configuration.'';
+      };
+      logPath = mkOption {
+        default = "/var/log/kippo";
+        type = types.string;
+        description = ''Path of log files needed for operation and configuration.'';
+      };
+      pidPath = mkOption {
+        default = "/run/kippo";
+        type = types.string;
+        description = ''Path of pid files needed for operation.'';
+      };
+      extraConfig = mkOption {
+        default = "";
+        type = types.string;
+        description = ''Extra verbatim configuration added to the end of kippo.cfg.'';
+      };
+    };
+
+  };
+  config = mkIf cfg.enable {
+    environment.systemPackages = with pkgs.pythonPackages; [
+      python twisted pycrypto pyasn1 ];
+
+    environment.etc."kippo.cfg".text = ''
+        # Automatically generated by NixOS.
+        # See ${pkgs.kippo}/src/kippo.cfg for details.
+        [honeypot]
+        log_path = ${cfg.logPath}
+        download_path = ${cfg.logPath}/dl
+        filesystem_file = ${cfg.varPath}/honeyfs
+        filesystem_file = ${cfg.varPath}/fs.pickle
+        data_path = ${cfg.varPath}/data
+        txtcmds_path = ${cfg.varPath}/txtcmds
+        public_key = ${cfg.varPath}/keys/public.key
+        private_key = ${cfg.varPath}/keys/private.key
+        ssh_port = ${toString cfg.port}
+        hostname = ${cfg.hostname}
+        ${cfg.extraConfig}
+    '';
+
+    users.extraUsers = singleton {
+      name = "kippo";
+      description = "kippo web server privilege separation user";
+    };
+    users.extraGroups = singleton { name = "kippo"; };
+
+    systemd.services.kippo = with pkgs; {
+      description = "Kippo Web Server";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      environment.PYTHONPATH = "${pkgs.kippo}/src/:${pkgs.pythonPackages.pycrypto}/lib/python2.7/site-packages/:${pkgs.pythonPackages.pyasn1}/lib/python2.7/site-packages/:${pkgs.pythonPackages.python}/lib/python2.7/site-packages/:${pkgs.pythonPackages.twisted}/lib/python2.7/site-packages/:.";
+      preStart = ''
+        if [ ! -d ${cfg.varPath}/ ] ; then 
+            mkdir -p ${cfg.pidPath}
+            mkdir -p ${cfg.logPath}/tty
+            mkdir -p ${cfg.logPath}/dl
+            mkdir -p ${cfg.varPath}/keys
+            cp ${pkgs.kippo}/src/honeyfs ${cfg.varPath} -r
+            cp ${pkgs.kippo}/src/fs.pickle ${cfg.varPath}/fs.pickle
+            cp ${pkgs.kippo}/src/data ${cfg.varPath} -r
+            cp ${pkgs.kippo}/src/txtcmds ${cfg.varPath} -r
+
+            chmod u+rw ${cfg.varPath} -R
+            chmod u+rw ${cfg.pidPath}
+            chown kippo.kippo ${cfg.varPath} -R
+            chown kippo.kippo ${cfg.pidPath}
+            chown kippo.kippo ${cfg.logPath} -R
+            chmod u+rw ${cfg.logPath} -R
+        fi
+      '';
+
+      serviceConfig.ExecStart = "${pkgs.pythonPackages.twisted}/bin/twistd -y ${pkgs.kippo}/src/kippo.tac --syslog --rundir=${cfg.varPath}/ --pidfile=${cfg.pidPath}/kippo.pid --prefix=kippo -n";
+      serviceConfig.PermissionsStartOnly = true;
+      serviceConfig.User = "kippo"; 
+      serviceConfig.Group = "kippo"; 
+    };
+};
+}
+
+

nixos/modules/services/ttys/kmscon.nix

···
+{ config, pkgs, ... }:
+let
+  inherit (pkgs.lib) mkOption types mkIf optionalString;
+
+  cfg = config.services.kmscon;
+
+  configDir = pkgs.writeTextFile { name = "kmscon-config"; destination = "/kmscon.conf"; text = cfg.extraConfig; };
+in {
+  options = {
+    services.kmscon = {
+      enable = mkOption {
+        description = ''
+          Use kmscon as the virtual console instead of gettys.
+          kmscon is a kms/dri-based userspace virtual terminal implementation.
+          It supports a richer feature set than the standard linux console VT,
+          including full unicode support, and when the video card supports drm
+          should be much faster.
+        '';
+        type = types.bool;
+        default = false;
+      };
+
+      hwRender = mkOption {
+        description = "Whether to use 3D hardware acceleration to render the console.";
+        type = types.bool;
+        default = false;
+      };
+
+      extraConfig = mkOption {
+        description = "Extra contents of the kmscon.conf file.";
+        type = types.lines;
+        default = "";
+        example = "font-size=14";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    # Largely copied from unit provided with kmscon source
+    systemd.units."kmsconvt@.service".text = ''
+      [Unit]
+      Description=KMS System Console on %I
+      Documentation=man:kmscon(1)
+      After=systemd-user-sessions.service
+      After=plymouth-quit-wait.service
+      After=systemd-logind.service
+      Requires=systemd-logind.service
+      Before=getty.target
+      Conflicts=getty@%i.service
+      OnFailure=getty@%i.service
+      IgnoreOnIsolate=yes
+      ConditionPathExists=/dev/tty0
+
+      [Service]
+      ExecStart=${pkgs.kmscon}/bin/kmscon "--vt=%I" --seats=seat0 --no-switchvt --configdir ${configDir} --login -- ${pkgs.shadow}/bin/login -p
+      UtmpIdentifier=%I
+      TTYPath=/dev/%I
+      TTYReset=yes
+      TTYVHangup=yes
+      TTYVTDisallocate=yes
+
+      X-RestartIfChanged=false
+    '';
+
+    systemd.units."autovt@.service".linkTarget = "${config.systemd.units."kmsconvt@.service".unit}/kmsconvt@.service";
+
+    services.kmscon.extraConfig = mkIf cfg.hwRender ''
+      drm
+      hwaccel
+    '';
+
+    services.mesa.enable = mkIf cfg.hwRender true;
+  };
+}

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

···
         pkgs.xfce.xfce4session
         pkgs.xfce.xfce4settings
         pkgs.xfce.xfce4mixer
+        pkgs.xfce.xfce4screenshooter
         pkgs.xfce.xfconf
         pkgs.xfce.xfdesktop
         pkgs.xfce.xfwm4

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

···
 
       ${cfg.displayManager.sessionCommands}
 
+      # Allow the user to execute commands at the beginning of the X session.
+      if test -f ~/.xprofile; then
+          source ~/.xprofile
+      fi
+
       # Allow the user to setup a custom session type.
       if test -x ~/.xsession; then
           exec ~/.xsession

nixos/modules/services/x11/mesa.nix

···
+{ config, pkgs, pkgs_i686, ... }:
+let
+  inherit (pkgs.lib) mkOption types mkIf optional optionals elem optionalString optionalAttrs;
+
+  cfg = config.services.mesa;
+
+  kernelPackages = config.boot.kernelPackages;
+in {
+  options = {
+    services.mesa.enable = mkOption {
+      description = "Whether this configuration requires mesa.";
+      type = types.bool;
+      default = false;
+      internal = true;
+    };
+
+    services.mesa.driSupport = mkOption {
+      type = types.bool;
+      default = true;
+      description = ''
+        Whether to enable accelerated OpenGL rendering through the
+        Direct Rendering Interface (DRI).
+      '';
+    };
+
+    services.mesa.driSupport32Bit = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        On 64-bit systems, whether to support Direct Rendering for
+        32-bit applications (such as Wine).  This is currently only
+        supported for the <literal>nvidia</literal> driver and for
+        <literal>mesa</literal>.
+      '';
+    };
+
+    services.mesa.s3tcSupport = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Make S3TC(S3 Texture Compression) via libtxc_dxtn available
+        to OpenGL drivers. It is essential for many games to work
+        with FOSS GPU drivers.
+
+        Using this library may require a patent license depending on your location.
+      '';
+    };
+
+
+    services.mesa.videoDrivers = mkOption {
+      type = types.listOf types.str;
+      # !!! We'd like "nv" here, but it segfaults the X server.
+      default = [ "ati" "cirrus" "intel" "vesa" "vmware" ];
+      example = [ "vesa" ];
+      description = ''
+        The names of the video drivers that the mesa should
+        support.  Mesa will try all of the drivers listed
+        here until it finds one that supports your video card.
+      '';
+    };
+  };
+
+  config = mkIf cfg.enable {
+    system.activationScripts.setup-opengl.deps = [];
+    system.activationScripts.setup-opengl.text = ''
+      rm -f /run/opengl-driver{,-32}
+      ${optionalString (!cfg.driSupport32Bit) "ln -sf opengl-driver /run/opengl-driver-32"}
+
+      ${# !!! The OpenGL driver depends on what's detected at runtime.
+        if elem "nvidia" cfg.videoDrivers then
+          ''
+            ln -sf ${kernelPackages.nvidia_x11} /run/opengl-driver
+            ${optionalString cfg.driSupport32Bit
+              "ln -sf ${pkgs_i686.linuxPackages.nvidia_x11.override { libsOnly = true; kernel = null; } } /run/opengl-driver-32"}
+          ''
+        else if elem "nvidiaLegacy173" cfg.videoDrivers then
+          "ln -sf ${kernelPackages.nvidia_x11_legacy173} /run/opengl-driver"
+        else if elem "nvidiaLegacy304" cfg.videoDrivers then
+          ''
+            ln -sf ${kernelPackages.nvidia_x11_legacy304} /run/opengl-driver
+            ${optionalString cfg.driSupport32Bit
+              "ln -sf ${pkgs_i686.linuxPackages.nvidia_x11_legacy304.override { libsOnly = true; kernel = null; } } /run/opengl-driver-32"}
+          ''
+        else if elem "ati_unfree" cfg.videoDrivers then
+          "ln -sf ${kernelPackages.ati_drivers_x11} /run/opengl-driver"
+        else
+          ''
+            ${optionalString cfg.driSupport "ln -sf ${pkgs.mesa_drivers} /run/opengl-driver"}
+            ${optionalString cfg.driSupport32Bit
+              "ln -sf ${pkgs_i686.mesa_drivers} /run/opengl-driver-32"}
+          ''
+      }
+    '';
+
+    environment.variables.LD_LIBRARY_PATH =
+      [ "/run/opengl-driver/lib" "/run/opengl-driver-32/lib" ]
+      ++ optional cfg.s3tcSupport "${pkgs.libtxc_dxtn}/lib"
+      ++ optional (cfg.s3tcSupport && cfg.driSupport32Bit) "${pkgs_i686.libtxc_dxtn}/lib";
+
+    boot.extraModulePackages =
+      optional (elem "nvidia" cfg.videoDrivers) kernelPackages.nvidia_x11 ++
+      optional (elem "nvidiaLegacy173" cfg.videoDrivers) kernelPackages.nvidia_x11_legacy173 ++
+      optional (elem "nvidiaLegacy304" cfg.videoDrivers) kernelPackages.nvidia_x11_legacy304 ++
+      optional (elem "virtualbox" cfg.videoDrivers) kernelPackages.virtualboxGuestAdditions ++
+      optional (elem "ati_unfree" cfg.videoDrivers) kernelPackages.ati_drivers_x11;
+
+    boot.blacklistedKernelModules =
+      optionals (elem "nvidia" cfg.videoDrivers) [ "nouveau" "nvidiafb" ];
+
+    environment.etc =  (optionalAttrs (elem "ati_unfree" cfg.videoDrivers) {
+        "ati".source = "${kernelPackages.ati_drivers_x11}/etc/ati";
+      })
+      // (optionalAttrs (elem "nvidia" cfg.videoDrivers) {
+        "OpenCL/vendors/nvidia.icd".source = "${kernelPackages.nvidia_x11}/lib/vendors/nvidia.icd";
+      });
+  };
+}

nixos/modules/services/x11/xserver.nix

···
     virtualbox   = { modules = [ kernelPackages.virtualboxGuestAdditions ]; driverName = "vboxvideo"; };
   };
 
-  driverNames =
-    optional (cfg.videoDriver != null) cfg.videoDriver ++ cfg.videoDrivers;
+  driverNames = config.services.mesa.videoDrivers;
 
   drivers = flip map driverNames
     (name: { inherit name; driverName = name; } //
···
         description = ''
           The name of the video driver for your graphics card.  This
           option is obsolete; please set the
-          <option>videoDrivers</option> instead.
-        '';
-      };
-
-      videoDrivers = mkOption {
-        type = types.listOf types.str;
-        # !!! We'd like "nv" here, but it segfaults the X server.
-        default = [ "ati" "cirrus" "intel" "vesa" "vmware" ];
-        example = [ "vesa" ];
-        description = ''
-          The names of the video drivers that the X server should
-          support.  The X server will try all of the drivers listed
-          here until it finds one that supports your video card.
+          <option>services.mesa.videoDrivers</option> instead.
         '';
       };
 
···
         '';
       };
 
-      driSupport = mkOption {
-        type = types.bool;
-        default = true;
-        description = ''
-          Whether to enable accelerated OpenGL rendering through the
-          Direct Rendering Interface (DRI).
-        '';
-      };
-
-      driSupport32Bit = mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-          On 64-bit systems, whether to support Direct Rendering for
-          32-bit applications (such as Wine).  This is currently only
-          supported for the <literal>nvidia</literal> driver and for
-          <literal>mesa</literal>.
-        '';
-      };
-
-      s3tcSupport = mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-          Make S3TC(S3 Texture Compression) via libtxc_dxtn available
-          to OpenGL drivers. It is essential for many games to work
-          with FOSS GPU drivers.
-
-          Using this library may require a patent license depending on your location.
-        '';
-      };
-
       startOpenSSHAgent = mkOption {
         type = types.bool;
         default = true;
···
   ###### implementation
 
   config = mkIf cfg.enable {
+    services.mesa.enable = true;
+    services.mesa.videoDrivers = mkIf (cfg.videoDriver != null) [ cfg.videoDriver ];
 
     assertions =
       [ { assertion = !(cfg.startOpenSSHAgent && cfg.startGnuPGAgent);
···
         }
       ];
 
-    boot.extraModulePackages =
-      optional (elem "nvidia" driverNames) kernelPackages.nvidia_x11 ++
-      optional (elem "nvidiaLegacy173" driverNames) kernelPackages.nvidia_x11_legacy173 ++
-      optional (elem "nvidiaLegacy304" driverNames) kernelPackages.nvidia_x11_legacy304 ++
-      optional (elem "virtualbox" driverNames) kernelPackages.virtualboxGuestAdditions ++
-      optional (elem "ati_unfree" driverNames) kernelPackages.ati_drivers_x11;
-
-    boot.blacklistedKernelModules =
-      optionals (elem "nvidia" driverNames) [ "nouveau" "nvidiafb" ];
-
-    environment.variables.LD_LIBRARY_PATH =
-      [ "/run/opengl-driver/lib" "/run/opengl-driver-32/lib" ]
-      ++ pkgs.lib.optional cfg.s3tcSupport "${pkgs.libtxc_dxtn}/lib"
-      ++ pkgs.lib.optional (cfg.s3tcSupport && cfg.driSupport32Bit) "${pkgs_i686.libtxc_dxtn}/lib";
-
     environment.etc =
       (optionals cfg.exportConfiguration
         [ { source = "${configFile}";
···
           { source = "${pkgs.xkeyboard_config}/etc/X11/xkb";
             target = "X11/xkb";
           }
-        ])
-      ++ (optionals (elem "ati_unfree" driverNames) [
-
-          # according toiive on #ati you don't need the pcs, it is like registry... keeps old stuff to make your
-          # life harder ;) Still it seems to be required
-          { source = "${kernelPackages.ati_drivers_x11}/etc/ati";
-            target = "ati";
-          }
-      ])
-      ++ (optionals (elem "nvidia" driverNames) [
-
-          { source = "${kernelPackages.nvidia_x11}/lib/vendors/nvidia.icd";
-            target = "OpenCL/vendors/nvidia.icd";
-          }
-      ]);
+        ]);
 
     environment.systemPackages =
       [ xorg.xorgserver
···
 
         preStart =
           ''
-            rm -f /run/opengl-driver{,-32}
-            ${optionalString (!cfg.driSupport32Bit) "ln -sf opengl-driver /run/opengl-driver-32"}
-
-            ${# !!! The OpenGL driver depends on what's detected at runtime.
-              if elem "nvidia" driverNames then
-                ''
-                  ln -sf ${kernelPackages.nvidia_x11} /run/opengl-driver
-                  ${optionalString cfg.driSupport32Bit
-                    "ln -sf ${pkgs_i686.linuxPackages.nvidia_x11.override { libsOnly = true; kernel = null; } } /run/opengl-driver-32"}
-                ''
-              else if elem "nvidiaLegacy173" driverNames then
-                "ln -sf ${kernelPackages.nvidia_x11_legacy173} /run/opengl-driver"
-              else if elem "nvidiaLegacy304" driverNames then
-                ''
-                  ln -sf ${kernelPackages.nvidia_x11_legacy304} /run/opengl-driver
-                  ${optionalString cfg.driSupport32Bit
-                    "ln -sf ${pkgs_i686.linuxPackages.nvidia_x11_legacy304.override { libsOnly = true; kernel = null; } } /run/opengl-driver-32"}
-                ''
-              else if elem "ati_unfree" driverNames then
-                "ln -sf ${kernelPackages.ati_drivers_x11} /run/opengl-driver"
-              else
-                ''
-                  ${optionalString cfg.driSupport "ln -sf ${pkgs.mesa_drivers} /run/opengl-driver"}
-                  ${optionalString cfg.driSupport32Bit
-                    "ln -sf ${pkgs_i686.mesa_drivers} /run/opengl-driver-32"}
-                ''
-            }
-
             ${cfg.displayManager.job.preStart}
 
             rm -f /tmp/.X0-lock

nixos/modules/system/boot/systemd.nix

···
   systemd = cfg.package;
 
   makeUnit = name: unit:
-    pkgs.runCommand "unit" { inherit (unit) text; preferLocalBuild = true; }
-      (if unit.enable then  ''
+    pkgs.runCommand "unit" ({ preferLocalBuild = true; } // optionalAttrs (unit.linkTarget == null) { inherit (unit) text; })
+      (if !unit.enable then  ''
+        mkdir -p $out
+        ln -s /dev/null $out/${name}
+      '' else if unit.linkTarget != null then ''
         mkdir -p $out
-        echo -n "$text" > $out/${name}
+        ln -s ${unit.linkTarget} $out/${name}
       '' else ''
         mkdir -p $out
-        ln -s /dev/null $out/${name}
+        echo -n "$text" > $out/${name}
       '');
 
   upstreamUnits =
···
       done
 
       for i in ${toString (mapAttrsToList (n: v: v.unit) cfg.units)}; do
-        ln -s $i/* $out/
+        ln -fs $i/* $out/
       done
 
       for i in ${toString cfg.packages}; do
···
       ln -s rescue.target $out/kbrequest.target
 
       mkdir -p $out/getty.target.wants/
-      ln -s ../[e-mail] $out/getty.target.wants/
+      ln -s ../[e-mail] $out/getty.target.wants/
 
       ln -s ../local-fs.target ../remote-fs.target ../network.target ../nss-lookup.target \
             ../nss-user-lookup.target ../swap.target $out/multi-user.target.wants/
···
             unit = mkOption {
               internal = true;
               description = "The generated unit.";
+            };
+            linkTarget = mkOption {
+              default = null;
+              description = "The file to symlink this target to.";
+              type = types.nullOr types.path;
             };
           };
           config = {

nixos/modules/system/etc/setup-etc.pl

···
         open MODE, "<$_.mode";
         my $mode = <MODE>; chomp $mode;
         close MODE;
-        copy "$static/$fn", "$target.tmp" or warn;
-        chmod oct($mode), "$target.tmp" or warn;
-        rename "$target.tmp", $target or warn;
+        if ($mode eq "direct-symlink") {
+            atomicSymlink readlink("$static/$fn"), $target or warn;
+        } else {
+            copy "$static/$fn", "$target.tmp" or warn;
+            chmod oct($mode), "$target.tmp" or warn;
+            rename "$target.tmp", $target or warn;
+        }
     } elsif (-l "$_") {
         atomicSymlink "$static/$fn", $target or warn;
     }

nixos/tests/firefox.nix

···
       $machine->waitForWindow(qr/Valgrind/);
       $machine->sleep(40); # wait until Firefox has finished loading the page
       $machine->screenshot("screen");
+
     '';
 
 }

pkgs/applications/audio/audacious/default.nix

···
 }:
 
 let
-  version = "3.4.1";
+  version = "3.4.3";
 in
 stdenv.mkDerivation {
   name = "audacious-${version}";
 
   src = fetchurl {
     url = "http://distfiles.audacious-media-player.org/audacious-${version}.tar.bz2";
-    sha256 = "0wf99b0nrk90fyak4gpwi076qnsrmv1j8958cvi57rxig21lvvap";
+    sha256 = "04lzwdr1lx6ghbfxzygvnbmdl420w6rm453ds5lyb0hlvzs58d0q";
   };
 
   pluginsSrc = fetchurl {
     url = "http://distfiles.audacious-media-player.org/audacious-plugins-${version}.tar.bz2";
-    sha256 = "02ivrxs6109nmmz9pkbf9dkm36s2lyp9vfv59sm0acxxd4db71md";
+    sha256 = "00r88q9fs9a0gicdmk2svcans7igcqgacrw303a5bn44is7pmrmy";
   };
 
   buildInputs =
···
       (
         source $stdenv/setup
         # gsettings schemas for file dialogues
-        for file in "$out"/bin/*; do
+        for file in "$out/bin/"*; do
           wrapProgram "$file" --prefix XDG_DATA_DIRS : "$XDG_ADD"
         done
       )

pkgs/applications/audio/drumkv1/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "drumkv1-${version}";
-  version = "0.3.5";
+  version = "0.3.6";
 
   src = fetchurl {
     url = "mirror://sourceforge/drumkv1/${name}.tar.gz";
-    sha256 = "125aa1lmmwjdbzyv13yaax4n6ni7h7v7c7clmjaz7bglzay7xq5w";
+    sha256 = "13prman3jlh3xz56675vnnnghnmmbxpq8gqdhv5llgd8ggzhmyjn";
   };
 
   buildInputs = [ jackaudio libsndfile lv2 qt4 ];

pkgs/applications/audio/qjackctl/default.nix

···
     description = "A Qt application to control the JACK sound server daemon";
     homepage = http://qjackctl.sourceforge.net/;
     license = "GPL";
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/streamripper/default.nix

···
+{ stdenv, fetchurl , glib, pkgconfig, libogg, libvorbis }:
+
+stdenv.mkDerivation rec {
+  name = "streamripper-${version}";
+  version = "1.64.6";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/streamripper/${name}.tar.gz";
+    sha256 = "0hnyv3206r0rfprn3k7k6a0j959kagsfyrmyjm3gsf3vkhp5zmy1";
+  };
+
+  buildInputs = [ pkgconfig glib libogg libvorbis ];
+
+  meta = with stdenv.lib; {
+    homepage = http://streamripper.sourceforge.net/;
+    description = "Application that lets you record streaming mp3 to your hard drive";
+    license = licenses.gpl2;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ the-kenny ];
+  };
+}

pkgs/applications/editors/eclipse/default.nix

···
-{ stdenv, fetchurl, patchelf, makeDesktopItem, makeWrapper
+{ stdenv, fetchurl, makeDesktopItem, makeWrapper
 , freetype, fontconfig, libX11, libXext, libXrender, zlib
 , glib, gtk, libXtst, jre
 }:
···
         categories = "Application;Development;";
       };
 
-      buildInputs = [ makeWrapper patchelf ];
+      buildInputs = [ makeWrapper ];
 
       buildCommand = ''
         # Unpack tarball.

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

···
 { stdenv, fetchurl, emacs, texinfo }:
 
 stdenv.mkDerivation rec {
-  name = "haskell-mode-13.07";
+  name = "haskell-mode-13.10";
 
   src = fetchurl {
-    url = "https://github.com/haskell/haskell-mode/archive/v13.07.tar.gz";
-    sha256 = "15c8ncj9mykkrizy1a8l94gq37s8hj13v3p5rgyaj9z0cwgl85kx";
+    url = "https://github.com/haskell/haskell-mode/archive/v13.10.tar.gz";
+    sha256 = "0hcg7wpalcdw8j36m8vd854zrrgym074r7m903rpwfrhx9mlg02b";
   };
 
   buildInputs = [ emacs texinfo ];

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

···
       mkdir -p "dist"
       cat > build.properties <<EOF
         dist.lisp.dir = dist/share/emacs/site-lisp
-        dist.java.lib.dir = dist/lib/java
-        dist.jar.jde.file = dist/lib/java/jde.jar
+        dist.java.lib.dir = dist/share/java
+        dist.jar.jde.file = dist/share/java/jde.jar
         dist.java.src.dir = dist/src/${name}/java
         dist.doc.dir  dist/doc/${name}
         prefix.dir = $out
···
       for i in "lisp/"*.el
       do
         sed -i "$i" -e "s|@out@|$out|g ;
-                        s|@javadir@|$out/lib/java|g ;
+                        s|@javadir@|$out/share/java|g ;
                         s|@datadir@|$out/share/${name}|g"
       done
     '';
···
 
       # Move everything that's not a JAR to $datadir.  This includes
       # `sun_checks.xml', license files, etc.
-      cd "$out/lib/java"
+      cd "$out/share/java"
       for i in *
       do
         if echo $i | grep -qv '\.jar''$'

pkgs/applications/editors/emacs-modes/jdee/java-directory.patch

···
 -    (oset this bsh-cmd-dir (expand-file-name "bsh-commands" jde-java-directory))
 -    (oset this checkstyle-jar  (expand-file-name "lib/checkstyle-all.jar" jde-java-directory))
 -    (oset this regexp-jar (expand-file-name "lib/jakarta-regexp.jar" jde-java-directory))
-+  (let ((jde-java-directory "@out@/lib/java"))
++  (let ((jde-java-directory "@out@/share/java"))
 +
 +    (oset this bsh-cmd-dir "@datadir@/bsh-commands")
 +    (oset this checkstyle-jar  (expand-file-name "checkstyle-all.jar" jde-java-directory))
···
 -	  (concat
 -	   (jde-find-jde-data-directory)
 -	   "java/"))
-+	 (jde-java-directory "@out@/lib/java")
++	 (jde-java-directory "@out@/share/java")
  	 (args (append
  		(unless jde-checkstyle-expanded-properties-file
  		  (jde-checkstyle-get-property-args this))
···
 -	     (jde-java-directory
 -	      (expand-file-name "java"
 -	       (jde-find-jde-data-directory)))
-+	     (jde-java-directory "@out@/lib/java")
++	     (jde-java-directory "@out@/share/java")
  	     (vm-args 
  		(let (args)
  		  (setq args 

pkgs/applications/editors/jedit/default.nix

···
-{ stdenv, fetchurl, ant, jre }:
+{ stdenv, fetchurl, ant, jdk }:
+
+let version = "4.4.2"; in
 
 stdenv.mkDerivation {
-  name = "jedit-4.4.2";
+  name = "jedit-${version}";
 
   src = fetchurl {
-    url = mirror://sourceforge/jedit/jedit4.4.2source.tar.bz2;
+    url = "mirror://sourceforge/jedit/jedit${version}source.tar.bz2";
     sha256 = "5e9ad9c32871b77ef0b9fe46dcfcea57ec52558d36113b7280194a33430b8ceb";
   };
 
-  setSourceRoot = ''
-    sourceRoot=jEdit
-  '';
+  buildInputs = [ ant jdk ];
 
-  buildPhase = ''
-     ant build
-  '';
+  sourceRoot = "jEdit";
+
+  buildPhase = "ant build";
 
   installPhase = ''
     mkdir -p $out/share/jEdit
···
     cp -r macros/* $out/share/jEdit/macros
     mkdir -p $out/share/jEdit/doc
     cp -r doc/* $out/share/jEdit/doc
-    
+
     sed -i "s|Icon=.*|Icon=$out/share/jEdit/icons/jedit-icon48.png|g" package-files/linux/deb/jedit.desktop
     mkdir -p $out/share/applications
     mv package-files/linux/deb/jedit.desktop $out/share/applications/jedit.desktop
···
     patch package-files/linux/jedit << EOF
     5a6,8
     > # specify the correct JAVA_HOME
-    > JAVA_HOME=${jre}
+    > JAVA_HOME=${jdk.jre}/lib/openjdk/jre
     > 
     EOF
     sed -i "s|/usr/share/jEdit/@jar.filename@|$out/share/jEdit/jedit.jar|g" package-files/linux/jedit
···
     chmod +x $out/bin/jedit
   '';
 
-  buildInputs = [ ant ];
-
-  meta = { 
+  meta = {
     description = "Mature programmer's text editor (Java based)";
     homepage = http://www.jedit.org;
     license = "GPL";

pkgs/applications/graphics/gocr/default.nix

···
 { stdenv, fetchurl, tk }:
 
 stdenv.mkDerivation rec {
-  name = "gocr-0.49";
+  name = "gocr-0.50";
 
   src = fetchurl {
-    url = http://www-e.uni-magdeburg.de/jschulen/ocr/gocr-0.49.tar.gz;
-    sha256 = "06hpzp7rkkwfr1fvmc8kcfz9v490i9yir7f7imh13gmka0fr6afc";
+    url = "http://www-e.uni-magdeburg.de/jschulen/ocr/${name}.tar.gz";
+    sha256 = "1dgmcpapy7h68d53q2c5d0bpgzgfb2nw2blndnx9qhc7z12149mw";
   };
 
   postInstall = ''

pkgs/applications/graphics/zgrviewer/default.nix

···
   buildInputs = [jre unzip];
   buildPhase = "";
   installPhase = ''
-    mkdir -p "$out"/{bin,lib/java/zvtm/plugins,share/doc/zvtm}
+    mkdir -p "$out"/{bin,share/java/zvtm/plugins,share/doc/zvtm}
 
     cp overview.html *.license.* "$out/share/doc/zvtm"
 
-    cp -r target/* "$out/lib/java/zvtm/"
+    cp -r target/* "$out/share/java/zvtm/"
 
     echo '#!/bin/sh' > "$out/bin/zgrviewer"
-    echo "java -jar '$out/lib/java/zvtm/zgrviewer-${version}.jar'" >> "$out/bin/zgrviewer"
+    echo "java -jar '$out/share/java/zvtm/zgrviewer-${version}.jar'" >> "$out/bin/zgrviewer"
     chmod a+x "$out/bin/zgrviewer"
   '';
   meta = {

pkgs/applications/misc/fetchmail/default.nix

···
 { stdenv, fetchurl, openssl }:
 
 let
-  version = "6.3.20";
+  version = "6.3.26";
 in
 stdenv.mkDerivation {
   name="fetchmail-${version}";
 
   src = fetchurl {
     url = "http://download.berlios.de/fetchmail/fetchmail-${version}.tar.bz2";
-    sha256 = "22e94f11d885cb9330a197fd80217d44f65e6b087e4d4b4d83e573adfc24aa7b";
+    sha256 = "08rafrs1dlr11myr0p99kg4k80qyy0fa63gg3ac88zn49174lwhw";
   };
 
   buildInputs = [ openssl ];

pkgs/applications/misc/ikiwiki/default.nix

···
 
 let
   name = "ikiwiki";
-  version = "3.20130904.1";
+  version = "3.20140102";
 
   lib = stdenv.lib;
 in
···
 
   src = fetchurl {
     url = "http://ftp.de.debian.org/debian/pool/main/i/ikiwiki/${name}_${version}.tar.gz";
-    sha256 = "1nxycsz49y6801lbrvazzg7qc9q2vpr2ny1sba26f9gwc00c650h";
+    sha256 = "0nsyfq7j03cg4qq73kw7cxnc7wgbr2m75fqmmll77wyl9cb661lj";
   };
 
   buildInputs = [ perl TextMarkdown URI HTMLParser HTMLScrubber HTMLTemplate

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

···
     sha256 = "1baxwpdvak6nalr943g22z67r1d3fbibbkqvkvvar9xlvrs9gv20";
   };
   
-  configureFlags = if sslSupport then "--with-ssl" else "";
+  configureFlags = if sslSupport then "--with-ssl=${openssl}" else "";
   
-  buildInputs = [ ncurses gzip ] ++ stdenv.lib.optional sslSupport openssl;
+  buildInputs = [ ncurses gzip ];
   nativeBuildInputs = [ ncurses ];
 
   crossAttrs = {

pkgs/applications/networking/dropbox-cli/default.nix

···
   src = fetchurl {
     # Note: dropbox doesn't version this file. Annoying.
     url = "https://linux.dropbox.com/packages/dropbox.py";
-    sha256 = "0p1pg8bw6mlhqi5k8y3pgs7byg0kfvq57s53sh188lb5sxvlg7yz";
+    sha256 = "0505k0xrhbmsv7g5phxxnz5wbff6m5gdsqyxkhd95wdi9d71c43c";
   };
 
   buildInputs = [ coreutils python ];

pkgs/applications/networking/dropbox/default.nix

···
     else if stdenv.system == "i686-linux" then "ld-linux.so.2"
     else throw "Dropbox client for: ${stdenv.system} not supported!";
 
-  version = "2.4.7";
-  sha256 = if stdenv.system == "x86_64-linux" then "08fh0zx9q83dvivnbx5zr1cwb69ihhlx9mkbd3ikynk1wd8df8n8"
-    else if stdenv.system == "i686-linux" then "0rhblpahg2axglpi8iavsglffw83rj71qy113wj2dh6q72124j2h"
+  version = "2.6.2";
+  sha256 = if stdenv.system == "x86_64-linux" then "0j511nglqg2xngyl78ww7xk09v8yzhghk5cnj6slr9sldy83n7g9"
+    else if stdenv.system == "i686-linux" then "0n0y0wf313yjas4b89ag613jb80skby1qmfkyy1aazgjancf7v5i"
     else throw "Dropbox client for: ${stdenv.system} not supported!";
 
   # relative location where the dropbox libraries are stored

pkgs/applications/networking/p2p/freenet/default.nix

···
-{ stdenv, fetchurl, apacheAntOpenJDK, jre }:
+{ stdenv, fetchurl, ant, jdk }:
 
 let
   # The .gitmodules in freenet-official-20130413-eccc9b3198
···
   };
 in
 stdenv.mkDerivation {
-  name = "freenet-official-20130413-eccc9b3198";
+  name = "freenet-20130413-eccc9b3198";
 
   src = fetchurl {
     url = https://github.com/freenet/fred-official/tarball/eccc9b3198;
···
     sed '/antcall.*-ext/d' -i build.xml
   '';
 
-  buildInputs = [ apacheAntOpenJDK jre ];
+  buildInputs = [ ant jdk ];
 
   buildPhase = "ant package-only";
 
···
 
     cat <<EOF > $out/bin/freenet
     #!${stdenv.shell}
-    ${jre}/bin/java -cp $out/share/freenet/bcprov.jar:$out/share/freenet/freenet-ext.jar:$out/share/freenet/freenet.jar \\
+    ${jdk.jre}/bin/java -cp $out/share/freenet/bcprov.jar:$out/share/freenet/freenet-ext.jar:$out/share/freenet/freenet.jar \\
       -Xmx1024M freenet.node.NodeStarter
     EOF
     chmod +x $out/bin/freenet
   '';
 
-  meta = { 
+  meta = {
     description = "Decentralised and censorship-resistant network";
     homepage = https://freenetproject.org/;
     license = "GPLv2+";

pkgs/applications/networking/p2p/gnunet/default.nix

···
 , makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "gnunet-0.9.5a";
+  name = "gnunet-0.10.0";
 
   src = fetchurl {
     url = "mirror://gnu/gnunet/${name}.tar.gz";
-    sha256 = "1mxy1ikv44fia3cybpmiw298x5371a2qh8hr7pi55yg1xqbhfq0x";
+    sha256 = "0zqpc47kywhjrpphl0palz849khv00ra2gjrfkysp6p0gfsbvd0i";
   };
 
   buildInputs = [

pkgs/applications/networking/sniffers/wireshark/default.nix

···
-{ stdenv, fetchurl, pkgconfig, perl, flex, bison, libpcap, libnl, c-ares, gnutls, libgcrypt
-, geoip, heimdal, lua5, gtk, makeDesktopItem
+{ stdenv, fetchurl, pkgconfig, perl, flex, bison, libpcap, libnl, c-ares
+, gnutls, libgcrypt, geoip, heimdal, lua5, gtk, makeDesktopItem, python
 }:
 
-let version = "1.10.5"; in
+let version = "1.11.2"; in
 
 stdenv.mkDerivation {
   name = "wireshark-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/wireshark/wireshark-${version}.tar.bz2";
-    sha256 = "1xa1l6z8n1gwnyv5mq4zmyr0afy6s0qpl9wqflg3ipbkjpd908d0";
+    sha256 = "077hjnmqn44s8dx3pc38bxps5liicjnhzrnf6ky2x60m2cp7ngr3";
   };
 
-  buildInputs =
-    [ bison flex perl pkgconfig libpcap lua5 heimdal libgcrypt gnutls geoip libnl c-ares gtk ];
+  buildInputs = [
+    bison flex perl pkgconfig libpcap lua5 heimdal libgcrypt gnutls
+    geoip libnl c-ares gtk python
+  ];
 
-  configureFlags = "--disable-usr-local --enable-packet-editor --with-ssl";
+  configureFlags = "--disable-usr-local --disable-silent-rules --with-gtk2 --without-gtk3 --without-qt --with-ssl";
 
   desktopItem = makeDesktopItem {
     name = "Wireshark";
···
   postInstall = ''
     mkdir -p "$out"/share/applications/
     mkdir -p "$out"/share/icons/
-    cp "$desktopItem"/share/applications/* "$out"/share/applications/
+    cp "$desktopItem/share/applications/"* "$out/share/applications/"
     cp image/wsicon.svg "$out"/share/icons/wireshark.svg
   '';
+
+  enableParallelBuilding = true;
 
   meta = {
     homepage = http://www.wireshark.org/;

pkgs/applications/office/gnucash/default.nix

···
  */
 
 stdenv.mkDerivation rec {
-  name = "gnucash-2.4.13";
+  name = "gnucash-2.4.15";
 
   src = fetchurl {
     url = "mirror://sourceforge/gnucash/${name}.tar.bz2";
-    sha256 = "0j4m00a3r1hcrhkfjkx3sgi2r4id4wrc639i4s00j35rx80540pn";
+    sha256 = "058mgfwic6a2g7jq6iip5hv45md1qaxy25dj4lvlzjjr141wm4gx";
   };
 
   buildInputs = [

pkgs/applications/office/homebank/default.nix

···
 
 let
    download_root = "http://homebank.free.fr/public/";
-   name = "homebank-4.4";
+   name = "homebank-4.5.4";
    lastrelease = download_root + name + ".tar.gz";
    oldrelease = download_root + "old/" + name + ".tar.gz";
 in
···
 
   src = fetchurl {
     urls = [ lastrelease oldrelease ];
-    sha256 = "1lp7vhimn7aa2b4ik857w7d7rbbqcwlsffk8s8lw4fjyaxrr7f0k";
+    sha256 = "10xh76mxwbl56xp118gg3b4isv16yvhsvqxwqc28pqqxkpr7vpdk";
   };
 
   buildInputs = [ pkgconfig gtk libofx intltool ];

pkgs/applications/office/todo.txt-cli/default.nix

···
+{ stdenv, fetchurl }:
+let
+  version = "2.10";
+in stdenv.mkDerivation {
+  name = "todo.txt-cli-${version}";
+
+  src = fetchurl {
+    url = "https://github.com/ginatrapani/todo.txt-cli/releases/download/v${version}/todo.txt_cli-${version}.tar.gz";
+    sha256 = "1agn4zzbizrrylvbfi053b5mpb39bvl1gzziw08xibzfdyi1g55m";
+  };
+
+  installPhase = ''
+    install -vd $out/bin
+    install -vm 755 todo.sh $out/bin
+    install -vd $out/etc/bash_completion.d
+    install -vm 644 todo_completion $out/etc/bash_completion.d/todo
+    install -vd $out/etc/todo
+    install -vm 644 todo.cfg $out/etc/todo/config
+  '';
+
+  meta = {
+    description = "Simple plaintext todo list manager";
+    homepage = "http://todotxt.com";
+    license = stdenv.lib.licenses.gpl3;
+    maintainers = [ stdenv.lib.maintainers.shlevy ];
+    platforms = stdenv.lib.platforms.all;
+  };
+}

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

···
 in
 
 stdenv.mkDerivation {
-  name = "hol_light-20130324";
+  name = "hol_light-20140112";
   src = fetchsvn {
     url = http://hol-light.googlecode.com/svn/trunk;
-    rev = "157";
-    sha256 = "0d0pbnkw2gb11dn30ggfl91lhdxv86kd1fyiqn170w08n0gi805f";
+    rev = "179";
+    sha256 = "1j402s7142fj09bjijrkargwx03fvbdwmn0hgzzmi6s4p1y7gww0";
   };
 
   buildInputs = [ ocaml findlib camlp5 ];

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

···
 
 let
   name    = "maxima";
-  version = "5.31.3";
+  version = "5.32.1";
 
   searchPath =
     stdenv.lib.makeSearchPath "bin"
···
 
   src = fetchurl {
     url = "mirror://sourceforge/${name}/${name}-${version}.tar.gz";
-    sha256 = "1g959569plywqaxxp488ylblgkirqg24arwa93dplfxi4h7fc4km";
+    sha256 = "0krxha1jckgw5s52bjasf7bnkcnq81qyi2k1bcglgqzfp79b44gw";
   };
 
   buildInputs = [sbcl texinfo perl makeWrapper];

pkgs/applications/version-management/gource/default.nix

···
-{ stdenv, fetchurl, SDL, ftgl, pkgconfig, libpng, libjpeg, pcre, SDL_image, glew, mesa }:
+{ stdenv, fetchurl, SDL, ftgl, pkgconfig, libpng, libjpeg, pcre
+, SDL_image, glew, mesa, boostHeaders
+}:
 
-let
-  name = "gource-0.37";
-in
-stdenv.mkDerivation {
-  inherit name;
+stdenv.mkDerivation rec {
+  name = "gource-0.40";
 
   src = fetchurl {
     url = "http://gource.googlecode.com/files/${name}.tar.gz";
-    sha256 = "03kd9nn65cl1p2jgn6pvpxmvnfscz3c8jqds90fsc0z37ij2iiyn";
+    sha256 = "04nirh07xjslqsph557as4s50nlf91bi6v2l7vmbifmkdf90m2cw";
   };
 
-  buildInputs = [glew SDL ftgl pkgconfig libpng libjpeg pcre SDL_image mesa];
+  buildInputs = [
+    glew SDL ftgl pkgconfig libpng libjpeg pcre SDL_image mesa boostHeaders
+  ];
 
   NIX_CFLAGS_COMPILE = "-fpermissive"; # fix build with newer gcc versions
 
···
       by several third party tools for CVS repositories.
     '';
 
-    platforms = stdenv.lib.platforms.gnu;
-    maintainers = [ stdenv.lib.maintainers.simons ];
+    broken = true;
   };
 }

pkgs/applications/version-management/mercurial/default.nix

···
 , guiSupport ? false, tk ? null, curses }:
 
 let
-  name = "mercurial-2.8.1";
+  name = "mercurial-2.8.2";
 in
 
 stdenv.mkDerivation {
···
 
   src = fetchurl {
     url = "http://mercurial.selenic.com/release/${name}.tar.gz";
-    sha256 = "0riksf6p07yxfq1xlraqhl8cacsgb1gg7si185mlbdknrh2a4ffj";
+    sha256 = "0vxyxx91k6z0knfqslbwxswbc52abrg2pdf395kwvij026ibm9f8";
   };
 
   inherit python; # pass it so that the same version can be used in hg2git

pkgs/applications/video/mpv/default.nix

···
   waf = fetchurl {
     url = https://waf.googlecode.com/files/waf-1.7.13;
     sha256 = "03cc750049350ee01cdbc584b70924e333fcc17ba4a2d04648dab1535538a873";
-};
+  };
+
+  version = "0.3.2";
 
 in
 
 stdenv.mkDerivation rec {
-  name = "mpv-20131222";
+  name = "mpv-${version}";
 
-  src = fetchgit {
-    url = "https://github.com/mpv-player/mpv.git";
-    rev = "e6bea0ec5a";
-    sha256 = "984c7d19b1916b7e5befc370ffb7f6c31e560c64c47090b924a115d00c35a1a8";
+  src = fetchurl {
+    url = "https://github.com/mpv-player/mpv/archive/v${version}.tar.gz";
+    sha256 = "1vzdhzry2adyp2yh2dmy1qznqhnzar7g24rhi0vv624jgd20qax2";
   };
 
   buildInputs = with stdenv.lib;

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

···
   }:
 
 stdenv.mkDerivation rec {
-  name = "i3status-2.7";
+  name = "i3status-2.8";
 
   src = fetchurl {
     url = "http://i3wm.org/i3status/${name}.tar.bz2";
-    sha256 = "0cm6fhsc7hzsqni8pwhjl2l0rfd458paabn54cgzqnmwwdflwgq7";
+    sha256 = "1zh7z2qbw0jsrqdkc1irviq2n20mc5hq4h1mckyfcm238pfwa1mb";
   };
 
   buildInputs = [ confuse yajl alsaLib wirelesstools ];

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

···
 , libXtst, xextproto, readline, libXi, pkgconfig, perl, autoconf, automake }:
 
 stdenv.mkDerivation rec {
-  name = "ratpoison-1.4.5";
+  name = "ratpoison-1.4.6";
 
   src = fetchurl {
     url = "mirror://savannah/ratpoison/${name}.tar.gz";
-    sha256 = "7391079db20b8613eecfd81d64d243edc9d3c586750c8f2da2bb9db14d260f03";
+    sha256 = "1y1b38bng0naxfy50asshzg5xr1b2rn88mcgbds42y72d7y9d0za";
   };
 
   buildInputs =
···
   NIX_CFLAGS_COMPILE = "-I${freetype}/include/freetype2"; # urgh
 
   preConfigure = "autoreconf -vf";      # needed because of the patch above
-
-  patches = [ ./glibc-fix.patch ];
 
   postInstall = ''
     mkdir -p $out/share/emacs/site-lisp
···
        cripples Emacs and other quality pieces of software.
     '';
 
-    maintainers = [ stdenv.lib.maintainers.simons ];
-    platforms = stdenv.lib.platforms.linux;
+    hydraPlatforms = stdenv.lib.platforms.linux;
+    maintainers = [ ];
   };
 }

pkgs/applications/window-managers/ratpoison/glibc-fix.patch

···
-From 4ad0b38fb53506d613c4b4f7268dadfcedae9b8e Mon Sep 17 00:00:00 2001
-From: Shawn Betts <[e-mail]>
-Date: Mon, 13 Jul 2009 01:23:25 +0000
-Subject: check for getline in configure.in
-
-This fixes a build error encountered on glibc 2.10 systems
----
-diff --git a/configure.in b/configure.in
-index 0c1b42c..08f4ee8 100644
---- a/configure.in
-+++ b/configure.in
-@@ -146,7 +146,7 @@ AC_CHECK_HEADERS(unistd.h stdarg.h)
- dnl Checks for typedefs, structures, and compiler characteristics.
- 
- dnl Checks for library functions.
--AC_CHECK_FUNCS(getopt getopt_long setsid setpgid setpgrp putenv vsnprintf usleep)
-+AC_CHECK_FUNCS(getopt getopt_long setsid setpgid setpgrp putenv vsnprintf usleep getline)
- 
- AC_TYPE_SIGNAL
- 
---
-cgit v0.9.0.2

pkgs/build-support/release/ant-build.nix

···
 , antProperties ? []
 , antBuildInputs ? []
 , buildfile ? "build.xml"
-, ant ? pkgs.apacheAntOpenJDK
+, ant ? pkgs.ant
 , jre ? pkgs.openjdk
 , hydraAntLogger ? pkgs.hydraAntLogger
 , ... } @ args:
···
 
     antSetupPhase = with stdenv.lib; ''
       if test "$hydraAntLogger" != "" ; then
-        export ANT_ARGS="-logger org.hydra.ant.HydraLogger -lib `ls $hydraAntLogger/lib/java/*.jar | head -1`"
+        export ANT_ARGS="-logger org.hydra.ant.HydraLogger -lib `ls $hydraAntLogger/share/java/*.jar | head -1`"
       fi
       for abi in ${concatStringsSep " " (map (f: "`find ${f} -name '*.jar'`") antBuildInputs)}; do
         export ANT_ARGS="$ANT_ARGS -lib $abi"
···
     '';
 
     installPhase = ''
-      mkdir -p $out/lib/java
+      mkdir -p $out/share/java
       ${ if jars == [] then '' 
-           find . -name "*.jar" | xargs -I{} cp -v {} $out/lib/java
+           find . -name "*.jar" | xargs -I{} cp -v {} $out/share/java
          '' else stdenv.lib.concatMapStrings (j: ''
-           cp -v ${j} $out/lib/java
+           cp -v ${j} $out/share/java
          '') jars }
-      for j in $out/lib/java/*.jar ; do
+      for j in $out/share/java/*.jar ; do
         echo file jar $j >> $out/nix-support/hydra-build-products
       done
     '';
 
     generateWrappersPhase = 
       let 
-        cp = w: "-cp '${lib.optionalString (w ? classPath) w.classPath}${lib.optionalString (w ? mainClass) ":$out/lib/java/*"}'";
+        cp = w: "-cp '${lib.optionalString (w ? classPath) w.classPath}${lib.optionalString (w ? mainClass) ":$out/share/java/*"}'";
       in
       '' 
       header "Generating jar wrappers"

pkgs/build-support/setup-hooks/fix-darwin-dylib-names.sh

···
+# On Mac OS X, binaries refer to dynamic library dependencies using
+# either relative paths (e.g. "libicudata.dylib", searched relative to
+# $DYLD_LIBRARY_PATH) or absolute paths
+# (e.g. "/nix/store/.../lib/libicudata.dylib").  In Nix, the latter is
+# preferred since it allows programs to just work.  When linking
+# against a library (e.g. "-licudata"), the linker uses the install
+# name embedded in the dylib (which can be shown using "otool -D").
+# Most packages create dylibs with absolute install names, but some do
+# not.  This setup hook fixes dylibs by setting their install names to
+# their absolute path (using "install_name_tool -id").  It also
+# rewrites references in other dylibs to absolute paths.
+
+fixDarwinDylibNames() {
+    local flags=()
+    local old_id
+
+    for fn in "$@"; do
+        flags+=(-change "$(basename "$fn")" "$fn")
+    done
+
+    for fn in "$@"; do
+        if [ -L "$fn" ]; then continue; fi
+        echo "$fn: fixing dylib"
+        install_name_tool -id "$fn" "${flags[@]}" "$fn"
+    done
+}
+
+fixDarwinDylibNamesIn() {
+    local dir="$1"
+    fixDarwinDylibNames $(find "$dir" -name "*.dylib")
+}
+
+postFixup() {
+    fixDarwinDylibNamesIn "$prefix"
+}

pkgs/build-support/setup-hooks/set-java-classpath.sh

···
+# This setup hook adds every JAR in the share/java subdirectories of
+# the build inputs to $CLASSPATH.
+
+export CLASSPATH
+
+addPkgToClassPath () {
+    local jar
+    for jar in $1/share/java/*.jar; do
+        export CLASSPATH=''${CLASSPATH}''${CLASSPATH:+:}''${jar}
+    done
+}
+
+envHooks=(''${envHooks[@]} addPkgToClassPath)

pkgs/build-support/vm/default.nix

···
     args = ["-e" (vmRunCommand qemuCommandLinux)];
     origArgs = attrs.args;
     origBuilder = attrs.builder;
-    QEMU_OPTS = "-m ${toString (attrs.memSize or 512)}";
+    QEMU_OPTS = "${attrs.QEMU_OPTS or ""} -m ${toString (attrs.memSize or 512)}";
   });
 
 
···
         url = mirror://fedora/linux/releases/8/Everything/i386/os/repodata/primary.xml.gz;
         sha256 = "0kwf0jcp63pygpvgvwl4w58pph24xbcy6db6fnq2f3ly5myhz53n";
       };
-      urlPrefix = mirror://fedora/linux/releases/8/Everything/i386/os;
+      urlPrefix = http://archives.fedoraproject.org/pub/archive/fedora/linux/releases/8/Everything/i386/os;
       packages = commonFedoraPackages;
+    };
+
+    fedora8x86_64 = {
+      name = "fedora-8-x86_64";
+      fullName = "Fedora 8 (x86_64)";
+      packagesList = fetchurl {
+        url = mirror://fedora/linux/releases/8/Everything/x86_64/os/repodata/primary.xml.gz;
+        sha256 = "11bfmpy3nz82zzmj5lfravvzlw514v4718adi4b06ps9zv3zpy8r";
+      };
+      urlPrefix = http://archives.fedoraproject.org/pub/archive/fedora/linux/releases/8/Everything/x86_64/os;
+      packages = commonFedoraPackages;
+      archs = ["noarch" "x86_64"];
     };
 
     fedora9i386 = {
···
       packages = commonOpenSUSEPackages;
     };
 
-    centos64i386 = {
-      name = "centos-6.4-i386";
-      fullName = "CentOS 6.4 (i386)";
+    centos65i386 = {
+      name = "centos-6.5-i386";
+      fullName = "CentOS 6.5 (i386)";
       packagesList = fetchurl {
-        url = http://mirror.centos.org/centos/6.4/os/i386/repodata/87aa4c4e19f9a3ec93e3d820f1ea6b6ece8810cb45f117a16354465e57a1b50d-primary.xml.gz;
-        sha256 = "03dml5bmwijlcfhigwa5rc88ikkfdgmg286qwf9yr8zr3574ral7";
+        url = http://mirror.centos.org/centos/6.5/os/i386/repodata/a89f27cc7d3cea431f3bd605a1e9309c32d5d409abc1b51a7b5c71c05f18a0c2-primary.xml.gz;
+        sha256 = "1hm031gw0wawgcdbbhdb17adaclw63ls21fn7cgl7siwgp62g7x8";
       };
-      urlPrefix = http://mirror.centos.org/centos/6.4/os/i386/ ;
+      urlPrefix = http://mirror.centos.org/centos/6.5/os/i386/ ;
       archs = ["noarch" "i386"];
       packages = commonCentOSPackages;
     };
 
-    centos64x86_64 = {
-      name = "centos-6.4-x86_64";
-      fullName = "CentOS 6.4 (x86_64)";
+    centos65x86_64 = {
+      name = "centos-6.5-x86_64";
+      fullName = "CentOS 6.5 (x86_64)";
       packagesList = fetchurl {
-        url = http://mirror.centos.org/centos/6.4/os/x86_64/repodata/4d4030b92f010f466eb4f004312b9f532b9e85e60c5e6421e8b429c180ac1efe-primary.xml.gz;
-        sha256 = "1zhymj0c2adlx0hn8phcws2rwaskkwmk217hnip4c3q15ywk0h2d";
+        url = http://mirror.centos.org/centos/6.5/os/x86_64/repodata/3353e378f5cb4bb6c3b3dd2ca266c6d68a1e29c36cf99f76aea3d8e158626024-primary.xml.gz;
+        sha256 = "0930c9cf3n53mrv9zybcqclix2nnqrka4b6xng1vcjybymwf6lrk";
       };
-      urlPrefix = http://mirror.centos.org/centos/6.4/os/x86_64/ ;
+      urlPrefix = http://mirror.centos.org/centos/6.5/os/x86_64/ ;
       archs = ["noarch" "x86_64"];
       packages = commonCentOSPackages;
     };

pkgs/desktops/gnome-3/core/evince/default.nix

···
     # by `g_file_info_get_content_type ()'.
     wrapProgram "$out/bin/evince" \
       --set GDK_PIXBUF_MODULE_FILE ${librsvg}/lib/gdk-pixbuf/loaders.cache \
-      --prefix XDG_DATA_DIRS : "${gnome3.gnome_icon_theme}/share:${gnome3.gsettings_desktop_schemas}/share:${shared_mime_info}/share:$out/share"
+      --prefix XDG_DATA_DIRS : "${gnome3.gnome_icon_theme}/share:${gnome3.gsettings_desktop_schemas}/share:${gtk3}/share:${shared_mime_info}/share:$out/share"
   '';
+
   doCheck = false; # would need pythonPackages.dogTail, which is missing
 
   meta = with stdenv.lib; {
···
 
     license = "GPLv2+";
     platforms = platforms.linux;
+    maintainers = [ maintainers.vcunat ];
   };
 }

pkgs/desktops/xfce/applications/xfce4-screenshooter.nix

···
+{ stdenv, fetchurl, pkgconfig, intltool, xfce4panel, libxfce4util, gtk, libsoup
+, exo}:
+
+stdenv.mkDerivation rec {
+  p_name  = "xfce4-screenshooter";
+  ver_maj = "1.8";
+  ver_min = "1";
+
+  src = fetchurl {
+    url = "mirror://xfce/src/apps/${p_name}/${ver_maj}/${name}.tar.bz2";
+    sha256 = "40419892bd28989315eed053c159bba0f4264ed8c6c6738806024e481eab9492";
+  };
+  name = "${p_name}-${ver_maj}.${ver_min}";
+
+  buildInputs = [
+    pkgconfig intltool xfce4panel libxfce4util gtk libsoup exo
+  ];
+
+  meta = {
+    homepage = http://goodies.xfce.org/projects/applications/xfce4-screenshooter;
+    description = "Xfce screenshooter";
+    license = "GPLv2+";
+  };
+}

pkgs/desktops/xfce/default.nix

···
   xfce4notifyd    = callPackage ./applications/xfce4-notifyd.nix { };
   xfce4taskmanager= callPackage ./applications/xfce4-taskmanager.nix { };
   xfce4terminal   = callPackage ./applications/terminal.nix { };
+  xfce4screenshooter   = callPackage ./applications/xfce4-screenshooter.nix { };
 
   #### ART                  from "mirror://xfce/src/art/${p_name}/${ver_maj}/${name}.tar.bz2"
 

pkgs/development/compilers/closure/default.nix

···
   buildInputs = [ gnutar ];
 
   installPhase = ''
-    mkdir -p $out/lib/java $out/bin
+    mkdir -p $out/share/java $out/bin
     tar -xzf $src
-    cp -r compiler.jar $out/lib/java/
+    cp -r compiler.jar $out/share/java/
     echo "#!${bash}/bin/bash" > $out/bin/closure-compiler
-    echo "${jre}/bin/java -jar $out/lib/java/compiler.jar \"\$@\"" >> $out/bin/closure-compiler
+    echo "${jre}/bin/java -jar $out/share/java/compiler.jar \"\$@\"" >> $out/bin/closure-compiler
     chmod +x $out/bin/closure-compiler
   '';
 

pkgs/development/compilers/gcc/4.8/default.nix

···
     enableParallelBuilding = !profiledCompiler;
 
     patches = []
+      ++ optional stdenv.isArm ./arm-eabi.patch
       ++ optional enableParallelBuilding ./parallel-bconfig.patch
-      ++ optional stdenv.isArm [ ./arm-eabi.patch ]
       ++ optional (cross != null) ./libstdc++-target.patch
       # ++ optional noSysDirs ./no-sys-dirs.patch
       # The GNAT Makefiles did not pay attention to CFLAGS_FOR_TARGET for its

pkgs/development/compilers/llvm/default.nix

···
-{ stdenv, fetchurl, perl, groff, cmake, python, libffi, binutils }:
+{ stdenv, fetchurl, perl, groff, cmake, python, libffi, binutils, version }:
 
-let version = "3.3"; in
+with { inherit (stdenv.lib) optional; };
+
+assert version == "3.4" || version == "3.3";
 
 stdenv.mkDerivation rec {
   name = "llvm-${version}";
 
   src = fetchurl {
     url    = "http://llvm.org/releases/${version}/llvm-${version}.src.tar.gz";
-    sha256 = "0y3mfbb5qzcpw3v5qncn69x1hdrrrfirgs82ypi2annhf0g6nxk8";
+    sha256 =
+      if version == "3.4" then "0a169ba045r4apb9cv6ncrwl83l7yiajnzirkcdlhj1cd4nn3995"
+        else       /*3.3*/     "0y3mfbb5qzcpw3v5qncn69x1hdrrrfirgs82ypi2annhf0g6nxk8";
   };
 
-  patches = [
-    ./more-memory-for-bugpoint.patch # The default rlimits are too low for shared libraries.
-    ./no-rule-aarch64.patch # http://llvm.org/bugs/show_bug.cgi?id=16625
-  ];
+  patches =
+  	# The default rlimits in 3.3 are too low for shared libraries.
+    optional (version == "3.3") ./more-memory-for-bugpoint.patch
+    ++ [ ./no-rule-aarch64.patch ] # http://llvm.org/bugs/show_bug.cgi?id=16625
+  ;
 
   # libffi was propagated before, but it wasn't even being used, so
   # unless something needs it just an input is fine.
···
     "-DCMAKE_BUILD_TYPE=Release"
     "-DLLVM_ENABLE_FFI=ON"
     "-DLLVM_BINUTILS_INCDIR=${binutils}/include"
-    "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=R600" # for mesa
-  ] ++ lib.optional (!isDarwin) "-DBUILD_SHARED_LIBS=ON";
+  ]
+    ++ optional (version == "3.3") "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=R600" # for mesa
+    ++ optional (!isDarwin) "-DBUILD_SHARED_LIBS=ON";
 
   enableParallelBuilding = true;
 

pkgs/development/compilers/openjdk-darwin/default.nix

···
 {stdenv, fetchurl, ...}:
+let
+jdk = stdenv.mkDerivation {
+    name = "openjdk6-b16-24_apr_2009-r1";
 
-stdenv.mkDerivation {
-  name = "openjdk6-b16-24_apr_2009-r1";
+    src = fetchurl {
+      url = http://hg.bikemonkey.org/archive/openjdk6_darwin/openjdk6-b16-24_apr_2009-r1.tar.bz2;
+      sha256 = "14pbv6jjk95k7hbgiwyvjdjv8pccm7m8a130k0q7mjssf4qmpx1v";
+    };
 
-  src = fetchurl {
-    url = http://hg.bikemonkey.org/archive/openjdk6_darwin/openjdk6-b16-24_apr_2009-r1.tar.bz2;
-    sha256 = "14pbv6jjk95k7hbgiwyvjdjv8pccm7m8a130k0q7mjssf4qmpx1v";
-  };
+    installPhase = ''
+      mkdir -p $out
+      cp -vR * $out/
+    '';
 
-  installPhase = ''
-    mkdir -p $out
-    cp -vR * $out/
-  '';
+    passthru.jre = jdk;
 
-}
+  };
+in jdk

pkgs/development/compilers/openjdk/default.nix

···
-{ stdenv
-, fetchurl
-, unzip
-, zip
-, procps
-, coreutils
-, alsaLib
-, ant
-, freetype
-, cups
-, which
-, jdk
-, nettools
-, libX11
-, libXt
-, libXext
-, libXrender
-, libXtst
-, libXi
-, libXinerama
-, libXcursor
-, fontconfig
-, cpio
-, cacert
-, jreOnly ? false
-, perl
-}:
+{ stdenv, fetchurl, unzip, zip, procps, coreutils, alsaLib, ant, freetype, cups
+, which, jdk, nettools, libX11, libXt, libXext, libXrender, libXtst, libXi, libXinerama
+, libXcursor, fontconfig, cpio, cacert, perl, setJavaClassPath }:
 
 let
 
···
 in
 
 stdenv.mkDerivation rec {
-  name = "openj${if jreOnly then "re" else "dk"}-7u${update}b${build}";
+  name = "openjdk-7u${update}b${build}";
 
   src = fetchurl {
     url = http://www.java.net/download/openjdk/jdk7u40/promoted/b43/openjdk-7u40-fcs-src-b43-26_aug_2013.zip;
     sha256 = "15h5nmbw6yn5596ccakqdbs0vd8hmslsfg5sfk8wmjvn31bfmy00";
   };
 
-  #  outputs = [ "out" ] ++ stdenv.lib.optionals (! jreOnly) [ "jre" ];
+  outputs = [ "out" "jre" ];
 
-  buildInputs = [
-    unzip
-    procps
-    ant
-    which
-    zip
-    cpio
-    nettools
-    alsaLib
-    libX11
-    libXt
-    libXext
-    libXrender
-    libXtst
-    libXi
-    libXinerama
-    libXcursor
-    fontconfig
-    perl
-  ];
+  buildInputs =
+    [ unzip procps ant which zip cpio nettools alsaLib
+      libX11 libXt libXext libXrender libXtst libXi libXinerama libXcursor
+      fontconfig perl
+    ];
 
   NIX_LDFLAGS = "-lfontconfig -lXcursor -lXinerama";
 
···
 
     sed -i "s@/bin/echo -e@${coreutils}/bin/echo -e@" \
       openjdk/{jdk,corba}/make/common/shared/Defs-utils.gmk
-
-    sed -i "s@<Xrender.h>@<X11/extensions/Xrender.h>@" \
-      openjdk/jdk/src/solaris/native/sun/java2d/x11/XRSurfaceData.c
   '';
 
   patches = [ ./cppflags-include-fix.patch ];
+
+  NIX_NO_SELF_RPATH = true;
 
   makeFlags = [
     "SORT=${coreutils}/bin/sort"
···
     "UNLIMITED_CRYPTO=1"
   ];
 
-  configurePhase = ''
-    make $makeFlags sanity
-  '';
+  configurePhase = "true";
 
   installPhase = ''
-    mkdir -p $out
-    cp -av build/*/j2${if jreOnly then "re" else "sdk"}-image/* $out
+    mkdir -p $out/lib/openjdk $out/share $jre/lib/openjdk
+
+    cp -av build/*/j2sdk-image/* $out/lib/openjdk
+
+    # Move some stuff to top-level.
+    mv $out/lib/openjdk/include $out/include
+    mv $out/lib/openjdk/man $out/share/man
 
     # Remove some broken manpages.
     rm -rf $out/share/man/ja*
 
     # Remove crap from the installation.
-    rm -rf $out/demo $out/sample
+    rm -rf $out/lib/openjdk/demo $out/lib/openjdk/sample
+
+    # Move the JRE to a separate output.
+    mv $out/lib/openjdk/jre $jre/lib/openjdk/
+    ln -s $jre/lib/openjdk/jre $out/lib/openjdk/jre
+
+    # Remove duplicate binaries.
+    for i in $(cd $out/lib/openjdk/bin && echo *); do
+      if cmp -s $out/lib/openjdk/bin/$i $jre/lib/openjdk/jre/bin/$i; then
+        ln -sfn $jre/lib/openjdk/jre/bin/$i $out/lib/openjdk/bin/$i
+      fi
+    done
 
     # Generate certificates.
-    pushd $out/${if ! jreOnly then "jre/" else ""}lib/security
+    pushd $jre/lib/openjdk/jre/lib/security
     rm cacerts
-    perl ${./generate-cacerts.pl} $out/bin/keytool ${cacert}/etc/ca-bundle.crt
+    perl ${./generate-cacerts.pl} $jre/lib/openjdk/jre/bin/keytool ${cacert}/etc/ca-bundle.crt
     popd
+
+    ln -s $out/lib/openjdk/bin $out/bin
+    ln -s $jre/lib/openjdk/jre/bin $jre/bin
+  ''; # */
+
+  # FIXME: this is unnecessary once the multiple-outputs branch is merged.
+  preFixup = ''
+    prefix=$jre stripDirs "$stripDebugList" "''${stripDebugFlags:--S}"
+    patchELF $jre
+    propagatedNativeBuildInputs+=" $jre"
+
+    # Propagate the setJavaClassPath setup hook from the JRE so that
+    # any package that depends on the JRE has $CLASSPATH set up
+    # properly.
+    mkdir -p $jre/nix-support
+    echo -n "${setJavaClassPath}" > $jre/nix-support/propagated-native-build-inputs
+
+    # Set JAVA_HOME automatically.
+    mkdir -p $out/nix-support
+    cat <<EOF > $out/nix-support/setup-hook
+    if [ -z "\$JAVA_HOME" ]; then export JAVA_HOME=$out/lib/openjdk; fi
+    EOF
   '';
-#  '' + (if jreOnly then "" else ''
-#    if [ -z $jre ]; then
-#      exit 0
-#    fi
-#    mkdir -p $jre
-#    cp -av build/*/j2re-image/* $jre
-#  '');
 
   meta = {
     homepage = http://openjdk.java.net/;
-
     license = "GPLv2";
-
     description = "The open-source Java Development Kit";
-
     maintainers = [ stdenv.lib.maintainers.shlevy ];
-
     platforms = stdenv.lib.platforms.linux;
   };
 

pkgs/development/compilers/polyml/default.nix

···
 {stdenv, fetchurl}:
 
 let
-  version = "5.4.1";
+  version = "5.5.1";
 in
 
 stdenv.mkDerivation {
···
 
   src = fetchurl {
     url = "mirror://sourceforge/polyml/polyml.${version}.tar.gz";
-    sha256 = "514d1d07be487b783d4dfa29dbd550b3396640579ce135a9eb5a61f08e7f9cac";
+    sha256 = "16i0ir5mydl7381aijihkll19khp3z8dq0g2ja6k0pcbpkd0k06g";
   };
 
   meta = {

pkgs/development/compilers/swi-prolog/default.nix

···
-{ stdenv, fetchurl, gmp, readline, openssl, libjpeg, unixODBC, zlib,
-   libXinerama, libXft, libXpm, libSM, libXt, freetype, pkgconfig,
-   fontconfig }:
+{ stdenv, fetchurl, gmp, readline, openssl, libjpeg, unixODBC, zlib
+, libXinerama, libXft, libXpm, libSM, libXt, freetype, pkgconfig
+, fontconfig
+}:
 
 let
-  version = "6.4.1";
+  version = "6.6.1";
 in
 stdenv.mkDerivation {
   name = "swi-prolog-${version}";
 
   src = fetchurl {
     url = "http://www.swi-prolog.org/download/stable/src/pl-${version}.tar.gz";
-    sha256 = "1szqqwypqfd0qr3sk0qlip1ar22kpqgba6b44klmr1aag0lrahs8";
+    sha256 = "033b7z60jd1907p9idaa3xzbid2aadhqcdwsa2g9c1c7q8fj1gy8";
   };
 
-  buildInputs = [gmp readline openssl libjpeg unixODBC libXinerama
-    libXft libXpm libSM libXt zlib freetype pkgconfig fontconfig];
+  buildInputs = [ gmp readline openssl libjpeg unixODBC libXinerama
+    libXft libXpm libSM libXt zlib freetype pkgconfig fontconfig ];
+
   configureFlags = "--with-world --enable-gmp --enable-shared";
-  makeFlags = "world";
+
+  buildFlags = "world";
 
   meta = {
     homepage = http://www.swi-prolog.org/;
     description = "A Prolog compiler and interpreter";
     license = "LGPL";
 
-    platforms = stdenv.lib.platforms.unix;
+    hydraPlatforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/development/eclipse/ecj/default.nix

···
-{ stdenv, fetchurl, unzip, ant, gcj }:
+{ stdenv, fetchurl, unzip, ant, jdk, makeWrapper }:
 
 let
   version = "3.7.2";
   date    = "201202080800";
-  isGCJ   = stdenv.lib.strings.substring 0 3 gcj.name == "gcj";
-  javaExec  = if isGCJ then "gij" else "java";
-  javaFlags = if isGCJ then "--cp" else "-cp";
 in
-  stdenv.mkDerivation rec {
-    name = "ecj-${version}";
 
-    src = fetchurl {
-      url = "http://eclipse.ialto.org/eclipse/downloads/drops/R-${version}-${date}/ecjsrc-${version}.jar";
-      sha256 = "0swyysbyfmv068x8q1c5jqpwk5zb4xahg17aypx5rwb660f8fpbm";
-    };
+stdenv.mkDerivation rec {
+  name = "ecj-${version}";
 
-    buildInputs = [ unzip ant gcj ];
+  src = fetchurl {
+    url = "http://eclipse.ialto.org/eclipse/downloads/drops/R-${version}-${date}/ecjsrc-${version}.jar";
+    sha256 = "0swyysbyfmv068x8q1c5jqpwk5zb4xahg17aypx5rwb660f8fpbm";
+  };
 
-    unpackPhase = ''
-      mkdir "${name}"
-      cd "${name}"
-      unzip "$src"
-    '';
+  buildInputs = [ unzip ant jdk makeWrapper ];
 
-    # Use whatever compiler Ant knows.
-    buildPhase = "ant build";
+  unpackPhase = ''
+    mkdir "${name}"
+    cd "${name}"
+    unzip "$src"
+  '';
 
-    installPhase = ''
-      mkdir -pv "$out/lib/java"
-      cp -v *.jar "$out/lib/java"
+  # Use whatever compiler Ant knows.
+  buildPhase = "ant build";
 
-      mkdir -pv "$out/bin"
-      cat > "$out/bin/ecj" <<EOF
-#! /bin/sh
-exec "$(type -P ${javaExec})" ${javaFlags} "$out/lib/java/ecj.jar" org.eclipse.jdt.internal.compiler.batch.Main \$@
-EOF
+  installPhase = ''
+    mkdir -pv $out/share/java
+    cp -v *.jar $out/share/java
 
-      chmod u+x "$out/bin/ecj"
-    '';
+    mkdir -pv $out/bin
+    makeWrapper ${jdk.jre}/bin/java $out/bin/ecj \
+      --add-flags "-cp $out/share/java/ecj.jar org.eclipse.jdt.internal.compiler.batch.Main"
 
-    meta = {
-      description = "The Eclipse Compiler for Java (ECJ)";
+    # Add a setup hook that causes Ant to use the ECJ.
+    mkdir -p $out/nix-support
+    cat <<EOF > $out/nix-support/setup-hook
+    export NIX_ANT_ARGS="-Dbuild.compiler=org.eclipse.jdt.core.JDTCompilerAdapter \$NIX_ANT_ARGS"
+    EOF
+  '';
 
-      longDescription = ''
-        ECJ is an incremental Java compiler.  Implemented as an Eclipse
-        builder, it is based on technology evolved from VisualAge for Java
-        compiler.  In particular, it allows users to run and debug code which
-        still contains unresolved errors.
-      '';
+  meta = {
+    description = "The Eclipse Compiler for Java (ECJ)";
 
-      homepage = http://www.eclipse.org/jdt/core/index.php;
+    longDescription = ''
+      ECJ is an incremental Java compiler.  Implemented as an Eclipse
+      builder, it is based on technology evolved from VisualAge for Java
+      compiler.  In particular, it allows users to run and debug code which
+      still contains unresolved errors.
+    '';
+
+    homepage = http://www.eclipse.org/jdt/core/index.php;
 
-      # http://www.eclipse.org/legal/epl-v10.html (free software, copyleft)
-      license = "EPLv1.0";
+    # http://www.eclipse.org/legal/epl-v10.html (free software, copyleft)
+    license = "EPLv1.0";
 
-      maintainers = [ ];
-    };
-  }
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/development/interpreters/clojure/binary.nix

···
-{stdenv, fetchurl, unzip}:
-
-stdenv.mkDerivation rec {
-  version = "1.5.1";
-  name = "clojure-binary-${version}";
-
-  src = fetchurl {
-    url = "http://repo1.maven.org/maven2/org/clojure/clojure/${version}/clojure-${version}.zip";
-    sha256 = "1qgiji6ddvv40khp3qb3xfz09g7p4nnsh3pywqglb9f16v534yzy";
-  };
-
-
-  buildInputs = [ unzip ];
-
-  phases = "unpackPhase installPhase";
-
-  installPhase = "
-    mkdir -p $out/lib/java
-    cp clojure-${version}.jar clojure.jar
-    install -t $out/lib/java clojure.jar
-  ";
-
-  meta = {
-    description = "a Lisp dialect for the JVM";
-    homepage = http://clojure.org/;
-    license = stdenv.lib.licenses.bsd3;
-    longDescription = ''
-      Clojure is a dynamic programming language that targets the Java
-      Virtual Machine. It is designed to be a general-purpose language,
-      combining the approachability and interactive development of a
-      scripting language with an efficient and robust infrastructure for
-      multithreaded programming. Clojure is a compiled language - it
-      compiles directly to JVM bytecode, yet remains completely
-      dynamic. Every feature supported by Clojure is supported at
-      runtime. Clojure provides easy access to the Java frameworks, with
-      optional type hints and type inference, to ensure that calls to Java
-      can avoid reflection.
-
-      Clojure is a dialect of Lisp, and shares with Lisp the code-as-data
-      philosophy and a powerful macro system. Clojure is predominantly a
-      functional programming language, and features a rich set of immutable,
-      persistent data structures. When mutable state is needed, Clojure
-      offers a software transactional memory system and reactive Agent
-      system that ensure clean, correct, multithreaded designs.
-    '';
-  };
-}

pkgs/development/interpreters/clojure/clooj-wrapper.nix

···
-{writeTextFile, jre, clooj}:
-
-writeTextFile {
-  name = "clooj-wrapper";
-  executable = true;
-  destination = "/bin/clooj";
-  text = ''
-    #!/bin/sh
-    exec ${jre}/bin/java -jar ${clooj}/lib/java/clooj.jar
-  '';
-}

pkgs/development/interpreters/clojure/clooj.nix

···
-{stdenv, fetchurl}:
+{ stdenv, fetchurl, jre, makeWrapper }:
 
-let
+let version = "0.4.4"; in
+
+stdenv.mkDerivation {
+  name = "clooj-${version}";
+
   jar = fetchurl {
-    url = https://github.com/downloads/arthuredelstein/clooj/clooj-0.1.36-STANDALONE.jar;
-    sha256 = "173c66c0aade3ae5d21622f629e60efa51a03ad83c087b02c25e806c5b7f838c";
+    url = "http://www.mediafire.com/download/prkf64humftrmz3/clooj-${version}-standalone.jar";
+    sha256 = "0hbc29bg2a86rm3sx9kvj7h7db9j0kbnrb706wsfiyk3zi3bavnd";
   };
-in
 
-stdenv.mkDerivation {
-  name = "clooj-0.1.32";
+  buildInputs = [ makeWrapper ];
 
   phases = "installPhase";
 
   installPhase = ''
-    mkdir -p $out/lib/java
-    ln -s ${jar} $out/lib/java/clooj.jar
+    mkdir -p $out/share/java
+    ln -s $jar $out/share/java/clooj.jar
+    makeWrapper ${jre}/bin/java $out/bin/clooj --add-flags "-jar $out/share/java/clooj.jar"
   '';
 
   meta = {
-    description = "clooj, a lightweight IDE for clojure";
+    description = "A lightweight IDE for Clojure";
     homepage = https://github.com/arthuredelstein/clooj;
     license = stdenv.lib.licenses.bsd3;
   };

pkgs/development/interpreters/clojure/default.nix

···
-{stdenv, fetchurl, unzip, ant, version ? "1.4.0" }:
+{ stdenv, fetchurl, unzip, ant, jdk, makeWrapper }:
+
+let version = "1.5.1"; in
 
-let 
-  src_hashes = {
-    "1.4.0" = "27a5a151d5cc1bc3e52dff47c66111e637fefeb42d9bedfa1284a1a31d080171";
-    "1.5.0-RC1" = "111jm0nxkvqr1vrwcpvr70v5paasp8msrj5h8zm1c144c8zc1vln";
-  };
-in 
 stdenv.mkDerivation {
   name = "clojure-${version}";
 
   src = fetchurl {
     url = "http://repo1.maven.org/maven2/org/clojure/clojure/${version}/clojure-${version}.zip";
-    sha256 = (builtins.getAttr version src_hashes); 
+    sha256 = "1qgiji6ddvv40khp3qb3xfz09g7p4nnsh3pywqglb9f16v534yzy";
   };
 
-  buildInputs = [ unzip ant ];
+  buildInputs = [ unzip ant jdk makeWrapper ];
 
   buildPhase = "ant jar";
 
-  installPhase = "
-    mkdir -p $out/lib/java
-    install -t $out/lib/java clojure.jar
-  ";
+  installPhase = ''
+    mkdir -p $out/share/java $out/bin
+    install -t $out/share/java clojure.jar
+    makeWrapper ${jdk.jre}/bin/java $out/bin/clojure --add-flags "-cp $out/share/java/clojure.jar clojure.main"
+  '';
 
   meta = {
-    description = "a Lisp dialect for the JVM";
+    description = "A Lisp dialect for the JVM";
     homepage = http://clojure.org/;
     license = stdenv.lib.licenses.bsd3;
     longDescription = ''

pkgs/development/interpreters/clojure/wrapper.nix

···
-{writeTextFile, jre, clojure}:
-
-writeTextFile {
-  name = "clojure-wrapper";
-  executable = true;
-  destination = "/bin/clojure";
-  text = ''
-    #!/bin/sh
-    exec ${jre}/bin/java -cp ${clojure}/lib/java/clojure.jar clojure.main
-  '';
-}

pkgs/development/interpreters/io/default.nix

···
 }:
 
 stdenv.mkDerivation {
-  name = "io-2011.09.12";
+  name = "io-2013.12.04";
   src = fetchurl {
-    url = http://github.com/stevedekorte/io/tarball/2011.09.12;
-    name = "io-2011.09.12.tar.gz";
-    sha256 = "14nhk5vkk74pbf36jsfaxqh2ihi5d7jby79yf1ibbax319xbjk3v";
+    url = http://github.com/stevedekorte/io/tarball/2013.12.04;
+    name = "io-2013.12.04.tar.gz";
+    sha256 = "0kvwr32xdpcr32rnv301xr5l89185dsisbj4v465m68isas0gjm5";
   };
 
   buildInputs = [

pkgs/development/interpreters/kaffe/builder.sh

···
-source $stdenv/setup || exit 1
-
-configureFlags="--with-jikes=$jikes/bin/jikes --enable-pure-java-math"
-genericBuild
-

pkgs/development/interpreters/kaffe/default.nix

···
-{stdenv, fetchurl, alsaLib, xlibs, jikes}:
-
-stdenv.mkDerivation {
-  name = "kaffe-1.1.4";
-  builder = ./builder.sh;
-  src = fetchurl {
-    url = ftp://ftp.kaffe.org/pub/kaffe/v1.1.x-development/kaffe-1.1.4.tar.gz;
-    md5 = "94d6e7035ba68c2221dce68bb5b3f6e9";
-  };
-  inherit jikes alsaLib;
-  inherit (xlibs) libXaw libX11;
-
-  buildInputs = [jikes alsaLib xlibs.libXaw xlibs.libX11];
-}

pkgs/development/interpreters/lua-5/5.2.nix

···
-{ stdenv, fetchurl, readline }:
+{ stdenv, fetchurl, readline, compat ? false }:
 
 let
   dsoPatch = fetchurl {
···
   patches = [ dsoPatch ];
 
   configurePhase = ''
-    makeFlagsArray=( INSTALL_TOP=$out INSTALL_MAN=$out/share/man/man1 PLAT=linux CFLAGS="-DLUA_USE_LINUX -O2 -fPIC" LDLAGS="-fPIC" V=${majorVersion} R=${version} )
+    makeFlagsArray=( INSTALL_TOP=$out INSTALL_MAN=$out/share/man/man1 PLAT=linux CFLAGS="-DLUA_USE_LINUX -O2 -fPIC${if compat then " -DLUA_COMPAT_ALL" else ""}" LDLAGS="-fPIC" V=${majorVersion} R=${version} )
     installFlagsArray=( TO_BIN="lua luac" TO_LIB="liblua.a liblua.so liblua.so.${majorVersion} liblua.so.${version}" INSTALL_DATA='cp -d' )
   '';
 

pkgs/development/interpreters/maude/default.nix

···
 
   buildInputs = [flex bison ncurses buddy tecla gmpxx libsigsegv makeWrapper];
 
-  configurePhase = ''./configure --disable-dependency-tracking --prefix=$out --datadir=$out/share/maude TECLA_LIBS="-ltecla -lncursesw" CFLAGS="-O3" CXXFLAGS="-O3"'';
+  preConfigure = ''
+    configureFlagsArray=(
+      --datadir=$out/share/maude
+      TECLA_LIBS="-ltecla -lncursesw"
+      CFLAGS="-O3" CXXFLAGS="-O3"
+    )
+  '';
 
   doCheck = true;
 
-  postInstall =
-  ''
+  postInstall = ''
     for n in "$out/bin/"*; do wrapProgram "$n" --suffix MAUDE_LIB ':' "$out/share/maude"; done
     mkdir -p $out/share/maude
     cp ${fullMaude} $out/share/maude/full-maude.maude
···
       rewriting logic computation.
     '';
 
-    platforms = stdenv.lib.platforms.all;
+    hydraPlatforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/development/interpreters/rascal/default.nix

···
+{ stdenv, fetchurl, makeWrapper, jdk }:
+
+stdenv.mkDerivation rec {
+  name = "rascal-0.6.2";
+
+  src = fetchurl {
+    url = "http://update.rascal-mpl.org/console/${name}.jar";
+    sha256 = "1z4mwdbdc3r24haljnxng8znlfg2ihm9bf9zq8apd9a32ipcw4i6";
+  };
+
+  buildInputs = [ makeWrapper jdk ];
+
+  unpackPhase = "true";
+
+  installPhase =
+    ''
+      mkdir -p $out/bin
+      makeWrapper ${jdk}/bin/java $out/bin/rascal \
+        --add-flags "-Djava.home=$JAVA_HOME -jar ${src}" \
+    '';
+
+  meta = {
+    homepage = http://www.rascal-mpl.org/;
+    description = "Command-line REPL for the Rascal metaprogramming language";
+    license = stdenv.lib.licenses.epl10;
+    maintainers = [ stdenv.lib.maintainers.eelco ];
+  };
+}

pkgs/development/libraries/boost/1.55.nix

···
-{ stdenv, fetchurl, icu, expat, zlib, bzip2, python
+{ stdenv, fetchurl, icu, expat, zlib, bzip2, python, fixDarwinDylibNames
+, toolset ? null
 , enableRelease ? true
 , enableDebug ? false
 , enableSingleThreaded ? false
···
              "cflags=-fexceptions"
            else
              "";
+
+  withToolset = stdenv.lib.optionalString (toolset != null) " --with-toolset=${toolset}";
 in
 
 stdenv.mkDerivation {
···
 
   enableParallelBuilding = true;
 
-  buildInputs = [icu expat zlib bzip2 python];
+  buildInputs =
+    [ icu expat zlib bzip2 python ]
+    ++ stdenv.lib.optional stdenv.isDarwin fixDarwinDylibNames;
 
   configureScript = "./bootstrap.sh";
-  configureFlags = "--with-icu=${icu} --with-python=${python}/bin/python";
+  configureFlags = "--with-icu=${icu} --with-python=${python}/bin/python" + withToolset;
 
-  buildPhase = "./b2 -j$NIX_BUILD_CORES -sEXPAT_INCLUDE=${expat}/include -sEXPAT_LIBPATH=${expat}/lib --layout=${layout} variant=${variant} threading=${threading} link=${link} ${cflags} install";
+  buildPhase = "${stdenv.lib.optionalString (toolset == "clang") "unset NIX_ENFORCE_PURITY; "}./b2 -j$NIX_BUILD_CORES -sEXPAT_INCLUDE=${expat}/include -sEXPAT_LIBPATH=${expat}/lib --layout=${layout} variant=${variant} threading=${threading} link=${link} ${cflags} install${withToolset}";
 
   # normal install does not install bjam, this is a separate step
   installPhase = ''
     cd tools/build/v2
-    sh bootstrap.sh
-    ./b2 -j$NIX_BUILD_CORES -sEXPAT_INCLUDE=${expat}/include -sEXPAT_LIBPATH=${expat}/lib --layout=${layout} variant=${variant} threading=${threading} link=${link} ${cflags} install
+    sh bootstrap.sh${withToolset}
+    ./b2 -j$NIX_BUILD_CORES -sEXPAT_INCLUDE=${expat}/include -sEXPAT_LIBPATH=${expat}/lib --layout=${layout} variant=${variant} threading=${threading} link=${link} ${cflags} install${withToolset}
+    rm $out/bin/bjam
+    ln -s $out/bin/b2 $out/bin/bjam
   '';
 
   crossAttrs = rec {

pkgs/development/libraries/cppunit/default.nix

···
   meta = {
     homepage = "http://sourceforge.net/apps/mediawiki/cppunit/";
     description = "C++ unit testing framework";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
     maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

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

···
 { stdenv, fetchurl, config, pkgconfig, yasm, zlib, bzip2, alsaLib, texinfo, perl
 , lame, speex, libtheora, libvorbis, libvpx, x264, xvidcore, libopus
 , libvdpau, libva, faac, libdc1394, libXext, libXfixes, SDL
-, freetype, fontconfig, fdk_aac
+, freetype, fontconfig, fdk_aac, gnutls
 }:
 
 stdenv.mkDerivation rec {
···
   x11grabSupport = config.ffmpeg.x11grab or false;
   playSupport = config.ffmpeg.play or true;
   freetypeSupport = config.ffmpeg.freetype or true;
+  gnutlsSupport = config.ffmpeg.gnutls or true;
 
   # `--enable-gpl' (as well as the `postproc' and `swscale') mean that
   # the resulting library is GPL'ed, so it can only be used in GPL'ed
···
     ++ stdenv.lib.optional x11grabSupport "--enable-x11grab"
     ++ stdenv.lib.optional playSupport "--enable-ffplay"
     ++ stdenv.lib.optional freetypeSupport "--enable-libfreetype --enable-fontconfig"
-    ++ stdenv.lib.optional fdkAACSupport "--enable-libfdk_aac --enable-nonfree";
+    ++ stdenv.lib.optional fdkAACSupport "--enable-libfdk_aac --enable-nonfree"
+    ++ stdenv.lib.optional gnutlsSupport "--enable-gnutls";
 
   buildInputs = [ pkgconfig lame yasm zlib bzip2 alsaLib texinfo perl ]
     ++ stdenv.lib.optional mp3Support lame
···
     ++ stdenv.lib.optionals x11grabSupport [ libXext libXfixes ]
     ++ stdenv.lib.optional playSupport SDL
     ++ stdenv.lib.optionals freetypeSupport [ freetype fontconfig ]
-    ++ stdenv.lib.optional fdkAACSupport fdk_aac;
+    ++ stdenv.lib.optional fdkAACSupport fdk_aac
+    ++ stdenv.lib.optional gnutlsSupport gnutls;
 
   enableParallelBuilding = true;
 

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

···
 
 cabal.mkDerivation (self: {
   pname = "SHA";
-  version = "1.6.2.1";
-  sha256 = "0knzwqgwshr9b0rf8mf6xmgp3qxv4yavg0zy9xz4zmgm5319mvla";
+  version = "1.6.4";
+  sha256 = "13d7sg8r0qqs425banrwd15hahy8gnl4k81q0wfqld77xpb2vvbj";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ binary ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "Stream";
-  version = "0.4.6.1";
-  sha256 = "19z052rd0varq5cbw0i0f0vkbpb40kqg6i93kz2brk6a101q5llp";
+  version = "0.4.7.1";
+  sha256 = "08h0h6pwvfcj92n7mk5za36x9agpqnax12cjlvd68zwghjf9qxy3";
   buildDepends = [ lazysmallcheck QuickCheck ];
   meta = {
     description = "A library for manipulating infinite lists";

pkgs/development/libraries/haskell/aeson-lens/default.nix

···
+{ cabal, aeson, doctest, lens, text, unorderedContainers, vector }:
+
+cabal.mkDerivation (self: {
+  pname = "aeson-lens";
+  version = "0.5.0.0";
+  sha256 = "1pr8cxkx41wi7095cp1gpqrwadwx6azcrdi1kr1ik0fs6606dkks";
+  buildDepends = [ aeson lens text unorderedContainers vector ];
+  testDepends = [ doctest ];
+  meta = {
+    description = "Lens of Aeson";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "attoparsec-enumerator";
-  version = "0.3.1";
-  sha256 = "10h6i23vhcishp599s4lbp0c46wcba99w6iv4ickdr1avrm9z2m7";
+  version = "0.3.2";
+  sha256 = "1jrrdhzqjfb78bhnjpy0j0qywqd2j67an41pcn8y6331nzmzsrl8";
   buildDepends = [ attoparsec enumerator text ];
   meta = {
     homepage = "https://john-millikin.com/software/attoparsec-enumerator/";

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

···
+{ cabal, attempt, base64Bytestring, blazeBuilder, caseInsensitive
+, cereal, conduit, cryptoApi, cryptohash, cryptohashCryptoapi
+, dataDefault, failure, filepath, httpConduit, httpTypes
+, liftedBase, monadControl, mtl, resourcet, text, time
+, transformers, utf8String, xmlConduit
+}:
+
+cabal.mkDerivation (self: {
+  pname = "aws";
+  version = "0.8.4";
+  sha256 = "0p4m07lw33wd82phwfvyr1alqx3bsafnf25n60h1mss7l0rzyn0i";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    attempt base64Bytestring blazeBuilder caseInsensitive cereal
+    conduit cryptoApi cryptohash cryptohashCryptoapi dataDefault
+    failure filepath httpConduit httpTypes liftedBase monadControl mtl
+    resourcet text time transformers utf8String xmlConduit
+  ];
+  meta = {
+    homepage = "http://github.com/aristidb/aws";
+    description = "Amazon Web Services (AWS) for Haskell";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

pkgs/development/libraries/haskell/blaze-html/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "blaze-html";
-  version = "0.6.1.2";
-  sha256 = "09a9gp40y31im763bri755if5j369a8m4kkl3c4wabq8q21y8z7m";
+  version = "0.6.1.3";
+  sha256 = "0hjyi3iv2770wicgfjipa901vk7mwr8kknfqvj3v9kzcvb4lq5aq";
   buildDepends = [ blazeBuilder blazeMarkup text ];
   testDepends = [
     blazeBuilder blazeMarkup HUnit QuickCheck testFramework

pkgs/development/libraries/haskell/blaze-markup/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "blaze-markup";
-  version = "0.5.1.6";
-  sha256 = "09w0mwws1xz0h0h99n6ppbdycnrv5y74x6asgzvrzqaslrp5rhvm";
+  version = "0.5.2.1";
+  sha256 = "1drq98q70jfbxsdf3b6n5ksr1pcy8h5cgjngg6h3kd6vww3vysdy";
   buildDepends = [ blazeBuilder text ];
   testDepends = [
     blazeBuilder HUnit QuickCheck testFramework testFrameworkHunit

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

···
 
 cabal.mkDerivation (self: {
   pname = "conduit";
-  version = "1.0.9.3";
-  sha256 = "162lf83v0cip48y7a5mgvxrxnpr1vpc4lpcr8rbh0w981wkaxk4h";
+  version = "1.0.10";
+  sha256 = "12vqh747rdldw3n42cxzd77rzb66129dc690n23q5xy7pbhzilfp";
   buildDepends = [
     liftedBase mmorph monadControl mtl resourcet text transformers
     transformersBase void

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

···
 
 cabal.mkDerivation (self: {
   pname = "crypto-conduit";
-  version = "0.5.2.1";
-  sha256 = "1i9m4pzy4ib9n941zlh398idmxcjak2496c4c73i8bmikryahl8p";
+  version = "0.5.2.2";
+  sha256 = "1969jys4za3m818jvnfcsv5hpc50bcvkrmy9lxr8fz854q01vhk2";
   buildDepends = [ cereal conduit cryptoApi transformers ];
   testDepends = [
     cereal conduit cryptoApi cryptocipher cryptohashCryptoapi hspec
     skein transformers
   ];
-  patchPhase = ''
-    sed -i -e 's|crypto-api >=.*|crypto-api|' crypto-conduit.cabal
-  '';
   jailbreak = true;
   doCheck = false;
   meta = {

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

···
+{ cabal, configurator, fgl, filepath, HDBC, HDBCPostgresql
+, HDBCSqlite3, HUnit, mtl, random, text, time, yamlLight
+}:
+
+cabal.mkDerivation (self: {
+  pname = "dbmigrations";
+  version = "0.7";
+  sha256 = "1mpmka6jszip8sm8k9mrk0fg1q7wp36n0szyiqy7fnbzijfw0xlz";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    configurator fgl filepath HDBC HDBCPostgresql HDBCSqlite3 HUnit mtl
+    random text time yamlLight
+  ];
+  meta = {
+    description = "An implementation of relational database \"migrations\"";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

pkgs/development/libraries/haskell/diagrams/contrib.nix

···
 
 cabal.mkDerivation (self: {
   pname = "diagrams-contrib";
-  version = "1.1";
-  sha256 = "1f2rcqmcf94ykas4qjfcksh89z2p0hr4s1zkcx0izphrazjyj9gq";
+  version = "1.1.0.1";
+  sha256 = "1vgfk3drs61am5z0146pq17i00ygsi2pyz8qipf6c30c9wri9hjp";
   buildDepends = [
     arithmoi circlePacking colour dataDefault dataDefaultClass
     diagramsCore diagramsLib forceLayout lens MonadRandom mtl parsec

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

···
+{ cabal, aeson, aesonLens, digestiveFunctors, HUnit, lens, mtl
+, safe, tasty, tastyHunit, text, vector
+}:
+
+cabal.mkDerivation (self: {
+  pname = "digestive-functors-aeson";
+  version = "1.1.3";
+  sha256 = "0194yd2b9irm1gmk3d8awrsrmsr4lml63wr4vm8a92s7w3hdy0db";
+  buildDepends = [
+    aeson aesonLens digestiveFunctors lens safe text vector
+  ];
+  testDepends = [
+    aeson digestiveFunctors HUnit mtl tasty tastyHunit text
+  ];
+  meta = {
+    homepage = "http://github.com/ocharles/digestive-functors-aeson";
+    description = "Run digestive-functors forms against JSON";
+    license = self.stdenv.lib.licenses.gpl3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

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

···
-{ cabal, doctest, filepath, transformers, transformersCompat }:
+{ cabal, doctest, filepath, tagged, transformers
+, transformersCompat
+}:
 
 cabal.mkDerivation (self: {
   pname = "distributive";
-  version = "0.3.2";
-  sha256 = "1n2xnjffrbfw736qn9w5fxy4pjl2319yhimkglhbayq85pz51r1h";
-  buildDepends = [ transformers transformersCompat ];
+  version = "0.4";
+  sha256 = "11zln3h7pflv1f6jfma5b505p4wnr9xrs711mhh3a8xi20n4r318";
+  buildDepends = [ tagged transformers transformersCompat ];
   testDepends = [ doctest filepath ];
   meta = {
     homepage = "http://github.com/ekmett/distributive/";

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

···
 
 cabal.mkDerivation (self: {
   pname = "encoding";
-  version = "0.6.7.2";
-  sha256 = "0b1z5824vdkcc51bd1vgcbaniw3fv9dmd5qczjc89b5lhrl7qq0d";
+  version = "0.7";
+  sha256 = "1h6yki4d3912sr8nsk1cff2pdvzw8ys6xnzi97b5ay1f8i28bmi5";
   buildDepends = [
     binary extensibleExceptions HaXml mtl regexCompat
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "esqueleto";
-  version = "1.3.4.2";
-  sha256 = "1gp0jy8ra11ansari659wqvwafw1pi2svl3w16wa5dv9xk3v9pr6";
+  version = "1.3.4.3";
+  sha256 = "1p35nzaqmpcc7slr10ihlc54kz5zv5ak0ql848m3xpbjfzq6f6vc";
   buildDepends = [
     conduit monadLogger persistent resourcet tagged text transformers
     unorderedContainers

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

···
 
 cabal.mkDerivation (self: {
   pname = "fast-logger";
-  version = "2.1.2";
-  sha256 = "0kz31jfhc40wlw3b49zcsn97y6vc9qqnaci743mgjskv4zbqaf34";
+  version = "2.1.4";
+  sha256 = "1fb75wx1v9h7690x43kd85lq1h9zi8nq438pqclzzrcfidsnm6z5";
   buildDepends = [ blazeBuilder filepath text ];
   testDepends = [ hspec ];
   meta = {

pkgs/development/libraries/haskell/ghc-mod/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ghc-mod";
-  version = "3.1.4";
-  sha256 = "1sm8wj6vcgbm91z762h6rbq68njj5384a69w4k3q0qzdyix0cxym";
+  version = "3.1.5";
+  sha256 = "1sjam6cqz9dhgsdv4sm1lgmwq5dhs9x5q3p1h7l0n34w2q7cc6if";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/gloss-raster/default.nix

···
-{ cabal, gloss, repa, llvm }:
+{ cabal, gloss, llvm, repa }:
 
 cabal.mkDerivation (self: {
   pname = "gloss-raster";
   version = "1.8.1.1";
   sha256 = "0qqk2fizmv1zdvi8lljxiqdwlmfzni4qzsdvm2jbvgg5qjx9l9qp";
-  buildDepends = [ gloss repa llvm ];
+  buildDepends = [ gloss repa ];
+  extraLibraries = [ llvm ];
   meta = {
     homepage = "http://gloss.ouroborus.net";
     description = "Parallel rendering of raster images";

pkgs/development/libraries/haskell/haskeline/0.7.1.2.nix

···
+{ cabal, filepath, terminfo, transformers, utf8String }:
+
+cabal.mkDerivation (self: {
+  pname = "haskeline";
+  version = "0.7.1.2";
+  sha256 = "178hzal5gqw3rmgijv9ph9xa6d4sld279z4a8cjyx3hv4azciwr4";
+  buildDepends = [ filepath terminfo transformers utf8String ];
+  configureFlags = "-fterminfo";
+  meta = {
+    homepage = "http://trac.haskell.org/haskeline";
+    description = "A command-line interface for user input, written in Haskell";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.andres ];
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "haskell-packages";
-  version = "0.2.3.1";
-  sha256 = "0sryw0gdwkgd53la6gryf7i5h8rlpys6j8nh75f9j014i4y1p0jw";
+  version = "0.2.3.3";
+  sha256 = "1i3x392dwryhw6k02bd2r9wn9iwwmcqzjhk7gx5lx1vhyb470qr2";
   buildDepends = [
     aeson Cabal deepseq EitherT filepath haskellSrcExts hseCpp mtl
     optparseApplicative tagged

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

···
 
 cabal.mkDerivation (self: {
   pname = "heist";
-  version = "0.13.0.3";
-  sha256 = "0aynsb74i7yzw02cqd9fhcbz6sqkid98l6gpzxssaydq7vnkpj7a";
+  version = "0.13.0.4";
+  sha256 = "15iixsjlx3zd44dcdxla5pgpl16995pk9g34zjqynmhcj7sfv5as";
   buildDepends = [
     aeson attoparsec blazeBuilder blazeHtml directoryTree dlist errors
     filepath hashable MonadCatchIOTransformers mtl random text time

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

···
 
 cabal.mkDerivation (self: {
   pname = "hexpat";
-  version = "0.20.5";
-  sha256 = "09p8mh2b76ymgfv64zpddywdf34n7b78agri6kjnhls0xsk8260a";
+  version = "0.20.6";
+  sha256 = "02ms6lchj6k0krqjk47bibfb0cbpbc16ip9f22c4rgp04qkzp60b";
   buildDepends = [ deepseq List text transformers utf8String ];
   meta = {
     homepage = "http://haskell.org/haskellwiki/Hexpat/";

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

···
+{ cabal, attoparsec, cmdargs, filepath, haskellSrcExts, lens, mtl
+, split, tasty, tastyGolden, text
+}:
+
+cabal.mkDerivation (self: {
+  pname = "hsimport";
+  version = "0.2.6.8";
+  sha256 = "0brz7lxbnkwhjlbvs7xk3012mp9419v9wpczwa3nahl5afzbsp3i";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    attoparsec cmdargs haskellSrcExts lens mtl split text
+  ];
+  testDepends = [ filepath tasty tastyGolden ];
+  doCheck = false;
+  meta = {
+    description = "A command line program for extending the import list of a Haskell source file";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "http-attoparsec";
-  version = "0.1.0";
-  sha256 = "1ncdjzgb5kv20y9kps4nawvbwaqnfil9g552if638vv8hag8cwq9";
+  version = "0.1.1";
+  sha256 = "12l892fix11mrvm10awwvv31y59q5rb6gb0sqjp6l4p4ym9ngqa3";
   buildDepends = [ attoparsec httpTypes ];
   meta = {
     homepage = "https://github.com/tlaitinen/http-attoparsec";

pkgs/development/libraries/haskell/http-client/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "http-client";
-  version = "0.2.0.3";
-  sha256 = "0dy0nf92404hlg4f4zifx6b1qs5wadgky7snqrizl5kk5af43i4h";
+  version = "0.2.1";
+  sha256 = "1hwr8pjlal88b6clmrs0cksmyy1vmbybvr78s6kb2ppwrzmd2v8q";
   buildDepends = [
     base64Bytestring blazeBuilder caseInsensitive cookie dataDefault
     deepseq failure httpTypes network publicsuffixlist text time

pkgs/development/libraries/haskell/http-common/default.nix

···
+{ cabal, base64Bytestring, blazeBuilder, caseInsensitive, mtl
+, network, text, transformers, unorderedContainers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "http-common";
+  version = "0.7.1.1";
+  sha256 = "1a0szaqs1halrv4kx57g2hd4vcdhks7pfal0hyq19af2pncaz1h8";
+  buildDepends = [
+    base64Bytestring blazeBuilder caseInsensitive mtl network text
+    transformers unorderedContainers
+  ];
+  meta = {
+    homepage = "http://research.operationaldynamics.com/projects/http-streams/";
+    description = "Common types for HTTP clients and servers";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, aeson, aesonPretty, attoparsec, base64Bytestring
+, blazeBuilder, caseInsensitive, HsOpenSSL, hspec
+, hspecExpectations, httpCommon, HUnit, ioStreams
+, MonadCatchIOTransformers, mtl, network, opensslStreams, snapCore
+, snapServer, systemFileio, systemFilepath, text, transformers
+, unorderedContainers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "http-streams";
+  version = "0.7.1.1";
+  sha256 = "0wh07gdb9w48mwsjvg07dq6gjvdm8ls654ki180r7p38v93rsmfx";
+  buildDepends = [
+    aeson attoparsec base64Bytestring blazeBuilder caseInsensitive
+    HsOpenSSL httpCommon ioStreams mtl network opensslStreams text
+    transformers unorderedContainers
+  ];
+  testDepends = [
+    aeson aesonPretty attoparsec base64Bytestring blazeBuilder
+    caseInsensitive HsOpenSSL hspec hspecExpectations httpCommon HUnit
+    ioStreams MonadCatchIOTransformers mtl network opensslStreams
+    snapCore snapServer systemFileio systemFilepath text transformers
+    unorderedContainers
+  ];
+  doCheck = false;
+  meta = {
+    homepage = "http://research.operationaldynamics.com/projects/http-streams/";
+    description = "An HTTP client using io-streams";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/httpd-shed/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "httpd-shed";
-  version = "0.4";
-  sha256 = "c03f784742bdc3053c7e867e587ee859a9a3adaa082d36bdb2ea69da1b02069f";
+  version = "0.4.0.1";
+  sha256 = "04m07wqhaggkgksha7x528y890j30ay5axipfy6b1ma9cf0a9jwq";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ network ];

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

···
+{ cabal }:
+
+cabal.mkDerivation (self: {
+  pname = "interlude";
+  version = "0.1.2";
+  sha256 = "1yiv24n0mfjzbpm9p6djllhwck3brjz9adzyp6k4fpk430304k7s";
+  meta = {
+    homepage = "http://malde.org/~ketil/";
+    description = "Replaces some Prelude functions for enhanced error reporting";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "intervals";
-  version = "0.4";
-  sha256 = "0w33arfv1hd3a3l4rvn67nh5q6w05jj6hjlbjmbmrjyhwg35jnac";
+  version = "0.4.1";
+  sha256 = "09pgy400r47lsa9w5g5dxydshw7lv9i4yv65ld1arssx3n59wyvl";
   buildDepends = [ distributive ];
   testDepends = [ doctest filepath ];
   meta = {

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

···
+{ cabal, attoparsec, blazeBuilder, deepseq, filepath, HUnit, mtl
+, network, primitive, QuickCheck, testFramework, testFrameworkHunit
+, testFrameworkQuickcheck2, text, time, transformers, vector, zlib
+, zlibBindings
+}:
+
+cabal.mkDerivation (self: {
+  pname = "io-streams";
+  version = "1.1.4.0";
+  sha256 = "0fkys15ih3ld4l5rqjlsmhdkf9w3xnhj6hbbahazx7pj0xsv1hyh";
+  buildDepends = [
+    attoparsec blazeBuilder network primitive text time transformers
+    vector zlibBindings
+  ];
+  testDepends = [
+    attoparsec blazeBuilder deepseq filepath HUnit mtl network
+    primitive QuickCheck testFramework testFrameworkHunit
+    testFrameworkQuickcheck2 text time transformers vector zlib
+    zlibBindings
+  ];
+  configureFlags = "-fNoInteractiveTests";
+  meta = {
+    description = "Simple, composable, and easy-to-use stream I/O";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "linear";
-  version = "1.3.1.1";
-  sha256 = "174pqqc2gx8aigm51hfg7di35qbx65sgcqv6y1p25c2853g9h97y";
+  version = "1.4";
+  sha256 = "1a2l68q0l2vlp4wpf5wqvpnag326s38k2ifh8hcfczjhsg9cq45a";
   buildDepends = [
     binary distributive hashable reflection semigroupoids semigroups
     tagged transformers unorderedContainers vector

pkgs/development/libraries/haskell/network-conduit-tls/default.nix

···
 { cabal, aeson, certificate, conduit, connection, cprngAes
-, cryptoApi, cryptoRandomApi, dataDefault, monadControl, network
-, networkConduit, pem, systemFileio, systemFilepath, tls, tlsExtra
-, transformers
+, cryptoApi, cryptoRandomApi, dataDefault, HUnit, monadControl, mtl
+, network, networkConduit, pem, systemFileio, systemFilepath, tls
+, tlsExtra, transformers
 }:
 
 cabal.mkDerivation (self: {
   pname = "network-conduit-tls";
-  version = "1.0.2";
-  sha256 = "0m3sbb4vpsjf568zaaxri8x7x46wngf5y2s5chgjzfmbj0amkl51";
+  version = "1.0.3";
+  sha256 = "0l8h9pfrrqzkf45cp5r8kxpzc2fi6m01s4zkrh0d226rbps3gmvc";
   buildDepends = [
     aeson certificate conduit connection cprngAes cryptoApi
     cryptoRandomApi dataDefault monadControl network networkConduit pem
     systemFileio systemFilepath tls tlsExtra transformers
   ];
+  testDepends = [ conduit connection HUnit mtl networkConduit ];
   meta = {
     homepage = "https://github.com/snoyberg/conduit";
     description = "Create TLS-aware network code with conduits";

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

···
 
 cabal.mkDerivation (self: {
   pname = "network-conduit";
-  version = "1.0.0";
-  sha256 = "16kgg6wkpl10kcwfijm9iqi7r5gababaymxyhmjab6axfzknppk3";
+  version = "1.0.1";
+  sha256 = "1argxj87a5rzza061lvvfmix2vrlz62dskj4pwlsq0d22dg8y332";
   buildDepends = [
     conduit liftedBase monadControl network transformers
   ];

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

···
+{ cabal, HsOpenSSL, HUnit, ioStreams, network, testFramework
+, testFrameworkHunit
+}:
+
+cabal.mkDerivation (self: {
+  pname = "openssl-streams";
+  version = "1.1.0.0";
+  sha256 = "0xww3n1mhw0sp9nkx4847gqbq4wnfcnc2m782kn5n8jxnjnm1fqn";
+  buildDepends = [ HsOpenSSL ioStreams network ];
+  testDepends = [
+    HsOpenSSL HUnit ioStreams network testFramework testFrameworkHunit
+  ];
+  doCheck = false;
+  meta = {
+    description = "OpenSSL network support for io-streams";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "pandoc-types";
-  version = "1.12.3";
-  sha256 = "1klfplpn2faw9da7xw5h5sx44annc2g7himyzyvb436wjnkjan0j";
+  version = "1.12.3.1";
+  sha256 = "0q9wj3vkhnvl1l2hbg9nmcbshkf23nmaylm3zmqj5j95vay60hkr";
   buildDepends = [ aeson syb ];
   meta = {
     homepage = "http://johnmacfarlane.net/pandoc";

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

···
 
 cabal.mkDerivation (self: {
   pname = "pandoc";
-  version = "1.12.3";
-  sha256 = "007pcb93s1frcyx3x4shcb6bynysy7g0hvrqlxs4991a7jp360bl";
+  version = "1.12.3.1";
+  sha256 = "0kvw10d2cnv16w9y9zx2l2gmn3zsrxppa9lllvqh1jah54rbn1pc";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/parsers/0.10.1.2.nix pkgs/development/libraries/haskell/parsers/0.10.2.nix

···
 
 cabal.mkDerivation (self: {
   pname = "parsers";
-  version = "0.10.1.2";
-  sha256 = "1malfr2ls7f6di2rj2jcyxyqvjz0vb3p3v06j0r9if1bkjfzfp2j";
+  version = "0.10.2";
+  sha256 = "092wck874sdyyh4aql5kzsm8k9a7dscgndvzarhh98by5k3n45bk";
   buildDepends = [
     charset parsec text transformers unorderedContainers
   ];

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

···
 { cabal, aeson, attoparsec, base64Bytestring, blazeHtml
 , blazeMarkup, conduit, hspec, liftedBase, monadControl
-, monadLogger, pathPieces, poolConduit, resourcet, silently, sqlite
-, text, time, transformers, transformersBase, unorderedContainers
-, vector
+, monadLogger, pathPieces, poolConduit, resourcet, scientific
+, silently, sqlite, text, time, transformers, transformersBase
+, unorderedContainers, vector
 }:
 
 cabal.mkDerivation (self: {
   pname = "persistent";
-  version = "1.3.0";
-  sha256 = "03m2knmjkm25n48shqc7i7mjr0npwdq2dva8ygv9imzjdcb1146m";
+  version = "1.3.0.2";
+  sha256 = "16bq0l6nqjpzlbzm47ip2m8b5yhwhf28fpv3hxy7qsnzmy7siv6y";
   buildDepends = [
     aeson attoparsec base64Bytestring blazeHtml blazeMarkup conduit
     liftedBase monadControl monadLogger pathPieces poolConduit
-    resourcet silently text time transformers transformersBase
-    unorderedContainers vector
+    resourcet scientific silently text time transformers
+    transformersBase unorderedContainers vector
   ];
   testDepends = [
     aeson attoparsec base64Bytestring blazeHtml conduit hspec
-    monadControl monadLogger pathPieces resourcet text time
+    monadControl monadLogger pathPieces resourcet scientific text time
     transformers unorderedContainers vector
   ];
   extraLibraries = [ sqlite ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "postgresql-simple";
-  version = "0.4.0.1";
-  sha256 = "03lj7z0n6yx55xap9606slcp0yiignwild7sibkrmg05jkb193nn";
+  version = "0.4.0.2";
+  sha256 = "0gx9jmmzv6aaa6z88i3j51f5hp153dbwzw3x7jx329c5pjp536g9";
   buildDepends = [
     aeson attoparsec blazeBuilder blazeTextual postgresqlLibpq text
     time transformers uuid vector

pkgs/development/libraries/haskell/quickcheck-instances/default.nix

···
-{ cabal, QuickCheck, text, time }:
+{ cabal, hashable, QuickCheck, text, time, unorderedContainers }:
 
 cabal.mkDerivation (self: {
   pname = "quickcheck-instances";
-  version = "0.3.5";
-  sha256 = "1ak55d3yi6ii01921zihn8mk12mws78w05gmhk766kpylhhgni5f";
-  buildDepends = [ QuickCheck text time ];
+  version = "0.3.6";
+  sha256 = "1vaqwsdgi2mirplzg66zysc1ivjjr0qxyiibsh6j771hxs9qk2pr";
+  buildDepends = [
+    hashable QuickCheck text time unorderedContainers
+  ];
   meta = {
     homepage = "https://github.com/aslatter/qc-instances";
     description = "Common quickcheck instances";

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

···
   sha256 = "0xwxds884pqywjbc4j6qkx27nbi64sihig8ps9v884sk08021wrp";
   buildDepends = [ deepseq hashable text ];
   testDepends = [ smallcheck tasty tastySmallcheck text ];
-  doCheck = false;
   meta = {
     homepage = "https://github.com/basvandijk/scientific";
     description = "Arbitrary-precision floating-point numbers represented using scientific notation";

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

···
 
 cabal.mkDerivation (self: {
   pname = "semigroups";
-  version = "0.12.1";
-  sha256 = "0jxgd487d99cc721wyaxvazphlv567hbb57vdfjn4hq9ly4w464q";
+  version = "0.12.2";
+  sha256 = "0qk6m477iwk17j2a1yfxfkhvfrdv94nnx32zlqjqqxjfbi71c30g";
   buildDepends = [ hashable nats text unorderedContainers ];
   meta = {
     homepage = "http://github.com/ekmett/semigroups/";

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

···
 
 cabal.mkDerivation (self: {
   pname = "shelly";
-  version = "1.4.0.1";
-  sha256 = "0hra0dk1zma15jd1cag04lcvw6cmddhghi4gpajrrvyij0pi6ij7";
+  version = "1.4.1";
+  sha256 = "04yi5kc9jfcpc1rq3prypc832xgv94lrzv3i8saf1rg8a6najwbx";
   buildDepends = [
     mtl systemFileio systemFilepath text time unixCompat
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "skein";
-  version = "1.0.8";
-  sha256 = "0qga3r73zzbj4kkwl8c3p7d1myjyv6dv6g0dwc77fqnmikzcnils";
+  version = "1.0.8.1";
+  sha256 = "1xh8hx1d8hk3kqg07pb2ikc814037bw1xhawskrpxq3x37xff4q4";
   buildDepends = [ cereal cryptoApi tagged ];
   testDepends = [ cereal cryptoApi filepath hspec tagged ];
   jailbreak = true;

pkgs/development/libraries/haskell/snap/core.nix

···
 
 cabal.mkDerivation (self: {
   pname = "snap-core";
-  version = "0.9.5.0";
-  sha256 = "1i5xmgfy807rm6f47l7p7z99nw9bq8vldlfvzi1gxzz8ic80slm4";
+  version = "0.9.6.0";
+  sha256 = "0v5bp8dw867gq92p3qw3h2yv6bhr2b7gy72rs26m9crk2dsfx9pa";
   buildDepends = [
     attoparsec attoparsecEnumerator blazeBuilder blazeBuilderEnumerator
     bytestringMmap caseInsensitive deepseq enumerator filepath hashable

pkgs/development/libraries/haskell/snap/server.nix

···
 
 cabal.mkDerivation (self: {
   pname = "snap-server";
-  version = "0.9.3.4";
-  sha256 = "0i95gf7wpf0gyns4rnl1wp2f53cwfmjg0qb8jxpynwklvsm6zf88";
+  version = "0.9.4.0";
+  sha256 = "0jcg99byygdxx42p1w0a8nvyh2w2hrqj2j9n76hf7sa65f67j828";
   buildDepends = [
     attoparsec attoparsecEnumerator blazeBuilder blazeBuilderEnumerator
     caseInsensitive enumerator MonadCatchIOTransformers mtl network

pkgs/development/libraries/haskell/snap/snap.nix

···
 
 cabal.mkDerivation (self: {
   pname = "snap";
-  version = "0.13.1.2";
-  sha256 = "19s7v9wc988yxynwqdhrhncz8vn9ic6d95gwfi1m0gpxxk5qlzzz";
+  version = "0.13.2.0";
+  sha256 = "1jwgl6dmi1ljfqvfjxcsv3q4h9lcqpmxk4zsjkxdx77z201lhm3b";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "stylish-haskell";
-  version = "0.5.9.0";
-  sha256 = "1iy0d437yd6hgmxmiqa0b6lvg4gw838jxqwn83kdpy1mlykqwmgq";
+  version = "0.5.9.1";
+  sha256 = "0wh0n63nywwzlp9glgm10jyidlcyl944ylnfg5phiahr39946x6y";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/terminfo/0.4.0.0.nix

···
+{ cabal, ncurses }:
+
+cabal.mkDerivation (self: {
+  pname = "terminfo";
+  version = "0.4.0.0";
+  sha256 = "10y8mhpazcpwwvg1avc0zxq534rwavg82q69l7wm5np24sb5lrv8";
+  extraLibraries = [ ncurses ];
+  meta = {
+    homepage = "https://github.com/judah/terminfo";
+    description = "Haskell bindings to the terminfo library";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.andres ];
+  };
+})

pkgs/development/libraries/haskell/type-eq/default.nix

···
-{ cabal }:
+{ cabal, cpphs }:
 
 cabal.mkDerivation (self: {
   pname = "type-eq";
-  version = "0.4";
-  sha256 = "1cvbqxwkiybxbpzr98yl2pnx5w4zrr340z86q40zirgr1f0ch674";
+  version = "0.4.1";
+  sha256 = "0l8nkrdn1hs8ddhh85qm176f9v42fdck9iscn4swd92vj7bfci7k";
+  buildTools = [ cpphs ];
   meta = {
     homepage = "http://github.com/glaebhoerl/type-eq";
     description = "Type equality evidence you can carry around";

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

···
     Cabal deepseq mtl parallel parsec QuickCheck random terminfo
     utf8String vector
   ];
+  jailbreak = true;
   doCheck = false;
   meta = {
     homepage = "https://github.com/coreyoconnor/vty";

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

···
 
 cabal.mkDerivation (self: {
   pname = "wai-extra";
-  version = "2.0.1.2";
-  sha256 = "1afwmahi4cfbpid8vlqdh4xadsv7bz4n6js5a3fmzlf6sv8v1qg2";
+  version = "2.0.2";
+  sha256 = "1va9lds6vziid3kksyp1pl4bz1l02qjybm4x438q5a7n6yxmmd65";
   buildDepends = [
     ansiTerminal base64Bytestring blazeBuilder blazeBuilderConduit
     caseInsensitive conduit dataDefault fastLogger httpTypes liftedBase

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

···
 
 cabal.mkDerivation (self: {
   pname = "wai-logger";
-  version = "2.1.0";
-  sha256 = "1vb2nih78qw7ha1v67hsyyplarxxg5zh82pmh85sdbdykp5cwz0c";
+  version = "2.1.1";
+  sha256 = "1cdl5nglb8jghi0yndpabraihgh681m5q1j77wsxzckxisga73j8";
   buildDepends = [
     blazeBuilder byteorder caseInsensitive fastLogger httpTypes network
     unixTime wai

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

···
 
 cabal.mkDerivation (self: {
   pname = "warp-tls";
-  version = "2.0.0.1";
-  sha256 = "1hwzwlqmq1nkxmp3zjplnkrh80v0awbrb2fwzd4ndyla8akgia1p";
+  version = "2.0.1";
+  sha256 = "0qz02awxrfqmmckias21dh0irmf44vamv24jjjrbb6bjxbr4ldd0";
   buildDepends = [
     certificate conduit cprngAes cryptocipher cryptoRandomApi network
     networkConduit pem tls tlsExtra transformers wai warp

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

···
 
 cabal.mkDerivation (self: {
   pname = "warp";
-  version = "2.0.1";
-  sha256 = "1sgsiw75xm3b1bv0cnpkx6vn6k0r1an3c94xw5bab4h7blb9jk4a";
+  version = "2.0.2";
+  sha256 = "1v28kfs311kr7n4hraqh5dzhw2gy0da2rp30732adivy9aj9grl9";
   buildDepends = [
     blazeBuilder blazeBuilderConduit caseInsensitive conduit hashable
     httpAttoparsec httpDate httpTypes liftedBase network networkConduit

pkgs/development/libraries/haskell/websockets-snap/default.nix

···
+{ cabal, blazeBuilder, enumerator, ioStreams, mtl, snapCore
+, snapServer, websockets
+}:
+
+cabal.mkDerivation (self: {
+  pname = "websockets-snap";
+  version = "0.8.2.1";
+  sha256 = "13q1vrrcka91w9yad3jw1w68hp59n851hkn9a3hylw0cqs7008az";
+  buildDepends = [
+    blazeBuilder enumerator ioStreams mtl snapCore snapServer
+    websockets
+  ];
+  meta = {
+    description = "Snap integration for the websockets library";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

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

···
+{ cabal, attoparsec, base64Bytestring, binary, blazeBuilder
+, caseInsensitive, entropy, HUnit, ioStreams, mtl, network
+, QuickCheck, random, SHA, testFramework, testFrameworkHunit
+, testFrameworkQuickcheck2, text
+}:
+
+cabal.mkDerivation (self: {
+  pname = "websockets";
+  version = "0.8.1.1";
+  sha256 = "0mgazf0s9sl53r5smidrfqcx7rq2v4kfm37f4f6mjrl656qxpbwd";
+  buildDepends = [
+    attoparsec base64Bytestring binary blazeBuilder caseInsensitive
+    entropy ioStreams mtl network random SHA text
+  ];
+  testDepends = [
+    attoparsec base64Bytestring binary blazeBuilder caseInsensitive
+    entropy HUnit ioStreams mtl network QuickCheck random SHA
+    testFramework testFrameworkHunit testFrameworkQuickcheck2 text
+  ];
+  meta = {
+    homepage = "http://jaspervdj.be/websockets";
+    description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

pkgs/development/libraries/haskell/wl-pprint-terminfo/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wl-pprint-terminfo";
-  version = "3.7";
-  sha256 = "01lzk8wfynb98ks8a0gvj8qffi50zlfaywlc9axr6j7h8rrblnm3";
+  version = "3.7.1";
+  sha256 = "04220hgrjjsz0ir65s6ynrjgdmqlfcw49fb158w7wgxxh69kc7h6";
   buildDepends = [
     nats semigroups terminfo text transformers wlPprintExtras
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/ekmett/wl-pprint-terminfo/";
     description = "A color pretty printer with terminfo support";

pkgs/development/libraries/haskell/wl-pprint-text/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wl-pprint-text";
-  version = "1.1.0.1";
-  sha256 = "1rb5jmryxzcn6j8xalvsgwr61d1qzmsjyfp3iiq10n565bja70za";
+  version = "1.1.0.2";
+  sha256 = "0wbfqp38as2qpn66sq4hvl3hzvj66v301cz9rmgnx2i62r0a3s81";
   buildDepends = [ text ];
   meta = {
     description = "A Wadler/Leijen Pretty Printer for Text values";

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

···
 
 cabal.mkDerivation (self: {
   pname = "xmlhtml";
-  version = "0.2.3";
-  sha256 = "0yg56rj8ylnaawqx3h54g0dlayql87h40anbp7lccnl70pzbk6c7";
+  version = "0.2.3.1";
+  sha256 = "138nryn68f58cvg971qw7vw0kprsw5g39j3fmf0bz83sg4g98nmd";
   buildDepends = [
     blazeBuilder blazeHtml blazeMarkup parsec text unorderedContainers
   ];

pkgs/development/libraries/haskell/xss-sanitize/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "xss-sanitize";
-  version = "0.3.4.1";
-  sha256 = "11s7vkp8c7gdfv9vaq81p954jsc319xrfi9vv6wgfb3pqjf800mh";
+  version = "0.3.4.2";
+  sha256 = "1sx44vkixxydv75cds5g9si7hzm2hdl395p3bdycq2zky0mnxwra";
   buildDepends = [
     attoparsec cssText network tagsoup text utf8String
   ];

pkgs/development/libraries/haskell/yaml-light/default.nix

···
+{ cabal, HsSyck }:
+
+cabal.mkDerivation (self: {
+  pname = "yaml-light";
+  version = "0.1.4";
+  sha256 = "05pxkqp91l275n48p1aqijzh34vvzi7cx2nls879b95fz2dr8lhk";
+  buildDepends = [ HsSyck ];
+  meta = {
+    description = "A light-weight wrapper with utility functions around HsSyck";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ocharles ];
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "yaml";
-  version = "0.8.5.2";
-  sha256 = "1x285bd57ifp50afgx5i9chwmnlb0l716dsh691fjqj0xsr9kjgv";
+  version = "0.8.5.3";
+  sha256 = "028wxp3jcvdy63707jhxm9mmkbxz9ni1c63rb7wvzjswijp3p95b";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-bin";
-  version = "1.2.5.5";
-  sha256 = "1dgbrdvfr5n4nxrm86sp2njf0kjnv0rapf28wy76j9qkisvn905k";
+  version = "1.2.5.6";
+  sha256 = "1acqfg9g5xjfmpby1xham2ygvbydn0srw2c7hajvfwalc6zkxrny";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-core";
-  version = "1.2.6.4";
-  sha256 = "0s5lc3drm1ayd7mikpn4gkn7c7c9zspgsl5087ia2jlkayzj5n14";
+  version = "1.2.6.5";
+  sha256 = "1xry2jhm4rj3a7fg4xdx5q6fah8dixnrhzyk4176a60a3q8j3lal";
   buildDepends = [
     aeson attoparsecConduit blazeBuilder blazeHtml blazeMarkup
     caseInsensitive cereal clientsession conduit cookie dataDefault

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

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-routes";
-  version = "1.2.0.5";
-  sha256 = "0150plfdd9x70sc6zzy66lv9vbla7p9bx06yi6vlqkfvzsrx2cx7";
+  version = "1.2.0.6";
+  sha256 = "0hd2f2w9pb865fn9qijh3j73sc1x7gzd4c0q5mgjy9lh9hd4kzix";
   buildDepends = [ pathPieces text vector ];
   testDepends = [ hspec HUnit pathPieces text ];
   meta = {

pkgs/development/libraries/http_parser/default.nix pkgs/development/libraries/http-parser/default.nix

···
-{ stdenv, fetchurl, gyp, utillinux, python }:
+{ stdenv, fetchurl, gyp, utillinux, python, fixDarwinDylibNames }:
 
 let
   version = "2.1";
···
 
   buildFlags = [ "BUILDTYPE=Release" ];
 
-  buildInputs = [ gyp ] ++ (stdenv.lib.optional stdenv.isLinux utillinux) ++ stdenv.lib.optional stdenv.isDarwin python;
+  buildInputs =
+    [ gyp ]
+    ++ stdenv.lib.optional stdenv.isLinux utillinux
+    ++ stdenv.lib.optionals stdenv.isDarwin [ python fixDarwinDylibNames ];
 
   doCheck = !stdenv.isDarwin;
 
···
     mkdir -p $out/include
     mv http_parser.h $out/include
   '';
-
-  postFixup = if stdenv.isDarwin then ''
-    install_name_tool -id $out/lib/libhttp_parser.dylib $out/lib/libhttp_parser.dylib
-    install_name_tool -id $out/lib/libhttp_parser_strict.dylib $out/lib/libhttp_parser_strict.dylib
-  '' else null;
 
   meta = {
     description = "An HTTP message parser written in C";

pkgs/development/libraries/icu/default.nix

···
-{stdenv, fetchurl}:
+{ stdenv, fetchurl, fixDarwinDylibNames }:
 
 let
 
···
       + (stdenv.lib.replaceChars ["."] ["_"] version) + "-src.tgz";
     sha256 = "14l0kl17nirc34frcybzg0snknaks23abhdxkmsqg3k9sil5wk9g";
   };
+
+  # FIXME: This fixes dylib references in the dylibs themselves, but
+  # not in the programs in $out/bin.
+  buildInputs = stdenv.lib.optional stdenv.isDarwin fixDarwinDylibNames;
 
   postUnpack = ''
     sourceRoot=''${sourceRoot}/source

pkgs/development/libraries/java/hydra-ant-logger/default.nix

···
-{ fetchsvn, stdenv, ant }:
+{ fetchgit, stdenv, ant, jdk }:
 
 stdenv.mkDerivation rec {
   name = "hydra-ant-logger-${version}";
   version = "2010.2";
 
-  src = fetchsvn {
-    url = https://svn.nixos.org/repos/nix/hydra-ant-logger/trunk;
-    rev = 20396;
-    sha256 = "1lp5zy80m4y2kq222q2x052ys5mlhgc7y4kxh2bl48744f1fkgyr";
+  src = fetchgit {
+    url = https://github.com/NixOS/hydra-ant-logger.git;
+    rev = "dae3224f4ed42418d3492bdf5bee4f825819006f";
+    sha256 = "01s7m6007rn9107rw5wcgna7i20x6p6kfzl4f79jrvpkjy6kz176";
   };
 
-  buildInputs = [ ant ];
+  buildInputs = [ ant jdk ];
 
-  buildPhase = ''
-    ln -s ${ant}/lib/ant.jar lib/ant.jar
-    ant 
-  '';
+  buildPhase = "mkdir lib; ant";
 
-  installPhase = '' 
-    mkdir -p "$out/lib/java"
-    cp -v *.jar "$out/lib/java"
+  installPhase = ''
+    mkdir -p $out/share/java
+    cp -v *.jar $out/share/java
   '';
 }

pkgs/development/libraries/java/icedtea/default.nix

···
-/* XXX: This is work in progress and it needs your help!  */
-
-/* See http://icedtea.classpath.org/wiki/BuildRequirements for a
-   list of dependencies.  */
-
-{ fetchurl, stdenv, which
-, wget, cpio, file, ecj, gcj, ant, gawk, procps, inetutils, zip, unzip, zlib
-, alsaLib, cups, lesstif, freetype, classpath, libjpeg, libpng, giflib
-, xalanj, xerces, rhino
-, libX11, libXp, libXtst, libXinerama, libXt, libXrender, xproto
-, pkgconfig, xulrunner, pulseaudio }:
-
-let
-  # These variables must match those in the top-level `Makefile.am'.
-  openjdkVersion   = "b16";
-  openjdkDate      = "24_apr_2009";
-  openjdkURL       =
-    "http://download.java.net/openjdk/jdk6/promoted/${openjdkVersion}/";
-  openjdkSourceZip = "openjdk-6-src-${openjdkVersion}-${openjdkDate}.tar.gz";
-
-  openjdk          = fetchurl {
-    url = "${openjdkURL}${openjdkSourceZip}";
-    sha256 = "084lkhsnj29finb6pmvrh83nqbliwv32gdi5q5sv43dpv24r85cn";
-  };
-
-  hotspot          = fetchurl {
-    url = "http://hg.openjdk.java.net/hsx/hsx14/master/archive/09f7962b8b44.tar.gz";
-    sha256 = "1jbd9ki5ip96293mv1qil20yqcgvkmcrhs302j0n8i8f3v1j70bf";
-  };
-
-in
-
-stdenv.mkDerivation rec {
-  name = "icedtea6-1.6.1";
-
-  src = fetchurl {
-    url = "http://icedtea.classpath.org/download/source/${name}.tar.gz";
-    sha256 = "11vaanfmz842x576wrw5qldpkksi8wqjmh9wikn5gxyjk87qq3k5";
-  };
-
-  buildInputs = [
-    wget  # Not actually used, thanks to `--with-openjdk-src-zip' et al.
-    which cpio file ecj gcj ant gawk procps inetutils zip unzip zlib
-    alsaLib cups lesstif freetype classpath libjpeg libpng giflib
-    xalanj xerces
-    libX11 libXp libXtst libXinerama libXt libXrender xproto
-    pkgconfig /* xulrunner */ pulseaudio
-  ];
-
-  preConfigure =
-    '' # Use the Sun-compatible tools (`jar', etc.).
-       export PATH="${gcj.gcc}/lib/jvm/bin:$PATH"
-
-       # Copy patches.
-       cp -v "${./nixos-slash-bin.patch}" patches/nixos-slash-bin.patch
-    '';
-
-  configureFlags =
-    stdenv.lib.concatStringsSep " "
-      [ "--with-gcj-home=${gcj}"
-        "--with-ecj" "--with-ecj-jar=${ecj}/lib/java/ecj.jar"
-        "--with-openjdk-src-zip=${openjdk}"
-        "--with-hotspot-src-zip=${hotspot}"
-        "--with-ant-home=${ant}/lib/java"
-        "--with-xalan2-jar=${xalanj}/lib/java/xalan.jar"
-        "--with-xalan2-serializer-jar=${xalanj}/lib/java/xalan.jar"
-        "--with-xerces2-jar=${xerces}/lib/java/xercesImpl.jar"
-        "--with-rhino=${rhino}/lib/java/js.jar"
-        "--disable-plugin" # FIXME: Enable it someday.
-
-        "--with-parallel-job"
-      ];
-
-  makeFlags =
-    [ # Have OpenCDK use tools from $PATH.
-      "ALT_UNIXCCS_PATH=" "ALT_UNIXCOMMAND_PATH=" "ALT_USRBIN_PATH="
-      "ALT_COMPILER_PATH=" "ALT_DEVTOOLS_PATH="
-
-      # Libraries.
-      "ALT_MOTIF_DIR="
-      "ALT_FREETYPE_HEADERS_PATH=${freetype}/include"
-      "ALT_FREETYPE_LIB_PATH=${freetype}/lib"
-      "ALT_CUPS_HEADERS_PATH=${cups}/include"
-      "ALT_CUPS_LIB_PATH=${cups}/lib"
-
-      # Tell IcedTea about our patches.
-      "DISTRIBUTION_PATCHES=patches/nixos-slash-bin.patch"
-    ];
-
-  meta = {
-    description = "IcedTea, a libre Java development kit based on OpenJDK";
-
-    longDescription =
-      '' The IcedTea project provides a harness to build the source code from
-         http://openjdk.java.net using Free Software build tools and adds a
-         number of key features to the upstream OpenJDK codebase: a Free
-         64-bit plugin with LiveConnect and Java Web Start support, support
-         for additional platforms via a pure interpreted mode in HotSpot
-         (Zero) or the alternative CACAO virtual machine.  Experimental JIT
-         support for Zero is also available via Shark.
-      '';
-
-    license = "GPLv2"; /* and multiple-licensing, e.g., for the plug-ins */
-
-    homepage = http://icedtea.classpath.org/;
-
-    maintainers = [ ];
-
-    # Restrict to GNU systems for now.
-    platforms = stdenv.lib.platforms.gnu;
-
-    broken = true;
-  };
-}

pkgs/development/libraries/java/icedtea/nixos-slash-bin.patch

···
-Remove references to /bin/echo to allow NixOS builds.
-
---- openjdk/jdk/make/common/shared/Defs-utils.gmk	2009-04-24 09:33:55.000000000 +0200
-+++ openjdk/jdk/make/common/shared/Defs-utils.gmk	2010-01-19 15:39:29.000000000 +0100
-@@ -177,7 +177,7 @@ ifeq ($(PLATFORM),linux)
- 
-   NAWK           = $(USRBIN_PATH)gawk
-   # Intrinsic unix command, with backslash-escaped character interpretation
--  ECHO           = /bin/echo -e
-+  ECHO           = echo -e
-   # These are really in UTILS_USR_BIN_PATH on Linux (only sccs is not)
-   AR             = $(UTILS_USR_BIN_PATH)ar
-   AS             = $(UTILS_USR_BIN_PATH)as
-@@ -195,6 +195,6 @@ ifeq ($(PLATFORM),solaris)
-   # Intrinsic unix command, with backslash-escaped character interpretation
-   #   (not using -e  will cause build failure when using /bin/bash)
-   #   (using -e breaks something else)
--  ECHO           = /usr/bin/echo
-+  ECHO           = echo
- endif

pkgs/development/libraries/java/rhino/default.nix

···
     sha256 = "1pb08d9j81d0wz5wj31idz198iwhqb7mch872n08jh1354rjlqwk";
   };
 in
-  stdenv.mkDerivation {
-    name = "rhino-${version}";
 
-    src = fetchurl {
-      url = "ftp://ftp.mozilla.org/pub/mozilla.org/js/rhino1_7R2.zip";
-      sha256 = "1p32hkghi6bkc3cf2dcqyaw5cjj7403mykcp0fy8f5bsnv0pszv7";
-    };
+stdenv.mkDerivation {
+  name = "rhino-${version}";
 
-    patches = [ ./gcj-type-mismatch.patch ];
+  src = fetchurl {
+    url = "ftp://ftp.mozilla.org/pub/mozilla.org/js/rhino1_7R2.zip";
+    sha256 = "1p32hkghi6bkc3cf2dcqyaw5cjj7403mykcp0fy8f5bsnv0pszv7";
+  };
 
-    preConfigure =
-      '' find -name \*.jar -or -name \*.class -exec rm -v {} \;
+  patches = [ ./gcj-type-mismatch.patch ];
 
-         # The build process tries to download it by itself.
-         mkdir -p "build/tmp-xbean"
-         ln -sv "${xbeans}" "build/tmp-xbean/xbean.zip"
-      '';
+  preConfigure =
+    ''
+      find -name \*.jar -or -name \*.class -exec rm -v {} \;
 
-    buildInputs = [ unzip ant javac jvm ];
+      # The build process tries to download it by itself.
+      mkdir -p "build/tmp-xbean"
+      ln -sv "${xbeans}" "build/tmp-xbean/xbean.zip"
+    '';
 
-    buildPhase = "ant ${options} jar";
-    doCheck    = false;
+  buildInputs = [ unzip ant javac jvm ];
 
-    # FIXME: Install javadoc as well.
-    installPhase =
-      '' mkdir -p "$out/lib/java"
-         cp -v *.jar "$out/lib/java"
-      '';
+  buildPhase = "ant ${options} jar";
+  doCheck    = false;
 
-    meta = {
-      description = "Mozilla Rhino: JavaScript for Java";
+  # FIXME: Install javadoc as well.
+  installPhase =
+    ''
+      mkdir -p "$out/share/java"
+      cp -v *.jar "$out/share/java"
+    '';
 
-      longDescription =
-        '' Rhino is an open-source implementation of JavaScript written
-           entirely in Java.  It is typically embedded into Java applications
-           to provide scripting to end users.
-        '';
+  meta = {
+    description = "Mozilla Rhino: JavaScript for Java";
 
-      homepage = http://www.mozilla.org/rhino/;
+    longDescription =
+      '' Rhino is an open-source implementation of JavaScript written
+         entirely in Java.  It is typically embedded into Java applications
+         to provide scripting to end users.
+      '';
 
-      licenses = [ "MPLv1.1" /* or */ "GPLv2+" ];
+    homepage = http://www.mozilla.org/rhino/;
 
-      maintainers = [ ];
-    };
-  }
+    licenses = [ "MPLv1.1" /* or */ "GPLv2+" ];
+  };
+}

pkgs/development/libraries/java/xalanj/default.nix

···
-{ fetchurl, stdenv, ant, javac, jvm, xerces }:
-
-let
-  version = "2.7.1";
-  options = "-Dbuild.compiler=gcj";   # FIXME: We assume GCJ here.
-in
-  stdenv.mkDerivation {
-    name = "xalan-j-${version}";
-
-    src = fetchurl {
-      url = "mirror://apache/xml/xalan-j/source/xalan-j_2_7_1-src.tar.gz";
-      sha256 = "0hxhx0n0ynflq1d01sma658ipwn3f3902x6n8mfk70mqkdiallps";
-    };
-
-    buildInputs = [ ant javac jvm xerces ];
-
-    configurePhase =
-      '' rm -v lib/xerces*.jar
-         export CLASSPATH="${xerces}/lib/java"
-      '';
-
-    buildPhase = "ant ${options} jar";
-    doCheck    = false;
-
-    # FIXME: Install javadoc as well.
-    installPhase =
-      '' mkdir -p "$out/lib/java"
-         cp -v build/x*.jar "$out/lib/java"
-      '';
-
-    meta = {
-      description = "Apache Xalan-Java, an XSLT processor";
-
-      longDescription =
-        '' Xalan-Java is an XSLT processor for transforming XML documents
-           into HTML, text, or other XML document types.  It implements XSL
-           Transformations (XSLT) Version 1.0 and XML Path Language (XPath)
-           Version 1.0 and can be used from the command line, in an applet or a
-           servlet, or as a module in other program.
-
-           Xalan-Java implements the javax.xml.transform interface in Java
-           API for XML Processing (JAXP) 1.3.  This interface provides a
-           modular framework and a standard API for performing XML
-           transformations, and utilizes system properties to determine which
-           Transformer and which XML parser to use.
-
-           Xalan-Java also implements the javax.xml.xpath interface in JAXP
-           1.3, which provides an object-model neutral API for evaluation of
-           XPath expressions and access to the evaluation environment.
-        '';
-
-      homepage = http://xml.apache.org/xalan-j/;
-      license = "Apache-2.0";
-
-      maintainers = [ ];
-    };
-  }

pkgs/development/libraries/java/xerces/default.nix

···
-{ fetchurl, stdenv, ant, javac, jvm }:
-
-let
-  version = "2.9.1";
-  tools   = fetchurl {
-    url = "mirror://apache/xerces/j/source/Xerces-J-tools.${version}.tar.gz";
-    sha256 = "1zzbq9ijy0f3v8w2sws9w79bkda34m9i01993md94n8fccnkiwac";
-  };
-  options = "-Dbuild.compiler=gcj";   # FIXME: We assume GCJ here.
-in
-  stdenv.mkDerivation {
-    name = "xerces-j-${version}";
-
-    src = fetchurl {
-      url = "mirror://apache/xerces/j/source/Xerces-J-src.${version}.tar.gz";
-      sha256 = "14h5jp58999f0rg4mkyab015hkgsxa8n6cx53ia0sjialxi01bqk";
-    };
-
-    buildInputs = [ ant javac jvm ];
-
-    configurePhase = "tar xzvf ${tools}";
-    buildPhase     = "ant ${options} jar";
-
-    # The `tests' directory is missing from the tarball.
-    doCheck = false;
-
-    # FIXME: Install javadoc as well.
-    installPhase =
-      '' mkdir -p "$out/lib/java"
-         cp -v build/xerces*.jar "$out/lib/java"
-      '';
-
-    meta = {
-      description = "Apache Xerces, an XML parser for Java";
-
-      longDescription =
-        '' Xerces2 Java is a library for parsing, validating and manipulating
-           XML documents.
-
-           Xerces 2.x introduced the Xerces Native Interface (XNI), a
-           complete framework for building parser components and
-           configurations that is extremely modular and easy to program.  XNI
-           is merely an internal set of interfaces.  There is no need for an
-           XML application programmer to learn XNI if they only intend to
-           interface to the Xerces2 parser using standard interfaces like
-           JAXP, DOM, and SAX.  Xerces developers and application developers
-           that need more power and flexibility than that provided by the
-           standard interfaces should read and understand XNI.
-        '';
-
-      homepage = http://xerces.apache.org/xerces2-j/;
-
-      license = "Apache-2.0";
-
-      maintainers = [ ];
-    };
-  }

pkgs/development/libraries/libgcrypt/git.nix

···
-{ fetchgit, stdenv, libgpgerror, autoconf, automake, libtool, transfig, ghostscript, texinfo }:
-
-stdenv.mkDerivation rec {
-  name = "libgcrypt-git-20130524";
-
-  src = fetchgit {
-    url = git://git.gnupg.org/libgcrypt.git;
-    rev = "99b18aa53";
-    sha256 = "1rhbpxqrkfszlv8jvw8s4apwklal07k8zxv5q555l7binc1j1j3z";
-  };
-
-  nativeBuildInputs = [ autoconf automake libtool transfig ghostscript texinfo ];
-
-  propagatedBuildInputs = [ libgpgerror ];
-
-  preConfigure = ''
-    sh autogen.sh
-  '';
-
-  preBuild = ''
-    (cd doc; make stamp-vti)
-  '';
-
-  doCheck = true;
-
-  # For some reason the tests don't find `libgpg-error.so'.
-  checkPhase = ''
-    LD_LIBRARY_PATH="${libgpgerror}/lib:$LD_LIBRARY_PATH" \
-    make check
-  '';
-
-  meta = {
-    description = "GNU Libgcrypt, a general-pupose cryptographic library";
-
-    longDescription = ''
-      GNU Libgcrypt is a general purpose cryptographic library based on
-      the code from GnuPG.  It provides functions for all
-      cryptographic building blocks: symmetric ciphers, hash
-      algorithms, MACs, public key algorithms, large integer
-      functions, random numbers and a lot of supporting functions.
-    '';
-
-    license = "LGPLv2+";
-
-    homepage = https://www.gnu.org/software/libgcrypt/;
-    platforms = stdenv.lib.platforms.all;
-  };
-}

pkgs/development/libraries/libtsm/default.nix

···
+{ stdenv, fetchurl, libxkbcommon, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "libtsm-3";
+
+  src = fetchurl {
+    url = "http://freedesktop.org/software/kmscon/releases/${name}.tar.xz";
+    sha256 = "01ygwrsxfii0pngfikgqsb4fxp8n1bbs47l7hck81h9b9bc1ah8i";
+  };
+
+  buildInputs = [ libxkbcommon pkgconfig ];
+
+  configureFlags = [ "--disable-debug" ];
+
+  meta = {
+    description = "Terminal-emulator State Machine";
+    homepage = "http://www.freedesktop.org/wiki/Software/kmscon/libtsm/";
+    license = stdenv.lib.licenses.mit;
+    maintainers = [ stdenv.lib.maintainers.shlevy ];
+  };
+}

pkgs/development/libraries/opencascade/oce.nix

···
 ftgl, freetype}:
 
 stdenv.mkDerivation rec {
-  name = "opencascade-oce-0.13-dev";
+  name = "opencascade-oce-0.14.1";
   src = fetchurl {
-    url = https://api.github.com/repos/tpaviot/oce/tarball/bd77743bfa0e765c3a57d116a62d75b50e1a455;
-    name = "${name}.tar.gz";
-    sha256 = "1w7z326la9427yb23hbalsksk6w4ma5xil4jscnvi8mk6g48wyxv";
+    url = https://github.com/tpaviot/oce/archive/OCE-0.14.1.tar.gz;
+    sha256 = "0pfc94nmzipm6zmxywxbly1cpfr6wadxasqqkkbdvzg937mrwl5d";
   };
 
   buildInputs = [ mesa tcl tk file libXmu libtool qt4 ftgl freetype cmake ];

pkgs/development/libraries/tecla/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "tecla-1.6.1";
+  name = "tecla-1.6.2";
 
   src = fetchurl {
     url = "http://www.astro.caltech.edu/~mcs/tecla/lib${name}.tar.gz";
-    sha256 = "18crv6q5f9g0cg6ry5h9dsa10inhpslklrv20h70f58lpm3jknr1";
+    sha256 = "1f5p1v9ac5r1f6pjzwacb4yf8m6z19rv77p76j7fix34hd9dnqcc";
   };
 
   configureFlags = "CFLAGS=-O3 CXXFLAGS=-O3";
···
     description = "Tecla command-line editing library";
     license = "as-is";
 
-    platforms = stdenv.lib.platforms.all;
+    hydraPlatforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/development/libraries/ti-rpc/default.nix

···
-{ fetchurl, stdenv }:
+{ fetchurl, stdenv, krb5 }:
 
 stdenv.mkDerivation rec {
-  name = "libtirpc-0.2.3";
+  name = "libtirpc-0.2.4";
 
   src = fetchurl {
     url = "mirror://sourceforge/libtirpc/${name}.tar.bz2";
-    sha256 = "0g4jd8da0kfxz5lv1x5v7f3mfxw53cck8g2zz4llrjmlj42flaag";
+    sha256 = "18a337wa4amf0k21wnimp3yzs5l3cxqndz4x3x8bm993zhfy5hs5";
   };
+
+  buildInputs = [ krb5 ];
 
   # http://www.sourcemage.org/projects/grimoire/repository/revisions/d6344b6a3a94b88ed67925a474de5930803acfbf
   preConfigure = ''
···
        already supports IPv6.  So, the FreeBSD release 5.2.1 TI-RPC has
        been ported to replace the SunRPC of the glibc.
     '';
-
-    platforms = stdenv.lib.platforms.all;
-    maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/development/libraries/xercesc/default.nix

···
     homepage = http://xerces.apache.org/xerces-c/;
     description = "Validating XML parser written in a portable subset of C++";
     license = "ASL2.0";
+    platforms = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
   };
 }

pkgs/development/mobile/androidenv/default.nix

···
     alsaLib_32bit = pkgs_i686.alsaLib;
   };
   
+  androidsdk_2_2 = androidsdk {
+    platformVersions = [ "8" ];
+    abiVersions = [ "armeabi-v7a" ];
+    useGoogleAPIs = true;
+  };
+  
+  androidsdk_4_0 = androidsdk {
+    platformVersions = [ "15" ];
+    abiVersions = [ "armeabi-v7a" ];
+    useGoogleAPIs = true;
+  };
+  
   androidsdk_4_1 = androidsdk {
     platformVersions = [ "16" ];
     abiVersions = [ "armeabi-v7a" ];

pkgs/development/mobile/titaniumenv/build-app.nix

···
-{stdenv, androidsdk, titaniumsdk, xcodewrapper}:
+{stdenv, androidsdk, titaniumsdk, xcodewrapper, jdk}:
 { appId, name, appName ? null, src, target, androidPlatformVersions ? [ "8" ], androidAbiVersions ? [ "armeabi" "armeabi-v7a" ]
 , release ? false, androidKeyStore ? null, androidKeyAlias ? null, androidKeyStorePassword ? null
-, iosKeyFile ? null, iosCertificateName ? null, iosCertificate ? null, iosCertificatePassword ? null, iosDistribute ? false
+, iosMobileProvisioningProfile ? null, iosCertificateName ? null, iosCertificate ? null, iosCertificatePassword ? null, iosDistribute ? false
 }:
 
 assert (release && target == "android") -> androidKeyStore != null && androidKeyAlias != null && androidKeyStorePassword != null;
-assert (release && target == "iphone") -> iosKeyFile != null && iosCertificateName != null && iosCertificate != null && iosCertificatePassword != null;
+assert (release && target == "iphone") -> iosMobileProvisioningProfile != null && iosCertificateName != null && iosCertificate != null && iosCertificatePassword != null;
 
 let
   androidsdkComposition = androidsdk {
···
   name = stdenv.lib.replaceChars [" "] [""] name;
   inherit src;
   
-  buildInputs = [] ++ stdenv.lib.optional (stdenv.system == "x86_64-darwin") xcodewrapper;
-
+  buildInputs = [ jdk ] ++ stdenv.lib.optional (stdenv.system == "x86_64-darwin") xcodewrapper;
+  
   buildPhase = ''
     export HOME=$TMPDIR
 
···
             security unlock-keychain -p "" $keychainName
             security import ${iosCertificate} -k $keychainName -P "${iosCertificatePassword}" -A
 
-            provisioningId=$(grep UUID -A1 -a ${iosKeyFile} | grep -o "[-A-Z0-9]\{36\}")
+            provisioningId=$(grep UUID -A1 -a ${iosMobileProvisioningProfile} | grep -o "[-A-Z0-9]\{36\}")
    
             # Ensure that the requested provisioning profile can be found
             
             if [ ! -f "$HOME/Library/MobileDevice/Provisioning Profiles/$provisioningId.mobileprovision" ]
             then
                 mkdir -p "$HOME/Library/MobileDevice/Provisioning Profiles"
-                cp ${iosKeyFile} "$HOME/Library/MobileDevice/Provisioning Profiles/$provisioningId.mobileprovision"
+                cp ${iosMobileProvisioningProfile} "$HOME/Library/MobileDevice/Provisioning Profiles/$provisioningId.mobileprovision"
             fi
             
-            ${titaniumsdk}/mobilesdk/*/*/iphone/builder.py distribute 6.0 $(pwd) ${appId} "${_appName}" "$provisioningId" "${iosCertificateName}" $out universal "$HOME/Library/Keychains/$keychainName"
+            ${titaniumsdk}/mobilesdk/*/*/iphone/builder.py distribute 7.0 $(pwd) ${appId} "${_appName}" "$provisioningId" "${iosCertificateName}" $out universal "$HOME/Library/Keychains/$keychainName"
             
             # Remove our generated keychain
             
···
                 security unlock-keychain -p "" $keychainName
                 security import ${iosCertificate} -k $keychainName -P "${iosCertificatePassword}" -A
 
-                provisioningId=$(grep UUID -A1 -a ${iosKeyFile} | grep -o "[-A-Z0-9]\{36\}")
+                provisioningId=$(grep UUID -A1 -a ${iosMobileProvisioningProfile} | grep -o "[-A-Z0-9]\{36\}")
    
                 # Ensure that the requested provisioning profile can be found
             
                 if [ ! -f "$HOME/Library/MobileDevice/Provisioning Profiles/$provisioningId.mobileprovision" ]
                 then
                     mkdir -p "$HOME/Library/MobileDevice/Provisioning Profiles"
-                    cp ${iosKeyFile} "$HOME/Library/MobileDevice/Provisioning Profiles/$provisioningId.mobileprovision"
+                    cp ${iosMobileProvisioningProfile} "$HOME/Library/MobileDevice/Provisioning Profiles/$provisioningId.mobileprovision"
                 fi
             
-                ${titaniumsdk}/mobilesdk/*/*/iphone/builder.py adhoc 6.0 $(pwd) ${appId} "${_appName}" "$provisioningId" "${iosCertificateName}" universal "$HOME/Library/Keychains/$keychainName"
+                ${titaniumsdk}/mobilesdk/*/*/iphone/builder.py adhoc 7.0 $(pwd) ${appId} "${_appName}" "$provisioningId" "${iosCertificateName}" universal "$HOME/Library/Keychains/$keychainName"
             
                 # Remove our generated keychain
             
···
             
             cp -av * $out
             cd $out
-            ${titaniumsdk}/mobilesdk/*/*/iphone/builder.py build 6.0 $(pwd) ${appId} "${_appName}" universal
+            ${titaniumsdk}/mobilesdk/*/*/iphone/builder.py build 7.0 $(pwd) ${appId} "${_appName}" universal
           ''
 
       else throw "Target: ${target} is not supported!"}

pkgs/development/mobile/titaniumenv/default.nix

···
-{pkgs, pkgs_i686, version ? "3.1"}:
+{pkgs, pkgs_i686, xcodeVersion ? "5.0"}:
 
-let
-  titaniumexpr = if version == "2.1" then
-    ./titaniumsdk-2.1.nix
-  else if version == "3.1" then
-    ./titaniumsdk.nix
-  else
-    throw "Unknown Titanium SDK version: ${version}";
-in
 rec {
   androidenv = pkgs.androidenv;
 
-  xcodeenv = if pkgs.stdenv.system == "x86_64-darwin" then pkgs.xcodeenv else null;
+  xcodeenv = if pkgs.stdenv.system == "x86_64-darwin" then pkgs.xcodeenv.override {
+    version = xcodeVersion;
+  } else null;
   
-  titaniumsdk = import titaniumexpr {
+  titaniumsdk = import ./titaniumsdk.nix {
     inherit (pkgs) stdenv fetchurl unzip makeWrapper python jdk;
   };
   
   buildApp = import ./build-app.nix {
-    inherit (pkgs) stdenv;
+    inherit (pkgs) stdenv jdk;
     inherit (androidenv) androidsdk;
     inherit (xcodeenv) xcodewrapper;
     inherit titaniumsdk;

pkgs/development/mobile/titaniumenv/examples/default.nix

···
 { nixpkgs ? <nixpkgs>
-, system ? builtins.currentSystem
-, version ? "3.1"
+, systems ? [ "x86_64-linux" "x86_64-darwin" ]
+, xcodeVersion ? "5.0"
+, rename ? false
+, newBundleId ? "com.example.kitchensink", iosMobileProvisioningProfile ? null, iosCertificate ? null, iosCertificateName ? "Example", iosCertificatePassword ? ""
 }:
 
 let
-  pkgs = import nixpkgs { inherit system; };
-  pkgs_darwin_x86_64 = import nixpkgs { system = "x86_64-darwin"; };
-  versionString = pkgs.stdenv.lib.replaceChars [ "." ] [ "_" ] version;
+  pkgs = import nixpkgs {};
 in
 rec {
-  kitchensink_android = import ./kitchensink {
+  kitchensink_android_debug = pkgs.lib.genAttrs systems (system:
+  let
+    pkgs = import nixpkgs { inherit system; };
+  in
+  import ./kitchensink {
     inherit (pkgs) fetchgit;
-    titaniumenv = builtins.getAttr "titaniumenv_${versionString}" pkgs;
+    titaniumenv = pkgs.titaniumenv.override { inherit xcodeVersion; };
     target = "android";
-  };
+  });
   
-  kitchensink_iphone = import ./kitchensink {
-    inherit (pkgs_darwin_x86_64) fetchgit;
-    titaniumenv = builtins.getAttr "titaniumenv_${versionString}" pkgs_darwin_x86_64;
-    target = "iphone";
-  };
+  kitchensink_android_release = pkgs.lib.genAttrs systems (system:
+  let
+    pkgs = import nixpkgs { inherit system; };
+  in
+  import ./kitchensink {
+    inherit (pkgs) fetchgit;
+    titaniumenv = pkgs.titaniumenv.override { inherit xcodeVersion; };
+    target = "android";
+    release = true;
+  });
   
-  emulate_kitchensink = import ./emulate-kitchensink {
-    inherit (pkgs.titaniumenv) androidenv;
-    kitchensink = kitchensink_android;
-  };
+  emulate_kitchensink_debug = pkgs.lib.genAttrs systems (system:
+  let
+    pkgs = import nixpkgs { inherit system; };
+  in
+  import ./emulate-kitchensink {
+    inherit (pkgs) androidenv;
+    kitchensink = builtins.getAttr system kitchensink_android_debug;
+  });
   
+  emulate_kitchensink_release = pkgs.lib.genAttrs systems (system:
+  let
+    pkgs = import nixpkgs { inherit system; };
+  in
+  import ./emulate-kitchensink {
+    inherit (pkgs) androidenv;
+    kitchensink = builtins.getAttr system kitchensink_android_release;
+  });
+  
+} // (if builtins.elem "x86_64-darwin" systems then 
+  let
+    pkgs = import nixpkgs { system = "x86_64-darwin"; };
+  in
+  rec {
+  kitchensink_ios_development = import ./kitchensink {
+    inherit (pkgs) fetchgit;
+    titaniumenv = pkgs.titaniumenv.override { inherit xcodeVersion; };
+    target = "iphone";
+  };
+
   simulate_kitchensink_iphone = import ./simulate-kitchensink {
-    inherit (pkgs_darwin_x86_64) stdenv;
-    inherit (pkgs_darwin_x86_64.titaniumenv) xcodeenv;
-    kitchensink = kitchensink_iphone;
+    inherit (pkgs) stdenv;
+    xcodeenv = pkgs.xcodeenv.override { version = xcodeVersion; };
+    kitchensink = kitchensink_ios_development;
     device = "iPhone";
   };
   
   simulate_kitchensink_ipad = import ./simulate-kitchensink {
-    inherit (pkgs_darwin_x86_64) stdenv;
-    inherit (pkgs_darwin_x86_64.titaniumenv) xcodeenv;
-    kitchensink = kitchensink_iphone;
+    inherit (pkgs) stdenv;
+    xcodeenv = pkgs.xcodeenv.override { version = xcodeVersion; };
+    kitchensink = kitchensink_ios_development;
     device = "iPad";
   };
-}
+} else {}) // (if rename then
+  let
+    pkgs = import nixpkgs { system = "x86_64-darwin"; };
+  in
+  {
+    kitchensink_ipa = import ./kitchensink {
+      inherit (pkgs) stdenv fetchgit;
+      titaniumenv = pkgs.titaniumenv.override { inherit xcodeVersion; };
+      target = "iphone";
+      release = true;
+      rename = true;
+      inherit newBundleId iosMobileProvisioningProfile iosCertificate iosCertificateName iosCertificatePassword;
+    };
+  }
+  
+else {})

pkgs/development/mobile/titaniumenv/examples/kitchensink/default.nix

···
-{titaniumenv, fetchgit, target, androidPlatformVersions ? [ "11" ]}:
+{ titaniumenv, fetchgit, target, androidPlatformVersions ? [ "11" ], release ? false
+, rename ? false, stdenv ? null, newBundleId ? null, iosMobileProvisioningProfile ? null, iosCertificate ? null, iosCertificateName ? null, iosCertificatePassword ? null
+}:
+
+assert rename -> (stdenv != null && newBundleId != null && iosMobileProvisioningProfile != null && iosCertificate != null && iosCertificateName != null && iosCertificatePassword != null);
 
-titaniumenv.buildApp {
-  name = "KitchenSink-${target}";
-  appName = "KitchenSink";
-  appId = "com.appcelerator.kitchensink";
+let
   src = fetchgit {
     url = https://github.com/appcelerator/KitchenSink.git;
-    rev = "b68757ef6639e3da564e21038dc9c1aee1f80907";
-    sha256 = "17yabdkl0p6pf2a2lcgw1kid2smwc8rnpx0i9fa4avj6930cbh5i";
+    rev = "d9f39950c0137a1dd67c925ef9e8046a9f0644ff";
+    sha256 = "0aj42ac262hw9n9blzhfibg61kkbp3wky69rp2yhd11vwjlcq1qc";
   };
   
-  inherit target androidPlatformVersions;
+  # Rename the bundle id to something else
+  renamedSrc = stdenv.mkDerivation {
+    name = "KitchenSink-renamedsrc";
+    inherit src;
+    buildPhase = ''
+      sed -i -e "s|com.appcelerator.kitchensink|${newBundleId}|" tiapp.xml
+      sed -i -e "s|com.appcelerator.kitchensink|${newBundleId}|" manifest
+    '';
+    installPhase = ''
+      mkdir -p $out
+      mv * $out
+    '';
+  };
+in
+titaniumenv.buildApp {
+  name = "KitchenSink-${target}-${if release then "release" else "debug"}";
+  appName = "KitchenSink";
+  appId = if rename then newBundleId else "com.appcelerator.kitchensink";
+  src = if rename then renamedSrc else src;
   
-  /*release = true;
-  androidKeyStore = /home/sander/keystore;
-  androidKeyAlias = "sander";
-  androidKeyStorePassword = "foobar";*/
+  inherit target androidPlatformVersions release;
+  
+  androidKeyStore = ./keystore;
+  androidKeyAlias = "myfirstapp";
+  androidKeyStorePassword = "mykeystore";
   
-  /*release = true;
-  iosKeyFile = /Users/sander/Downloads/profile.mobileprovision;
-  iosCertificateName = "My Company";
-  iosCertificate = /Users/sander/Downloads/c.p12;
-  iosCertificatePassword = "";*/
+  inherit iosMobileProvisioningProfile iosCertificate iosCertificateName iosCertificatePassword;
 }

pkgs/development/mobile/titaniumenv/examples/kitchensink/generatekeystore.sh

···
+#!/bin/sh -e
+
+( echo "John Doe"
+  echo "My Company"
+  echo "My Organization"
+  echo "My City"
+  echo "My State"
+  echo "US"
+  echo "yes"
+) | keytool --genkeypair --alias myfirstapp --keystore ./keystore --storepass mykeystore

pkgs/development/mobile/titaniumenv/fixselfruntimev8.sed

···
-s|apk_zip.write(os.path.join(lib_source_dir, fname), lib_dest_dir + fname)|info = zipfile.ZipInfo(lib_dest_dir + fname)\n\t\t\t\t\tinfo.compress_type = zipfile.ZIP_DEFLATED\n\t\t\t\t\tinfo.create_system = 3\n\t\t\t\t\tf = open(os.path.join(lib_source_dir, fname))\n\t\t\t\t\tapk_zip.writestr(info, f.read())\n\t\t\t\t\tf.close()|

pkgs/development/mobile/titaniumenv/titaniumsdk-2.1.nix

···
-{stdenv, fetchurl, unzip, makeWrapper, python, jdk}:
-
-stdenv.mkDerivation {
-  name = "titanium-mobilesdk-2.1.4.v20121109124659";
-  src = if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") then fetchurl {
-    url = http://builds.appcelerator.com.s3.amazonaws.com/mobile/2_1_X/mobilesdk-2.1.4.v20121109124659-linux.zip;
-    sha1 = "381eb4b06b5a261ddf336c52d4714e5626142697";
-  }
-  else if stdenv.system == "x86_64-darwin" then fetchurl {
-    url = http://builds.appcelerator.com.s3.amazonaws.com/mobile/2_1_X/mobilesdk-2.1.4.v20121109124659-osx.zip;
-    sha1 = "1cef5803f0c7b7bb35feb88d3f91bbb191e3953e";
-  }
-  else throw "Platform: ${stdenv.system} not supported!";
-  
-  buildInputs = [ unzip makeWrapper ];
-  
-  buildCommand = ''
-    mkdir -p $out
-    cd $out
-    yes y | unzip $src
-    
-    # Fix shebang header for python scripts
-    
-    find . -name \*.py | while read i
-    do
-        sed -i -e "s|#!/usr/bin/env python|#!${python}/bin/python|" $i
-    done
-   
-    # Zip files do not support timestamps lower than 1980. We have to apply a few work-arounds to cope with that
-    # Yes, I know it's nasty :-)
-    
-    cd mobilesdk/*/*/android
-    
-    sed -i -f ${./fixtiverify.sed} builder.py
-    sed -i -f ${./fixselfruntimev8.sed} builder.py
-    sed -i -f ${./fixnativelibs.sed} builder.py
-    
-    # Patch some executables
-    
-    ${if stdenv.system == "i686-linux" then
-      ''
-        patchelf --set-interpreter ${stdenv.gcc.libc}/lib/ld-linux.so.2 titanium_prep.linux32
-      ''
-      else if stdenv.system == "x86_64-linux" then
-      ''
-        patchelf --set-interpreter ${stdenv.gcc.libc}/lib/ld-linux-x86-64.so.2 titanium_prep.linux64
-      ''
-      else ""}
-    
-    # Wrap builder script
-    
-    wrapProgram `pwd`/builder.py \
-      --prefix PYTHONPATH : ${python.modules.sqlite3}/lib/python*/site-packages \
-      --prefix PATH : ${jdk}/bin \
-      --prefix JAVA_HOME : ${jdk}
-  '' + stdenv.lib.optionalString (stdenv.system == "x86_64-darwin") ''
-    # 'ditto' utility is needed to copy stuff to the Xcode organizer. Dirty, but this allows it to work.
-    sed -i -e "s|ditto|/usr/bin/ditto|g" $out/mobilesdk/osx/*/iphone/builder.py
-  '';
-}

pkgs/development/mobile/titaniumenv/titaniumsdk.nix

···
         sed -i -e "s|#!/usr/bin/env python|#!${python}/bin/python|" $i
     done
    
+    # Rename ugly version number
+    cd mobilesdk/*
+    mv 3.1.4.v20130926144546 3.1.4.GA
+    cd 3.1.4.GA
+    
     # Zip files do not support timestamps lower than 1980. We have to apply a few work-arounds to cope with that
     # Yes, I know it's nasty :-)
     
-    cd mobilesdk/*/*/android
+    cd android
     
     sed -i -f ${./fixtiverify.sed} builder.py
     sed -i -f ${./fixtiprofiler.sed} builder.py
···
     
     # Wrap builder script
     
-    wrapProgram `pwd`/builder.py \
-      --prefix PYTHONPATH : ${python.modules.sqlite3}/lib/python*/site-packages \
-      --prefix PATH : ${jdk}/bin \
-      --prefix JAVA_HOME : ${jdk}
+    mv builder.py .builder.py
+    cat > builder.py <<EOF
+    #!${python}/bin/python
+    
+    import os, sys
+    
+    os.environ['PYTHONPATH'] = '$(echo ${python.modules.sqlite3}/lib/python*/site-packages)'
+    os.environ['JAVA_HOME'] = '${if stdenv.system == "x86_64-darwin" then jdk else "${jdk}/lib/openjdk"}'
+    
+    os.execv('$(pwd)/.builder.py', sys.argv)
+    EOF
+    
+    chmod +x builder.py
+    
   '' + stdenv.lib.optionalString (stdenv.system == "x86_64-darwin") ''
     # 'ditto' utility is needed to copy stuff to the Xcode organizer. Dirty, but this allows it to work.
     sed -i -e "s|ditto|/usr/bin/ditto|g" $out/mobilesdk/osx/*/iphone/builder.py

pkgs/development/mobile/xcodeenv/simulate-app.nix

···
 {stdenv, xcodewrapper}:
 { name, appName ? null, app
 , device ? "iPhone", baseDir ? ""
-, sdkVersion ? "6.1"
+, sdkVersion ? "7.0"
 }:
 
 let

pkgs/development/python-modules/pyqt/4.x.nix

···
 { stdenv, fetchurl, python, sip, qt4, pythonDBus, pkgconfig, lndir, makeWrapper }:
 
-stdenv.mkDerivation rec {
-  name = "PyQt-x11-gpl-4.10.3";
+let version = "4.10.2"; # kde410.pykde4 doesn't build with 4.10.3
+in
+stdenv.mkDerivation {
+  name = "PyQt-x11-gpl-${version}";
 
   src = fetchurl {
-    url = "mirror://sourceforge/pyqt/PyQt4/PyQt-4.10.3/PyQt-x11-gpl-4.10.3.tar.gz";
-    sha256 = "0c7nifx3w0b9w1k0g9dvav1rv1lvd7awmq0zkqn3n8clyfzbw4x7";
+    url = "mirror://sourceforge/pyqt/PyQt4/PyQt-${version}/PyQt-x11-gpl-${version}.tar.gz";
+    sha256 = "1zp69caqq195ymp911d0cka8619q78hzmfxvj7c51w2y53zg4z3l";
   };
 
   configurePhase = ''
···
     for i in $out/bin/*; do
       wrapProgram $i --prefix PYTHONPATH : "$PYTHONPATH"
     done
-  ''; # */
+  '';
 
   enableParallelBuilding = true;
 

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

···
 { stdenv, fetchurl, python }:
 
 stdenv.mkDerivation rec {
-  name = "sip-4.15.4";
+  name = "sip-4.14.7"; # kde410.pykde4 doesn't build with 4.15
 
   src = fetchurl {
     url = "mirror://sourceforge/pyqt/sip/${name}/${name}.tar.gz";
-    sha256 = "0a12lmqkf342yg42ygnjm1fyldcx9pzhy7z68p4ms4ydfcl78jsr";
+    sha256 = "1dv1sdwfmnq481v80k2951amzs9s87d4qhk0hpwrhb1sllh92rh5";
   };
 
   configurePhase = stdenv.lib.optionalString stdenv.isDarwin ''

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

···
 
 let
   name = "cppcheck";
-  version = "1.62";
+  version = "1.63";
 in
 stdenv.mkDerivation {
   name = "${name}-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/${name}/${name}-${version}.tar.bz2";
-    sha256 = "031x2khbk0anlacpdk5g5r3q3y4xj0z5zsfhf2wcv189hxl7698c";
+    sha256 = "0r10z44qydqxxxlxiggl2nzksd3gkb7bp784dfmpnnr1jd2zqjwj";
   };
 
   configurePhase = "makeFlags=PREFIX=$out";

pkgs/development/tools/build-managers/apache-ant/ant-contrib.nix

···
-args: with args;
-
-stdenv.mkDerivation {
-  name = "ant-contrib-1.0b3";
-
-  installPhase = ''
-    mkdir -p $out
-    mv ant-contrib*.jar $out/
-  '';
-
-  phases = "unpackPhase installPhase";
-
-  src = fetchurl {
-    url = mirror://sourceforge/ant-contrib/ant-contrib-1.0b3-bin.tar.bz2;
-    sha256 = "96effcca2581c1ab42a4828c770b48d54852edf9e71cefc9ed2ffd6590571ad1";
-  };
-}

pkgs/development/tools/build-managers/apache-ant/builder.sh

···
-source $stdenv/setup
-
-tar jxf $src || exit 1
-mkdir -p $out
-
-mv apache-ant-*/* $out || exit 1
-
-# add ant-contrib
-cp $antContrib/*.jar $out/lib
-
-# remove crap in the root directory
-
-for file in $out/*
-do
-  if test -f $file ; then
-    rm $file
-  fi
-done
-rm -rf $out/docs
-
-# prevent the use of hacky scripts. This will be handled in Nix.
-rm $out/bin/* || exit 1
-
-# add ant script. This script is to be invoked with all
-# appropiate variables and will try to be clever or user-friendly.
-
-cat >> $out/bin/ant <<EOF
-#! /bin/sh
-
-export JAVA_HOME=$jdk
-export JAVACMD=$jdk/bin/java
-export LANG="en_US"
-
-export ANT_HOME=$out
- 
-if [ -z "\$LOCALCLASSPATH" ] ; then
-    LOCALCLASSPATH=\$ANT_HOME/lib/ant-launcher.jar
-else
-    LOCALCLASSPATH=\$ANT_HOME/lib/ant-launcher.jar:\$LOCALCLASSPATH
-fi
-
-if [ -n "\$JIKESPATH" ]; then
-  exec "\$JAVACMD" \$NIX_ANT_OPTS \$ANT_OPTS -classpath "\$LOCALCLASSPATH" -Dant.home="\${ANT_HOME}" -Djikes.class.path="\$JIKESPATH" org.apache.tools.ant.launch.Launcher \$NIX_ANT_ARGS \$ANT_ARGS -lib "$CLASSPATH" "\$@"
-else
-  exec "\$JAVACMD" \$NIX_ANT_OPTS \$ANT_OPTS -classpath "\$LOCALCLASSPATH" -Dant.home="\${ANT_HOME}" org.apache.tools.ant.launch.Launcher \$NIX_ANT_ARGS \$ANT_ARGS -lib "$CLASSPATH" "\$@"
-  fi
-fi
-EOF
-
-chmod a+x $out/bin/ant
-
-ln -s $out/bin/ant $out/bin/antRun
-

pkgs/development/tools/build-managers/apache-ant/default.nix

···
-{ fetchurl, stdenv, jdk }:
+{ fetchurl, stdenv, makeWrapper }:
+
+let version = "1.9.3"; in
 
-let
+stdenv.mkDerivation {
+  name = "ant-${version}";
+
+  buildInputs = [ makeWrapper ];
 
-  antContrib = import ./ant-contrib.nix {
-    inherit fetchurl stdenv;
+  src = fetchurl {
+    url = "mirror://apache/ant/binaries/apache-ant-${version}-bin.tar.bz2";
+    sha1 = "efcf206e24b0dd1583c501182ad163af277951a4";
   };
 
-  version = "1.8.4";
+  contrib = fetchurl {
+    url = mirror://sourceforge/ant-contrib/ant-contrib-1.0b3-bin.tar.bz2;
+    sha256 = "96effcca2581c1ab42a4828c770b48d54852edf9e71cefc9ed2ffd6590571ad1";
+  };
 
-in
+  installPhase =
+    ''
+      mkdir -p $out/bin $out/lib/ant
+      mv * $out/lib/ant/
 
-stdenv.mkDerivation {
-  name = "ant-${(builtins.parseDrvName jdk.name).name}-${version}";
+      # Get rid of the manual (35 MiB).  Maybe we should put this in a
+      # separate output.  Also get rid of the Ant scripts since we
+      # provide our own.
+      rm -rf $out/lib/ant/{manual,bin,WHATSNEW}
 
-  builder = ./builder.sh;
-  
-  buildInputs = [ antContrib jdk ];
+      # Install ant-contrib.
+      unpackFile $contrib
+      cp -p ant-contrib/ant-contrib-*.jar $out/lib/ant/lib/
 
-  inherit antContrib jdk;
+      cat >> $out/bin/ant <<EOF
+      #! ${stdenv.shell} -e
 
-  src = fetchurl {
-    url = "mirror://apache/ant/binaries/apache-ant-${version}-bin.tar.bz2";
-    sha1 = "d9e3e83dd9664cfe1dcd4841c082db3f559af922";
-  };
+      ANT_HOME=$out/lib/ant
+
+      # Find the JDK by looking for javac.  As a fall-back, find the
+      # JRE by looking for java.  The latter allows just the JRE to be
+      # used with (say) ECJ as the compiler.  Finally, allow the GNU
+      # JVM.
+      if [ -z "\$JAVA_HOME" ]; then
+          for i in javac java gij; do
+              if p="\$(type -p \$i)"; then
+                  export JAVA_HOME="\$(dirname \$(dirname \$(readlink -f \$p)))"
+                  break
+              fi
+          done
+          if [ -z "\$JAVA_HOME" ]; then
+              echo "\$0: cannot find the JDK or JRE" >&2
+              exit 1
+          fi
+      fi
+
+      if [ -z \$NIX_JVM ]; then
+          if [ -e \$JAVA_HOME/bin/java ]; then
+              NIX_JVM=\$JAVA_HOME/bin/java
+          elif [ -e \$JAVA_HOME/bin/gij ]; then
+              NIX_JVM=\$JAVA_HOME/bin/gij
+          else
+              NIX_JVM=java
+          fi
+      fi
+
+      LOCALCLASSPATH="\$ANT_HOME/lib/ant-launcher.jar\''${LOCALCLASSPATH:+:}\$LOCALCLASSPATH"
+
+      if [ -e \$JAVA_HOME/lib/tools.jar ]; then
+          LOCALCLASSPATH="\$JAVA_HOME/lib/tools.jar\''${LOCALCLASSPATH:+:}\$LOCALCLASSPATH"
+      fi
+
+      exec \$NIX_JVM \$NIX_ANT_OPTS \$ANT_OPTS -classpath "\$LOCALCLASSPATH" \
+          -Dant.home=\$ANT_HOME -Dant.library.dir="\$ANT_LIB" \
+          org.apache.tools.ant.launch.Launcher \$NIX_ANT_ARGS \$ANT_ARGS \
+          -cp "\$CLASSPATH" "\$@"
+      EOF
+
+      chmod +x $out/bin/ant
+    ''; # */
 
   meta = {
-    description = "Java-based build tool";
+    homepage = http://ant.apache.org/;
+    description = "A Java-based build tool";
+
+    longDescription = ''
+      Apache Ant is a Java-based build tool.  In theory, it is kind of like
+      Make, but without Make's wrinkles.
+
+      Why another build tool when there is already make, gnumake, nmake, jam,
+      and others? Because all those tools have limitations that Ant's
+      original author couldn't live with when developing software across
+      multiple platforms.  Make-like tools are inherently shell-based -- they
+      evaluate a set of dependencies, then execute commands not unlike what
+      you would issue in a shell.  This means that you can easily extend
+      these tools by using or writing any program for the OS that you are
+      working on.  However, this also means that you limit yourself to the
+      OS, or at least the OS type such as Unix, that you are working on.
+
+      Ant is different.  Instead of a model where it is extended with
+      shell-based commands, Ant is extended using Java classes.  Instead of
+      writing shell commands, the configuration files are XML-based, calling
+      out a target tree where various tasks get executed.  Each task is run
+      by an object that implements a particular Task interface.
+    '';
+
+    license = stdenv.lib.licenses.asl20;
+    maintainers = [ stdenv.lib.maintainers.eelco ];
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/development/tools/build-managers/apache-ant/from-source.nix

···
-{ stdenv, fetchurl, gcj, junit }:
-
-let version = "1.7.1"; in
-
-/* TODO: Once we have Icedtea, use this Nix expression to build Ant with
-   Sun's javac.  */
-
-stdenv.mkDerivation {
-  name = "ant-gcj-${version}";
-
-  src = fetchurl {
-    url = "mirror://apache/ant/source/apache-ant-${version}-src.tar.bz2";
-    sha256 = "19pvqvgkxgpgsqm4lvbki5sm0z84kxmykdqicvfad47gc1r9mi2d";
-  };
-
-  patches = [ ./use-gcj.patch ];
-
-  buildInputs = [ gcj junit ];
-
-  configurePhase = ''
-    mkdir -p "tool-aliases/bin"
-    cd "tool-aliases/bin"
-    cat > javac <<EOF
-#!/bin/sh
-opts="-C"
-echo 'running \`gcj '"\$opts \$@'..."
-exec "$(type -P gcj)" \$opts \$@
-EOF
-    chmod +x javac
-    ln -sv $(type -P gij) java
-    export PATH="$PWD:$PATH"
-
-    cd ../..
-    export JAVA_HOME="$PWD/tool-aliases"
-
-    # Make JUnit visible.
-    export CLASSPATH="$(find ${junit} -name \*.jar -printf "%p:")"
-  '';
-
-  # Note: We don't build the javadoc.
-  buildPhase = ''
-    mkdir -p "$out"
-    ./build.sh -Dant.install="$out" install-lite
-  '';
-
-  installPhase = ''
-    # Actually, everything is already installed at this point, so we just
-    # rearrange a few things.
-    rm -v "$out/bin/"*.bat
-
-    mkdir -p "$out/lib/java"
-    mv -v "$out/lib/"*.jar "$out/lib/java"
-    sed -i "$out/bin/ant" \
-        -e "s|^ANT_LIB=.*$|ANT_LIB=$out/lib/java|g ;
-            s|JAVACMD=java.*$|JAVACMD=${gcj}/lib/jvm/bin/java|g ;
-            /^ant_exec_command/i export ANT_HOME=$out"
-  '';
-
-  meta = {
-    description = "Java-based build tool";
-
-    longDescription = ''
-      Apache Ant is a Java-based build tool.  In theory, it is kind of like
-      Make, but without Make's wrinkles.
-
-      Why another build tool when there is already make, gnumake, nmake, jam,
-      and others? Because all those tools have limitations that Ant's
-      original author couldn't live with when developing software across
-      multiple platforms.  Make-like tools are inherently shell-based -- they
-      evaluate a set of dependencies, then execute commands not unlike what
-      you would issue in a shell.  This means that you can easily extend
-      these tools by using or writing any program for the OS that you are
-      working on.  However, this also means that you limit yourself to the
-      OS, or at least the OS type such as Unix, that you are working on.
-
-      Ant is different.  Instead of a model where it is extended with
-      shell-based commands, Ant is extended using Java classes.  Instead of
-      writing shell commands, the configuration files are XML-based, calling
-      out a target tree where various tasks get executed.  Each task is run
-      by an object that implements a particular Task interface.
-    '';
-
-    homepage = http://ant.apache.org/;
-
-    license = "APLv2";
-
-    maintainers = [ ];
-    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
-  };
-}

pkgs/development/tools/build-managers/apache-ant/use-gcj.patch

···
-Setting `java.compiler' or `build.compiler' in `build.properties' isn't enough.
-
---- apache-ant-1.7.1/build.xml	2008-06-27 07:05:23.000000000 +0200
-+++ apache-ant-1.7.1/build.xml	2009-09-24 15:10:53.000000000 +0200
-@@ -578,12 +578,7 @@
-       classname="com.jcraft.jsch.Session"
-       classpathref="classpath"/>
- 
--    <condition property="build.compiler" value="classic">
--      <not>
--        <isset property="jdk1.3+"/>
--      </not>
--    </condition>
--    <property name="build.compiler" value="modern"/>
-+    <property name="build.compiler" value="gcj"/>
- 
-     <!--check for XSD support in the parser-->
-     <condition property="xmlschema.present">

pkgs/development/tools/build-managers/leiningen/builder.sh

···
 #!/bin/bash
 
-set -e
-
 source $stdenv/setup
 
-mkdir -pv $out/bin $out/lib
+mkdir -pv $out/bin $out/share/java
 
 out_bin=$out/bin/lein
 
 cp -v $src $out_bin
-cp -v $jarsrc $out/lib
-cp -v $clojure/lib/java/* $out/lib
+cp -v $jarsrc $out/share/java
+cp -v $clojure/share/java/* $out/share/java/
 
 for p in $patches;
 do

pkgs/development/tools/build-managers/leiningen/lein_2.3.0.patch

···
 46c47
 < LEIN_JAR=/usr/share/java/leiningen-$LEIN_VERSION-standalone.jar
 ---
-> LEIN_JAR=$(find $(dirname $0)/../lib -name *-standalone.jar | head -n 1)
+> LEIN_JAR=$(find $(dirname $0)/../share/java -name *-standalone.jar | head -n 1)

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

···
-{ cabal, filepath }:
+{ cabal, filepath, HUnit, interlude, json }:
 
 cabal.mkDerivation (self: {
   pname = "hasktags";
-  version = "0.68.2";
-  sha256 = "0lb28vj8mhaskw3n7wpjgbj0311ywh76yc0ajczzsiqa3p6mypss";
+  version = "0.68.5";
+  sha256 = "0yr7icaww5kiczmi64n2ypkwabs4yl8wl2kf67zmgclp12kqik81";
   isLibrary = false;
   isExecutable = true;
-  buildDepends = [ filepath ];
+  buildDepends = [ filepath HUnit interlude json ];
   meta = {
+    homepage = "http://github.com/MarcWeber/hasktags";
     description = "Produces ctags \"tags\" and etags \"TAGS\" files for Haskell programs";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

pkgs/development/tools/misc/automake/automake-1.14.x.nix

···
 { stdenv, fetchurl, perl, autoconf, makeWrapper, doCheck ? false }:
 
 stdenv.mkDerivation rec {
-  name = "automake-1.14";
+  name = "automake-1.14.1";
 
   src = fetchurl {
     url = "mirror://gnu/automake/${name}.tar.xz";
-    sha256 = "0nc0zqq8j336kamizzd86wb19vhbwywv5avcjh3cyx230xfqy671";
+    sha256 = "0s86rzdayj1licgj35q0mnynv5xa8f4p32m36blc5jk9id5z1d59";
   };
 
   buildInputs = [ perl autoconf ];

pkgs/development/tools/parsing/jikespg/builder.sh

···
-source $stdenv/setup
-
-set -e
-
-configurePhase() {
-  tar zxvf $src 
-  cd jikespg/src
-}
-
-installPhase() {
-  mkdir -p $out/bin
-  cp jikespg $out/bin
-}
-
-genericBuild

pkgs/development/tools/parsing/jikespg/default.nix

···
 
 stdenv.mkDerivation {
   name = "jikespg-1.3";
-  builder = ./builder.sh;
+
   src = fetchurl {
     url = mirror://sourceforge/jikes/jikespg-1.3.tar.gz;
     md5 = "eba183713d9ae61a887211be80eeb21f";
+  };
+
+  sourceRoot = "jikespg/src";
+
+  installPhase =
+    ''
+      mkdir -p $out/bin
+      cp jikespg $out/bin
+    '';
+
+  meta = {
+    homepage = http://jikes.sourceforge.net/;
+    description = "The Jikes Parser Generator";
   };
 }

pkgs/development/web/nodejs/no-xcode.patch

···
 diff -Naur a/tools/gyp/pylib/gyp/xcode_emulation.py b/tools/gyp/pylib/gyp/xcode_emulation.py
---- a/tools/gyp/pylib/gyp/xcode_emulation.py	2013-11-12 21:22:12.000000000 +0100
-+++ b/tools/gyp/pylib/gyp/xcode_emulation.py	2013-12-17 11:07:11.000000000 +0100
-@@ -285,8 +285,15 @@
-     if sdk_root.startswith('/'):
-       return sdk_root
+--- a/tools/gyp/pylib/gyp/xcode_emulation.py	2013-12-19 00:49:45.000000000 +0100
++++ b/tools/gyp/pylib/gyp/xcode_emulation.py	2014-01-13 13:46:19.000000000 +0100
+@@ -295,11 +295,20 @@
+ 
+   def _XcodeSdkPath(self, sdk_root):
      if sdk_root not in XcodeSettings._sdk_path_cache:
--      XcodeSettings._sdk_path_cache[sdk_root] = self._GetSdkVersionInfoItem(
--          sdk_root, 'Path')
-+      try:
-+        XcodeSettings._sdk_path_cache[sdk_root] = self._GetSdkVersionInfoItem(
-+            sdk_root, 'Path')
-+      except:
-+        # if this fails it's because xcodebuild failed, which means
-+        # the user is probably on a CLT-only system, where there
-+        # is no valid SDK root
-+        XcodeSettings._sdk_path_cache[sdk_root] = None
+-      sdk_path = self._GetSdkVersionInfoItem(sdk_root, 'Path')
+-      XcodeSettings._sdk_path_cache[sdk_root] = sdk_path
+-      if sdk_root:
+-        XcodeSettings._sdk_root_cache[sdk_path] = sdk_root
+-    return XcodeSettings._sdk_path_cache[sdk_root]
++        try:
++            sdk_path = self._GetSdkVersionInfoItem(sdk_root, 'Path')
++            XcodeSettings._sdk_path_cache[sdk_root] = sdk_path
++            
++            if sdk_root:
++                XcodeSettings._sdk_root_cache[sdk_path] = sdk_root
++        except:
++            # if this fails it's because xcodebuild failed, which means
++            # the user is probably on a CLT-only system, where there
++            # is no valid SDK root
++            XcodeSettings._sdk_path_cache[sdk_root] = None
 +
-     return XcodeSettings._sdk_path_cache[sdk_root]
++    return None;
++    #return XcodeSettings._sdk_path_cache[sdk_root]
  
    def _AppendPlatformVersionMinFlags(self, lst):
-@@ -397,10 +404,11 @@
+     self._Appendf(lst, 'MACOSX_DEPLOYMENT_TARGET', '-mmacosx-version-min=%s')
+@@ -409,10 +418,11 @@
  
      cflags += self._Settings().get('WARNING_CFLAGS', [])
  
···
  
      self.configname = None
      return cflags
-@@ -647,10 +655,11 @@
+@@ -659,10 +669,11 @@
      for rpath in self._Settings().get('LD_RUNPATH_SEARCH_PATHS', []):
        ldflags.append('-Wl,-rpath,' + rpath)
  
···
  
      self.configname = None
      return ldflags
-@@ -826,7 +835,10 @@
+@@ -843,7 +854,10 @@
          l = '-l' + m.group(1)
        else:
          l = library
···
  
    def AdjustLibraries(self, libraries, config_name=None):
      """Transforms entries like 'Cocoa.framework' in libraries into entries like
+@@ -956,12 +970,15 @@
+     # Since the value returned by this function is only used when ARCHS is not
+     # set, then on iOS we return "i386", as the default xcode project generator
+     # does not set ARCHS if it is not set in the .gyp file.
+-    if self.isIOS:
+-      return 'i386'
+-    version, build = self._XcodeVersion()
+-    if version >= '0500':
+-      return 'x86_64'
+-    return 'i386'
++    try:
++        if self.isIOS:
++          return 'i386'
++        version, build = self._XcodeVersion()
++        if version >= '0500':
++          return 'x86_64'
++        return 'i386'
++    except:
++        return 'x86_64'
+ 
+ class MacPrefixHeader(object):
+   """A class that helps with emulating Xcode's GCC_PREFIX_HEADER feature.

pkgs/games/flightgear/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "2.12.0";
+  version = "2.12.1";
   name = "flightgear-${version}";
 
   src = fetchurl {
     url = "http://ftp.linux.kiev.ua/pub/fgfs/Source/${name}.tar.bz2";
-    sha256 = "0h9ka4pa2njxbvy5jlmnsjy5ynzms504ygqn7hd80g3c58drsjc4";
+    sha256 = "1wj0a9k9pq404lylmv7v5f05vmrqd8fwj61kr78vldf44n44gixw";
   };
 
   datasrc = fetchurl {
-    url = "http://ftp.igh.cnrs.fr/pub/flightgear/ftp/Shared/FlightGear-data-${version}.tar.bz";
-    sha256 = "0qjvcj2cz7ypa91v95lws44fg8c1p0pazv24ljkai2m2r0jgsv8k";
+    url = "http://ftp.igh.cnrs.fr/pub/flightgear/ftp/Shared/FlightGear-${version}-data.tar.bz2";
+    sha256 = "0hlsvzz12pyzw3mb4xsv4iwblrbf7d27mdprll64kr7p1h9qlmkl";
   };
 
   # Of all the files in the source and data archives, there doesn't seem to be
···
 
   meta = with stdenv.lib; {
     description = "Flight simulator";
-    maintainers = with maintainers; [ raskin ];
+    maintainers = with maintainers; [ raskin the-kenny ];
     platforms = platforms.linux;
     hydraPlatforms = []; # disabled from hydra because it's so big
     license = licenses.gpl2;

pkgs/misc/emulators/wine/stable.nix

···
     license = "LGPL";
     inherit version;
     description = "An Open Source implementation of the Windows API on top of X, OpenGL, and Unix";
-    maintainers = [stdenv.lib.maintainers.raskin stdenv.lib.maintainers.simons];
+    maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/misc/emulators/wine/unstable.nix

···
 assert stdenv.isLinux;
 assert stdenv.gcc.gcc != null;
 
-let 
+let
     version = "1.7.10";
     name = "wine-${version}";
 
···
     license = "LGPL";
     inherit version;
     description = "An Open Source implementation of the Windows API on top of X, OpenGL, and Unix";
-    maintainers = [stdenv.lib.maintainers.raskin stdenv.lib.maintainers.simons];
+    maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
   };
 }

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.12.6";
+  version = "3.12.7";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "085c4d6663f7e85afe8ae196231f291b28187d4237e46492fa63e1726db04412";
+    sha256 = "1pmz1g919kbhf8mq23d25187gwzr8l85xj7bf9dvn3vpai7spafb";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.2.53";
+  version = "3.2.54";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1fvg76g3ixyz8spzzmw5gdfr0ni9wzi2g745vphknnd9a9rgwjdm";
+    sha256 = "15mr1mrsldvs3jx9nc25pfmmdbz2ykiaxnqc26chn6k425l4kn67";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.4.75";
+  version = "3.4.76";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "15i9gr66nbjvjjv9hwkvii307rn62627dq3pcp1j3zl472n302qr";
+    sha256 = "0rwa5n4z359351dnpfknmwi3f5is8haflpx9zq6rgb9dprv8af3j";
   };
 
   features.iwlwifi = true;

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

···
+{ stdenv
+, fetchurl
+, libtsm
+, systemd
+, libxkbcommon
+, libdrm
+, mesa
+, pango
+, pixman
+, pkgconfig
+, docbook_xsl
+, libxslt
+}:
+
+stdenv.mkDerivation rec {
+  name = "kmscon-8";
+
+  src = fetchurl {
+    url = "http://www.freedesktop.org/software/kmscon/releases/${name}.tar.xz";
+    sha256 = "0axfwrp3c8f4gb67ap2sqnkn75idpiw09s35wwn6kgagvhf1rc0a";
+  };
+
+  buildInputs = [
+    libtsm
+    systemd
+    libxkbcommon
+    libdrm
+    mesa
+    pango
+    pixman
+    pkgconfig
+    docbook_xsl
+    libxslt
+  ];
+
+  configureFlags = [
+    "--enable-multi-seat"
+    "--disable-debug"
+    "--enable-optimizations"
+    "--with-renderers=bbulk,gltex,pixman"
+  ];
+
+  meta = {
+    description = "KMS/DRM based System Console";
+    homepage = "http://www.freedesktop.org/wiki/Software/kmscon/";
+    license = stdenv.lib.licenses.mit;
+    maintainers = [ stdenv.lib.maintainers.shlevy ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/servers/dns/bind/default.nix

···
 { stdenv, fetchurl, openssl, libtool, perl, libxml2 }:
 
-let version = "9.9.3-P2"; in
+let version = "9.9.4-P2"; in
 
 stdenv.mkDerivation rec {
 
···
 
   src = fetchurl {
     url = "http://ftp.isc.org/isc/bind9/${version}/${name}.tar.gz";
-    sha256 = "0y66ns28n3bcq8hp8srgpaxi9ix7myh2rlcsrr3qpwvkgdnb12jy";
+    sha256 = "128aqizcjbakrqrijjpy54qffqz1jafa94lhnqig7lr63r1wdwsh";
   };
 
   patchPhase = ''

pkgs/servers/http/apache-modules/mod_wsgi/default.nix

···
 { stdenv, fetchurl, apacheHttpd, python }:
 
 stdenv.mkDerivation {
-  name = "mod_wsgi-3.3";
+  name = "mod_wsgi-3.4";
 
   src = fetchurl {
-    url = "http://modwsgi.googlecode.com/files/mod_wsgi-3.3.tar.gz";
-    sha256 = "0hrjksym0dlqn1ka1yf3x6ar801zqxfykwcxazjwz104k5w10vnr";
+    url = "http://modwsgi.googlecode.com/files/mod_wsgi-3.4.tar.gz";
+    sha256 = "1s5nnjssvcl6lzy7kxmrk47yz6sgfzk90i1y7jml0s0lks7ck1df";
   };
 
   buildInputs = [ apacheHttpd python ];

pkgs/servers/http/lighttpd/default.nix

···
 assert enableMagnet -> lua5 != null;
 
 stdenv.mkDerivation rec {
-  name = "lighttpd-1.4.33";
+  name = "lighttpd-1.4.34";
 
   src = fetchurl {
     url = "http://download.lighttpd.net/lighttpd/releases-1.4.x/${name}.tar.xz";
-    sha256 = "0331671snhhf48qb43mfb6l85v2rc3ryd3qvz56s8z454gfax1i8";
+    sha256 = "1dzgz3gkfyn97s4dm896yjanlhqzzsz38dhjdgla06xgynca1hdl";
   };
 
   buildInputs = [ pkgconfig pcre libxml2 zlib attr bzip2 which file openssl ]

pkgs/servers/kippo/default.nix

···
+# This is the installation portion of kippo.
+# This is somewhat jumbled together. There is no "easy_install" for kippo,
+# and there isn't a way to regenerate the twistd plugin cache.
+#
+# Use the services.kippo options to properly configure if on NixOS.
+# On other platforms there is a problem with hardcoded paths.
+# Your best bet is to change kippo source to customise
+# or manually copy the proper filesystems.
+# At a minimum the following are required in  /var/lib/kippo:
+#     honeyfs/
+#     fs.pickle
+#     data/
+#     txtcmds/
+#
+# There is also benefit in preparing /var/log/kippo
+#     tty/
+#     dl/
+#
+# Most of these files need read/write permissions.
+#
+# Read only files: kippo.tac and kippo.cfg
+#
+# Execution may look like this:
+# twistd -y kippo.tac --syslog --pidfile=kippo.pid
+#
+# Use this package at your own risk.
+
+{stdenv, pkgs, config, fetchurl, ... }:
+
+stdenv.mkDerivation rec {
+    name = "kippo-${version}";
+    version = "0.8";
+    src = fetchurl {
+      url = "https://kippo.googlecode.com/files/kippo-${version}.tar.gz";
+      sha1 = "f57a5cf88171cb005afe44a4b33cb16f825c33d6";
+    };
+    buildInputs = with pkgs.pythonPackages; [ pycrypto pyasn1 twisted ];
+    installPhase = ''
+        substituteInPlace ./kippo.tac --replace "kippo.cfg" "$out/src/kippo.cfg"
+        substituteInPlace ./kippo.cfg --replace "log_path = log" "log_path = /var/log/kippo" \
+            --replace "download_path = dl" "download_path = /var/log/kippo/dl" \
+            --replace "contents_path = honeyfs" "filesystem_file = /var/lib/kippo/honeyfs" \
+            --replace "filesystem_file = fs.pickle" "filesystem_file = /var/lib/kippo/fs.pickle" \
+            --replace "data_path = data" "data_path = /var/lib/kippo/data" \
+            --replace "txtcmds_path = txtcmds" "txtcmds_path = /var/lib/kippo/txtcmds" \
+            --replace "public_key = public.key" "public_key = /var/lib/kippo/keys/public.key" \
+            --replace "private_key = private.key" "private_key = /var/lib/kippo/keys/private.key" 
+        mkdir -p $out/bin
+        mkdir -p $out/src
+        mv ./* $out/src 
+        mv $out/src/utils/* $out/bin
+        '';
+
+    meta = {
+      homepage = https://code.google.com/p/kippo;
+      description = "SSH Honeypot";
+      longDescription = ''
+        Default port is 2222. Recommend using something like this for port redirection to default SSH port:
+        networking.firewall.extraCommands = '''
+        iptables -t nat -A PREROUTING -i IN_IFACE -p tcp --dport 22 -j REDIRECT --to-port 2222''' '';
+      license = stdenv.lib.licenses.bsd3;
+      platforms = pkgs.stdenv.lib.platforms.linux;
+      maintainers = pkgs.stdenv.lib.maintainers.tomberek;
+    };
+}

pkgs/servers/mail/mailman/default.nix

···
 { stdenv, fetchurl, python }:
 
 stdenv.mkDerivation rec {
-  name = "mailman-2.1.16";
+  name = "mailman-2.1.17";
 
   src = fetchurl {
     url = "mirror://gnu/mailman/${name}.tgz";
-    sha256 = "0qsgnqjfi07kdiwzik0i78a5q3q5kcw1r61g48abix9qjc32n5ax";
+    sha256 = "1rws4ghpq78ldp1si3z4pmiv1k4l8g6i6hjb2y4cwsjlxssahc64";
   };
 
   buildInputs = [ python ];

pkgs/servers/monitoring/munin/default.nix

···
-{ stdenv, fetchurl, makeWrapper, which, coreutils, rrdtool, perl, perlPackages
+{ stdenv, fetchgit, makeWrapper, which, coreutils, rrdtool, perl, perlPackages
 , python, ruby, openjdk, nettools
 }:
 
 stdenv.mkDerivation rec {
-  version = "2.0.17";
+  version = "2.0.19";
   name = "munin-${version}";
 
-  src = fetchurl {
-    url = "https://github.com/munin-monitoring/munin/archive/${version}.tar.gz";
-    sha256 = "0xfml2r6nssn3lcfqcf3yshxfijyrf9frnhdp83mg6raaznlhx1z";
+  src = fetchgit {
+    url = "git://github.com/munin-monitoring/munin.git";
+    rev = "refs/tags/${version}";
+    sha256 = "0027rrdrmcql68b475jlxnfgkijbfngynkjpdii6fgaszswqz3ay";
   };
 
   buildInputs = [ 
···
 
   preBuild = ''
     substituteInPlace "Makefile" \
-      --replace "/bin/pwd" "pwd"
+      --replace "/bin/pwd" "pwd" \
+      --replace "HTMLOld.3pm" "HTMLOld.3"
 
     # munin checks at build time if user/group exists, unpure
     sed -i '/CHECKUSER/d' Makefile

pkgs/servers/sql/postgresql/jdbc/builder.sh

···
-source $stdenv/setup
-
-set -e
-
-tar zxvf $src
-cd postgresql-jdbc-*
-ant
-
-mkdir -p $out/share/java
-cp jars/*.jar $out/share/java

pkgs/servers/sql/postgresql/jdbc/default.nix

···
-{ stdenv, fetchurl, ant }:
+{ stdenv, fetchurl, ant, jdk }:
+
+let version = "9.3-1100"; in
 
 stdenv.mkDerivation rec {
-  name = "postgresql-jdbc-9.1-902";
-  builder = ./builder.sh;
+  name = "postgresql-jdbc-${version}";
 
   src = fetchurl {
-    url = "http://jdbc.postgresql.org/download/${name}.src.tar.gz";
-    sha256 = "0sgwbiw5vfxcl0g1yzsndgxdha74cr8ag6y65i0jhgg5g8qc56bz";
+    url = "http://jdbc.postgresql.org/download/postgresql-jdbc-${version}.src.tar.gz";
+    sha256 = "0mbdzhzg4ws0i7ps98rg0q5n68lsrdm2klj7y7skaix0rpa57gp6";
   };
 
-  buildInputs = [ant];
+  buildInputs = [ ant jdk ];
+
+  buildPhase = "ant";
+
+  installPhase =
+    ''
+      mkdir -p $out/share/java
+      cp jars/*.jar $out/share/java
+    '';
 
   meta = {
     homepage = http://jdbc.postgresql.org/;

pkgs/servers/x11/xorg/default.nix

···
   })) // {inherit fontsproto libpciaccess randrproto renderproto videoproto xextproto xorgserver xproto ;};
 
   xf86videoati = (stdenv.mkDerivation ((if overrides ? xf86videoati then overrides.xf86videoati else x: x) {
-    name = "xf86-video-ati-7.1.0";
+    name = "xf86-video-ati-7.2.0";
     builder = ./builder.sh;
     src = fetchurl {
-      url = mirror://xorg/individual/driver/xf86-video-ati-7.1.0.tar.bz2;
-      sha256 = "1k8hwszx1zj17z0657dna8q4k7x67adc163z44jiccyb3w2l9bn8";
+      url = mirror://xorg/individual/driver/xf86-video-ati-7.2.0.tar.bz2;
+      sha256 = "1i5fknbbhynl5hv2dzznzcf0yadpm28jzvx7xl38vlfpr3ymw3zk";
     };
     buildInputs = [pkgconfig fontsproto libdrm udev libpciaccess randrproto renderproto videoproto xextproto xf86driproto xorgserver xproto ];
   })) // {inherit fontsproto libdrm udev libpciaccess randrproto renderproto videoproto xextproto xf86driproto xorgserver xproto ;};

pkgs/servers/x11/xorg/tarballs-7.7.list

···
 mirror://xorg/individual/driver/xf86-input-void-1.4.0.tar.bz2
 mirror://xorg/individual/driver/xf86-video-ark-0.7.5.tar.bz2
 mirror://xorg/individual/driver/xf86-video-ast-0.98.0.tar.bz2
-mirror://xorg/individual/driver/xf86-video-ati-7.1.0.tar.bz2
+mirror://xorg/individual/driver/xf86-video-ati-7.2.0.tar.bz2
 mirror://xorg/individual/driver/xf86-video-cirrus-1.5.2.tar.bz2
 mirror://xorg/individual/driver/xf86-video-dummy-0.3.7.tar.bz2
 mirror://xorg/individual/driver/xf86-video-fbdev-0.4.4.tar.bz2

pkgs/tools/X11/xbindkeys/default.nix

···
 { stdenv, fetchurl, libX11, guile }:
 
-let version = "1.8.5"; in
+let version = "1.8.6"; in
 stdenv.mkDerivation {
   name = "xbindkeys-${version}";
   src = fetchurl {
     url = "http://www.nongnu.org/xbindkeys/xbindkeys-${version}.tar.gz";
-    sha256 = "10gwyvj69yyqgk1xxbrl37gx3c3jfpgr92mz62b1x5q6jiq7hbyn";
+    sha256 = "060df6d8y727jp1inp7blp44cs8a7jig7vcm8ndsn6gw36z1h3bc";
   };
 
   buildInputs = [ libX11 guile ];

pkgs/tools/backup/duplicity/default.nix

···
 { stdenv, fetchurl, python, librsync, ncftp, gnupg, boto, makeWrapper }:
 
+let
+  version = "0.6.22";
+in
 stdenv.mkDerivation {
-  name = "duplicity-0.6.21";
+  name = "duplicity-${version}";
 
   src = fetchurl {
-    url = "http://code.launchpad.net/duplicity/0.6-series/0.6.21/+download/duplicity-0.6.21.tar.gz";
-    sha256 = "01ppxzghnig7al9cwi8ap95y0d3j5n0vf3ag06iw3ysiq6k8lqm3";
+    url = "http://code.launchpad.net/duplicity/0.6-series/${version}/+download/duplicity-${version}.tar.gz";
+    sha256 = "04jskh1j85s35vfzm9gylpl7ysn5njbl0gcg92bhc7v88l29nj3g";
   };
 
   installPhase = ''

pkgs/tools/compression/lzip/default.nix

···
 { stdenv, fetchurl, texinfo }:
 
 stdenv.mkDerivation rec {
-  name = "lzip-1.14";
+  name = "lzip-1.15";
 
   buildInputs = [ texinfo ];
 
   src = fetchurl {
     url = "mirror://savannah/lzip/${name}.tar.gz";
-    sha256 = "1rybhk2pxpfh2789ck9mrkdv3bpx7b7miwndlshb5vb02m9crxbz";
+    sha256 = "1dh5vmj5apizfawnsm50y7z064yx7cz3313przph16gwd3dgrlvw";
   };
 
   configureFlags = "CPPFLAGS=-DNDEBUG CFLAGS=-O3 CXXFLAGS=-O3";

pkgs/tools/compression/pigz/default.nix

···
 { stdenv, fetchurl, zlib, utillinux }:
 
 let name = "pigz";
-    version = "2.2.4";
+    version = "2.3.1";
 in
 stdenv.mkDerivation {
   name = name + "-" + version;
 
   src = fetchurl {
     url = "http://www.zlib.net/${name}/${name}-${version}.tar.gz";
-    sha256 = "7e7967c47f66c07be97cbfa25c8816b72f9d35258466ea31eddc7666c914160e";
+    sha256 = "0m5gw134wfqy1wwqzla0f6c88bxys1sq5gs22zrphf9a8bjhr6v2";
   };
 
   buildInputs = [zlib] ++ stdenv.lib.optional stdenv.isLinux utillinux;
···
     homepage = "http://www.zlib.net/pigz/";
     description = "A parallel implementation of gzip for multi-core machines";
 
-    platforms = stdenv.lib.platforms.unix;
+    hydraPlatforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/tools/filesystems/e2fsprogs/default.nix

···
 { stdenv, fetchurl, pkgconfig, libuuid }:
 
 stdenv.mkDerivation rec {
-  name = "e2fsprogs-1.42.8";
+  name = "e2fsprogs-1.42.9";
 
   src = fetchurl {
     url = "mirror://sourceforge/e2fsprogs/${name}.tar.gz";
-    sha256 = "b984aaf1fe888d6a4cf8c2e8d397207879599b5368f1d33232c1ec9d68d00c97";
+    sha256 = "00i83w22sbyq849as9vmaf2xcx1d06npvriyv8m0z81gx43ar4ig";
   };
 
   buildInputs = [ pkgconfig libuuid ];

pkgs/tools/graphics/graphviz/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "graphviz-2.28.0";
+  name = "graphviz-2.36.0";
 
   src = fetchurl {
     url = "http://www.graphviz.org/pub/graphviz/ARCHIVE/${name}.tar.gz";
-    sha256 = "0xpwg99cd8sp0c6r8klsmc66h1pday64kmnr4v6f9jkqqmrpkank";
+    sha256 = "0qb30z5sxlbjni732ndad3j4x7l36vsxpxn4fmf5fn7ivvc6dz9p";
   };
 
   buildInputs =
···
       pango gd gts
     ] ++ stdenv.lib.optionals (xlibs != null) [ xlibs.xlibs xlibs.libXrender ]
     ++ stdenv.lib.optional (stdenv.system == "x86_64-darwin") gettext;
-
-  patches = [ ./fix-broken-memcp-signature.patch ];
 
   CPPFLAGS = stdenv.lib.optionalString (stdenv.system == "x86_64-darwin") "-I${cairo}/include/cairo";
 

pkgs/tools/graphics/graphviz/fix-broken-memcp-signature.patch

···
-diff -ubr graphviz-2.28.0-orig/lib/cdt/cdt.h graphviz-2.28.0-new/lib/cdt/cdt.h
---- graphviz-2.28.0-orig/lib/cdt/cdt.h	2012-11-11 20:05:55.674397100 +0100
-+++ graphviz-2.28.0-new/lib/cdt/cdt.h	2012-11-11 20:06:28.069511092 +0100
-@@ -238,11 +238,6 @@
- extern int		dtstat _ARG_((Dt_t*, Dtstat_t*, int));
- extern unsigned int	dtstrhash _ARG_((unsigned int, Void_t*, int));
- 
--#if !_PACKAGE_ast
--extern int		memcmp _ARG_((const Void_t*, const Void_t*, size_t));
--extern int		strcmp _ARG_((const char*, const char*));
--#endif
--
- #undef extern
- _END_EXTERNS_
- 

pkgs/tools/misc/cpuminer/default.nix

···
+{ stdenv, fetchurl, curl, jansson }:
+
+stdenv.mkDerivation rec {
+  name = "cpuminer-${version}";
+  version = "2.3.2";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/cpuminer/pooler-${name}.tar.gz";
+    sha256 = "10xnb58w90kq8xgnkk0z99c0b9p9pxhkhkcs9dml5pgxfrlakckg";
+  };
+
+  buildInputs = [ curl jansson ];
+
+  meta = {
+    homepage = https://github.com/pooler/cpuminer;
+    description = "CPU miner for Litecoin and Bitcoin";
+    license = stdenv.lib.licenses.gpl2;
+    platforms = stdenv.lib.platforms.all;
+  };
+}

pkgs/tools/misc/direnv/default.nix

···
 { fetchurl, stdenv, go }:
 
 let
-  version = "2.2.0";
+  version = "2.2.1";
 in
 stdenv.mkDerivation {
   name = "direnv-${version}";
   src = fetchurl {
     url = "http://github.com/zimbatm/direnv/archive/v${version}.tar.gz";
     name = "direnv-${version}.tar.gz";
-    sha256 = "e718ec2eec4e3a6ff78938445fc9702d7835ccfc8fa90f4293e387ac1305bf98";
+    sha256 = "6d55cb96189e20609a08133fe9392c50209cd435b4f77e3baaa0f423d82ae59a";
   };
 
   buildInputs = [ go ];

pkgs/tools/misc/jdiskreport/builder.sh

···
 
 jar=$(ls */*.jar)
 
-mkdir -p $out/lib/java
-mv $jar $out/lib/java
+mkdir -p $out/share/java
+mv $jar $out/share/java
 
 mkdir -p $out/bin
 cat > $out/bin/jdiskreport <<EOF
 #! $SHELL -e
-exec $jre/bin/java -jar $out/lib/java/$(basename $jar)
+exec $jre/bin/java -jar $out/share/java/$(basename $jar)
 EOF
 chmod +x $out/bin/jdiskreport

pkgs/tools/misc/smc/default.nix

···
     mkdir -p "$out/share/smc"
     mkdir -p "$out/share/smc/lib"
     mkdir -p "$out/share/icons"
-    mkdir -p "$out/lib/java"
+    mkdir -p "$out/share/java"
 
-    cp bin/Smc.jar "$out/lib/java/"
+    cp bin/Smc.jar "$out/share/java/"
     cp -r examples/ docs/ tools/ README.txt LICENSE.txt "$out/share/smc/"
     cp -r lib/* "$out/share/smc/lib/"
     cp misc/smc.ico "$out/share/icons/"
 
     cat > "$out/bin/smc" << EOF
     #!${stdenv.shell}
-    ${jre}/bin/java -jar "$out/lib/java/Smc.jar" "\$@"
+    ${jre}/bin/java -jar "$out/share/java/Smc.jar" "\$@"
     EOF
     chmod a+x "$out/bin/smc"
   '';

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

···
 { stdenv, fetchurl, python, zip }:
 
 let
-  version = "2014.01.07.5";
+  version = "2014.01.08";
 in
 stdenv.mkDerivation rec {
   name = "youtube-dl-${version}";
 
   src = fetchurl {
     url = "http://youtube-dl.org/downloads/${version}/${name}.tar.gz";
-    sha256 = "04b05wn0irx1h91zys8cwk56nwwd3nx7il6ydrcikyndv2vniz0m";
+    sha256 = "0a83j62w2k5fdxp3fvs0zr6r81w7jkzzzr8r8wim1yyi6k8cjcwv";
   };
 
   buildInputs = [ python ];

pkgs/tools/networking/ddclient/default.nix

···
 {buildPerlPackage, fetchurl, perlPackages, iproute}:
 
 buildPerlPackage {
-  name = "ddclient-3.8.1";
+  name = "ddclient-3.8.2";
 
   src = fetchurl {
-    url = mirror://sourceforge/ddclient/ddclient-3.8.1.tar.gz ;
-    sha256 = "f22ac7b0ec78e310d7b88a1cf636e5c00360b2ed9c087f231b3522ef3e6295f2";
+    url = mirror://sourceforge/ddclient/ddclient-3.8.2.tar.gz ;
+    sha256 = "17mcdqxcwa6c05m8xhxi4r37j4qvbp3wgbpvzqgmrmgwava5wcrw";
   };
 
   buildInputs = [ perlPackages.IOSocketSSL perlPackages.DigestSHA1 ];

pkgs/tools/networking/p2p/gtk-gnutella/default.nix

···
 
 let
   name = "gtk-gnutella";
-  version = "1.0.0";
+  version = "1.0.1";
 in
 stdenv.mkDerivation {
   name = "${name}-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/${name}/${name}-${version}.tar.bz2";
-    sha256 = "11nri43q99zbxql9wg3pkq98vcgzvbndpzc3a1jlg3lzh7css0hc";
+    sha256 = "010gzk2xqqkm309qnj5k28ghh9i92vvpnn8ly9apzb5gh8bqfm0g";
   };
 
   buildInputs = [pkgconfig glib gtk libxml2 bison gettext zlib];

pkgs/tools/networking/pdsh/default.nix

···
 {stdenv, fetchurl, perl, readline, rsh, ssh, pam}:
 
 let
-  name = "pdsh-2.26";
+  name = "pdsh-2.29";
 in
 stdenv.mkDerivation {
   inherit name;
 
   src = fetchurl {
     url = "http://pdsh.googlecode.com/files/${name}.tar.bz2";
-    sha256 = "ada2f35509064bf9cd0fd5ca39a351108cdd6f5155b05f39f1711a271298469a";
+    sha256 = "1kvzz01fyaxfqmbh53f4ljfsgvxdykh5jyr6fh4f1bw2ywxr1w2p";
   };
 
   buildInputs = [perl readline ssh pam];
···
       while timeouts occur on some connections.
     '';
 
-    hydraPlatforms = stdenv.lib.platforms.unix;
+    hydraPlatforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/tools/security/fail2ban/default.nix

···
 { stdenv, fetchurl, pythonPackages, unzip, gamin }:
 
-let version = "0.8.10"; in
+let version = "0.8.11"; in
 
 pythonPackages.buildPythonPackage {
   name = "fail2ban-${version}";
···
   src = fetchurl {
     url    = "https://github.com/fail2ban/fail2ban/zipball/${version}";
     name   = "fail2ban-${version}.zip";
-    sha256 = "0zbjwnghpdnzan7hn40cjjh2r06p2ph5kblpm0w1r72djwsk67x9";
+    sha256 = "0g87c1yfa6lxb68iz3sq3gxqf5c1a8m2anlvk3lsrx1mczbq0dlc";
   };
 
   buildInputs = [ unzip ];

pkgs/tools/security/sudo/default.nix

···
 { stdenv, fetchurl, coreutils, pam, groff }:
 
 stdenv.mkDerivation rec {
-  name = "sudo-1.8.8";
+  name = "sudo-1.8.9p3";
 
   src = fetchurl {
     urls =
       [ "ftp://ftp.sudo.ws/pub/sudo/${name}.tar.gz"
         "ftp://ftp.sudo.ws/pub/sudo/OLD/${name}.tar.gz"
       ];
-    sha256 = "1j9gk6pfqry44gvp41p7ajfnpl58jw8shbxmvq381ywpj8g1r4cz";
+    sha256 = "1dy549nwplc3d1147fvcl8p8hbrc7sslqldi6229r4pbibng1cd2";
   };
 
   postConfigure = ''

pkgs/tools/security/tor/torbrowser.nix

···
+{ stdenv, fetchurl, buildEnv
+, xlibs, alsaLib, dbus, dbus_glib, glib, gtk, atk, pango, freetype, fontconfig
+, gdk_pixbuf, cairo, zlib}:
+let
+  bits = if stdenv.system == "x86_64-linux" then "64"
+         else "32";
+
+  # isolated tor environment
+  torEnv = buildEnv {
+    name = "tor-env";
+    paths = [
+      stdenv.gcc.gcc zlib glib alsaLib dbus dbus_glib gtk atk pango freetype
+      fontconfig gdk_pixbuf cairo xlibs.libXrender xlibs.libX11 xlibs.libXext
+      xlibs.libXt
+    ];
+  };
+
+in stdenv.mkDerivation rec {
+  name = "tor-browser-${version}";
+  version = "3.5";
+
+  src = fetchurl {
+    url = "https://www.torproject.org/dist/torbrowser/${version}/tor-browser-linux${bits}-${version}_en-US.tar.xz";
+    sha256 = if bits == "64" then
+      "e448dc90365a88d73a6ff85347adbe763ef0f800d0cb2e7b7165d7f0646f7c41" else
+      "b0b29b4e75cd4a1aaecf7f4716216edcfc5947516744e2eaeae38bec1d03cea1";
+  };
+
+  patchPhase = ''
+    patchelf --set-interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" Browser/firefox
+    patchelf --set-interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" Tor/tor
+  '';
+
+  doCheck = true;
+  checkPhase = ''
+    # Just do a simple test if all libraries get loaded by running help on
+    # firefox and tor
+    echo "Checking firefox..."
+    LD_LIBRARY_PATH=${torEnv}/lib Browser/firefox --help 1> /dev/null
+    echo "Checking tor..."
+    LD_LIBRARY_PATH=${torEnv}/lib:Tor Tor/tor --help 1> /dev/null
+  '';
+
+  installPhase = ''
+    ensureDir $out/share/tor-browser
+    ensureDir $out/bin
+    cp -R * $out/share/tor-browser
+
+    cat > "$out/bin/tor-browser" << EOF
+      export HOME="\$HOME/.torbrowser"
+      if [ ! -d \$HOME ]; then
+        mkdir -p \$HOME && cp -R $out/share/tor-browser/Data \$HOME/ && chmod -R +w \$HOME
+        echo "pref(\"extensions.torlauncher.tordatadir_path\", \"\$HOME/Data/Tor/\");" >> \
+          ~/Data/Browser/profile.default/preferences/extension-overrides.js
+      fi
+      export LD_LIBRARY_PATH=${torEnv}/lib:$out/share/tor-browser/Tor
+      $out/share/tor-browser/Browser/firefox -no-remote -profile ~/Data/Browser/profile.default "$@"
+    EOF
+    chmod +x $out/bin/tor-browser
+  '';
+
+  buildInputs = [ stdenv ];
+
+  meta = with stdenv.lib; {
+    description = "Tor Browser Bundle for GNU/Linux, everything you need to safely browse the Internet";
+    homepage = https://www.torproject.org/;
+    platforms = ["i686-linux" "x86_64-linux"];
+    maintainers = [ maintainers.offline ];
+  };
+}

pkgs/tools/system/ipmitool/default.nix

···
 
 let
   pkgname = "ipmitool";
-  version = "1.8.11";
+  version = "1.8.13";
 in
 stdenv.mkDerivation {
   name = "${pkgname}-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/${pkgname}/${pkgname}-${version}.tar.gz";
-    sha256 = "5612f4835d89a6f2cede588eef978a05d63435cf2646256300d9785d8020a13e";
+    sha256 = "0drkfa1spqh1vlzrx7jwm3cw1qar46a9xvqsgycn92ylgsr395n1";
   };
 
   buildInputs = [ openssl ];

pkgs/tools/system/logrotate/default.nix

···
 { stdenv, fetchurl, gzip, popt }:
 
 stdenv.mkDerivation rec {
-  name = "logrotate-3.8.3";
+  name = "logrotate-3.8.7";
 
   src = fetchurl {
     url = "https://fedorahosted.org/releases/l/o/logrotate/${name}.tar.gz";
-    sha256 = "0xqrz8xzs2c1vx8l5h9lp2ciwwifj7y52xsppb1vrvbi254vyxh7";
+    sha256 = "0r1bs40gwi8awx6rjq3n4lw9fgws97ww2li7z87683p380gnkfpn";
   };
 
   # Logrotate wants to access the 'mail' program; to be done.

pkgs/tools/system/syslog-ng/default.nix

···
-{stdenv, fetchurl, eventlog, pkgconfig, glib}:
+{ stdenv, fetchurl, eventlog, pkgconfig, glib, python }:
 
 stdenv.mkDerivation {
-  name = "syslog-ng-3.1.2";
+  name = "syslog-ng-3.5.3";
 
   src = fetchurl {
-    url = "http://www.balabit.com/downloads/files?path=/syslog-ng/sources/3.1.2/source/syslog-ng_3.1.2.tar.gz";
-    sha256 = "0a508l4j11336jn5kg65l70rf7xbpdxi2n477rvp5p48cc1adcg2";
+    url = "http://www.balabit.com/downloads/files?path=/syslog-ng/sources/3.5.3/source/syslog-ng_3.5.3.tar.gz";
+    sha256 = "1l3424qn9bf9z742pqba8x3dj7g729asimmhlizv1rvjlaxa2jd3";
   };
 
-  buildInputs = [eventlog pkgconfig glib];
+  buildInputs = [ eventlog pkgconfig glib python ];
   configureFlags = "--enable-dynamic-linking";
 
   meta = {
     homepage = "http://www.balabit.com/network-security/syslog-ng/";
     description = "Next-generation syslogd with advanced networking and filtering capabilities";
     license = "GPLv2";
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.simons ];
   };
 }

pkgs/tools/text/dos2unix/default.nix

···
 {stdenv, fetchurl, perl, gettext }:
 
 stdenv.mkDerivation {
-  name = "dos2unix-6.0.3";
+  name = "dos2unix-6.0.4";
   
   src = fetchurl {
-    url = http://waterlan.home.xs4all.nl/dos2unix/dos2unix-6.0.3.tar.gz;
-    sha256 = "014sxyidqmjvc5xp5dmcimxd3apl8gyv6whc44vkb65151dqq9pm";
+    url = http://waterlan.home.xs4all.nl/dos2unix/dos2unix-6.0.4.tar.gz;
+    sha256 = "0ymkp55shilzcrn60w1ni92gck7pbqxhi9qsnsii7gkz996j5gb6";
   };
 
   configurePhase = ''

pkgs/tools/typesetting/fop/default.nix

···
   name = "fop-1.1";
 
   src = fetchurl {
-    url = "http://apache.uib.no/xmlgraphics/fop/source/${name}-src.tar.gz";
+    url = "mirror://apache/xmlgraphics/fop/source/${name}-src.tar.gz";
     sha256 = "08i56d57w5dl5bqchr34x9165hvi5h4bhiflxhi0a4wd56rlq5jq";
   };
 
   buildInputs = [ ant jdk ];
 
-  buildPhase = ''
-    ant
-  '';
+  buildPhase = "ant";
 
   installPhase = ''
-    mkdir -p "$out/bin"
-    mkdir -p "$out/lib"
-    mkdir -p "$out/share/doc/fop"
+    mkdir -p $out/bin $out/lib $out/share/doc/fop
 
-    cp build/*.jar lib/*.jar "$out/lib/"
-    cp -r README examples/ "$out/share/doc/fop/"
+    cp build/*.jar lib/*.jar $out/lib/
+    cp -r README examples/ $out/share/doc/fop/
 
     # There is a fop script in the source archive, but it has many impurities.
     # Instead of patching out 90 % of the script, we write our own.
     cat > "$out/bin/fop" <<EOF
     #!${stdenv.shell}
     java_exec_args="-Djava.awt.headless=true"
-    # Note the wildcard; it will be passed to java and java will expand it
-    LOCALCLASSPATH="$out/lib/*"
-    exec "${jdk}/bin/java" \$java_exec_args -classpath "\$LOCALCLASSPATH" org.apache.fop.cli.Main "\$@"
+    exec ${jdk.jre}/bin/java \$java_exec_args -classpath "$out/lib/*" org.apache.fop.cli.Main "\$@"
     EOF
-    chmod a+x "$out/bin/fop"
+    chmod a+x $out/bin/fop
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/typesetting/xmlto/default.nix

···
 , bash, getopt, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "xmlto-0.0.23";
+  name = "xmlto-0.0.25";
   src = fetchurl {
     url = "http://fedorahosted.org/releases/x/m/xmlto/${name}.tar.bz2";
-    sha256 = "1i5iihx304vj52nik42drs7z6z58m9szahng113r4mgd1mvb5zx9";
+    sha256 = "0dp5nxq491gymq806za0dk4hngfmq65ysrqbn0ypajqbbl6vf71n";
   };
 
   patchPhase = ''

pkgs/top-level/all-packages.nix

···
 
   platforms = import ./platforms.nix;
 
+  setJavaClassPath = makeSetupHook { } ../build-support/setup-hooks/set-java-classpath.sh;
+
+  fixDarwinDylibNames = makeSetupHook { } ../build-support/setup-hooks/fix-darwin-dylib-names.sh;
+
 
   ### TOOLS
 
···
 
   aegisub = callPackage ../applications/video/aegisub {
     wxGTK = wxGTK29;
-    lua = lua5_1; 
+    lua = lua5_1;
   };
 
   aespipe = callPackage ../tools/security/aespipe { };
···
 
   xcodeenv = callPackage ../development/mobile/xcodeenv { };
 
-  titaniumenv_2_1 = import ../development/mobile/titaniumenv {
-    inherit pkgs;
-    pkgs_i686 = pkgsi686Linux;
-    version = "2.1";
-  };
-
-  titaniumenv_3_1 = import ../development/mobile/titaniumenv {
+  titaniumenv = callPackage ../development/mobile/titaniumenv {
     inherit pkgs;
     pkgs_i686 = pkgsi686Linux;
   };
-
-  titaniumenv = titaniumenv_3_1;
 
   inherit (androidenv) androidsdk_4_1;
 
···
   mcrl2 = callPackage ../tools/misc/mcrl2 { };
 
   syslogng = callPackage ../tools/system/syslog-ng { };
+
   rsyslog = callPackage ../tools/system/rsyslog { };
 
   mcrypt = callPackage ../tools/misc/mcrypt { };
···
   colormake = callPackage ../development/tools/build-managers/colormake { };
 
   cowsay = callPackage ../tools/misc/cowsay { };
+
+  cpuminer = callPackage ../tools/misc/cpuminer { };
 
   cuetools = callPackage ../tools/cd-dvd/cuetools { };
 
···
 
   logstash = callPackage ../tools/misc/logstash { };
 
+  kippo = callPackage ../servers/kippo { };
+
   klavaro = callPackage ../games/klavaro {};
 
   minidlna = callPackage ../tools/networking/minidlna {
···
 
   torbutton = callPackage ../tools/security/torbutton { };
 
+  torbrowser = callPackage ../tools/security/tor/torbrowser.nix { };
+
   torsocks = callPackage ../tools/security/tor/torsocks.nix { };
 
   trickle = callPackage ../tools/networking/trickle {};
···
 
   clang = wrapClang clangUnwrapped;
 
-  libcxxLLVM = callPackage ../development/compilers/llvm { stdenv = libcxxStdenv; };
+  libcxxLLVM = callPackage ../development/compilers/llvm { stdenv = libcxxStdenv; version="3.3"; };
 
   clangSelf = clangWrapSelf (callPackage ../development/compilers/llvm/clang.nix {
      stdenv = libcxxStdenv;
···
       callPackage ../development/compilers/openjdk-darwin { }
     else
       let
-        openjdkBootstrap = callPackage ../development/compilers/openjdk/bootstrap.nix {};
-        openjdkStage1 = callPackage ../development/compilers/openjdk {
-          jdk = openjdkBootstrap;
-          ant = pkgs.ant.override { jdk = openjdkBootstrap; };
-        };
+        openjdkBootstrap = callPackage ../development/compilers/openjdk/bootstrap.nix { };
       in callPackage ../development/compilers/openjdk {
-        jdk = openjdkStage1;
-        ant = pkgs.ant.override { jdk = openjdkStage1; };
+        jdk = openjdkBootstrap;
       };
 
-  openjre = pkgs.openjdk.override {
-    jreOnly = true;
-  };
+  openjre = pkgs.openjdk.jre;
 
   jdk = if stdenv.isDarwin || stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux"
     then pkgs.openjdk
···
 
   lessc = callPackage ../development/compilers/lessc { };
 
-  llvm = callPackage ../development/compilers/llvm {
+  llvm = llvm_33; # deprecated, depend on llvm_* directly
+  llvm_34 = callPackage ../development/compilers/llvm {
+    version = "3.4";
     stdenv = if stdenv.isDarwin
       then stdenvAdapters.overrideGCC stdenv gccApple
       else stdenv;
   };
+  llvm_33 = llvm_34.override { version = "3.3"; };
 
   mentorToolchains = recurseIntoAttrs (
     callPackage_i686 ../development/compilers/mentor {}
···
 
   clojure = callPackage ../development/interpreters/clojure { };
 
-  clojureUnstable = callPackage ../development/interpreters/clojure { version = "1.5.0-RC1"; };
-
-  clojure_binary = callPackage ../development/interpreters/clojure/binary.nix { };
-
-  clojure_wrapper = callPackage ../development/interpreters/clojure/wrapper.nix {
-    #clojure = clojure_binary;
-  };
-
-  clooj_standalone_binary = callPackage ../development/interpreters/clojure/clooj.nix { };
-
-  clooj_wrapper = callPackage ../development/interpreters/clojure/clooj-wrapper.nix {
-    clooj = clooj_standalone_binary;
-  };
+  clooj = callPackage ../development/interpreters/clojure/clooj.nix { };
 
   erlangR14B04 = callPackage ../development/interpreters/erlang/R14B04.nix { };
   erlangR15B03 = callPackage ../development/interpreters/erlang/R15B03.nix { };
···
   j = callPackage ../development/interpreters/j {};
 
   jmeter = callPackage ../applications/networking/jmeter {};
-
-  kaffe = callPackage ../development/interpreters/kaffe { };
 
   kona = callPackage ../development/interpreters/kona {};
 
···
   lua5_0 = callPackage ../development/interpreters/lua-5/5.0.3.nix { };
   lua5_1 = callPackage ../development/interpreters/lua-5/5.1.nix { };
   lua5_2 = callPackage ../development/interpreters/lua-5/5.2.nix { };
+  lua5_2_compat = callPackage ../development/interpreters/lua-5/5.2.nix {
+    compat = true;
+  };
   lua5 = lua5_1;
 
   luarocks = callPackage ../development/tools/misc/luarocks {
···
     openjdk = null;
     gnuplot = null;
   };
-  octaveFull = (lowPrio (callPackage ../development/interpreters/octave { 
+  octaveFull = (lowPrio (callPackage ../development/interpreters/octave {
     fltk = fltk13;
     qt = qt4;
   }));
···
 
   racket = callPackage ../development/interpreters/racket { };
 
-  regina = callPackage ../development/interpreters/regina {};
+  rascal = callPackage ../development/interpreters/rascal { };
+
+  regina = callPackage ../development/interpreters/regina { };
 
   renpy = callPackage ../development/interpreters/renpy {
     wrapPython = pythonPackages.wrapPython;
···
   ant = apacheAnt;
 
   apacheAnt = callPackage ../development/tools/build-managers/apache-ant { };
-
-  apacheAntOpenJDK = apacheAnt.override { jdk = openjdk; };
-  apacheAntOracleJDK = ant.override { jdk = pkgs.oraclejdk; };
-
-  apacheAntGcj = callPackage ../development/tools/build-managers/apache-ant/from-source.nix {
-    # must be either pre-built or built with GCJ *alone*
-    gcj = gcj.gcc; # use the raw GCJ, which has ${gcj}/lib/jvm
-  };
 
   astyle = callPackage ../development/tools/misc/astyle { };
 
···
 
   hsqldb = callPackage ../development/libraries/java/hsqldb { };
 
-  http_parser = callPackage ../development/libraries/http_parser { inherit (pythonPackages) gyp; };
+  http_parser = callPackage ../development/libraries/http-parser { inherit (pythonPackages) gyp; };
 
   hunspell = callPackage ../development/libraries/hunspell { };
 
···
 
   hydraAntLogger = callPackage ../development/libraries/java/hydra-ant-logger { };
 
-  icedtea = callPackage ../development/libraries/java/icedtea {
-    ant = apacheAntGcj;
-    xerces = xercesJava;
-    xulrunner = icecatXulrunner3;
-    inherit (xlibs) libX11 libXp libXtst libXinerama libXt
-      libXrender xproto;
-  };
-
   icu = callPackage ../development/libraries/icu { };
 
   id3lib = callPackage ../development/libraries/id3lib { };
···
   libgcrypt = callPackage ../development/libraries/libgcrypt { };
 
   libgcrypt_1_6 = lowPrio (callPackage ../development/libraries/libgcrypt/1.6.nix { });
-
-  libgcrypt_git = lowPrio (callPackage ../development/libraries/libgcrypt/git.nix { });
 
   libgdiplus = callPackage ../development/libraries/libgdiplus { };
 
···
 
   libtoxcore = callPackage ../development/libraries/libtoxcore { };
 
+  libtsm = callPackage ../development/libraries/libtsm { };
+
   libtunepimp = callPackage ../development/libraries/libtunepimp { };
 
   libtxc_dxtn = callPackage ../development/libraries/libtxc_dxtn { };
···
   redland = pkgs.librdf_redland;
 
   rhino = callPackage ../development/libraries/java/rhino {
-    ant = apacheAntGcj;
     javac = gcj;
     jvm = gcj;
   };
···
   SDL2_gfx = callPackage ../development/libraries/SDL2_gfx { };
 
   serd = callPackage ../development/libraries/serd {};
-  
+
   serf = callPackage ../development/libraries/serf {};
 
   silgraphite = callPackage ../development/libraries/silgraphite {};
···
 
   xercesc = callPackage ../development/libraries/xercesc {};
 
-  xercesJava = callPackage ../development/libraries/java/xerces {
-    ant   = apacheAntGcj;  # for bootstrap purposes
-    javac = gcj;
-    jvm   = gcj;
-  };
-
   xlibsWrapper = callPackage ../development/libraries/xlibs-wrapper {
     packages = [
       freetype fontconfig xlibs.xproto xlibs.libX11 xlibs.libXt
···
 
   v8 = callPackage ../development/libraries/v8 { inherit (pythonPackages) gyp; };
 
-  xalanj = xalanJava;
-  xalanJava = callPackage ../development/libraries/java/xalanj {
-    ant    = apacheAntGcj;  # for bootstrap purposes
-    javac  = gcj;
-    jvm    = gcj;
-    xerces = xercesJava;  };
-
   xmlsec = callPackage ../development/libraries/xmlsec { };
 
   zziplib = callPackage ../development/libraries/zziplib { };
···
 
   jquery_ui = callPackage ../development/libraries/javascript/jquery-ui { };
 
+
   ### DEVELOPMENT / LISP MODULES
 
   asdf = callPackage ../development/lisp-modules/asdf {
     texLive = null;
   };
+
   clwrapperFunction = callPackage ../development/lisp-modules/clwrapper;
-  wrapLisp = lisp: clwrapperFunction {lisp=lisp;};
-  lispPackagesFor = clwrapper: callPackage ../development/lisp-modules/lisp-packages.nix{
+
+  wrapLisp = lisp: clwrapperFunction { inherit lisp; };
+
+  lispPackagesFor = clwrapper: callPackage ../development/lisp-modules/lisp-packages.nix {
     inherit clwrapper;
   };
+
   lispPackagesClisp = lispPackagesFor (wrapLisp clisp);
   lispPackagesSBCL = lispPackagesFor (wrapLisp sbcl);
   lispPackages = recurseIntoAttrs lispPackagesSBCL;
+
 
   ### DEVELOPMENT / PERL MODULES
 
···
   jujuutils = callPackage ../os-specific/linux/jujuutils { };
 
   kbd = callPackage ../os-specific/linux/kbd { };
+
+  kmscon = callPackage ../os-specific/linux/kmscon { };
 
   latencytop = callPackage ../os-specific/linux/latencytop { };
 
···
     slibGuile = slibGuile.override { scheme = guile_1_8; };
     goffice = goffice_0_8;
   };
+
   goffice_0_8 = callPackage ../desktops/gnome-3/misc/goffice/0.8.nix {
     inherit (gnome2) libglade libgnomeui;
     gconf = gnome2.GConf;
···
     inherit (gnome3) goffice gnome_icon_theme;
   };
 
-  gnunet = callPackage ../applications/networking/p2p/gnunet { };
+  gnunet = callPackage ../applications/networking/p2p/gnunet {
+    libgcrypt = libgcrypt_1_6;
+  };
 
   gnunet_svn = lowPrio (callPackage ../applications/networking/p2p/gnunet/svn.nix {
     libgcrypt = libgcrypt_1_6;
···
   tkcvs = callPackage ../applications/version-management/tkcvs { };
 
   tla = callPackage ../applications/version-management/arch { };
+
+  todo-txt-cli = callPackage ../applications/office/todo.txt-cli { };
 
   torchat = callPackage ../applications/networking/instant-messengers/torchat {
     wrapPython = pythonPackages.wrapPython;
···
   };
 
   splix = callPackage ../misc/cups/drivers/splix { };
+
+  streamripper = callPackage ../applications/audio/streamripper { };
 
   tetex = callPackage ../tools/typesetting/tex/tetex { libpng = libpng12; };
 

pkgs/top-level/haskell-defaults.nix

···
       haskellPlatform = self.haskellPlatform_2012_4_0_0;
       cabalInstall_1_16_0_2 = self.cabalInstall_1_16_0_2.override { Cabal = self.Cabal_1_16_0_3; };
       cabal2nix = self.cabal2nix.override { Cabal = self.Cabal_1_16_0_3; hackageDb = self.hackageDb.override { Cabal = self.Cabal_1_16_0_3; }; };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc741Prefs =
···
       haskellPlatform = self.haskellPlatform_2012_2_0_0;
       cabalInstall_1_16_0_2 = self.cabalInstall_1_16_0_2.override { Cabal = self.Cabal_1_16_0_3; };
       cabal2nix = self.cabal2nix.override { Cabal = self.Cabal_1_16_0_3; hackageDb = self.hackageDb.override { Cabal = self.Cabal_1_16_0_3; }; };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc722Prefs =
···
       hspecExpectations = self.hspecExpectations.override {
         HUnit = self.HUnit_1_2_5_2;
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc721Prefs = ghc722Prefs;
···
       hspecExpectations = self.hspecExpectations.override {
         HUnit = self.HUnit_1_2_5_2;
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc703Prefs =
···
       hspecExpectations = self.hspecExpectations.override {
         HUnit = self.HUnit_1_2_5_2;
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc702Prefs = ghc701Prefs;
···
       hspecExpectations = self.hspecExpectations.override {
         HUnit = self.HUnit_1_2_5_2;
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc6123Prefs = ghc6122Prefs;
···
       hspecExpectations = self.hspecExpectations.override {
         HUnit = self.HUnit_1_2_5_2;
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc6121Prefs =
···
       hspecExpectations = self.hspecExpectations.override {
         HUnit = self.HUnit_1_2_5_2;
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   ghc6104Prefs =
···
         mtl = self.mtl_2_1_2;
         HTTP = self.HTTP_4000_1_1.override { mtl = self.mtl_2_1_2; };
       };
+      haskeline = self.haskeline_0_7_1_1;
+      terminfo = self.terminfo_0_3_2_6;
     };
 
   # Abstraction for Haskell packages collections

pkgs/top-level/haskell-packages.nix

···
 
   aeson = callPackage ../development/libraries/haskell/aeson {};
 
+  aesonLens = callPackage ../development/libraries/haskell/aeson-lens {};
+
   aesonPretty = callPackage ../development/libraries/haskell/aeson-pretty {};
 
   alternativeIo = callPackage ../development/libraries/haskell/alternative-io {};
···
   attoparsecConduit = callPackage ../development/libraries/haskell/attoparsec-conduit {};
 
   attoparsecEnumerator = callPackage ../development/libraries/haskell/attoparsec-enumerator {};
+
+  aws = callPackage ../development/libraries/haskell/aws {};
 
   authenticate = callPackage ../development/libraries/haskell/authenticate {};
 
···
 
   DAV = callPackage ../development/libraries/haskell/DAV {};
 
+  dbmigrations = callPackage ../development/libraries/haskell/dbmigrations {};
+
   dbus = callPackage ../development/libraries/haskell/dbus {};
 
   deepseq_1_1_0_0 = callPackage ../development/libraries/haskell/deepseq/1.1.0.0.nix {};
···
   };
 
   digestiveFunctors = callPackage ../development/libraries/haskell/digestive-functors {};
+
+  digestiveFunctorsAeson = callPackage ../development/libraries/haskell/digestive-functors-aeson {};
 
   digestiveFunctorsHeist = callPackage ../development/libraries/haskell/digestive-functors-heist {};
 
···
 
   haskelldb = callPackage ../development/libraries/haskell/haskelldb {};
 
-  haskeline = callPackage ../development/libraries/haskell/haskeline {};
+  haskeline_0_7_1_1 = callPackage ../development/libraries/haskell/haskeline/0.7.1.1.nix {};
+  haskeline_0_7_1_2 = callPackage ../development/libraries/haskell/haskeline/0.7.1.2.nix {};
+  haskeline = self.haskeline_0_7_1_2;
 
   haskelineClass = callPackage ../development/libraries/haskell/haskeline-class {};
 
···
 
   hseCpp = callPackage ../development/libraries/haskell/hse-cpp {};
 
+  hsimport = callPackage ../development/libraries/haskell/hsimport {};
+
   HTF = callPackage ../development/libraries/haskell/HTF {};
 
   HTTP_4000_0_6 = callPackage ../development/libraries/haskell/HTTP/4000.0.6.nix {};
···
   httpClientMultipart = callPackage ../development/libraries/haskell/http-client-multipart {};
 
   httpClientTls = callPackage ../development/libraries/haskell/http-client-tls {};
+
+  httpCommon = callPackage ../development/libraries/haskell/http-common {};
 
   httpReverseProxy = callPackage ../development/libraries/haskell/http-reverse-proxy {};
 
···
 
   httpDate = callPackage ../development/libraries/haskell/http-date {};
 
+  httpStreams = callPackage ../development/libraries/haskell/http-streams {};
+
   httpTypes = callPackage ../development/libraries/haskell/http-types {};
 
   HUnit_1_2_0_3 = callPackage ../development/libraries/haskell/HUnit/1.2.0.3.nix {};
···
   indexedFree = callPackage ../development/libraries/haskell/indexed-free {};
 
   instantGenerics = callPackage ../development/libraries/haskell/instant-generics {};
+
+  interlude = callPackage ../development/libraries/haskell/interlude {};
 
   intervals = callPackage ../development/libraries/haskell/intervals {};
 
···
 
   ioStorage = callPackage ../development/libraries/haskell/io-storage {};
 
+  ioStreams = callPackage ../development/libraries/haskell/io-streams {};
+
   iproute = callPackage ../development/libraries/haskell/iproute {};
 
   irc = callPackage ../development/libraries/haskell/irc {};
···
   OpenGLRaw_1_4_0_0 = callPackage ../development/libraries/haskell/OpenGLRaw/1.4.0.0.nix {};
   OpenGLRaw = self.OpenGLRaw_1_4_0_0;
 
+  opensslStreams = callPackage ../development/libraries/haskell/openssl-streams {};
+
   operational = callPackage ../development/libraries/haskell/operational {};
 
   optparseApplicative = callPackage ../development/libraries/haskell/optparse-applicative {};
···
   parsec  = self.parsec3;
 
   parsers_0_9 = callPackage ../development/libraries/haskell/parsers/0.9.nix {};
-  parsers_0_10_1_2 = callPackage ../development/libraries/haskell/parsers/0.10.1.2.nix {};
-  parsers = self.parsers_0_10_1_2;
+  parsers_0_10_2 = callPackage ../development/libraries/haskell/parsers/0.10.2.nix {};
+  parsers = self.parsers_0_10_2;
 
   parsimony = callPackage ../development/libraries/haskell/parsimony {};
 
···
 
   terminalProgressBar = callPackage ../development/libraries/haskell/terminal-progress-bar {};
 
-  terminfo = callPackage ../development/libraries/haskell/terminfo {
-    inherit (pkgs) ncurses;
-  };
+  terminfo_0_3_2_6 = callPackage ../development/libraries/haskell/terminfo/0.3.2.6.nix { inherit (pkgs) ncurses; };
+  terminfo_0_4_0_0 = callPackage ../development/libraries/haskell/terminfo/0.4.0.0.nix { inherit (pkgs) ncurses; };
+  terminfo = self.terminfo_0_4_0_0;
 
   testFramework = callPackage ../development/libraries/haskell/test-framework {};
 
···
 
   webRoutesBoomerang = callPackage ../development/libraries/haskell/web-routes-boomerang {};
 
+  websockets = callPackage ../development/libraries/haskell/websockets {};
+
+  websocketsSnap = callPackage ../development/libraries/haskell/websockets-snap {};
+
   CouchDB = callPackage ../development/libraries/haskell/CouchDB {};
 
   wlPprint = callPackage ../development/libraries/haskell/wl-pprint {};
···
   xssSanitize = callPackage ../development/libraries/haskell/xss-sanitize {};
 
   yaml = callPackage ../development/libraries/haskell/yaml {};
+
+  yamlLight = callPackage ../development/libraries/haskell/yaml-light {};
 
   yap = callPackage ../development/libraries/haskell/yap {};
 

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

···
     passthru.names = [ "adm-zip" ];
   };
   by-spec."almond"."*" =
-    self.by-version."almond"."0.2.7";
-  by-version."almond"."0.2.7" = lib.makeOverridable self.buildNodePackage {
-    name = "almond-0.2.7";
+    self.by-version."almond"."0.2.9";
+  by-version."almond"."0.2.9" = lib.makeOverridable self.buildNodePackage {
+    name = "almond-0.2.9";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/almond/-/almond-0.2.7.tgz";
-        name = "almond-0.2.7.tgz";
-        sha1 = "9cda2385a3198cbd8fea8e0c6edc79d5a2c354c2";
+        url = "http://registry.npmjs.org/almond/-/almond-0.2.9.tgz";
+        name = "almond-0.2.9.tgz";
+        sha1 = "ee4543d653a2306d682091c11050d441034f5ed8";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "almond" ];
   };
-  "almond" = self.by-version."almond"."0.2.7";
+  "almond" = self.by-version."almond"."0.2.9";
   by-spec."amdefine"."*" =
     self.by-version."amdefine"."0.1.0";
   by-version."amdefine"."0.1.0" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."archiver" or []);
     deps = [
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
       self.by-version."iconv-lite"."0.2.11"
     ];
     peerDependencies = [
···
   by-spec."async"."~0.2.9" =
     self.by-version."async"."0.2.9";
   by-spec."aws-sdk"."*" =
-    self.by-version."aws-sdk"."2.0.0-rc5";
-  by-version."aws-sdk"."2.0.0-rc5" = lib.makeOverridable self.buildNodePackage {
-    name = "aws-sdk-2.0.0-rc5";
+    self.by-version."aws-sdk"."2.0.0-rc7";
+  by-version."aws-sdk"."2.0.0-rc7" = lib.makeOverridable self.buildNodePackage {
+    name = "aws-sdk-2.0.0-rc7";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.0-rc5.tgz";
-        name = "aws-sdk-2.0.0-rc5.tgz";
-        sha1 = "488d4c5f28dae9cde8705d40f63f6f3ca91b351e";
+        url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.0-rc7.tgz";
+        name = "aws-sdk-2.0.0-rc7.tgz";
+        sha1 = "4b367185bd093f2681aea2cfb1e3e85a06fa04cd";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "aws-sdk" ];
   };
-  "aws-sdk" = self.by-version."aws-sdk"."2.0.0-rc5";
+  "aws-sdk" = self.by-version."aws-sdk"."2.0.0-rc7";
   by-spec."aws-sdk".">=1.2.0 <2" =
-    self.by-version."aws-sdk"."1.17.0";
-  by-version."aws-sdk"."1.17.0" = lib.makeOverridable self.buildNodePackage {
-    name = "aws-sdk-1.17.0";
+    self.by-version."aws-sdk"."1.17.2";
+  by-version."aws-sdk"."1.17.2" = lib.makeOverridable self.buildNodePackage {
+    name = "aws-sdk-1.17.2";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-1.17.0.tgz";
-        name = "aws-sdk-1.17.0.tgz";
-        sha1 = "766bbe426cd573ce339196a5b2fa431fea6130f5";
+        url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-1.17.2.tgz";
+        name = "aws-sdk-1.17.2.tgz";
+        sha1 = "1e9c6ae5baa6f3eca29cece19f199040cd01cd30";
       })
     ];
     buildInputs =
···
       self.by-version."bower-json"."0.4.0"
       self.by-version."bower-logger"."0.2.1"
       self.by-version."bower-registry-client"."0.1.6"
-      self.by-version."cardinal"."0.4.3"
+      self.by-version."cardinal"."0.4.4"
       self.by-version."chalk"."0.2.1"
       self.by-version."chmodr"."0.1.0"
-      self.by-version."decompress-zip"."0.0.3"
+      self.by-version."decompress-zip"."0.0.4"
       self.by-version."fstream"."0.1.25"
       self.by-version."fstream-ignore"."0.0.7"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."graceful-fs"."2.0.1"
       self.by-version."handlebars"."1.0.12"
       self.by-version."inquirer"."0.3.5"
···
     deps = [
       self.by-version."hat"."0.0.3"
       self.by-version."connect"."2.12.0"
-      self.by-version."request"."2.30.0"
+      self.by-version."request"."2.31.0"
     ];
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "bson" ];
   };
-  by-spec."bson"."0.2.3" =
-    self.by-version."bson"."0.2.3";
-  by-version."bson"."0.2.3" = lib.makeOverridable self.buildNodePackage {
-    name = "bson-0.2.3";
-    src = [
-      (fetchurl {
-        url = "http://registry.npmjs.org/bson/-/bson-0.2.3.tgz";
-        name = "bson-0.2.3.tgz";
-        sha1 = "7651d2c4ec7cb90d10b5de0ef61663273b784839";
-      })
-    ];
-    buildInputs =
-      (self.nativeDeps."bson" or []);
-    deps = [
-      self.by-version."nan"."0.4.4"
-    ];
-    peerDependencies = [
-    ];
-    passthru.names = [ "bson" ];
-  };
   by-spec."bson"."0.2.5" =
     self.by-version."bson"."0.2.5";
   by-version."bson"."0.2.5" = lib.makeOverridable self.buildNodePackage {
···
   by-spec."bytes"."~0.2.1" =
     self.by-version."bytes"."0.2.1";
   by-spec."cardinal"."~0.4.0" =
-    self.by-version."cardinal"."0.4.3";
-  by-version."cardinal"."0.4.3" = lib.makeOverridable self.buildNodePackage {
-    name = "cardinal-0.4.3";
+    self.by-version."cardinal"."0.4.4";
+  by-version."cardinal"."0.4.4" = lib.makeOverridable self.buildNodePackage {
+    name = "cardinal-0.4.4";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/cardinal/-/cardinal-0.4.3.tgz";
-        name = "cardinal-0.4.3.tgz";
-        sha1 = "7b74c3d1541002bd3d5b555048206719af91d313";
+        url = "http://registry.npmjs.org/cardinal/-/cardinal-0.4.4.tgz";
+        name = "cardinal-0.4.4.tgz";
+        sha1 = "ca5bb68a5b511b90fe93b9acea49bdee5c32bfe2";
       })
     ];
     buildInputs =
···
   by-spec."cheerio"."~0.12.1" =
     self.by-version."cheerio"."0.12.4";
   by-spec."cheerio"."~0.13.0" =
-    self.by-version."cheerio"."0.13.0";
-  by-version."cheerio"."0.13.0" = lib.makeOverridable self.buildNodePackage {
-    name = "cheerio-0.13.0";
+    self.by-version."cheerio"."0.13.1";
+  by-version."cheerio"."0.13.1" = lib.makeOverridable self.buildNodePackage {
+    name = "cheerio-0.13.1";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/cheerio/-/cheerio-0.13.0.tgz";
-        name = "cheerio-0.13.0.tgz";
-        sha1 = "44f5112044e0e0148300dd16bf8bbd7755ce65f1";
+        url = "http://registry.npmjs.org/cheerio/-/cheerio-0.13.1.tgz";
+        name = "cheerio-0.13.1.tgz";
+        sha1 = "48af1134561b3527f83d9156c4f9a8ebd82b06ec";
       })
     ];
     buildInputs =
       (self.nativeDeps."cheerio" or []);
     deps = [
       self.by-version."htmlparser2"."3.4.0"
-      self.by-version."underscore"."1.4.4"
+      self.by-version."underscore"."1.5.2"
       self.by-version."entities"."0.3.0"
       self.by-version."CSSselect"."0.4.0"
     ];
···
     buildInputs =
       (self.nativeDeps."cli" or []);
     deps = [
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
     ];
     peerDependencies = [
     ];
···
   };
   by-spec."commander"."2.0.x" =
     self.by-version."commander"."2.0.0";
+  by-spec."commander"."2.1.0" =
+    self.by-version."commander"."2.1.0";
   by-spec."commander"."~0.6.1" =
     self.by-version."commander"."0.6.1";
   by-spec."config"."0.4.15" =
···
     buildInputs =
       (self.nativeDeps."connect-jade-static" or []);
     deps = [
-      self.by-version."jade"."1.0.2"
+      self.by-version."jade"."1.1.4"
     ];
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "console-browserify" ];
   };
-  by-spec."constantinople"."~1.0.2" =
+  by-spec."constantinople"."~1.0.1" =
     self.by-version."constantinople"."1.0.2";
   by-version."constantinople"."1.0.2" = lib.makeOverridable self.buildNodePackage {
     name = "constantinople-1.0.2";
···
     ];
     passthru.names = [ "constantinople" ];
   };
+  by-spec."constantinople"."~1.0.2" =
+    self.by-version."constantinople"."1.0.2";
   by-spec."cookie"."0.0.4" =
     self.by-version."cookie"."0.0.4";
   by-version."cookie"."0.0.4" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "cookies" ];
   };
   by-spec."core-util-is"."~1.0.0" =
-    self.by-version."core-util-is"."1.0.0";
-  by-version."core-util-is"."1.0.0" = lib.makeOverridable self.buildNodePackage {
-    name = "core-util-is-1.0.0";
+    self.by-version."core-util-is"."1.0.1";
+  by-version."core-util-is"."1.0.1" = lib.makeOverridable self.buildNodePackage {
+    name = "core-util-is-1.0.1";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/core-util-is/-/core-util-is-1.0.0.tgz";
-        name = "core-util-is-1.0.0.tgz";
-        sha1 = "740c74c400e72707b95cc75d509543f8ad7f83de";
+        url = "http://registry.npmjs.org/core-util-is/-/core-util-is-1.0.1.tgz";
+        name = "core-util-is-1.0.1.tgz";
+        sha1 = "6b07085aef9a3ccac6ee53bf9d3df0c1521a5538";
       })
     ];
     buildInputs =
···
     buildInputs =
       (self.nativeDeps."couch-login" or []);
     deps = [
-      self.by-version."request"."2.30.0"
+      self.by-version."request"."2.31.0"
     ];
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "css-parse" ];
   };
+  by-spec."css-parse"."1.7.x" =
+    self.by-version."css-parse"."1.7.0";
+  by-version."css-parse"."1.7.0" = lib.makeOverridable self.buildNodePackage {
+    name = "css-parse-1.7.0";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/css-parse/-/css-parse-1.7.0.tgz";
+        name = "css-parse-1.7.0.tgz";
+        sha1 = "321f6cf73782a6ff751111390fc05e2c657d8c9b";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."css-parse" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "css-parse" ];
+  };
   by-spec."css-stringify"."1.0.5" =
     self.by-version."css-stringify"."1.0.5";
   by-version."css-stringify"."1.0.5" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "decompress" ];
   };
   by-spec."decompress-zip"."~0.0.3" =
-    self.by-version."decompress-zip"."0.0.3";
-  by-version."decompress-zip"."0.0.3" = lib.makeOverridable self.buildNodePackage {
-    name = "decompress-zip-0.0.3";
+    self.by-version."decompress-zip"."0.0.4";
+  by-version."decompress-zip"."0.0.4" = lib.makeOverridable self.buildNodePackage {
+    name = "decompress-zip-0.0.4";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/decompress-zip/-/decompress-zip-0.0.3.tgz";
-        name = "decompress-zip-0.0.3.tgz";
-        sha1 = "14b174e5b6a528f0aa6c2e2157b7aa0152e7915a";
+        url = "http://registry.npmjs.org/decompress-zip/-/decompress-zip-0.0.4.tgz";
+        name = "decompress-zip-0.0.4.tgz";
+        sha1 = "c562431f76af8970afaf50226e42e1c47a57b086";
       })
     ];
     buildInputs =
···
       self.by-version."mkpath"."0.1.0"
       self.by-version."binary"."0.3.0"
       self.by-version."touch"."0.0.2"
-      self.by-version."readable-stream"."1.1.9"
+      self.by-version."readable-stream"."1.1.10"
       self.by-version."nopt"."2.1.2"
     ];
     peerDependencies = [
···
     peerDependencies = [
     ];
     passthru.names = [ "download" ];
+  };
+  by-spec."dox"."~0.4.4" =
+    self.by-version."dox"."0.4.4";
+  by-version."dox"."0.4.4" = lib.makeOverridable self.buildNodePackage {
+    name = "dox-0.4.4";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/dox/-/dox-0.4.4.tgz";
+        name = "dox-0.4.4.tgz";
+        sha1 = "4f898abbb88cd879c7c49a4973abc95b7f384823";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."dox" or []);
+    deps = [
+      self.by-version."github-flavored-markdown"."1.0.1"
+      self.by-version."commander"."0.6.1"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "dox" ];
   };
   by-spec."dtrace-provider"."0.2.8" =
     self.by-version."dtrace-provider"."0.2.8";
···
       self.by-version."bower-endpoint-parser"."0.2.1"
       self.by-version."bower-logger"."0.2.1"
       self.by-version."bower"."1.2.8"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
     ];
     peerDependencies = [
     ];
···
   "fetch-bower" = self.by-version."fetch-bower"."2.0.0";
   by-spec."fetch-bower".">=2 <3" =
     self.by-version."fetch-bower"."2.0.0";
+  by-spec."fields"."~0.1.11" =
+    self.by-version."fields"."0.1.11";
+  by-version."fields"."0.1.11" = lib.makeOverridable self.buildNodePackage {
+    name = "fields-0.1.11";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/fields/-/fields-0.1.11.tgz";
+        name = "fields-0.1.11.tgz";
+        sha1 = "d428e4a622c9f71d52f413fb2fde96cfdb51c520";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."fields" or []);
+    deps = [
+      self.by-version."colors"."0.6.2"
+      self.by-version."keypress"."0.1.0"
+      self.by-version."sprintf"."0.1.3"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "fields" ];
+  };
   by-spec."file-utils"."~0.1.1" =
     self.by-version."file-utils"."0.1.5";
   by-version."file-utils"."0.1.5" = lib.makeOverridable self.buildNodePackage {
···
       self.by-version."lodash"."2.1.0"
       self.by-version."iconv-lite"."0.2.11"
       self.by-version."rimraf"."2.2.5"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."minimatch"."0.2.14"
       self.by-version."findup-sync"."0.1.2"
       self.by-version."isbinaryfile"."0.1.9"
···
       (self.nativeDeps."fileset" or []);
     deps = [
       self.by-version."minimatch"."0.2.14"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
     ];
     peerDependencies = [
     ];
···
     ];
     peerDependencies = [
       self.by-version."generator-karma"."0.6.0"
-      self.by-version."yo"."1.1.1"
+      self.by-version."yo"."1.1.2"
     ];
     passthru.names = [ "generator-angular" ];
   };
···
       self.by-version."yeoman-generator"."0.13.4"
     ];
     peerDependencies = [
-      self.by-version."yo"."1.1.1"
+      self.by-version."yo"."1.1.2"
     ];
     passthru.names = [ "generator-karma" ];
   };
···
       self.by-version."yeoman-generator"."0.14.2"
     ];
     peerDependencies = [
-      self.by-version."yo"."1.1.1"
+      self.by-version."yo"."1.1.2"
     ];
     passthru.names = [ "generator-mocha" ];
   };
···
       self.by-version."cheerio"."0.12.4"
     ];
     peerDependencies = [
-      self.by-version."yo"."1.1.1"
+      self.by-version."yo"."1.1.2"
       self.by-version."generator-mocha"."0.1.3"
     ];
     passthru.names = [ "generator-webapp" ];
···
     ];
     passthru.names = [ "getobject" ];
   };
+  by-spec."github-flavored-markdown".">= 0.0.1" =
+    self.by-version."github-flavored-markdown"."1.0.1";
+  by-version."github-flavored-markdown"."1.0.1" = lib.makeOverridable self.buildNodePackage {
+    name = "github-flavored-markdown-1.0.1";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/github-flavored-markdown/-/github-flavored-markdown-1.0.1.tgz";
+        name = "github-flavored-markdown-1.0.1.tgz";
+        sha1 = "93361b87a31c25790d9c81a1b798214a737eab38";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."github-flavored-markdown" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "github-flavored-markdown" ];
+  };
   by-spec."github-url-from-git"."1.1.1" =
     self.by-version."github-url-from-git"."1.1.1";
   by-version."github-url-from-git"."1.1.1" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "github-url-from-username-repo" ];
   };
   by-spec."glob"."3" =
-    self.by-version."glob"."3.2.7";
-  by-version."glob"."3.2.7" = lib.makeOverridable self.buildNodePackage {
-    name = "glob-3.2.7";
+    self.by-version."glob"."3.2.8";
+  by-version."glob"."3.2.8" = lib.makeOverridable self.buildNodePackage {
+    name = "glob-3.2.8";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/glob/-/glob-3.2.7.tgz";
-        name = "glob-3.2.7.tgz";
-        sha1 = "275f39a0eee805694790924f36eac38e1db6d802";
+        url = "http://registry.npmjs.org/glob/-/glob-3.2.8.tgz";
+        name = "glob-3.2.8.tgz";
+        sha1 = "5506f4311721bcc618c7d8dba144188750307073";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "glob" ];
   };
+  by-spec."glob"."3.2.x" =
+    self.by-version."glob"."3.2.8";
   by-spec."glob"."3.x" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."glob".">= 3.1.4" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."glob".">=3.2.7 <4" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."glob"."~3.1.21" =
     self.by-version."glob"."3.1.21";
   by-version."glob"."3.1.21" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "glob" ];
   };
   by-spec."glob"."~3.2.0" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."glob"."~3.2.1" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."glob"."~3.2.6" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."glob"."~3.2.7" =
-    self.by-version."glob"."3.2.7";
+    self.by-version."glob"."3.2.8";
   by-spec."graceful-fs"."2" =
     self.by-version."graceful-fs"."2.0.1";
   by-version."graceful-fs"."2.0.1" = lib.makeOverridable self.buildNodePackage {
···
   };
   "grunt-contrib-jshint" = self.by-version."grunt-contrib-jshint"."0.8.0";
   by-spec."grunt-contrib-less"."*" =
-    self.by-version."grunt-contrib-less"."0.8.3";
-  by-version."grunt-contrib-less"."0.8.3" = lib.makeOverridable self.buildNodePackage {
-    name = "grunt-contrib-less-0.8.3";
+    self.by-version."grunt-contrib-less"."0.9.0";
+  by-version."grunt-contrib-less"."0.9.0" = lib.makeOverridable self.buildNodePackage {
+    name = "grunt-contrib-less-0.9.0";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/grunt-contrib-less/-/grunt-contrib-less-0.8.3.tgz";
-        name = "grunt-contrib-less-0.8.3.tgz";
-        sha1 = "8a0e9183577339ad08729f57a9a4adeff6c41410";
+        url = "http://registry.npmjs.org/grunt-contrib-less/-/grunt-contrib-less-0.9.0.tgz";
+        name = "grunt-contrib-less-0.9.0.tgz";
+        sha1 = "af1e6e76511c2bc328ef8d284058643ca5887675";
       })
     ];
     buildInputs =
       (self.nativeDeps."grunt-contrib-less" or []);
     deps = [
-      self.by-version."less"."1.5.1"
+      self.by-version."less"."1.6.1"
       self.by-version."grunt-lib-contrib"."0.6.1"
+      self.by-version."chalk"."0.4.0"
     ];
     peerDependencies = [
       self.by-version."grunt"."0.4.2"
     ];
     passthru.names = [ "grunt-contrib-less" ];
   };
-  "grunt-contrib-less" = self.by-version."grunt-contrib-less"."0.8.3";
+  "grunt-contrib-less" = self.by-version."grunt-contrib-less"."0.9.0";
   by-spec."grunt-contrib-requirejs"."*" =
     self.by-version."grunt-contrib-requirejs"."0.4.1";
   by-version."grunt-contrib-requirejs"."0.4.1" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."grunt-contrib-requirejs" or []);
     deps = [
-      self.by-version."requirejs"."2.1.9"
+      self.by-version."requirejs"."2.1.10"
     ];
     peerDependencies = [
       self.by-version."grunt"."0.4.2"
···
       (self.nativeDeps."guifi-earth" or []);
     deps = [
       self.by-version."coffee-script"."1.6.3"
-      self.by-version."jade"."1.0.2"
+      self.by-version."jade"."1.1.4"
       self.by-version."q"."1.0.0"
       self.by-version."xml2js"."0.4.1"
       self.by-version."msgpack"."0.2.1"
···
       self.by-version."domhandler"."2.0.3"
       self.by-version."domutils"."1.1.6"
       self.by-version."domelementtype"."1.1.1"
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
     ];
     peerDependencies = [
     ];
···
       self.by-version."domhandler"."2.1.0"
       self.by-version."domutils"."1.1.6"
       self.by-version."domelementtype"."1.1.1"
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
     ];
     peerDependencies = [
     ];
···
       self.by-version."domhandler"."2.2.0"
       self.by-version."domutils"."1.3.0"
       self.by-version."domelementtype"."1.1.1"
-      self.by-version."readable-stream"."1.1.9"
+      self.by-version."readable-stream"."1.1.10"
     ];
     peerDependencies = [
     ];
···
   };
   by-spec."http-signature"."~0.9.11" =
     self.by-version."http-signature"."0.9.11";
+  by-spec."humanize"."~0.0.9" =
+    self.by-version."humanize"."0.0.9";
+  by-version."humanize"."0.0.9" = lib.makeOverridable self.buildNodePackage {
+    name = "humanize-0.0.9";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/humanize/-/humanize-0.0.9.tgz";
+        name = "humanize-0.0.9.tgz";
+        sha1 = "1994ffaecdfe9c441ed2bdac7452b7bb4c9e41a4";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."humanize" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "humanize" ];
+  };
   by-spec."i"."0.3.x" =
     self.by-version."i"."0.3.2";
   by-version."i"."0.3.2" = lib.makeOverridable self.buildNodePackage {
···
     deps = [
       self.by-version."promzard"."0.2.1"
       self.by-version."read"."1.0.5"
-      self.by-version."read-package-json"."1.1.4"
+      self.by-version."read-package-json"."1.1.5"
       self.by-version."semver"."2.2.1"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
     ];
     peerDependencies = [
     ];
···
       self.by-version."fs-walk"."0.0.1"
       self.by-version."async"."0.2.9"
       self.by-version."express"."3.4.7"
-      self.by-version."jade"."1.0.2"
+      self.by-version."jade"."1.1.4"
       self.by-version."passport"."0.1.18"
       self.by-version."passport-http"."0.2.2"
       self.by-version."js-yaml"."3.0.1"
-      self.by-version."mongoose"."3.8.3"
+      self.by-version."mongoose"."3.8.4"
       self.by-version."gridfs-stream"."0.4.0"
       self.by-version."temp"."0.6.0"
       self.by-version."kue"."0.6.2"
···
     passthru.names = [ "istanbul" ];
   };
   by-spec."jade"."*" =
-    self.by-version."jade"."1.0.2";
-  by-version."jade"."1.0.2" = lib.makeOverridable self.buildNodePackage {
-    name = "jade-1.0.2";
+    self.by-version."jade"."1.1.4";
+  by-version."jade"."1.1.4" = lib.makeOverridable self.buildNodePackage {
+    name = "jade-1.1.4";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/jade/-/jade-1.0.2.tgz";
-        name = "jade-1.0.2.tgz";
-        sha1 = "86fed5d02d703f0309f06ddefa04a69fee00a2b1";
+        url = "http://registry.npmjs.org/jade/-/jade-1.1.4.tgz";
+        name = "jade-1.1.4.tgz";
+        sha1 = "7097f9f17577fa4a1f0b399925dba1752b91cbdc";
       })
     ];
     buildInputs =
       (self.nativeDeps."jade" or []);
     deps = [
-      self.by-version."commander"."2.0.0"
+      self.by-version."commander"."2.1.0"
       self.by-version."mkdirp"."0.3.5"
       self.by-version."transformers"."2.1.0"
       self.by-version."character-parser"."1.2.0"
-      self.by-version."monocle"."1.1.50"
+      self.by-version."monocle"."1.1.51"
       self.by-version."with"."2.0.0"
       self.by-version."constantinople"."1.0.2"
     ];
···
     ];
     passthru.names = [ "jade" ];
   };
-  "jade" = self.by-version."jade"."1.0.2";
+  "jade" = self.by-version."jade"."1.1.4";
   by-spec."jade"."0.26.3" =
     self.by-version."jade"."0.26.3";
   by-version."jade"."0.26.3" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "jade" ];
   };
   by-spec."jade".">= 0.0.1" =
-    self.by-version."jade"."1.0.2";
+    self.by-version."jade"."1.1.4";
+  by-spec."jade"."~0.35.0" =
+    self.by-version."jade"."0.35.0";
+  by-version."jade"."0.35.0" = lib.makeOverridable self.buildNodePackage {
+    name = "jade-0.35.0";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/jade/-/jade-0.35.0.tgz";
+        name = "jade-0.35.0.tgz";
+        sha1 = "75ec1d966a1203733613e8c180e2aa8685c16da9";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."jade" or []);
+    deps = [
+      self.by-version."commander"."2.0.0"
+      self.by-version."mkdirp"."0.3.5"
+      self.by-version."transformers"."2.1.0"
+      self.by-version."character-parser"."1.2.0"
+      self.by-version."monocle"."1.1.50"
+      self.by-version."with"."1.1.1"
+      self.by-version."constantinople"."1.0.2"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "jade" ];
+  };
   by-spec."jayschema"."*" =
-    self.by-version."jayschema"."0.2.2";
-  by-version."jayschema"."0.2.2" = lib.makeOverridable self.buildNodePackage {
-    name = "jayschema-0.2.2";
+    self.by-version."jayschema"."0.2.3";
+  by-version."jayschema"."0.2.3" = lib.makeOverridable self.buildNodePackage {
+    name = "jayschema-0.2.3";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/jayschema/-/jayschema-0.2.2.tgz";
-        name = "jayschema-0.2.2.tgz";
-        sha1 = "7bbe15c7756cca8c527427c4e424259df7b151c9";
+        url = "http://registry.npmjs.org/jayschema/-/jayschema-0.2.3.tgz";
+        name = "jayschema-0.2.3.tgz";
+        sha1 = "8f2e99d7f9dabda8d171eef2093ce9054671790d";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "jayschema" ];
   };
-  "jayschema" = self.by-version."jayschema"."0.2.2";
+  "jayschema" = self.by-version."jayschema"."0.2.3";
   by-spec."jedediah"."~0.1.0" =
     self.by-version."jedediah"."0.1.1";
   by-version."jedediah"."0.1.1" = lib.makeOverridable self.buildNodePackage {
···
       self.by-version."di"."0.0.1"
       self.by-version."socket.io"."0.9.16"
       self.by-version."chokidar"."0.8.1"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."minimatch"."0.2.14"
       self.by-version."http-proxy"."0.10.4"
       self.by-version."optimist"."0.6.0"
···
     ];
     peerDependencies = [
       self.by-version."karma"."0.11.12"
-      self.by-version."mocha"."1.16.2"
+      self.by-version."mocha"."1.17.0"
     ];
     passthru.names = [ "karma-mocha" ];
   };
···
     ];
     peerDependencies = [
       self.by-version."karma"."0.11.12"
-      self.by-version."requirejs"."2.1.9"
+      self.by-version."requirejs"."2.1.10"
     ];
     passthru.names = [ "karma-requirejs" ];
   };
···
     ];
     passthru.names = [ "keypress" ];
   };
+  by-spec."keypress"."~0.1.0" =
+    self.by-version."keypress"."0.1.0";
   by-spec."knox"."*" =
     self.by-version."knox"."0.8.8";
   by-version."knox"."0.8.8" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."lcov-result-merger" or []);
     deps = [
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
     ];
     peerDependencies = [
     ];
     passthru.names = [ "lcov-result-merger" ];
   };
   "lcov-result-merger" = self.by-version."lcov-result-merger"."0.0.2";
-  by-spec."less"."~1.5.1" =
-    self.by-version."less"."1.5.1";
-  by-version."less"."1.5.1" = lib.makeOverridable self.buildNodePackage {
-    name = "less-1.5.1";
+  by-spec."less"."~1.6.0" =
+    self.by-version."less"."1.6.1";
+  by-version."less"."1.6.1" = lib.makeOverridable self.buildNodePackage {
+    name = "less-1.6.1";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/less/-/less-1.5.1.tgz";
-        name = "less-1.5.1.tgz";
-        sha1 = "633313130efd12a3b78c56aa799dab3eeffffff4";
+        url = "http://registry.npmjs.org/less/-/less-1.6.1.tgz";
+        name = "less-1.6.1.tgz";
+        sha1 = "54e5e8d7b4fc43a14f8a32aaf0bae2d45ac287ca";
       })
     ];
     buildInputs =
       (self.nativeDeps."less" or []);
     deps = [
       self.by-version."mime"."1.2.11"
-      self.by-version."request"."2.30.0"
+      self.by-version."request"."2.31.0"
       self.by-version."mkdirp"."0.3.5"
       self.by-version."clean-css"."2.0.6"
       self.by-version."source-map"."0.1.31"
···
     deps = [
       self.by-version."async"."0.1.15"
       self.by-version."semver"."1.1.4"
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
     ];
     peerDependencies = [
     ];
···
     peerDependencies = [
     ];
     passthru.names = [ "long" ];
+  };
+  by-spec."longjohn"."~0.2.2" =
+    self.by-version."longjohn"."0.2.2";
+  by-version."longjohn"."0.2.2" = lib.makeOverridable self.buildNodePackage {
+    name = "longjohn-0.2.2";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/longjohn/-/longjohn-0.2.2.tgz";
+        name = "longjohn-0.2.2.tgz";
+        sha1 = "f1110be9407b2dfc13713cb5b57cb69ef843c4d9";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."longjohn" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "longjohn" ];
   };
   by-spec."lru-cache"."2" =
     self.by-version."lru-cache"."2.5.0";
···
     passthru.names = [ "mkpath" ];
   };
   by-spec."mocha"."*" =
-    self.by-version."mocha"."1.16.2";
-  by-version."mocha"."1.16.2" = lib.makeOverridable self.buildNodePackage {
-    name = "mocha-1.16.2";
+    self.by-version."mocha"."1.17.0";
+  by-version."mocha"."1.17.0" = lib.makeOverridable self.buildNodePackage {
+    name = "mocha-1.17.0";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mocha/-/mocha-1.16.2.tgz";
-        name = "mocha-1.16.2.tgz";
-        sha1 = "57766843f016a1308fe9fddb22f74676d6721ace";
+        url = "http://registry.npmjs.org/mocha/-/mocha-1.17.0.tgz";
+        name = "mocha-1.17.0.tgz";
+        sha1 = "583d12a9f21775b6d37d104ac7db05d557fa5d50";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "mocha" ];
   };
-  "mocha" = self.by-version."mocha"."1.16.2";
+  "mocha" = self.by-version."mocha"."1.17.0";
   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"."1.4.0-rc3";
-  by-version."mongodb"."1.4.0-rc3" = lib.makeOverridable self.buildNodePackage {
-    name = "mongodb-1.4.0-rc3";
+    self.by-version."mongodb"."1.4.0-rc4";
+  by-version."mongodb"."1.4.0-rc4" = lib.makeOverridable self.buildNodePackage {
+    name = "mongodb-1.4.0-rc4";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mongodb/-/mongodb-1.4.0-rc3.tgz";
-        name = "mongodb-1.4.0-rc3.tgz";
-        sha1 = "e605a2c85a337f85d766e2ed221a4caa201c0b4f";
+        url = "http://registry.npmjs.org/mongodb/-/mongodb-1.4.0-rc4.tgz";
+        name = "mongodb-1.4.0-rc4.tgz";
+        sha1 = "0d17168ec9b4e51a13300d4528478273b632aec5";
       })
     ];
     buildInputs =
       (self.nativeDeps."mongodb" or []);
     deps = [
-      self.by-version."bson"."0.2.3"
+      self.by-version."bson"."0.2.5"
       self.by-version."kerberos"."0.0.3"
     ];
     peerDependencies = [
     ];
     passthru.names = [ "mongodb" ];
   };
-  "mongodb" = self.by-version."mongodb"."1.4.0-rc3";
+  "mongodb" = self.by-version."mongodb"."1.4.0-rc4";
   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"."1.3.x" =
+  by-spec."mongodb"."1.3.23" =
     self.by-version."mongodb"."1.3.23";
   by-version."mongodb"."1.3.23" = lib.makeOverridable self.buildNodePackage {
     name = "mongodb-1.3.23";
···
     ];
     passthru.names = [ "mongodb" ];
   };
+  by-spec."mongodb"."1.3.x" =
+    self.by-version."mongodb"."1.3.23";
   by-spec."mongoose"."*" =
-    self.by-version."mongoose"."3.8.3";
-  by-version."mongoose"."3.8.3" = lib.makeOverridable self.buildNodePackage {
-    name = "mongoose-3.8.3";
+    self.by-version."mongoose"."3.8.4";
+  by-version."mongoose"."3.8.4" = lib.makeOverridable self.buildNodePackage {
+    name = "mongoose-3.8.4";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mongoose/-/mongoose-3.8.3.tgz";
-        name = "mongoose-3.8.3.tgz";
-        sha1 = "74425eb9ee9ca4a34c87b4624dc055131e0c7d0c";
+        url = "http://registry.npmjs.org/mongoose/-/mongoose-3.8.4.tgz";
+        name = "mongoose-3.8.4.tgz";
+        sha1 = "7ad48944d16213eb16c14ec5fbd25cf90d8c586c";
       })
     ];
     buildInputs =
       (self.nativeDeps."mongoose" or []);
     deps = [
       self.by-version."hooks"."0.2.1"
-      self.by-version."mongodb"."1.3.19"
+      self.by-version."mongodb"."1.3.23"
       self.by-version."ms"."0.1.0"
       self.by-version."sliced"."0.0.5"
       self.by-version."muri"."0.3.1"
-      self.by-version."mpromise"."0.3.0"
+      self.by-version."mpromise"."0.4.3"
       self.by-version."mpath"."0.1.1"
       self.by-version."regexp-clone"."0.0.1"
-      self.by-version."mquery"."0.3.2"
+      self.by-version."mquery"."0.4.1"
     ];
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "monocle" ];
   };
+  by-spec."monocle"."1.1.51" =
+    self.by-version."monocle"."1.1.51";
+  by-version."monocle"."1.1.51" = lib.makeOverridable self.buildNodePackage {
+    name = "monocle-1.1.51";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/monocle/-/monocle-1.1.51.tgz";
+        name = "monocle-1.1.51.tgz";
+        sha1 = "22ed16e112e9b056769c5ccac920e375249d89c0";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."monocle" or []);
+    deps = [
+      self.by-version."readdirp"."0.2.5"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "monocle" ];
+  };
   by-spec."mout"."~0.6.0" =
     self.by-version."mout"."0.6.0";
   by-version."mout"."0.6.0" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "mpromise" ];
   };
-  by-spec."mpromise"."0.3.0" =
-    self.by-version."mpromise"."0.3.0";
-  by-version."mpromise"."0.3.0" = lib.makeOverridable self.buildNodePackage {
-    name = "mpromise-0.3.0";
+  by-spec."mpromise"."0.4.3" =
+    self.by-version."mpromise"."0.4.3";
+  by-version."mpromise"."0.4.3" = lib.makeOverridable self.buildNodePackage {
+    name = "mpromise-0.4.3";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mpromise/-/mpromise-0.3.0.tgz";
-        name = "mpromise-0.3.0.tgz";
-        sha1 = "cb864c2f642eb2192765087e3692e1dc152afe4b";
+        url = "http://registry.npmjs.org/mpromise/-/mpromise-0.4.3.tgz";
+        name = "mpromise-0.4.3.tgz";
+        sha1 = "edc47a75a2a177b0e9382735db52dbec3808cc33";
       })
     ];
     buildInputs =
       (self.nativeDeps."mpromise" or []);
     deps = [
-      self.by-version."sliced"."0.0.5"
     ];
     peerDependencies = [
     ];
     passthru.names = [ "mpromise" ];
   };
-  by-spec."mquery"."0.3.2" =
-    self.by-version."mquery"."0.3.2";
-  by-version."mquery"."0.3.2" = lib.makeOverridable self.buildNodePackage {
-    name = "mquery-0.3.2";
+  by-spec."mquery"."0.4.1" =
+    self.by-version."mquery"."0.4.1";
+  by-version."mquery"."0.4.1" = lib.makeOverridable self.buildNodePackage {
+    name = "mquery-0.4.1";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/mquery/-/mquery-0.3.2.tgz";
-        name = "mquery-0.3.2.tgz";
-        sha1 = "074cb82c51ec1b15897d8afb80a7b3567a2f8eca";
+        url = "http://registry.npmjs.org/mquery/-/mquery-0.4.1.tgz";
+        name = "mquery-0.4.1.tgz";
+        sha1 = "c4626dd29203f3991abe9ddba88781256ad42fdf";
       })
     ];
     buildInputs =
···
     deps = [
       self.by-version."sliced"."0.0.5"
       self.by-version."debug"."0.7.0"
+      self.by-version."mongodb"."1.3.19"
       self.by-version."regexp-clone"."0.0.1"
     ];
     peerDependencies = [
···
     buildInputs =
       (self.nativeDeps."multiparty" or []);
     deps = [
-      self.by-version."readable-stream"."1.1.9"
+      self.by-version."readable-stream"."1.1.10"
       self.by-version."stream-counter"."0.2.0"
     ];
     peerDependencies = [
···
         url = "http://registry.npmjs.org/nan/-/nan-0.3.2.tgz";
         name = "nan-0.3.2.tgz";
         sha1 = "0df1935cab15369075ef160ad2894107aa14dc2d";
-      })
-    ];
-    buildInputs =
-      (self.nativeDeps."nan" or []);
-    deps = [
-    ];
-    peerDependencies = [
-    ];
-    passthru.names = [ "nan" ];
-  };
-  by-spec."nan"."~0.4.1" =
-    self.by-version."nan"."0.4.4";
-  by-version."nan"."0.4.4" = lib.makeOverridable self.buildNodePackage {
-    name = "nan-0.4.4";
-    src = [
-      (fetchurl {
-        url = "http://registry.npmjs.org/nan/-/nan-0.4.4.tgz";
-        name = "nan-0.4.4.tgz";
-        sha1 = "9db58eae63cee119807a0d01afd0655d956bea75";
       })
     ];
     buildInputs =
···
     passthru.names = [ "nijs" ];
   };
   "nijs" = self.by-version."nijs"."0.0.12";
+  by-spec."node-appc"."0.2.0" =
+    self.by-version."node-appc"."0.2.0";
+  by-version."node-appc"."0.2.0" = lib.makeOverridable self.buildNodePackage {
+    name = "node-appc-0.2.0";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/node-appc/-/node-appc-0.2.0.tgz";
+        name = "node-appc-0.2.0.tgz";
+        sha1 = "7bc7ec2a9c65e2e0b55a42669fae383329d51609";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."node-appc" or []);
+    deps = [
+      self.by-version."adm-zip"."0.4.3"
+      self.by-version."async"."0.2.9"
+      self.by-version."colors"."0.6.2"
+      self.by-version."diff"."1.0.8"
+      self.by-version."dox"."0.4.4"
+      self.by-version."jade"."0.35.0"
+      self.by-version."node-uuid"."1.4.1"
+      self.by-version."optimist"."0.6.0"
+      self.by-version."request"."2.27.0"
+      self.by-version."semver"."2.1.0"
+      self.by-version."sprintf"."0.1.3"
+      self.by-version."temp"."0.6.0"
+      self.by-version."wrench"."1.5.4"
+      self.by-version."uglify-js"."2.3.6"
+      self.by-version."xmldom"."0.1.17"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "node-appc" ];
+  };
   by-spec."node-expat"."*" =
     self.by-version."node-expat"."2.1.4";
   by-version."node-expat"."2.1.4" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."node-gyp" or []);
     deps = [
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."graceful-fs"."2.0.1"
       self.by-version."fstream"."0.1.25"
       self.by-version."minimatch"."0.2.14"
···
       self.by-version."nopt"."2.1.2"
       self.by-version."npmlog"."0.0.6"
       self.by-version."osenv"."0.0.3"
-      self.by-version."request"."2.30.0"
+      self.by-version."request"."2.31.0"
       self.by-version."rimraf"."2.2.5"
       self.by-version."semver"."2.2.1"
       self.by-version."tar"."0.1.19"
···
       self.by-version."socket.io"."0.9.16"
       self.by-version."express"."3.4.7"
       self.by-version."async"."0.2.9"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."rc"."0.3.2"
       self.by-version."strong-data-uri"."0.1.0"
       self.by-version."debug"."0.7.4"
···
   };
   "node-inspector" = self.by-version."node-inspector"."0.7.0-1";
   by-spec."node-protobuf"."*" =
-    self.by-version."node-protobuf"."1.0.9";
-  by-version."node-protobuf"."1.0.9" = lib.makeOverridable self.buildNodePackage {
-    name = "node-protobuf-1.0.9";
+    self.by-version."node-protobuf"."1.0.10";
+  by-version."node-protobuf"."1.0.10" = lib.makeOverridable self.buildNodePackage {
+    name = "node-protobuf-1.0.10";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/node-protobuf/-/node-protobuf-1.0.9.tgz";
-        name = "node-protobuf-1.0.9.tgz";
-        sha1 = "6b2e7682bb65e01a10e19179f8e162ac9a66a6e6";
+        url = "http://registry.npmjs.org/node-protobuf/-/node-protobuf-1.0.10.tgz";
+        name = "node-protobuf-1.0.10.tgz";
+        sha1 = "a8a02d55129efe1776bc3e038d7e6c676c001fcd";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "node-protobuf" ];
   };
-  "node-protobuf" = self.by-version."node-protobuf"."1.0.9";
+  "node-protobuf" = self.by-version."node-protobuf"."1.0.10";
   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 {
···
     self.by-version."node-uuid"."1.4.1";
   by-spec."node-uuid"."~1.4.0" =
     self.by-version."node-uuid"."1.4.1";
+  by-spec."node-uuid"."~1.4.1" =
+    self.by-version."node-uuid"."1.4.1";
   by-spec."node-wsfederation".">=0.1.1" =
     self.by-version."node-wsfederation"."0.1.1";
   by-version."node-wsfederation"."0.1.1" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "nodemailer" ];
   };
   by-spec."nodemon"."*" =
-    self.by-version."nodemon"."1.0.5";
-  by-version."nodemon"."1.0.5" = lib.makeOverridable self.buildNodePackage {
-    name = "nodemon-1.0.5";
+    self.by-version."nodemon"."1.0.8";
+  by-version."nodemon"."1.0.8" = lib.makeOverridable self.buildNodePackage {
+    name = "nodemon-1.0.8";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/nodemon/-/nodemon-1.0.5.tgz";
-        name = "nodemon-1.0.5.tgz";
-        sha1 = "795f57d018791bae6988b9e34b34bb4a11c84d21";
+        url = "http://registry.npmjs.org/nodemon/-/nodemon-1.0.8.tgz";
+        name = "nodemon-1.0.8.tgz";
+        sha1 = "fa737c8f0f331ee77c23f993ce3205615f0d27f9";
       })
     ];
     buildInputs =
···
     ];
     passthru.names = [ "nodemon" ];
   };
-  "nodemon" = self.by-version."nodemon"."1.0.5";
+  "nodemon" = self.by-version."nodemon"."1.0.8";
   by-spec."nomnom"."1.6.x" =
     self.by-version."nomnom"."1.6.2";
   by-version."nomnom"."1.6.2" = lib.makeOverridable self.buildNodePackage {
···
       self.by-version."npmlog"."0.0.6"
       self.by-version."ansi"."0.2.1"
       self.by-version."npm-registry-client"."0.3.3"
-      self.by-version."read-package-json"."1.1.4"
+      self.by-version."read-package-json"."1.1.5"
       self.by-version."read-installed"."0.2.5"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."init-package-json"."0.0.14"
       self.by-version."osenv"."0.0.3"
       self.by-version."lockfile"."0.4.2"
       self.by-version."retry"."0.6.0"
       self.by-version."once"."1.3.0"
-      self.by-version."npmconf"."0.1.9"
+      self.by-version."npmconf"."0.1.12"
       self.by-version."opener"."1.3.0"
       self.by-version."chmodr"."0.1.0"
       self.by-version."cmd-shim"."1.1.1"
···
     buildInputs =
       (self.nativeDeps."npm-registry-client" or []);
     deps = [
-      self.by-version."request"."2.30.0"
+      self.by-version."request"."2.31.0"
       self.by-version."graceful-fs"."2.0.1"
       self.by-version."semver"."2.0.11"
       self.by-version."slide"."1.1.5"
···
     buildInputs =
       (self.nativeDeps."npm-registry-client" or []);
     deps = [
-      self.by-version."request"."2.30.0"
+      self.by-version."request"."2.31.0"
       self.by-version."graceful-fs"."2.0.1"
       self.by-version."semver"."2.2.1"
       self.by-version."slide"."1.1.5"
···
     passthru.names = [ "npmconf" ];
   };
   by-spec."npmconf"."~0.1.2" =
-    self.by-version."npmconf"."0.1.9";
-  by-version."npmconf"."0.1.9" = lib.makeOverridable self.buildNodePackage {
-    name = "npmconf-0.1.9";
+    self.by-version."npmconf"."0.1.12";
+  by-version."npmconf"."0.1.12" = lib.makeOverridable self.buildNodePackage {
+    name = "npmconf-0.1.12";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/npmconf/-/npmconf-0.1.9.tgz";
-        name = "npmconf-0.1.9.tgz";
-        sha1 = "a6b256fdd23e347ef2465a2e6d57a9be4deb898f";
+        url = "http://registry.npmjs.org/npmconf/-/npmconf-0.1.12.tgz";
+        name = "npmconf-0.1.12.tgz";
+        sha1 = "7b89bbbb93fbbc449d7fac109e8164b47d105e90";
       })
     ];
     buildInputs =
···
     passthru.names = [ "npmconf" ];
   };
   by-spec."npmconf"."~0.1.7" =
-    self.by-version."npmconf"."0.1.9";
+    self.by-version."npmconf"."0.1.12";
   by-spec."npmlog"."*" =
     self.by-version."npmlog"."0.0.6";
   by-version."npmlog"."0.0.6" = lib.makeOverridable self.buildNodePackage {
···
     deps = [
       self.by-version."semver"."2.2.1"
       self.by-version."slide"."1.1.5"
-      self.by-version."read-package-json"."1.1.4"
+      self.by-version."read-package-json"."1.1.5"
       self.by-version."graceful-fs"."1.2.3"
     ];
     peerDependencies = [
···
     deps = [
       self.by-version."semver"."2.2.1"
       self.by-version."slide"."1.1.5"
-      self.by-version."read-package-json"."1.1.4"
+      self.by-version."read-package-json"."1.1.5"
       self.by-version."graceful-fs"."2.0.1"
     ];
     peerDependencies = [
···
     passthru.names = [ "read-installed" ];
   };
   by-spec."read-package-json"."1" =
-    self.by-version."read-package-json"."1.1.4";
-  by-version."read-package-json"."1.1.4" = lib.makeOverridable self.buildNodePackage {
-    name = "read-package-json-1.1.4";
+    self.by-version."read-package-json"."1.1.5";
+  by-version."read-package-json"."1.1.5" = lib.makeOverridable self.buildNodePackage {
+    name = "read-package-json-1.1.5";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/read-package-json/-/read-package-json-1.1.4.tgz";
-        name = "read-package-json-1.1.4.tgz";
-        sha1 = "c4effa9fac527deaee1cd84659c419693aa5294a";
+        url = "http://registry.npmjs.org/read-package-json/-/read-package-json-1.1.5.tgz";
+        name = "read-package-json-1.1.5.tgz";
+        sha1 = "f6a7a5820cc958ff02495badc55f7fe49a7677a1";
       })
     ];
     buildInputs =
       (self.nativeDeps."read-package-json" or []);
     deps = [
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."lru-cache"."2.5.0"
       self.by-version."normalize-package-data"."0.2.8"
       self.by-version."graceful-fs"."2.0.1"
···
     passthru.names = [ "read-package-json" ];
   };
   by-spec."read-package-json"."~1.1.4" =
-    self.by-version."read-package-json"."1.1.4";
+    self.by-version."read-package-json"."1.1.5";
   by-spec."readable-stream"."1.0" =
-    self.by-version."readable-stream"."1.0.17";
-  by-version."readable-stream"."1.0.17" = lib.makeOverridable self.buildNodePackage {
-    name = "readable-stream-1.0.17";
+    self.by-version."readable-stream"."1.0.24";
+  by-version."readable-stream"."1.0.24" = lib.makeOverridable self.buildNodePackage {
+    name = "readable-stream-1.0.24";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.17.tgz";
-        name = "readable-stream-1.0.17.tgz";
-        sha1 = "cbc295fdf394dfa1225d225d02e6b6d0f409fd4b";
+        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.24.tgz";
+        name = "readable-stream-1.0.24.tgz";
+        sha1 = "b5659d5772cd06992dffe5a3bee2eec480f1c2fe";
       })
     ];
     buildInputs =
···
     passthru.names = [ "readable-stream" ];
   };
   by-spec."readable-stream"."1.1" =
-    self.by-version."readable-stream"."1.1.9";
-  by-version."readable-stream"."1.1.9" = lib.makeOverridable self.buildNodePackage {
-    name = "readable-stream-1.1.9";
+    self.by-version."readable-stream"."1.1.10";
+  by-version."readable-stream"."1.1.10" = lib.makeOverridable self.buildNodePackage {
+    name = "readable-stream-1.1.10";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.9.tgz";
-        name = "readable-stream-1.1.9.tgz";
-        sha1 = "d87130fbf8f9ee9c3b4058b3c58a3e30db2fcfdd";
+        url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.10.tgz";
+        name = "readable-stream-1.1.10.tgz";
+        sha1 = "c616cbc30aa586724b7401c37de33b0b5c0c6429";
       })
     ];
     buildInputs =
       (self.nativeDeps."readable-stream" or []);
     deps = [
-      self.by-version."core-util-is"."1.0.0"
+      self.by-version."core-util-is"."1.0.1"
       self.by-version."debuglog"."0.0.2"
     ];
     peerDependencies = [
···
     passthru.names = [ "readable-stream" ];
   };
   by-spec."readable-stream"."~1.0.2" =
-    self.by-version."readable-stream"."1.0.17";
+    self.by-version."readable-stream"."1.0.24";
   by-spec."readable-stream"."~1.1.8" =
-    self.by-version."readable-stream"."1.1.9";
+    self.by-version."readable-stream"."1.1.10";
   by-spec."readable-stream"."~1.1.9" =
-    self.by-version."readable-stream"."1.1.9";
+    self.by-version."readable-stream"."1.1.10";
   by-spec."readdirp"."~0.2.3" =
     self.by-version."readdirp"."0.2.5";
   by-version."readdirp"."0.2.5" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "replace" ];
   };
   by-spec."request"."2" =
-    self.by-version."request"."2.30.0";
-  by-version."request"."2.30.0" = lib.makeOverridable self.buildNodePackage {
-    name = "request-2.30.0";
+    self.by-version."request"."2.31.0";
+  by-version."request"."2.31.0" = lib.makeOverridable self.buildNodePackage {
+    name = "request-2.31.0";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/request/-/request-2.30.0.tgz";
-        name = "request-2.30.0.tgz";
-        sha1 = "8e0d36f0806e8911524b072b64c5ee535a09d861";
+        url = "http://registry.npmjs.org/request/-/request-2.31.0.tgz";
+        name = "request-2.31.0.tgz";
+        sha1 = "4c8ac967c9a4b9410cb4ba1a61fdb644267eeeff";
       })
     ];
     buildInputs =
···
     passthru.names = [ "request" ];
   };
   by-spec."request"."2 >=2.20.0" =
-    self.by-version."request"."2.30.0";
+    self.by-version."request"."2.31.0";
   by-spec."request"."2 >=2.25.0" =
-    self.by-version."request"."2.30.0";
+    self.by-version."request"."2.31.0";
   by-spec."request"."2.16.2" =
     self.by-version."request"."2.16.2";
   by-version."request"."2.16.2" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "request" ];
   };
   by-spec."request".">=2.12.0" =
-    self.by-version."request"."2.30.0";
+    self.by-version."request"."2.31.0";
   by-spec."request"."~2" =
-    self.by-version."request"."2.30.0";
+    self.by-version."request"."2.31.0";
   by-spec."request"."~2.21.0" =
     self.by-version."request"."2.21.0";
   by-version."request"."2.21.0" = lib.makeOverridable self.buildNodePackage {
···
   };
   by-spec."request"."~2.30.0" =
     self.by-version."request"."2.30.0";
+  by-version."request"."2.30.0" = lib.makeOverridable self.buildNodePackage {
+    name = "request-2.30.0";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/request/-/request-2.30.0.tgz";
+        name = "request-2.30.0.tgz";
+        sha1 = "8e0d36f0806e8911524b072b64c5ee535a09d861";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."request" or []);
+    deps = [
+      self.by-version."qs"."0.6.6"
+      self.by-version."json-stringify-safe"."5.0.0"
+      self.by-version."forever-agent"."0.5.0"
+      self.by-version."node-uuid"."1.4.1"
+      self.by-version."mime"."1.2.11"
+      self.by-version."tough-cookie"."0.9.15"
+      self.by-version."form-data"."0.1.2"
+      self.by-version."tunnel-agent"."0.3.0"
+      self.by-version."http-signature"."0.10.0"
+      self.by-version."oauth-sign"."0.3.0"
+      self.by-version."hawk"."1.0.0"
+      self.by-version."aws-sign2"."0.5.0"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "request" ];
+  };
   by-spec."request-progress"."~0.3.0" =
     self.by-version."request-progress"."0.3.1";
   by-version."request-progress"."0.3.1" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "request-replay" ];
   };
   by-spec."requirejs"."~2.1" =
-    self.by-version."requirejs"."2.1.9";
-  by-version."requirejs"."2.1.9" = lib.makeOverridable self.buildNodePackage {
-    name = "requirejs-2.1.9";
+    self.by-version."requirejs"."2.1.10";
+  by-version."requirejs"."2.1.10" = lib.makeOverridable self.buildNodePackage {
+    name = "requirejs-2.1.10";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/requirejs/-/requirejs-2.1.9.tgz";
-        name = "requirejs-2.1.9.tgz";
-        sha1 = "624e10d22863e8db9aebfb8f21809ca59da42344";
+        url = "http://registry.npmjs.org/requirejs/-/requirejs-2.1.10.tgz";
+        name = "requirejs-2.1.10.tgz";
+        sha1 = "1e1d7f608790e532a422c6199dad2abe15484b54";
       })
     ];
     buildInputs =
···
     passthru.names = [ "requirejs" ];
   };
   by-spec."requirejs"."~2.1.0" =
-    self.by-version."requirejs"."2.1.9";
+    self.by-version."requirejs"."2.1.10";
   by-spec."resolve"."0.5.x" =
     self.by-version."resolve"."0.5.1";
   by-version."resolve"."0.5.1" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."s3http" or []);
     deps = [
-      self.by-version."aws-sdk"."1.17.0"
+      self.by-version."aws-sdk"."1.17.2"
       self.by-version."commander"."2.0.0"
       self.by-version."http-auth"."2.0.7"
       self.by-version."express"."3.4.4"
···
       (self.nativeDeps."sha" or []);
     deps = [
       self.by-version."graceful-fs"."2.0.1"
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
     ];
     peerDependencies = [
     ];
···
     ];
     passthru.names = [ "spdy" ];
   };
+  by-spec."sprintf"."~0.1.2" =
+    self.by-version."sprintf"."0.1.3";
+  by-version."sprintf"."0.1.3" = lib.makeOverridable self.buildNodePackage {
+    name = "sprintf-0.1.3";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/sprintf/-/sprintf-0.1.3.tgz";
+        name = "sprintf-0.1.3.tgz";
+        sha1 = "530fc31405d47422f6edb40f29bdafac599ede11";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."sprintf" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "sprintf" ];
+  };
+  by-spec."sprintf"."~0.1.3" =
+    self.by-version."sprintf"."0.1.3";
   by-spec."ssh-agent"."0.2.1" =
     self.by-version."ssh-agent"."0.2.1";
   by-version."ssh-agent"."0.2.1" = lib.makeOverridable self.buildNodePackage {
···
     passthru.names = [ "ssh-agent" ];
   };
   by-spec."ssh2"."~0.2.14" =
-    self.by-version."ssh2"."0.2.15";
-  by-version."ssh2"."0.2.15" = lib.makeOverridable self.buildNodePackage {
-    name = "ssh2-0.2.15";
+    self.by-version."ssh2"."0.2.16";
+  by-version."ssh2"."0.2.16" = lib.makeOverridable self.buildNodePackage {
+    name = "ssh2-0.2.16";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/ssh2/-/ssh2-0.2.15.tgz";
-        name = "ssh2-0.2.15.tgz";
-        sha1 = "4bdd245a6764ec3cf9689c08aa8467bdedfb3cb0";
+        url = "http://registry.npmjs.org/ssh2/-/ssh2-0.2.16.tgz";
+        name = "ssh2-0.2.16.tgz";
+        sha1 = "f0e2fe7f4e3223c74ddd430dac82506ed3d747c7";
       })
     ];
     buildInputs =
···
     buildInputs =
       (self.nativeDeps."stream-counter" or []);
     deps = [
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
     ];
     peerDependencies = [
     ];
···
     buildInputs =
       (self.nativeDeps."stream-counter" or []);
     deps = [
-      self.by-version."readable-stream"."1.1.9"
+      self.by-version."readable-stream"."1.1.10"
     ];
     peerDependencies = [
     ];
···
     passthru.names = [ "strong-data-uri" ];
   };
   by-spec."stylus"."*" =
-    self.by-version."stylus"."0.41.3";
-  by-version."stylus"."0.41.3" = lib.makeOverridable self.buildNodePackage {
-    name = "stylus-0.41.3";
+    self.by-version."stylus"."0.42.0";
+  by-version."stylus"."0.42.0" = lib.makeOverridable self.buildNodePackage {
+    name = "stylus-0.42.0";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/stylus/-/stylus-0.41.3.tgz";
-        name = "stylus-0.41.3.tgz";
-        sha1 = "0a49c3f2f4f6b6719e7cca823052b9df87acaeb7";
+        url = "http://registry.npmjs.org/stylus/-/stylus-0.42.0.tgz";
+        name = "stylus-0.42.0.tgz";
+        sha1 = "5dc4d50dd205dbb7e6af6bf7f19546da24148e44";
       })
     ];
     buildInputs =
       (self.nativeDeps."stylus" or []);
     deps = [
-      self.by-version."cssom"."0.2.5"
+      self.by-version."css-parse"."1.7.0"
       self.by-version."mkdirp"."0.3.5"
       self.by-version."debug"."0.7.4"
       self.by-version."sax"."0.5.8"
+      self.by-version."glob"."3.2.8"
     ];
     peerDependencies = [
     ];
     passthru.names = [ "stylus" ];
   };
-  "stylus" = self.by-version."stylus"."0.41.3";
+  "stylus" = self.by-version."stylus"."0.42.0";
   by-spec."stylus"."0.27.2" =
     self.by-version."stylus"."0.27.2";
   by-version."stylus"."0.27.2" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "sudo-block" ];
   };
-  by-spec."superagent"."0.15.7" =
-    self.by-version."superagent"."0.15.7";
-  by-version."superagent"."0.15.7" = lib.makeOverridable self.buildNodePackage {
-    name = "superagent-0.15.7";
+  by-spec."superagent"."0.16.0" =
+    self.by-version."superagent"."0.16.0";
+  by-version."superagent"."0.16.0" = lib.makeOverridable self.buildNodePackage {
+    name = "superagent-0.16.0";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/superagent/-/superagent-0.15.7.tgz";
-        name = "superagent-0.15.7.tgz";
-        sha1 = "095c70b8afffbc072f1458f39684d4854d6333a3";
+        url = "http://registry.npmjs.org/superagent/-/superagent-0.16.0.tgz";
+        name = "superagent-0.16.0.tgz";
+        sha1 = "f38df4a476565dffdbaa07764b81a19f0ab38a4e";
       })
     ];
     buildInputs =
···
   };
   by-spec."superagent"."~0.15.7" =
     self.by-version."superagent"."0.15.7";
+  by-version."superagent"."0.15.7" = lib.makeOverridable self.buildNodePackage {
+    name = "superagent-0.15.7";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/superagent/-/superagent-0.15.7.tgz";
+        name = "superagent-0.15.7.tgz";
+        sha1 = "095c70b8afffbc072f1458f39684d4854d6333a3";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."superagent" or []);
+    deps = [
+      self.by-version."qs"."0.6.5"
+      self.by-version."formidable"."1.0.14"
+      self.by-version."mime"."1.2.5"
+      self.by-version."emitter-component"."1.0.0"
+      self.by-version."methods"."0.0.1"
+      self.by-version."cookiejar"."1.3.0"
+      self.by-version."debug"."0.7.4"
+      self.by-version."reduce-component"."1.0.1"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "superagent" ];
+  };
   by-spec."supertest"."*" =
-    self.by-version."supertest"."0.8.2";
-  by-version."supertest"."0.8.2" = lib.makeOverridable self.buildNodePackage {
-    name = "supertest-0.8.2";
+    self.by-version."supertest"."0.8.3";
+  by-version."supertest"."0.8.3" = lib.makeOverridable self.buildNodePackage {
+    name = "supertest-0.8.3";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/supertest/-/supertest-0.8.2.tgz";
-        name = "supertest-0.8.2.tgz";
-        sha1 = "2da3519f7c9dcfa8759e2de9c794f1d4acc0333b";
+        url = "http://registry.npmjs.org/supertest/-/supertest-0.8.3.tgz";
+        name = "supertest-0.8.3.tgz";
+        sha1 = "7af32af5bd74514f3fabc444facc9858ae438593";
       })
     ];
     buildInputs =
       (self.nativeDeps."supertest" or []);
     deps = [
-      self.by-version."superagent"."0.15.7"
+      self.by-version."superagent"."0.16.0"
       self.by-version."methods"."0.1.0"
     ];
     peerDependencies = [
     ];
     passthru.names = [ "supertest" ];
   };
-  "supertest" = self.by-version."supertest"."0.8.2";
+  "supertest" = self.by-version."supertest"."0.8.3";
   by-spec."swig"."0.14.x" =
     self.by-version."swig"."0.14.0";
   by-version."swig"."0.14.0" = lib.makeOverridable self.buildNodePackage {
···
     buildInputs =
       (self.nativeDeps."through2" or []);
     deps = [
-      self.by-version."readable-stream"."1.0.17"
+      self.by-version."readable-stream"."1.0.24"
       self.by-version."xtend"."2.0.6"
     ];
     peerDependencies = [
···
     ];
     passthru.names = [ "tinycolor" ];
   };
+  by-spec."titanium"."*" =
+    self.by-version."titanium"."3.2.1-beta";
+  by-version."titanium"."3.2.1-beta" = lib.makeOverridable self.buildNodePackage {
+    name = "titanium-3.2.1-beta";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/titanium/-/titanium-3.2.1-beta.tgz";
+        name = "titanium-3.2.1-beta.tgz";
+        sha1 = "3d92e09ea627584f11bec903052c6501f85ee8fa";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."titanium" or []);
+    deps = [
+      self.by-version."async"."0.2.9"
+      self.by-version."colors"."0.6.2"
+      self.by-version."fields"."0.1.11"
+      self.by-version."humanize"."0.0.9"
+      self.by-version."jade"."0.35.0"
+      self.by-version."longjohn"."0.2.2"
+      self.by-version."moment"."2.4.0"
+      self.by-version."node-appc"."0.2.0"
+      self.by-version."optimist"."0.6.0"
+      self.by-version."request"."2.27.0"
+      self.by-version."semver"."2.2.1"
+      self.by-version."sprintf"."0.1.3"
+      self.by-version."temp"."0.6.0"
+      self.by-version."winston"."0.6.2"
+      self.by-version."wrench"."1.5.4"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "titanium" ];
+  };
+  "titanium" = self.by-version."titanium"."3.2.1-beta";
   by-spec."tmp"."~0.0.20" =
     self.by-version."tmp"."0.0.23";
   by-version."tmp"."0.0.23" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "uglify-js" ];
   };
+  by-spec."uglify-js"."~2.3.6" =
+    self.by-version."uglify-js"."2.3.6";
   by-spec."uglify-js"."~2.4.0" =
     self.by-version."uglify-js"."2.4.8";
   by-version."uglify-js"."2.4.8" = lib.makeOverridable self.buildNodePackage {
···
     self.by-version."underscore"."1.4.4";
   by-spec."underscore"."~1.4.4" =
     self.by-version."underscore"."1.4.4";
+  by-spec."underscore"."~1.5" =
+    self.by-version."underscore"."1.5.2";
   by-spec."underscore"."~1.5.2" =
     self.by-version."underscore"."1.5.2";
   by-spec."underscore.string"."~2.2.1" =
···
       self.by-version."socket.io"."0.9.16"
       self.by-version."moment"."2.4.0"
       self.by-version."async"."0.2.9"
-      self.by-version."ssh2"."0.2.15"
+      self.by-version."ssh2"."0.2.16"
       self.by-version."rc"."0.3.2"
       self.by-version."uuid"."1.4.1"
       self.by-version."winston"."0.7.2"
···
       self.by-version."adm-zip"."0.4.3"
       self.by-version."kew"."0.1.7"
       self.by-version."mkdirp"."0.3.5"
-      self.by-version."npmconf"."0.1.9"
+      self.by-version."npmconf"."0.1.12"
       self.by-version."phantomjs"."1.9.2-6"
       self.by-version."tmp"."0.0.23"
       self.by-version."follow-redirects"."0.0.3"
···
     ];
     passthru.names = [ "wiredep" ];
   };
+  by-spec."with"."~1.1.0" =
+    self.by-version."with"."1.1.1";
+  by-version."with"."1.1.1" = lib.makeOverridable self.buildNodePackage {
+    name = "with-1.1.1";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/with/-/with-1.1.1.tgz";
+        name = "with-1.1.1.tgz";
+        sha1 = "66bd6664deb318b2482dd0424ccdebe822434ac0";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."with" or []);
+    deps = [
+      self.by-version."uglify-js"."2.4.0"
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "with" ];
+  };
   by-spec."with"."~2.0.0" =
     self.by-version."with"."2.0.0";
   by-version."with"."2.0.0" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "wrench" ];
   };
+  by-spec."wrench"."~1.5.0" =
+    self.by-version."wrench"."1.5.4";
+  by-version."wrench"."1.5.4" = lib.makeOverridable self.buildNodePackage {
+    name = "wrench-1.5.4";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/wrench/-/wrench-1.5.4.tgz";
+        name = "wrench-1.5.4.tgz";
+        sha1 = "2e8d9d3db3568cc1c001a4c8dceca772e5d21643";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."wrench" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "wrench" ];
+  };
+  by-spec."wrench"."~1.5.4" =
+    self.by-version."wrench"."1.5.4";
   by-spec."ws"."0.4.x" =
     self.by-version."ws"."0.4.31";
   by-version."ws"."0.4.31" = lib.makeOverridable self.buildNodePackage {
···
     ];
     passthru.names = [ "xmlbuilder" ];
   };
+  by-spec."xmldom"."~0.1.16" =
+    self.by-version."xmldom"."0.1.17";
+  by-version."xmldom"."0.1.17" = lib.makeOverridable self.buildNodePackage {
+    name = "xmldom-0.1.17";
+    src = [
+      (fetchurl {
+        url = "http://registry.npmjs.org/xmldom/-/xmldom-0.1.17.tgz";
+        name = "xmldom-0.1.17.tgz";
+        sha1 = "c5debadc069f0a3967ddfbc01395a4d7cb0d4282";
+      })
+    ];
+    buildInputs =
+      (self.nativeDeps."xmldom" or []);
+    deps = [
+    ];
+    peerDependencies = [
+    ];
+    passthru.names = [ "xmldom" ];
+  };
   by-spec."xmlhttprequest"."1.4.2" =
     self.by-version."xmlhttprequest"."1.4.2";
   by-version."xmlhttprequest"."1.4.2" = lib.makeOverridable self.buildNodePackage {
···
       self.by-version."underscore.string"."2.3.3"
       self.by-version."lodash"."1.3.1"
       self.by-version."mkdirp"."0.3.5"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."debug"."0.7.4"
       self.by-version."isbinaryfile"."0.1.9"
       self.by-version."dargs"."0.1.0"
···
       self.by-version."underscore.string"."2.3.3"
       self.by-version."lodash"."2.2.1"
       self.by-version."mkdirp"."0.3.5"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."debug"."0.7.4"
       self.by-version."isbinaryfile"."0.1.9"
       self.by-version."dargs"."0.1.0"
···
     ];
     passthru.names = [ "yeoman-generator" ];
   };
-  by-spec."yeoman-generator"."~0.15.0" =
-    self.by-version."yeoman-generator"."0.15.0";
-  by-version."yeoman-generator"."0.15.0" = lib.makeOverridable self.buildNodePackage {
-    name = "yeoman-generator-0.15.0";
+  by-spec."yeoman-generator"."~0.16.0" =
+    self.by-version."yeoman-generator"."0.16.0";
+  by-version."yeoman-generator"."0.16.0" = lib.makeOverridable self.buildNodePackage {
+    name = "yeoman-generator-0.16.0";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/yeoman-generator/-/yeoman-generator-0.15.0.tgz";
-        name = "yeoman-generator-0.15.0.tgz";
-        sha1 = "938eb791307cf9233bff3fd403302b5bc9cfe06a";
+        url = "http://registry.npmjs.org/yeoman-generator/-/yeoman-generator-0.16.0.tgz";
+        name = "yeoman-generator-0.16.0.tgz";
+        sha1 = "0d1b655ea31660ab66837af1e686b795eae57c59";
       })
     ];
     buildInputs =
       (self.nativeDeps."yeoman-generator" or []);
     deps = [
-      self.by-version."cheerio"."0.13.0"
+      self.by-version."cheerio"."0.13.1"
       self.by-version."rimraf"."2.2.5"
       self.by-version."diff"."1.0.8"
       self.by-version."mime"."1.2.11"
       self.by-version."underscore.string"."2.3.3"
       self.by-version."lodash"."2.4.1"
       self.by-version."mkdirp"."0.3.5"
-      self.by-version."glob"."3.2.7"
+      self.by-version."glob"."3.2.8"
       self.by-version."debug"."0.7.4"
       self.by-version."isbinaryfile"."2.0.0"
       self.by-version."dargs"."0.1.0"
···
     passthru.names = [ "yeoman-generator" ];
   };
   by-spec."yo"."*" =
-    self.by-version."yo"."1.1.1";
-  by-version."yo"."1.1.1" = lib.makeOverridable self.buildNodePackage {
-    name = "yo-1.1.1";
+    self.by-version."yo"."1.1.2";
+  by-version."yo"."1.1.2" = lib.makeOverridable self.buildNodePackage {
+    name = "yo-1.1.2";
     src = [
       (fetchurl {
-        url = "http://registry.npmjs.org/yo/-/yo-1.1.1.tgz";
-        name = "yo-1.1.1.tgz";
-        sha1 = "9c26dfef997c6114272c8b3980c6b02256e874d0";
+        url = "http://registry.npmjs.org/yo/-/yo-1.1.2.tgz";
+        name = "yo-1.1.2.tgz";
+        sha1 = "a0d4da72e83fa0e0dbfe1d0ba258881b240ab854";
       })
     ];
     buildInputs =
       (self.nativeDeps."yo" or []);
     deps = [
-      self.by-version."yeoman-generator"."0.15.0"
+      self.by-version."yeoman-generator"."0.16.0"
       self.by-version."nopt"."2.1.2"
       self.by-version."lodash"."2.4.1"
       self.by-version."update-notifier"."0.1.7"
···
     ];
     passthru.names = [ "yo" ];
   };
-  "yo" = self.by-version."yo"."1.1.1";
+  "yo" = self.by-version."yo"."1.1.2";
   by-spec."yo".">=1.0.0" =
-    self.by-version."yo"."1.1.1";
+    self.by-version."yo"."1.1.2";
   by-spec."yo".">=1.0.0-rc.1.1" =
-    self.by-version."yo"."1.1.1";
+    self.by-version."yo"."1.1.2";
   by-spec."zeparser"."0.0.5" =
     self.by-version."zeparser"."0.0.5";
   by-version."zeparser"."0.0.5" = lib.makeOverridable self.buildNodePackage {

pkgs/top-level/node-packages.json

···
 , "rethinkdb"
 , "bower2nix"
 , "fetch-bower"
+, "titanium"
 ]

pkgs/top-level/release-python.nix

···
   antlr = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   antlr3 = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   apacheAntGcj = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  apacheAntOpenJDK = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  apacheAntOracleJDK = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   apparmor = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   aqbanking = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   arb = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
···
   clisp = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   clisp_2_44_1 = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   clojure = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  clojure_wrapper = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  clooj_wrapper = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   clucene_core_2 = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   clutter = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   clutter_gtk = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
···
   icecat3Wrapper = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   icecat3Xul = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   icecatXulrunner3 = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  icedtea = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   icewm = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   idutils = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   ikiwiki = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
···
   julia = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   jwm = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   k3d = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  kaffe = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   kde3 = {
     arts = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
     kdelibs = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
···
   x11vnc = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   x2vnc = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   x2x = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  xalanJava = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xaos = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xapianBindings = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xapianBindings10 = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
···
   xdaliclock = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xdotool = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xen = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
-  xercesJava = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xf86_input_mtrack = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xf86_input_multitouch = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };
   xf86_input_wacom = { type = "job"; systems = ["x86_64-linux"]; schedulingPriority = 4; };