Merge remote-tracking branch 'origin/master' into staging

doc/Makefile

···
 
 NEWS.html: release-notes.xml
 	$(XSLTPROC) --nonet --xinclude --output $@ $(NEWS_OPTS) \
-	  $(docbookxsl)/html/docbook.xsl release-notes.xml
+	  $(docbookxsl)/xhtml/docbook.xsl release-notes.xml
 
 NEWS.txt: release-notes.xml
 	$(XSLTPROC) --nonet --xinclude quote-literals.xsl release-notes.xml | \
 	  $(XSLTPROC) --nonet --output $@.tmp.html $(NEWS_OPTS) \
-	  $(docbookxsl)/html/docbook.xsl -
+	  $(docbookxsl)/xhtml/docbook.xsl -
 	LANG=en_US w3m -dump $@.tmp.html > $@
 	rm $@.tmp.html
 
 manual.html: *.xml
 	$(XSLTPROC) --nonet --xinclude --output manual.html \
-	  $(docbookxsl)/html/docbook.xsl manual.xml
+	  $(docbookxsl)/xhtml/docbook.xsl manual.xml
 
 manual.pdf: *.xml
 	$(dblatex) \

lib/maintainers.nix

···
   iElectric = "Domen Kozar <[e-mail]>";
   iyzsong = "Song Wenwu <[e-mail]>";
   jcumming = "Jack Cummings <[e-mail]>";
+  jgeerds = "Jascha Geerds <[e-mail]>";
   joamaki = "Jussi Maki <[e-mail]>";
   joelteon = "Joel Taylor <[e-mail]>";
   jwiegley = "John Wiegley <[e-mail]>";

nixos/modules/config/ldap.nix

···
 { config, lib, pkgs, ... }:
 
-with lib;
 with pkgs;
+with lib;
 
 let
 

nixos/modules/config/networking.nix

···
 
   options = {
 
-    networking.extraHosts = pkgs.lib.mkOption {
+    networking.extraHosts = lib.mkOption {
       type = types.lines;
       default = "";
       example = "192.168.0.1 lanlocalhost";
···
       '';
     };
 
-    networking.dnsSingleRequest = pkgs.lib.mkOption {
+    networking.dnsSingleRequest = lib.mkOption {
       type = types.bool;
       default = false;
       description = ''

nixos/modules/config/pulseaudio.nix

···
 { config, lib, pkgs, ... }:
 
-with lib;
 with pkgs;
+with lib;
 
 let
 

nixos/modules/config/swap.nix

···
 { config, lib, pkgs, utils, ... }:
 
-with lib;
 with utils;
+with lib;
 
 {
 

nixos/modules/config/unix-odbc-drivers.nix

···
 
     environment.etc."odbcinst.ini".text =
       let inis = config.environment.unixODBCDrivers;
-      in pkgs.lib.concatStringsSep "\n" inis;
+      in lib.concatStringsSep "\n" inis;
 
   };
 

nixos/modules/hardware/network/intel-2100bg.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 {
 
···
 
   options = {
 
-    networking.enableIntel2100BGFirmware = pkgs.lib.mkOption {
+    networking.enableIntel2100BGFirmware = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         Turn on this option if you want firmware for the Intel
         PRO/Wireless 2100BG to be loaded automatically.  This is
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.networking.enableIntel2100BGFirmware {
+  config = lib.mkIf config.networking.enableIntel2100BGFirmware {
 
     hardware.enableAllFirmware = true;
 

nixos/modules/hardware/network/intel-2200bg.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 {
 
···
 
   options = {
 
-    networking.enableIntel2200BGFirmware = pkgs.lib.mkOption {
+    networking.enableIntel2200BGFirmware = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         Turn on this option if you want firmware for the Intel
         PRO/Wireless 2200BG to be loaded automatically.  This is
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.networking.enableIntel2200BGFirmware {
+  config = lib.mkIf config.networking.enableIntel2200BGFirmware {
 
     hardware.enableAllFirmware = true;
 

nixos/modules/hardware/network/intel-3945abg.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 {
 
···
 
   options = {
 
-    networking.enableIntel3945ABGFirmware = pkgs.lib.mkOption {
+    networking.enableIntel3945ABGFirmware = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         This option enables automatic loading of the firmware for the Intel
         PRO/Wireless 3945ABG.
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.networking.enableIntel3945ABGFirmware {
+  config = lib.mkIf config.networking.enableIntel3945ABGFirmware {
 
     hardware.enableAllFirmware = true;
 

nixos/modules/hardware/network/ralink.nix

···
-{pkgs, config, ...}:
+{pkgs, config, lib, ...}:
 
 {
 
···
 
   options = {
 
-    networking.enableRalinkFirmware = pkgs.lib.mkOption {
+    networking.enableRalinkFirmware = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         Turn on this option if you want firmware for the RT73 NIC.
       '';
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.networking.enableRalinkFirmware {
+  config = lib.mkIf config.networking.enableRalinkFirmware {
     hardware.enableAllFirmware = true;
   };
 

nixos/modules/hardware/network/rtl8192c.nix

···
-{pkgs, config, ...}:
+{pkgs, config, lib, ...}:
 
 {
 
···
 
   options = {
 
-    networking.enableRTL8192cFirmware = pkgs.lib.mkOption {
+    networking.enableRTL8192cFirmware = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         Turn on this option if you want firmware for the RTL8192c (and related) NICs.
       '';
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.networking.enableRTL8192cFirmware {
+  config = lib.mkIf config.networking.enableRTL8192cFirmware {
     hardware.enableAllFirmware = true;
   };
 

nixos/modules/hardware/network/smc-2632w/default.nix

···
-{pkgs, config, ...}:
+{lib, config, ...}:
 
 {
   hardware = {
     pcmcia = {
-      firmware = [ (pkgs.lib.cleanSource ./firmware) ];
+      firmware = [ (lib.cleanSource ./firmware) ];
     };
   };
 }

nixos/modules/hardware/opengl.nix

···
 
   config = mkIf cfg.enable {
 
-    assertions = pkgs.lib.singleton {
+    assertions = lib.singleton {
       assertion = cfg.driSupport32Bit -> pkgs.stdenv.isx86_64;
       message = "Option driSupport32Bit only makes sense on a 64-bit system.";
     };

nixos/modules/installer/cd-dvd/system-tarball-fuloong2f.nix

···
   # default root password is empty.
   services.openssh.enable = true;
 
-  jobs.openssh.startOn = pkgs.lib.mkOverride 50 "";
+  jobs.openssh.startOn = lib.mkOverride 50 "";
 
   boot.loader.grub.enable = false;
   boot.loader.generationsDir.enable = false;

nixos/modules/installer/cd-dvd/system-tarball-pc.nix

···
   # not be started by default on the installation CD because the
   # default root password is empty.
   services.openssh.enable = true;
-  jobs.openssh.startOn = pkgs.lib.mkOverride 50 "";
+  jobs.openssh.startOn = lib.mkOverride 50 "";
 
   # To be able to use the systemTarball to catch troubles.
   boot.crashDump = {

nixos/modules/installer/cd-dvd/system-tarball-sheevaplug.nix

···
   # not be started by default on the installation CD because the
   # default root password is empty.
   services.openssh.enable = true;
-  jobs.openssh.startOn = pkgs.lib.mkOverride 50 "";
+  jobs.openssh.startOn = lib.mkOverride 50 "";
 
   # cpufrequtils fails to build on non-pc
   powerManagement.enable = false;

nixos/modules/installer/tools/tools.nix

···
 # This module generates nixos-install, nixos-rebuild,
 # nixos-generate-config, etc.
 
-{ config, pkgs, modulesPath, ... }:
+{ config, pkgs, modulesPath, lib, ... }:
 
 let
 
···
         test -e "$out/chrome/content/jquery-1.5.2.js" ||
           cp -f "$jquery" "$out/chrome/content/jquery-1.5.2.js"
       '';
-      gui = pkgs.lib.cleanSource "${modulesPath}/../gui";
+      gui = lib.cleanSource "${modulesPath}/../gui";
       jquery = pkgs.fetchurl {
         url = http://code.jquery.com/jquery-1.5.2.min.js;
         sha256 = "8f0a19ee8c606b35a10904951e0a27da1896eafe33c6e88cb7bcbe455f05a24a";

nixos/modules/misc/ids.nix

···
 # This module defines the global list of uids and gids.  We keep a
 # central list to prevent id collisions.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 {
   options = {
 
-    ids.uids = pkgs.lib.mkOption {
+    ids.uids = lib.mkOption {
       internal = true;
       description = ''
         The user IDs used in NixOS.
       '';
     };
 
-    ids.gids = pkgs.lib.mkOption {
+    ids.gids = lib.mkOption {
       internal = true;
       description = ''
         The group IDs used in NixOS.
···
       influxdb = 125;
       nsd = 126;
       gitolite = 127;
+      znc = 128;
 
       # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!
 
···
       teamspeak = 124;
       influxdb = 125;
       nsd = 126;
+      znc = 128;
 
       # When adding a gid, make sure it doesn't match an existing uid. And don't use gids above 399!
 

nixos/modules/misc/lib.nix

···
-{ config, pkgs, ... }:
+{ config, lib, ... }:
 
 {
   options = {
-    lib = pkgs.lib.mkOption {
+    lib = lib.mkOption {
       default = {};
 
-      type = pkgs.lib.types.attrsOf pkgs.lib.types.attrs;
+      type = lib.types.attrsOf lib.types.attrs;
 
       description = ''
         This option allows modules to define helper functions, constants, etc.

nixos/modules/misc/passthru.nix

···
 # This module allows you to export something from configuration
 # Use case: export kernel source expression for ease of configuring
 
-{ config, pkgs, ... }:
+{ config, lib, ... }:
 
 {
   options = {
-    passthru = pkgs.lib.mkOption {
+    passthru = lib.mkOption {
       visible = false;
       description = ''
         This attribute set will be exported as a system attribute.

nixos/modules/module-list.nix

···
   ./services/networking/wicd.nix
   ./services/networking/wpa_supplicant.nix
   ./services/networking/xinetd.nix
+  ./services/networking/znc.nix
   ./services/printing/cupsd.nix
   ./services/scheduling/atd.nix
   ./services/scheduling/cron.nix

nixos/modules/programs/blcr.nix

···
-{ config, pkgs, ... }:
+{ config, lib, ... }:
 
 let
-  inherit (pkgs.lib) mkOption mkIf;
+  inherit (lib) mkOption mkIf;
   cfg = config.environment.blcr;
   blcrPkg = config.boot.kernelPackages.blcr;
 in

nixos/modules/programs/screen.nix

···
-{ config, pkgs, ... }:
+{ config, lib, ... }:
 
 let
-  inherit (pkgs.lib) mkOption mkIf types;
+  inherit (lib) mkOption mkIf types;
   cfg = config.programs.screen;
 in
 

nixos/modules/programs/shadow.nix

···
 
   options = {
 
-    users.defaultUserShell = pkgs.lib.mkOption {
+    users.defaultUserShell = lib.mkOption {
       description = ''
         This option defines the default shell assigned to user
         accounts.  This must not be a store path, since the path is
···
   config = {
 
     environment.systemPackages =
-      pkgs.lib.optional config.users.mutableUsers pkgs.shadow;
+      lib.optional config.users.mutableUsers pkgs.shadow;
 
     environment.etc =
       [ { # /etc/login.defs: global configuration for pwdutils.  You

nixos/modules/programs/virtualbox.nix

···
   services.udev.extraRules =
     ''
       KERNEL=="vboxdrv",    OWNER="root", GROUP="vboxusers", MODE="0660", TAG+="systemd"
+      KERNEL=="vboxdrvu",   OWNER="root", GROUP="root",      MODE="0666", TAG+="systemd"
       KERNEL=="vboxnetctl", OWNER="root", GROUP="root",      MODE="0600", TAG+="systemd"
       SUBSYSTEM=="usb_device", ACTION=="add", RUN+="${virtualbox}/libexec/virtualbox/VBoxCreateUSBNode.sh $major $minor $attr{bDeviceClass}"
       SUBSYSTEM=="usb", ACTION=="add", ENV{DEVTYPE}=="usb_device", RUN+="${virtualbox}/libexec/virtualbox/VBoxCreateUSBNode.sh $major $minor $attr{bDeviceClass}"

nixos/modules/services/amqp/activemq/default.nix

···
 { config, lib, pkgs, ... }:
 
-with lib;
 with pkgs;
+with lib;
 
 let
 

nixos/modules/services/backup/sitecopy-backup.nix

···
         touch ${stateDir}/sitecopy.secrets
         chown root ${stateDir}/sitecopy.secrets
 
-        ${pkgs.lib.concatStrings (map ( b: ''
+        ${lib.concatStrings (map ( b: ''
             unset secrets
             unset secret
             secrets=`grep '^${b.server}' ${stateDir}/sitecopy.secrets | head -1`

nixos/modules/services/databases/postgresql.nix

···
           Defines how users authenticate themselves to the server. By
           default, "trust" access to local users will always be granted
           along with any other custom options. If you do not want this,
-          set this option using "pkgs.lib.mkForce" to override this
+          set this option using "lib.mkForce" to override this
           behaviour.
         '';
       };

nixos/modules/services/desktops/gnome3/gnome-documents.nix

···
 # GNOME Documents daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/gnome-keyring.nix

···
 # GNOME Keyring daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/gnome-online-accounts.nix

···
 # GNOME Online Accounts daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/gnome-online-miners.nix

···
 # GNOME Online Miners daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/gnome-user-share.nix

···
 # GNOME User Share daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/gvfs.nix

···
 # gvfs backends
 
-{ config, pkgs, ... }:
+{ config, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/seahorse.nix

···
 # Seahorse daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/desktops/gnome3/tracker.nix

···
 # Tracker daemon.
 
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   gnome3 = config.environment.gnome3.packageSet;

nixos/modules/services/hardware/acpid.nix

···
             echo "event=${event.event}" > $fn
             echo "action=${pkgs.writeScript "${event.name}.sh" event.action}" >> $fn
           '';
-        in pkgs.lib.concatMapStrings f events
+        in lib.concatMapStrings f events
       }
     '';
 

nixos/modules/services/hardware/amd-hybrid-graphics.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 {
 
···
 
   options = {
 
-    hardware.amdHybridGraphics.disable = pkgs.lib.mkOption {
+    hardware.amdHybridGraphics.disable = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         Completely disable the AMD graphics card and use the
         integrated graphics processor instead.
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.hardware.amdHybridGraphics.disable {
+  config = lib.mkIf config.hardware.amdHybridGraphics.disable {
     systemd.services."amd-hybrid-graphics" = {
       path = [ pkgs.bash ];
       description = "Disable AMD Card";

nixos/modules/services/hardware/nvidia-optimus.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 let kernel = config.boot.kernelPackages; in
 
···
 
   options = {
 
-    hardware.nvidiaOptimus.disable = pkgs.lib.mkOption {
+    hardware.nvidiaOptimus.disable = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         Completely disable the NVIDIA graphics card and use the
         integrated graphics processor instead.
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.hardware.nvidiaOptimus.disable {
+  config = lib.mkIf config.hardware.nvidiaOptimus.disable {
     boot.blacklistedKernelModules = ["nouveau" "nvidia" "nvidiafb"];
     boot.kernelModules = [ "bbswitch" ];
     boot.extraModulePackages = [ kernel.bbswitch ];

nixos/modules/services/monitoring/monit.nix

···
 # Monit system watcher
 # http://mmonit.org/monit/
 
-{config, pkgs, ...}:
+{config, pkgs, lib, ...}:
 
-let inherit (pkgs.lib) mkOption mkIf;
+let inherit (lib) mkOption mkIf;
 in
 
 {

nixos/modules/services/monitoring/uptime.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 let
-  inherit (pkgs.lib) mkOption mkEnableOption mkIf mkMerge types optionalAttrs optional;
+  inherit (lib) mkOption mkEnableOption mkIf mkMerge types optionalAttrs optional;
 
   cfg = config.services.uptime;
 

nixos/modules/services/network-filesystems/openafs-client/default.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 let
-  inherit (pkgs.lib) mkOption mkIf;
+  inherit (lib) mkOption mkIf;
 
   cfg = config.services.openafsClient;
 

nixos/modules/services/network-filesystems/rsyncd.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
 
···
 
     networking.firewall.allowedTCPPorts = [ cfg.port ];
   };
-}
+}

nixos/modules/services/networking/connman.nix

···
 { config, lib, pkgs, ... }:
 
-with lib;
 with pkgs;
+with lib;
 
 let
   cfg = config.networking.connman;

nixos/modules/services/networking/ddclient.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 let
 
-  inherit (pkgs.lib) mkOption mkIf singleton;
+  inherit (lib) mkOption mkIf singleton;
 
   inherit (pkgs) ddclient;
 

nixos/modules/services/networking/dhcpd.nix

···
 
       ${cfg.extraConfig}
 
-      ${pkgs.lib.concatMapStrings
+      ${lib.concatMapStrings
           (machine: ''
             host ${machine.hostName} {
               hardware ethernet ${machine.ethernetAddress};

nixos/modules/services/networking/gvpe.nix

···
 # GNU Virtual Private Ethernet
 
-{config, pkgs, ...}:
+{config, pkgs, lib, ...}:
 
 let
-  inherit (pkgs.lib) mkOption mkIf;
+  inherit (lib) mkOption mkIf;
 
   cfg = config.services.gvpe;
 

nixos/modules/services/networking/networkmanager.nix

···
 { config, lib, pkgs, ... }:
 
-with lib;
 with pkgs;
+with lib;
 
 let
   cfg = config.networking.networkmanager;
···
       { source = "${networkmanager_pptp}/etc/NetworkManager/VPN/nm-pptp-service.name";
         target = "NetworkManager/VPN/nm-pptp-service.name";
       }
-    ] ++ pkgs.lib.optional (cfg.appendNameservers == [] || cfg.insertNameservers == [])
+    ] ++ optional (cfg.appendNameservers == [] || cfg.insertNameservers == [])
            { source = overrideNameserversScript;
              target = "NetworkManager/dispatcher.d/02overridedns";
            };

nixos/modules/services/networking/notbit.nix

···
 { config, lib, pkgs, ... }:
 
-with pkgs.lib;
+with lib;
 let
   cfg = config.services.notbit;
   varDir = "/var/lib/notbit";

nixos/modules/services/networking/nsd.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   cfg = config.services.nsd;

nixos/modules/services/networking/teamspeak3.nix

···
-{ config, pkgs, ... }:
+{ config, lib, pkgs, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   ts3 = pkgs.teamspeak_server;

nixos/modules/services/networking/znc.nix

···
+{ config, lib, pkgs, ...}:
+
+with lib;
+
+let
+  cfg = config.services.znc;
+
+  defaultUser = "znc"; # Default user to own process.
+
+  # Default user and pass:
+  # un=znc
+  # pw=nixospass
+
+  defaultUserName = "znc";
+  defaultPassBlock = "
+        <Pass password>
+                Method = sha256
+                Hash = e2ce303c7ea75c571d80d8540a8699b46535be6a085be3414947d638e48d9e93
+                Salt = l5Xryew4g*!oa(ECfX2o
+        </Pass>
+  ";
+
+  confOptions = { ... }: {
+    options = {
+      modules = mkOption {
+        type = types.listOf types.string;
+        default = [ "partyline" "webadmin" "adminlog" "log" ];
+        example = [ "partyline" "webadmin" "adminlog" "log" ];
+        description = ''
+          A list of modules to include in the `znc.conf` file.
+        '';
+      };
+
+      userName = mkOption {
+        default = defaultUserName;
+        example = "johntron";
+        type = types.string;
+        description = ''
+          The user name to use when generating the `znc.conf` file.
+          This is the user name used by the user logging into the ZNC web admin. 
+        '';
+      };
+
+      nick = mkOption {
+        default = "znc-user";
+        example = "john";
+        type = types.string;
+        description = ''
+          The IRC nick to use when generating the `znc.conf` file.
+        '';
+      };
+
+      passBlock = mkOption {
+        default = defaultPassBlock;
+        example = "Must be the block generated by the `znc --makepass` command.";
+        type = types.string;
+        description = ''
+          The pass block to use when generating the `znc.conf` file.
+          This is the password used by the user logging into the ZNC web admin.
+          This is the block generated by the `znc --makepass` command.
+          !!! If not specified, please change this after starting the service. !!!
+        '';
+      };
+
+      port = mkOption {
+        default = "5000";
+        example = "5000";
+        type = types.string;
+        description = ''
+          Specifies the port on which to listen.
+        '';
+      };
+ 
+      useSSL = mkOption {
+        default = true;
+        example = true;
+        type = types.bool;
+        description = ''
+          Indicates whether the ZNC server should use SSL when listening on the specified port.
+        '';
+      };
+
+    };
+  };
+
+  # Keep znc.conf in nix store, then symlink or copy into `dataDir`, depending on `mutable`.
+  mkZncConf = confOpts: ''
+    // Also check http://en.znc.in/wiki/Configuration
+    
+    AnonIPLimit = 10
+    ConnectDelay = 5
+    # Add `LoadModule = x` for each module...
+    ${concatMapStrings (n: "LoadModule = ${n}\n") confOpts.modules}
+    MaxBufferSize = 500
+    ProtectWebSessions = true
+    SSLCertFile = ${cfg.dataDir}/znc.pem
+    ServerThrottle = 30
+    Skin = dark-clouds
+    StatusPrefix = *
+    Version = 1.2
+
+    <Listener listener0>
+            AllowIRC = true
+            AllowWeb = true
+            IPv4 = true
+            IPv6 = false
+            Port = ${if confOpts.useSSL then "+" else ""}${confOpts.port}
+            SSL = ${if confOpts.useSSL then "true" else "false"}
+    </Listener>
+    
+    <User ${confOpts.userName}>
+            Admin = true
+            Allow = *
+            AltNick = ${confOpts.nick}_
+            AppendTimestamp = false
+            AutoClearChanBuffer = false
+            Buffer = 150
+            ChanModes = +stn
+            DenyLoadMod = false
+            DenySetBindHost = false
+            Ident = ident
+            JoinTries = 10
+            MaxJoins = 0
+            MaxNetworks = 1
+            MultiClients = true
+            Nick = ${confOpts.nick}
+            PrependTimestamp = true
+            QuitMsg = Quit
+            RealName = ${confOpts.nick}
+            TimestampFormat = [%H:%M:%S]
+            
+            ${confOpts.passBlock}
+    </User>
+  '';
+
+  zncConfFile = pkgs.writeTextFile {
+    name = "znc.conf";
+    text = if cfg.zncConf != ""
+      then cfg.zncConf
+      else mkZncConf cfg.confOptions;
+  };
+
+in
+
+{
+
+  ###### Interface
+
+  options = {
+    services.znc = {
+      enable = mkOption {
+        default = false;
+        example = true;
+        type = types.bool;
+        description = ''
+          Enable a ZNC service for a user.
+        '';
+      };
+
+      user = mkOption {
+        default = "znc";
+        example = "john";
+        type = types.string;
+        description = ''
+          The name of an existing user account to use to own the ZNC server process.
+          If not specified, a default user will be created to own the process.
+        '';
+      };
+
+      dataDir = mkOption {
+        default = "/home/${cfg.user}/.znc";
+        example = "/home/john/.znc";
+        type = types.string; 
+        description = ''
+          The data directory. Used for configuration files and modules.
+        '';
+      };
+
+      zncConf = mkOption {
+        default = "";
+        example = "See: http://wiki.znc.in/Configuration";
+        type = types.string;
+        description = ''
+          The contents of the `znc.conf` file to use when creating it.
+          If specified, `confOptions` will be ignored, and this value, as-is, will be used.
+          If left empty, a conf file with default values will be used.
+          Recommended to generate with `znc --makeconf` command.
+        '';
+      };
+
+      confOptions = mkOption {
+        default = {};
+        example = {
+          modules = [ "log" ];
+          userName = "john";
+          nick = "johntron";
+        };
+        type = types.optionSet;
+        description = ''
+          Values to use when creating a `znc.conf` file.
+        '';
+        options = confOptions; 
+      };
+ 
+      mutable = mkOption {
+        default = false;
+        example = true;
+        type = types.bool;
+        description = ''
+          Indicates whether to allow the contents of the `dataDir` directory to be changed
+          by the user at run-time.
+          If true, modifications to the ZNC configuration after its initial creation are not 
+            overwritten by a NixOS system rebuild.
+          If false, the ZNC configuration is rebuilt by every system rebuild.
+          If the user wants to manage the ZNC service using the web admin interface, this value
+            should be set to true.
+        '';
+      };
+ 
+      extraFlags = mkOption {
+        default = "";
+        example = "--debug";
+        type = types.string;
+        description = ''
+          Extra flags to use when executing znc command.
+        '';
+      };
+    };
+  };
+
+
+  ###### Implementation
+
+  config = mkIf cfg.enable {
+
+    systemd.services."znc-${cfg.user}" = {
+      description = "ZNC Server of ${cfg.user}.";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.service" ];
+      path = [ pkgs.znc ];
+      serviceConfig = {
+        User = "${cfg.user}";
+        Restart = "always";
+        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+        ExecStop   = "${pkgs.coreutils}/bin/kill -INT $MAINPID";
+      };
+      preStart = ''
+        ${pkgs.coreutils}/bin/mkdir -p ${cfg.dataDir}
+        ${pkgs.coreutils}/bin/chown ${cfg.user} ${cfg.dataDir} -R
+        ${pkgs.coreutils}/bin/mkdir -p ${cfg.dataDir}/configs
+
+        # If mutable, regenerate conf file every time.
+        ${optionalString (!cfg.mutable) ''
+          ${pkgs.coreutils}/echo "znc-${cfg.user} is set to be system-managed. Now deleting old znc.conf file to be regenerated."
+          ${pkgs.coreutils}/rm -f ${cfg.dataDir}/configs/znc.conf
+        ''}
+
+        # Ensure essential files exist.
+        if [[ ! -f ${cfg.dataDir}/configs/znc.conf ]]; then
+          ${pkgs.coreutils}/bin/echo "No znc.conf file found in ${cfg.dataDir}. Creating one now."
+          ${if (!cfg.mutable)
+            then "${pkgs.coreutils}/bin/ln --force -s ${zncConfFile} ${cfg.dataDir}/configs/znc.conf"
+            else ''
+              ${pkgs.coreutils}/bin/cp --no-clobber ${zncConfFile} ${cfg.dataDir}/configs/znc.conf
+              ${pkgs.coreutils}/bin/chmod u+rw ${cfg.dataDir}/configs/znc.conf
+              ${pkgs.coreutils}/bin/chown ${cfg.user} ${cfg.dataDir}/configs/znc.conf
+            ''}
+        fi
+
+        if [[ ! -f ${cfg.dataDir}/znc.pem ]]; then
+          ${pkgs.coreutils}/bin/echo "No znc.pem file found in ${cfg.dataDir}. Creating one now."
+          ${pkgs.znc}/bin/znc --makepem
+        fi
+      '';
+      script = "${pkgs.znc}/bin/znc --foreground --datadir ${cfg.dataDir} ${cfg.extraFlags}";
+    };
+
+    users.extraUsers = optional (cfg.user == defaultUser)
+      { name = defaultUser;
+        description = "ZNC server daemon owner";
+        group = defaultUser;
+        uid = config.ids.uids.znc;
+        createHome = true;
+        createUser = true;
+      };
+ 
+    users.extraGroups = optional (cfg.user == defaultUser)
+      { name = defaultUser;
+        gid = config.ids.gids.znc;
+        members = [ defaultUser ];
+      };
+
+  };
+}

nixos/modules/services/scheduling/cron.nix

···
         MAILTO="${config.services.cron.mailto}"
       ''}
       NIX_CONF_DIR=/etc/nix
-      ${pkgs.lib.concatStrings (map (job: job + "\n") config.services.cron.systemCronJobs)}
+      ${lib.concatStrings (map (job: job + "\n") config.services.cron.systemCronJobs)}
     '';
 
   # Vixie cron requires build-time configuration for the sendmail path.

nixos/modules/services/scheduling/fcron.nix

···
         MAILTO="${config.services.cron.mailto}"
       ''}
       NIX_CONF_DIR=/etc/nix
-      ${pkgs.lib.concatStrings (map (job: job + "\n") config.services.cron.systemCronJobs)}
+      ${lib.concatStrings (map (job: job + "\n") config.services.cron.systemCronJobs)}
     '';
 
   allowdeny = target: users:

nixos/modules/services/security/frandom.nix

···
-{pkgs, config, ...}:
+{lib, config, ...}:
 
 let kernel = config.boot.kernelPackages;
 in
···
 
   options = {
 
-    services.frandom.enable = pkgs.lib.mkOption {
+    services.frandom.enable = lib.mkOption {
       default = false;
-      type = pkgs.lib.types.bool;
+      type = lib.types.bool;
       description = ''
         enable the /dev/frandom device (a very fast random number generator)
       '';
···
 
   ###### implementation
 
-  config = pkgs.lib.mkIf config.services.frandom.enable {
+  config = lib.mkIf config.services.frandom.enable {
     boot.kernelModules = [ "frandom" ];
     boot.extraModulePackages = [ kernel.frandom ];
     services.udev.packages = [ kernel.frandom ];

nixos/modules/services/system/kerberos.nix

···
-{pkgs, config, ...}:
+{pkgs, config, lib, ...}:
 
 let
 
-  inherit (pkgs.lib) mkOption mkIf singleton;
+  inherit (lib) mkOption mkIf singleton;
 
   inherit (pkgs) heimdal;
 
···
     environment.systemPackages = [ heimdal ];
 
     services.xinetd.enable = true;
-    services.xinetd.services = pkgs.lib.singleton
+    services.xinetd.services = lib.singleton
       { name = "kerberos-adm";
         flags = "REUSE NAMEINARGS";
         protocol = "tcp";

nixos/modules/services/system/nscd.nix

···
   nssModulesPath = config.system.nssModules.path;
   cfg = config.services.nscd;
 
-  inherit (pkgs.lib) singleton;
+  inherit (lib) singleton;
 
   cfgFile = pkgs.writeText "nscd.conf" cfg.config;
 

nixos/modules/services/system/uptimed.nix

···
-{pkgs, config, ...}:
+{pkgs, config, lib, ...}:
 
 let
 
-  inherit (pkgs.lib) mkOption mkIf singleton;
+  inherit (lib) mkOption mkIf singleton;
 
   inherit (pkgs) uptimed;
 

nixos/modules/services/ttys/kmscon.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 let
-  inherit (pkgs.lib) mkOption types mkIf optionalString;
+  inherit (lib) mkOption types mkIf optionalString;
 
   cfg = config.services.kmscon;
 

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

···
 
   # Unpack Mediawiki and put the config file in its root directory.
   mediawikiRoot = pkgs.stdenv.mkDerivation rec {
-    name= "mediawiki-1.20.8";
+    name= "mediawiki-1.23.1";
 
     src = pkgs.fetchurl {
-      url = "http://download.wikimedia.org/mediawiki/1.20/${name}.tar.gz";
-      sha256 = "0yfmh5vnfbgpvicfqh7nh4hwdk4qbc6gfniv02vchkg5al0nn7ag";
+      url = "http://download.wikimedia.org/mediawiki/1.23/${name}.tar.gz";
+      sha256 = "07z5j8d988cdg4ml4n0vs9fwmj0p594ibbqdid16faxwqm52dkhl";
     };
 
     skins = config.skins;
···
         mkdir -p $out
         cp -r * $out
         cp ${mediawikiConfig} $out/LocalSettings.php
-        sed -i 's|/bin/bash|${pkgs.stdenv.shell}|' \
-          $out/maintenance/fuzz-tester.php \
-          $out/bin/ulimit.sh \
+        sed -i \
+        -e 's|/bin/bash|${pkgs.bash}/bin/bash|g' \
+        -e 's|/usr/bin/timeout|${pkgs.coreutils}/bin/timeout|g' \
+          $out/includes/limit.sh \
           $out/includes/GlobalFunctions.php
       '';
   };

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

···
-{ config, pkgs, serverInfo, ... }:
+{ config, pkgs, serverInfo, lib, ... }:
 
 let
   inherit (pkgs) mercurial;
-  inherit (pkgs.lib) mkOption;
+  inherit (lib) mkOption;
 
   urlPrefix = config.urlPrefix;
 

nixos/modules/services/web-servers/apache-httpd/tomcat-connector.nix

···
-{ config, pkgs, serverInfo, ... }:
+{ config, pkgs, serverInfo, lib, ... }:
 
 let
-  extraWorkersProperties = pkgs.lib.optionalString (config ? extraWorkersProperties) config.extraWorkersProperties;
+  extraWorkersProperties = lib.optionalString (config ? extraWorkersProperties) config.extraWorkersProperties;
   
   workersProperties = pkgs.writeText "workers.properties" ''
 # Define list of workers that will be used

nixos/modules/services/x11/window-managers/openbox.nix

···
-{pkgs, config, ...}:
+{lib, pkgs, config, ...}:
 
 let
-  inherit (pkgs.lib) mkOption mkIf;
+  inherit (lib) mkOption mkIf;
   cfg = config.services.xserver.windowManager.openbox;
 in
 

nixos/modules/services/x11/window-managers/xmonad.nix

···
-{pkgs, config, ...}:
+{pkgs, lib, config, ...}:
 
 let
-  inherit (pkgs.lib) mkOption mkIf optionals literalExample;
+  inherit (lib) mkOption mkIf optionals literalExample;
   cfg = config.services.xserver.windowManager.xmonad;
   xmonadEnv = cfg.haskellPackages.ghcWithPackages(self: [
     self.xmonad
···
       enableContribAndExtras = mkOption {
         default = false;
         example = true;
-        type = pkgs.lib.types.bool;
+        type = lib.types.bool;
         description = "Enable xmonad-{contrib,extras} in Xmonad.";
       };
     };

nixos/modules/tasks/encrypted-devices.nix

···
-{ config, pkgs, modulesPath, ... }:
+{ config, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   fileSystems = attrValues config.fileSystems ++ config.swapDevices;

nixos/modules/tasks/filesystems/f2fs.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
-with pkgs.lib;
+with lib;
 
 let
   inInitrd = any (fs: fs == "f2fs") config.boot.initrd.supportedFilesystems;

nixos/modules/tasks/filesystems/unionfs-fuse.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 {
-  config = pkgs.lib.mkMerge [
-    (pkgs.lib.mkIf (pkgs.lib.any (fs: fs == "unionfs-fuse") config.boot.initrd.supportedFilesystems) {
+  config = lib.mkMerge [
+    (lib.mkIf (lib.any (fs: fs == "unionfs-fuse") config.boot.initrd.supportedFilesystems) {
       boot.initrd.kernelModules = [ "fuse" ];
   
       boot.initrd.extraUtilsCommands = ''
···
           ln -s $(which umount) /nix/store/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-${pkgs.utillinux.name}/bin
         '';
     })
-    (pkgs.lib.mkIf (pkgs.lib.any (fs: fs == "unionfs-fuse") config.boot.supportedFilesystems) {
+    (lib.mkIf (lib.any (fs: fs == "unionfs-fuse") config.boot.supportedFilesystems) {
       system.fsPackages = [ pkgs.unionfs-fuse ];
     })
   ];

nixos/modules/testing/minimal-kernel.nix

···
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 let
-  configfile = builtins.storePath (builtins.toFile "config" (pkgs.lib.concatStringsSep "\n"
+  configfile = builtins.storePath (builtins.toFile "config" (lib.concatStringsSep "\n"
     (map (builtins.getAttr "configLine") config.system.requiredKernelConfig))
   );
 

nixos/modules/virtualisation/virtualbox-guest.nix

···
 
 in
 
-optionalAttrs (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) # ugly...
 {
 
   ###### interface
···
   ###### implementation
 
   config = mkIf cfg.enable {
+    assertions = [ {
+      assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;
+      message = "Virtualbox not currently supported on ${pkgs.stdenv.system}";
+    } ];
 
     environment.systemPackages = [ kernel.virtualboxGuestAdditions ];
 

nixos/tests/installer.nix

···
   # Rebuild the CD configuration with a little modification.
   rebuildCD = makeTest
     { inherit iso;
-      name = "rebuild-CD";
+      name = "rebuild-cd";
       nodes = { };
       testScript =
         ''

nixos/tests/mumble.nix

···
     $client1->execute("mumble mumble://client1\@server/test &");
     $client2->execute("mumble mumble://client2\@server/test &");
 
-    $client1->waitForWindow(qr/Mumble/);
-    $client2->waitForWindow(qr/Mumble/);
-    $server->sleep(3); # Wait some more for the Mumble UI
-
     # cancel client audio configuration
+    $client1->waitForWindow(qr/Audio Tuning Wizard/);
+    $client2->waitForWindow(qr/Audio Tuning Wizard/);
     $client1->sendKeys("esc");
     $client2->sendKeys("esc");
-    $server->sleep(1);
 
     # cancel client cert configuration
+    $client1->waitForWindow(qr/Certificate Management/);
+    $client2->waitForWindow(qr/Certificate Management/);
     $client1->sendKeys("esc");
     $client2->sendKeys("esc");
-    $server->sleep(1);
 
     # accept server certificate
+    $client1->waitForWindow(qr/^Mumble$/);
+    $client2->waitForWindow(qr/^Mumble$/);
     $client1->sendChars("y");
     $client2->sendChars("y");
 

nixos/tests/simple.nix

···
 import ./make-test.nix {
-  name = "simple"
+  name = "simple";
 
   machine = { config, pkgs, ... }: { };
 

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

···
 {stdenv, fetchurl, emacs}:
 
-let version = "1.3";
+let version = "2.0";
 
 in stdenv.mkDerivation {
   name = "writegood-mode-${version}";
   src = fetchurl {
     url = "https://github.com/bnbeckwith/writegood-mode/archive/v${version}.tar.gz";
-    sha256 = "0p34rgawnqg94vk4lcw14x99rrvsd23dmbwkxz2vax5kq6l8y5yf";
+    sha256 = "0wf7bj9d00ggy3xigym885a3njfr98i3aqrrawf8x6lgbfc56dgp";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/inferno/default.nix

···
+{ fetchurl, fetchhg, stdenv, xlibs, gcc46, makeWrapper }:
+
+stdenv.mkDerivation rec {
+  # Inferno is a rolling release from a mercurial repository. For the verison number
+  # of the package I'm using the mercurial commit number.
+  version = "645";
+  name = "inferno-${version}";
+
+  # The mercurial repository does not contain all the components needed for the
+  # runtime system. The 'base' package contains these. For this package I download
+  # the base, extract the elements required from that, and add them to the source
+  # pulled from the mercurial repository.
+  srcBase = fetchurl {
+    url = "http://www.vitanuova.com/dist/4e/inferno-20100120.tgz";
+    sha256 = "0msvy3iwl4n5k0ry0xiyysjkq0qsawmwn3hvg67hbi5y8g7f7l88";
+  };
+
+  src = fetchhg {
+    url    = "https://inferno-os.googlecode.com/hg";
+    rev    = "7ab390b860ca";
+    sha256 = "09y0iclb3yy10gw1p0182sddg64xh60q2fx4ai7lxyfb65i76qbh";
+  };
+
+  # Fails with gcc48 due to inferno triggering an optimisation issue with floating point.
+  buildInputs = [ gcc46 xlibs.libX11 xlibs.libXpm xlibs.libXext xlibs.xextproto makeWrapper ];
+
+  infernoWrapper = ./inferno;
+
+  configurePhase = ''
+    tar --strip-components=1 -xvf $srcBase inferno/fonts inferno/Mkdirs inferno/empties
+    sed -e 's@^ROOT=.*$@ROOT='"$out"'/share/inferno@g' -e 's@^OBJTYPE=.*$@OBJTYPE=386@g' -e 's@^SYSHOST=.*$@SYSHOST=Linux@g' -i mkconfig
+    mkdir prof
+    sh Mkdirs
+  '';
+
+  buildPhase = ''
+    export PATH=$PATH:$out/share/inferno/Linux/386/bin
+    mkdir -p $out/share/inferno
+    cp -r . $out/share/inferno
+    ./makemk.sh
+    mk nuke
+    mk
+  '';
+
+  installPhase = ''
+    mk install
+    mkdir -p $out/bin
+    makeWrapper $out/share/inferno/Linux/386/bin/emu $out/bin/emu \
+      --suffix LD_LIBRARY_PATH ':' "${gcc46.gcc}/lib" \
+      --suffix PATH ':' "$out/share/inferno/Linux/386/bin"
+    makeWrapper $infernoWrapper $out/bin/inferno \
+      --suffix LD_LIBRARY_PATH ':' "${gcc46.gcc}/lib" \
+      --suffix PATH ':' "$out/share/inferno/Linux/386/bin" \
+      --set INFERNO_ROOT "$out/share/inferno"
+  '';
+
+  meta = {
+    description = "A compact distributed operating system for building cross-platform distributed systems";
+    homepage = "http://inferno-os.org/";
+    license = stdenv.lib.licenses.gpl2;
+    maintainer = [ "Chris Double <[e-mail]>" ];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

pkgs/applications/inferno/inferno

···
+#! /usr/bin/env bash
+
+
+export INFERNO_HOME="$HOME/.local/share/inferno"
+if [ -n "$XDG_DATA_HOME" ]
+  then export INFERNO_HOME="$XDG_DATA_HOME/inferno"
+fi
+
+if [ ! -d $INFERNO_HOME ]; then
+  mkdir -p $INFERNO_HOME
+fi
+
+if [ ! -d $INFERNO_HOME/tmp ]; then
+  mkdir -p $INFERNO_HOME/tmp
+fi
+
+for d in $INFERNO_HOME/{acme,appl,dis,lib,man,module,usr/inferno}; do
+  if [ ! -d $d ]; then
+    mkdir -p $d
+    cp --no-preserve=all -r $INFERNO_ROOT/${d#$INFERNO_HOME/}/* $d/
+    chmod -R +w $d
+  fi
+done
+
+if [ ! -d $INFERNO_HOME/usr/$USER ]; then
+  mkdir -p $INFERNO_HOME/usr/$USER
+  cp -r $INFERNO_ROOT/usr/inferno/* $INFERNO_HOME/usr/$USER/
+  chmod -R +w $INFERNO_HOME/usr/$USER
+fi
+
+exec emu "$@" /dis/sh.dis -c "bind -b -c '#U*$INFERNO_HOME/' /; /dis/sh.dis"

pkgs/applications/misc/arbtt/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "arbtt";
-  version = "0.8";
-  sha256 = "0anjcg8ikd3jxc5rb3k215wj7ar4kg2plv8sdr8hv64758xkc5q9";
+  version = "0.8.1";
+  sha256 = "1qzmqjm8pfj59h0hrm28pp6qhzz2am5xq81mirnnchsgg52wrfn0";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

pkgs/applications/misc/xmobar/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "xmobar";
-  version = "0.20.1";
-  sha256 = "16jfgn6ciqxrwj6qjhbcpms7mzlbxfaxyxfxp64xvnw626xlpjvk";
+  version = "0.21";
+  sha256 = "1h0gsb808zm4j4kmw7fl4339wllc16ldy1ki96l8w3fvj30bcxpm";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [
···
   extraLibraries = [ libXrandr wirelesstools ];
   configureFlags = "-fall_extensions";
   meta = {
-    homepage = "http://projects.haskell.org/xmobar/";
+    homepage = "http://xmobar.org";
     description = "A Minimalistic Text Based Status Bar";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

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

···
   m4, glib_networking, gsettings_desktop_schemas, dconf }:
 
 stdenv.mkDerivation {
-  name = "dwb-2014-06-17";
+  name = "dwb-2014-07-03";
 
   src = fetchgit {
     url = "https://bitbucket.org/portix/dwb.git";
-    rev = "9f4bdb9a1f8d5e45071019da4626231dfebd4d8e";
-    sha256 = "1nj34w2hhw47jsmswsc1y6a09my8zdd01qxwai8dxdvisld3marm";
+    rev = "6224470489eb5ba92987e01396269f8b7cd78ada";
+    sha256 = "04p9frsnh1qz067cw36anvr41an789fba839svdjrdva0f2751g8";
   };
 
   buildInputs = [ pkgconfig makeWrapper gsettings_desktop_schemas libsoup webkit gtk3 gnutls json_c m4 ];

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

···
     sha256 = "137sslbgh0326lmwihcr2ybljgq9mzsx5wnciilpx884si22wpk8";
   };
 
-  nativeBuildInputs = [pkgconfig libxslt];
+  nativeBuildInputs = [ pkgconfig libxslt ];
   buildInputs = [ libxml2 dbus_glib sqlite libsoup libnice telepathy_glib gnutls ];
 
   configureFlags = "--with-ca-certificates=/etc/ssl/certs/ca-bundle.crt";
 
   meta = {
     homepage = http://telepathy.freedesktop.org;
+    description = "Jabber/XMPP connection manager for the Telepathy framework";
+    platforms = stdenv.lib.platforms.gnu;
   };
 }

pkgs/applications/networking/mailreaders/mutt/mailpath.patch

···
+diff -r 8f62001989cc configure.ac
+--- a/configure.ac	Sat Feb 08 10:24:22 2014 -0800
++++ b/configure.ac	Wed Jul 02 12:34:40 2014 +0200
+@@ -473,6 +473,8 @@
+                                 mutt_cv_mailpath=/usr/spool/mail
+                         elif test -d /usr/mail; then
+                                 mutt_cv_mailpath=/usr/mail
++                        elif test -d /tmp; then
++                               mutt_cv_mailpath=/tmp
+                         fi])
+                 ])
+         if test "$mutt_cv_mailpath" = no; then

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

···
 }:
 
 let
-  version = "2.83";
+  version = "2.84";
 in
 
 with { inherit (stdenv.lib) optional optionals optionalString; };
···
 
   src = fetchurl {
     url = "http://download.transmissionbt.com/files/transmission-${version}.tar.xz";
-    sha256 = "0cqlgl6jmjw1caybz6nzh3l8z0jak1dxba01isv72zvy2r8b1qdh";
+    sha256 = "1sxr1magqb5s26yvr5yhs1f7bmir8gl09niafg64lhgfnhv1kz59";
   };
 
   buildInputs = [ pkgconfig intltool file openssl curl libevent inotifyTools ]

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

···
 { cabal, ansiTerminal, filepath, HTTP, network, optparseApplicative
-, stringsearch, terminalSize, time, zlib
+, terminalSize, text, time, zlib
 }:
 
 cabal.mkDerivation (self: {
   pname = "sloane";
-  version = "1.8";
-  sha256 = "0c30slsswfqwzi39hk6jraxz1y1a2yn8g8nyjvlnggwajx2rlm6p";
+  version = "1.8.2";
+  sha256 = "0kdznrvyrax1gihqxxw36jfbmjri808ii827fa71v2ijlm416hk1";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [
-    ansiTerminal filepath HTTP network optparseApplicative stringsearch
-    terminalSize time zlib
+    ansiTerminal filepath HTTP network optparseApplicative terminalSize
+    text time zlib
   ];
   postInstall = ''
     mkdir -p $out/share/man/man1

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

···
 sqlite, gtk, patchelf, libXScrnSaver, libnotify, libX11, libxcb }:
 
 stdenv.mkDerivation rec {
-  name = "boinc-7.0.44";
+  name = "boinc-7.2.42";
 
   src = fetchgit {
     url = "git://boinc.berkeley.edu/boinc-v2.git";
-    rev = "7c449b1fb8a681ceb27d6895751b62a2b3adf0f2";
-    sha256 = "0hdramyl9nip3gadp7xiaz8ngyld15i93d8ai1nsd04bmrvdfqia";
+    rev = "dd0d630882547c123ca0f8fda7a62e058d60f6a9";
+    sha256 = "1zifpi3mjgaj68fba6kammp3x7z8n2x164zz6fj91xfiapnan56j";
   };
 
   buildInputs = [ libtool automake autoconf m4 pkgconfig curl mesa libXmu libXi

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

···
+{ stdenv, fetchhg, autoconf, sqlite }:
+
+stdenv.mkDerivation {
+  name = "vcprompt";
+
+  src = fetchhg {
+    url = "http://hg.gerg.ca/vcprompt/";
+    rev = "1.2.1";
+    sha256 = "03xqvp6bfl98bpacrw4n82qv9cw6a4fxci802s3vrygas989v1kj";
+  };
+
+  buildInputs = [ sqlite autoconf ];
+
+  preConfigure = ''
+    autoconf
+    makeFlags="$makeFlags PREFIX=$out"
+  '';
+
+  meta = with stdenv.lib; {
+    description = ''
+      A little C program that prints a short string with barebones information
+      about the current working directory for various version control systems
+    '';
+    homepage    = http://hg.gerg.ca/vcprompt;
+    maintainers = with maintainers; [ cstrahan ];
+    platforms   = with platforms; linux ++ darwin;
+  };
+}

pkgs/build-support/build-pecl.nix

···
-{ stdenv, php, autoreconfHook }:
+{ stdenv, php, autoreconfHook, fetchurl }:
 
-args: stdenv.mkDerivation (args // {
-  buildInputs = [ php autoreconfHook ] ++ args.buildInputs or [];
+{ name
+, buildInputs ? []
+, makeFlags ? []
+, src ? fetchurl {
+    url = "http://pecl.php.net/get/${name}.tgz";
+    inherit (args) sha256;
+  }
+, ...
+}@args:
 
-  makeFlags = [ "EXTENSION_DIR=$(out)/lib/php/extensions" ] ++ args.makeFlags or [];
+stdenv.mkDerivation (args // {
+  name = "php-${name}";
+
+  inherit src;
+
+  buildInputs = [ php autoreconfHook ] ++ buildInputs;
+
+  makeFlags = [ "EXTENSION_DIR=$(out)/lib/php/extensions" ] ++ makeFlags;
 
   autoreconfPhase = "phpize";
 })

pkgs/data/fonts/anonymous-pro/default.nix

···
   buildInputs = map (n: builtins.getAttr n x)
     (builtins.attrNames (builtins.removeAttrs x helperArgNames));
   sourceInfo = rec {
-    version="1.002";
+    version = "1.002";
     name="anonymousPro";
     url="http://www.ms-studio.com/FontSales/AnonymousPro-${version}.zip";
-    hash="86665847a51cdfb58a1e1dfd8b1ba33f183485affe50b53e3304f63d3d3552ab";
+    sha256 = "1asj6lykvxh46czbal7ymy2k861zlcdqpz8x3s5bbpqwlm3mhrl6";
   };
 in
 rec {
   src = a.fetchurl {
     url = sourceInfo.url;
-    sha256 = sourceInfo.hash;
+    sha256 = sourceInfo.sha256;
   };
 
   name = "${sourceInfo.name}-${sourceInfo.version}";
···
     license = with a.lib.licenses; ofl;
     hydraPlatforms = [];
     homepage = "http://www.marksimonson.com/fonts/view/anonymous-pro";
-  };
-  passthru = {
-    updateInfo = {
-      downloadPage = "http://www.ms-studio.com/FontSales/anonymouspro.html";
-    };
+    downloadPage = "http://www.ms-studio.com/FontSales/anonymouspro.html";
+    inherit (sourceInfo) version;
   };
 }) x
 

pkgs/data/fonts/anonymous-pro/default.upstream

···
+attribute_name anonymousPro
+url http://www.ms-studio.com/FontSales/anonymouspro.html
+version_link '/AnonymousPro-.*[.]zip$'
+do_overwrite (){
+  do_overwrite_just_version
+}

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

···
   buildInputs = [ pkgconfig gtk3 glib intltool itstool gnome3.libmediaart
                   gdk_pixbuf gnome3.gnome_icon_theme librsvg python3
                   gnome3.grilo libxml2 python3Packages.pygobject3 libnotify
-                  python3Packages.pycairo python3Packages.dbus
+                  python3Packages.pycairo python3Packages.dbus gnome3.totem-pl-parser
                   gst_all_1.gstreamer gst_all_1.gst-plugins-base
                   gst_all_1.gst-plugins-good gst_all_1.gst-plugins-bad
                   hicolor_icon_theme gnome3.gnome_icon_theme_symbolic
···
     let
       libPath = stdenv.lib.makeLibraryPath
         [ glib gtk3 libnotify tracker gnome3.grilo cairo
-          gst_all_1.gstreamer gst_all_1.gst-plugins-base
+          gst_all_1.gstreamer gst_all_1.gst-plugins-base gnome3.totem-pl-parser
           gst_all_1.gst-plugins-good gst_all_1.gst-plugins-bad ];
     in
     ''

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

···
   };
 
   propagatedUserEnvPkgs = [ gnome3.gnome_themes_standard
-                            gnome3.gnome_icon_theme hicolor_icon_theme
-                            gnome_online_accounts shared_mime_info
-                            gnome3.gnome_icon_theme_symbolic ];
+                            gnome_online_accounts shared_mime_info ];
   propagatedBuildInputs = [ folks telepathy_logger evolution_data_server
                             telepathy_mission_control ];
   buildInputs = [ pkgconfig gtk3 glib webkitgtk intltool itstool
···
                   gcr libsecret pulseaudio gnome3.yelp_xsl gdk_pixbuf
                   libnotify clutter libsoup gnutls libgee p11_kit
                   libcanberra_gtk3 telepathy_farstream farstream
+                  gnome3.gnome_icon_theme hicolor_icon_theme gnome3.gnome_icon_theme_symbolic
                   gnome3.gsettings_desktop_schemas file libtool librsvg ];
 
   NIX_CFLAGS_COMPILE = [ "-I${dbus_glib}/include/dbus-1.0"
···
     for f in $out/bin/* $out/libexec/*; do
       wrapProgram $f \
         --set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE" \
-        --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:${gnome3.gnome_themes_standard}/:${gnome3.gnome_themes_standard}/share:${hicolor_icon_theme}/share:$out/share:$GSETTINGS_SCHEMAS_PATH"
+        --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:${gnome3.gnome_themes_standard}/share:$out/share:$GSETTINGS_SCHEMAS_PATH"
     done
     rm $out/share/icons/hicolor/icon-theme.cache
   '';

pkgs/desktops/gnome-3/3.12/core/evolution-data-server/default.nix

···
                    ++ stdenv.lib.optional valaSupport "--enable-vala-bindings";
 
   preFixup = ''
-    for f in "$out/libexec/evolution-addressbook-factory" "$out/libexec/evolution-calendar-factory"; do
-      wrapProgram $f --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
+    for f in "$out/libexec/"*; do
+      wrapProgram "$f" --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
     done
   '';
 

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

···
 
     wrapProgram "$out/libexec/gnome-shell-calendar-server" \
       --prefix XDG_DATA_DIRS : "${evolution_data_server}/share:$out/share:$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH"
+
+    echo "${unzip}/bin" > $out/${passthru.mozillaPlugin}/extra-bin-path
   '';
+
+  enableParallelBuilding = true;
+
+  passthru = {
+    mozillaPlugin = "/lib/mozilla/plugins";
+  };
 
   meta = with stdenv.lib; {
     platforms = platforms.linux;

pkgs/development/compilers/compcert/default.nix

···
   buildInputs = [ coq ocaml ocamlPackages.menhir ];
 
   enableParallelBuilding = true;
-  configurePhase = "./configure -prefix $out -toolprefix ${gcc}/bin/ ia32-linux";
+  configurePhase = "./configure -prefix $out -toolprefix ${gcc}/bin/ " +
+    (if stdenv.isDarwin then "ia32-macosx" else "ia32-linux");
 
   meta = {
     description = "Formally verified C compiler";
     homepage    = "http://compcert.inria.fr";
     license     = stdenv.lib.licenses.inria;
-    platforms   = [ "i686-linux" ];
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    platforms   = stdenv.lib.platforms.linux ++
+                  stdenv.lib.platforms.darwin;
+    maintainers = [ stdenv.lib.maintainers.thoughtpolice
+                    stdenv.lib.maintainers.jwiegley ];
   };
 }

pkgs/development/compilers/go/1_0-gcc-bug.patch

···
+http://code.google.com/p/go/source/detail?r=8b13b2ec6b18
+--- a/src/cmd/cgo/gcc.go	2014-07-02 12:00:12.171796197 +0200
++++ b/src/cmd/cgo/gcc.go	2014-07-02 12:01:57.844472754 +0200
+@@ -840,6 +840,15 @@
+ func (p *Package) gccErrors(stdin []byte) string {
+ 	// TODO(rsc): require failure
+ 	args := p.gccCmd()
++
++	// GCC 4.8.0 has a bug: it sometimes does not apply
++	// -Wunused-value to values that are macros defined in system
++	// headers.  See issue 5118.  Adding -Wsystem-headers avoids
++	// that problem.  This will produce additional errors, but it
++	// doesn't matter because we will ignore all errors that are
++	// not marked for the cgo-test file.
++	args = append(args, "-Wsystem-headers")
++
+ 	if *debugGcc {
+ 		fmt.Fprintf(os.Stderr, "$ %s <<EOF\n", strings.Join(args, " "))
+ 		os.Stderr.Write(stdin)

pkgs/development/compilers/go/1_0-opt-error.patch

···
+https://code.google.com/p/go-wiki/wiki/OlderVersions
+--- a/src/cmd/cc/funct.c	2014-07-02 11:54:42.230663598 +0200
++++ b/src/cmd/cc/funct.c	2014-07-02 11:55:01.653790128 +0200
+@@ -269,7 +269,7 @@
+ 		goto bad;
+ 
+ 	f = alloc(sizeof(*f));
+-	for(o=0; o<sizeof(f->sym); o++)
++	for(o=0; o<nelem(f->sym); o++)
+ 		f->sym[o] = S;
+ 
+ 	t->funct = f;

pkgs/development/compilers/go/default.nix

···
     sed -i '/TestHostname/areturn' src/pkg/os/os_test.go
   '';
 
-  patches = [ ./cacert.patch ];
+  patches = [ ./cacert.patch ./1_0-opt-error.patch ./1_0-gcc-bug.patch ];
 
   GOOS = "linux";
   GOARCH = if stdenv.system == "i686-linux" then "386"

pkgs/development/compilers/rust/default.nix

···
 
 with if stdenv.system == "i686-linux" then {
   platform = "linux-i386";
-  snapshot = "3bef5684fd0582fbd4ddebd4514182d4f72924f7";
-  snapshot_sha = "1c72d65pcgm3z4sly7al09mjvpp8asxbbv7iyzzv5k8f66ny2agy";
+  snapshot = "84339ea0f796ae468ef86797ef4587274bec19ea";
   target = "i686-unknown-linux-gnu";
 } else if stdenv.system == "x86_64-linux" then {
   platform = "linux-x86_64";
-  snapshot = "a7b2af1076d48e4a687a71a21478293e834349bd";
-  snapshot_sha = "1c72d65pcgm3z4sly7al09mjvpp8asxbbv7iyzzv5k8f66ny2agy";
+  snapshot = "bd8a6bc1f28845b7f4b768f6bfa06e7fbdcfcaae";
   target = "x86_64-unknown-linux-gnu";
 } else if stdenv.system == "x86_64-darwin" then {
   platform = "macos-x86_64";
-  snapshot = "22b884a3876cb3e40ad942ad68a496b5f239fca5";
-  snapshot_sha = "0qabkvyryiwlqhzy1kscff27rx788bv7lh7d8m1hnsv38wqhwqqb";
+  snapshot = "4a8c2e1b7634d73406bac32a1a97893ec3ed818d";
 } else {};
-let snapshotDate = "2014-03-28";
-    snapshotRev = "b8601a3";
+let snapshotDate = "2014-06-21";
+    snapshotRev = "db9af1d";
     snapshotName = "rust-stage0-${snapshotDate}-${snapshotRev}-${platform}-${snapshot}.tar.bz2"; in
 stdenv.mkDerivation {
-  name = "rust-0.10";
+  name = "rust-0.11.0";
 
   src = fetchurl {
-    url = http://static.rust-lang.org/dist/rust-0.10.tar.gz;
-    sha256 = "c72cfbbf03016804a81d7b68e8258ffaf018f8f5a25550ad64571ce6c2642cf9";
+    url = http://static.rust-lang.org/dist/rust-0.11.0.tar.gz;
+    sha256 = "1fhi8iiyyj5j48fpnp93sfv781z1dm0xy94h534vh4mz91jf7cyi";
   };
 
   # We need rust to build rust. If we don't provide it, configure will try to download it.
···
     name = "rust-stage0";
     src = fetchurl {
       url = "http://static.rust-lang.org/stage0-snapshots/${snapshotName}";
-      sha256 = snapshot_sha;
+      sha1 = snapshot;
     };
+    dontStrip = true;
     installPhase = ''
       mkdir -p "$out"
       cp -r bin "$out/bin"
     '' + (if stdenv.isLinux then ''
-      patchelf --interpreter ${stdenv.glibc}/lib/${stdenv.gcc.dynamicLinker} \
-               --set-rpath ${stdenv.gcc.gcc}/lib/:${stdenv.gcc.gcc}/lib64/ \
-               $out/bin/rustc
+      patchelf --interpreter "${stdenv.glibc}/lib/${stdenv.gcc.dynamicLinker}" \
+               --set-rpath "${stdenv.gcc.gcc}/lib/:${stdenv.gcc.gcc}/lib64/" \
+               "$out/bin/rustc"
     '' else "");
   };
 
···
   patches = [ ./hardcode_paths.patch ./local_stage0.patch ];
   postPatch = ''
     substituteInPlace src/librustc/back/link.rs \
-      --subst-var-by "gccPath" ${stdenv.gcc}/bin/cc \
-      --subst-var-by "binutilsPath" ${stdenv.gcc.binutils}/bin/ar
+      --subst-var-by "ccPath" "${stdenv.gcc}/bin/cc" \
+      --subst-var-by "arPath" "${stdenv.gcc.binutils}/bin/ar"
   '';
 
   buildInputs = [ which file perl curl python27 makeWrapper ];

pkgs/development/compilers/rust/hardcode_paths.patch

···
 diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
-index f198a41..3a47e51 100644
+index 7a3e912..ced75fa 100644
 --- a/src/librustc/back/link.rs
 +++ b/src/librustc/back/link.rs
-@@ -730,7 +730,7 @@ pub fn get_cc_prog(sess: &Session) -> ~str {
-         _ => {},
-     }
+@@ -766,24 +766,15 @@ pub fn output_lib_filename(id: &CrateId) -> String {
  
--    get_system_tool(sess, "cc")
-+    ~"@gccPath@"
+ pub fn get_cc_prog(sess: &Session) -> String {
+     match sess.opts.cg.linker {
+-        Some(ref linker) => return linker.to_string(),
+-        None => {}
++        Some(ref linker) => linker.to_string(),
++        None => "@ccPath@".to_string()
+     }
+-
+-    // In the future, FreeBSD will use clang as default compiler.
+-    // It would be flexible to use cc (system's default C compiler)
+-    // instead of hard-coded gcc.
+-    // For win32, there is no cc command, so we add a condition to make it use gcc.
+-    match sess.targ_cfg.os {
+-        abi::OsWin32 => "gcc",
+-        _ => "cc",
+-    }.to_string()
  }
  
- pub fn get_ar_prog(sess: &Session) -> ~str {
-@@ -739,26 +739,7 @@ pub fn get_ar_prog(sess: &Session) -> ~str {
-         None => {}
+ pub fn get_ar_prog(sess: &Session) -> String {
+     match sess.opts.cg.ar {
+         Some(ref ar) => (*ar).clone(),
+-        None => "ar".to_string()
++        None => "@arPath@".to_string()
      }
- 
--    get_system_tool(sess, "ar")
--}
--
--fn get_system_tool(sess: &Session, tool: &str) -> ~str {
--    match sess.targ_cfg.os {
--        abi::OsAndroid => match sess.opts.cg.android_cross_path {
--            Some(ref path) => {
--                let tool_str = match tool {
--                    "cc" => "gcc",
--                    _ => tool
--                };
--                format!("{}/bin/arm-linux-androideabi-{}", *path, tool_str)
--            }
--            None => {
--                sess.fatal(format!("need Android NDK path for the '{}' tool \
--                                    (-C android-cross-path)", tool))
--            }
--        },
--        _ => tool.to_owned(),
--    }
-+    ~"@binutilsPath@"
  }
  
- fn remove(sess: &Session, path: &Path) {

pkgs/development/interpreters/angelscript/default.nix

···
     (builtins.attrNames (builtins.removeAttrs x helperArgNames));
   sourceInfo = rec {
     baseName="angelscript";
-    version="2.22.1";
+    version = "2.29.0";
     name="${baseName}-${version}";
     url="http://www.angelcode.com/angelscript/sdk/files/angelscript_${version}.zip";
-    hash="0fmw0cb7ymgyq31r4cfvsn4k86r20hj650fbzs9i7zl0p3lb6hpm";
+    sha256 = "1g0bi8dx832s3911rr3jymnffaz3q7cnbzl53nmi6hwsr2kpc6mx";
   };
 in
 rec {
   src = a.fetchurl {
     url = sourceInfo.url;
-    sha256 = sourceInfo.hash;
+    sha256 = sourceInfo.sha256;
   };
 
   inherit (sourceInfo) name version;
···
 
   prepareBuild = a.fullDepEntry ''
     cd angelscript/projects/gnuc
-    sed -i makefile -e "s@LOCAL = .*@LOCAL = $out@"
+    sed -i makefile -e "s@LOCAL [?]= .*@LOCAL = $out@"
     mkdir -p "$out/lib" "$out/bin" "$out/share" "$out/include"
     export SHARED=1 
     export VERSION="${version}"
···
     platforms = with a.lib.platforms;
       linux;
     license = a.lib.licenses.zlib;
-  };
-  passthru = {
-    updateInfo = {
-      downloadPage = "http://www.angelcode.com/angelscript/downloads.asp";
-    };
+    homepage="http://www.angelcode.com/angelscript/";
+    downloadPage = "http://www.angelcode.com/angelscript/downloads.html";
+    inherit version;
   };
 }) x
 

pkgs/development/interpreters/angelscript/default.upstream

···
+url http://www.angelcode.com/angelscript/downloads.html
+version_link '[.]zip$'
+version '.*_([0-9.]+)[.].*' '\1'
+do_overwrite () { do_overwrite_just_version ; }

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

···
-{ stdenv, fetchurl, readline }:
+{ stdenv, fetchurl, readline, makeWrapper }:
 
 let
   dsoPatch = fetchurl {
···
     sha256 = "2640fc56a795f29d28ef15e13c34a47e223960b0240e8cb0a82d9b0738695333";
   };
 
-  buildInputs = [ readline ];
+  buildInputs = [ readline makeWrapper ];
 
   patches = if stdenv.isDarwin then [ ./5.1.darwin.patch ] else [ dsoPatch ];
 
-  configurePhase = 
+  configurePhase =
     if stdenv.isDarwin
     then ''
     makeFlagsArray=( INSTALL_TOP=$out INSTALL_MAN=$out/share/man/man1 PLAT=macosx CFLAGS="-DLUA_USE_LINUX -fno-common -O2" LDLAGS="" )
···
     sed <"etc/lua.pc" >"$out/lib/pkgconfig/lua.pc" -e "s|^prefix=.*|prefix=$out|"
     mv "doc/"*.{gif,png,css,html} "$out/share/doc/lua/"
     rmdir $out/{share,lib}/lua/5.1 $out/{share,lib}/lua
+    wrapProgram $out/bin/lua \
+      --set LUA_PATH  '"$HOME/.nix-profile/lib/lua/5.1/?.lua;$HOME/.nix-profile/share/lua/5.1/?.lua"' \
+      --set LUA_CPATH '"$HOME/.nix-profile/lib/lua/5.1/?.so;$HOME/.nix-profile/share/lua/5.1/?.so"'
   '';
 
   meta = {

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

···
+{ stdenv, fetchurl, lua5 }:
+
+stdenv.mkDerivation rec {
+  version = "1.6.2";
+  name = "lua-filesystem-${version}";
+  isLibrary = true;
+  src = fetchurl {
+    url = "https://github.com/keplerproject/luafilesystem/archive/v1_6_2.tar.gz";
+    sha256 = "1n8qdwa20ypbrny99vhkmx8q04zd2jjycdb5196xdhgvqzk10abz";
+  };
+
+  buildInputs = [ lua5 ];
+
+  preBuild = ''
+    makeFlagsArray=(
+      PREFIX=$out
+      LUA_LIBDIR="$out/lib/lua/${lua5.luaversion}"
+      LUA_INC="-I${lua5}/include");
+  '';
+
+  meta = {
+    homepage = "https://github.com/keplerproject/luafilesystem";
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.flosse ];
+  };
+}

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

···
 let
 
   majorVersion = "2.7";
-  version = "${majorVersion}.7";
+  version = "${majorVersion}.8";
 
   src = fetchurl {
     url = "http://www.python.org/ftp/python/${version}/Python-${version}.tar.xz";
-    sha256 = "0y6s12rdi89k24p8zarhy9fqmyy459yg0d125c7cac4v136y70r9";
+    sha256 = "0nh7d3dp75f1aj0pamn4hla8s0l7nbaq4a38brry453xrfh11ppd";
   };
 
   patches =
···
 
     inherit majorVersion version src patches postPatch buildInputs;
 
+    LDFLAGS = stdenv.lib.optionalString (!stdenv.isDarwin) "-lgcc_s";
     C_INCLUDE_PATH = concatStringsSep ":" (map (p: "${p}/include") buildInputs);
     LIBRARY_PATH = concatStringsSep ":" (map (p: "${p}/lib") buildInputs);
 

pkgs/development/libraries/accountsservice/default.nix

···
 , libtool, gobjectIntrospection, polkit, systemd, coreutils }:
 
 stdenv.mkDerivation rec {
-  name = "accountsservice-0.6.35";
+  name = "accountsservice-0.6.37";
   
   src = fetchurl {
-    url = http://www.freedesktop.org/software/accountsservice/accountsservice-0.6.35.tar.xz;
-    sha256 = "0f1hzl6hw56xvwgmd4yvmdyj15xj1fafw45pzv3qarww7h0wg8b5";
+    url = http://www.freedesktop.org/software/accountsservice/accountsservice-0.6.37.tar.xz;
+    sha256 = "1hd58lrl698ij7w1xk3fpj8zp7h6m2hpzvfmbw9sfx4xvhv13cmh";
   };
 
   buildInputs = [ pkgconfig glib intltool libtool makeWrapper

pkgs/development/libraries/afflib/default.nix

···
 { stdenv, fetchurl, zlib, curl, expat, fuse, openssl }:
 
 stdenv.mkDerivation rec {
-  name = "afflib-3.6.12";
+  version = "3.7.4";
+  name = "afflib-${version}";
 
   src = fetchurl {
     url = "http://digitalcorpora.org/downloads/afflib/${name}.tar.gz";
-    sha256 = "1l13nrqjlvad112543qbyvrzai5by43zl96d3miklrhn26q9rs07";
+    sha256 = "18j1gjb31qjcmz6lry4m2d933w2a80iagg9g5vrpw5ig80lv10f8";
   };
 
   buildInputs = [ zlib curl expat fuse openssl ];
···
     platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.bsdOriginal;
     maintainers = [ stdenv.lib.maintainers.raskin ];
+    inherit version;
+    downloadPage = "http://digitalcorpora.org/downloads/afflib/";
+    updateWalker = true;
   };
 }

pkgs/development/libraries/allegro/5-unstable.nix

···
+
+x@{builderDefsPackage
+  , texinfo, libXext, xextproto, libX11, xproto, libXpm, libXt, libXcursor
+  , alsaLib, cmake, zlib, libpng, libvorbis, libXxf86dga, libXxf86misc
+  , xf86dgaproto, xf86miscproto, xf86vidmodeproto, libXxf86vm, openal, mesa
+  , kbproto, libjpeg, flac
+  , ...}:
+builderDefsPackage
+(a :
+let
+  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++
+    [];
+
+  buildInputs = map (n: builtins.getAttr n x)
+    (builtins.attrNames (builtins.removeAttrs x helperArgNames));
+  sourceInfo = rec {
+    baseName="allegro";
+    version = "5.1.8";
+    name="${baseName}-${version}";
+    project="alleg";
+    url="mirror://sourceforge/project/${project}/${baseName}/${version}/${name}.tar.gz";
+    hash="18fdppaqaf3g3rcqwhyvsmkzk3y14clz4l8cvmg4hvjgyf011f3i";
+  };
+in
+rec {
+  src = a.fetchurl {
+    url = sourceInfo.url;
+    sha256 = "180mhlhgxqh3ynazf9bssnd3riw77fazjw65yr64w0av53y0h1lz";
+  };
+
+  inherit (sourceInfo) name version;
+  inherit buildInputs;
+
+  /* doConfigure should be removed if not needed */
+  phaseNames = ["doCmake" "doMakeInstall"];
+
+  doCmake = a.fullDepEntry (''
+    export NIX_LDFLAGS="$NIX_LDFLAGS -lXext -lX11 -lXpm -lXcursor -lXxf86vm"
+    cmake -D CMAKE_INSTALL_PREFIX=$out -D CMAKE_SKIP_RPATH=ON .
+  '') ["minInit" "doUnpack" "addInputs"];
+
+  makeFlags = [
+  ];
+
+  meta = {
+    description = "A game programming library";
+    license = "free-noncopyleft"; # giftware
+    maintainers = with a.lib.maintainers;
+    [
+      raskin
+    ];
+    platforms = with a.lib.platforms;
+      linux;
+    inherit version;
+  };
+}) x
+

pkgs/development/libraries/allegro/5-unstable.upstream

···
+attribute_name allegro5
+url http://alleg.sourceforge.net/download.html
+version_link '/allegro-unstable/.*[.]tar[.].*/download$'
+SF_redirect
+do_overwrite () {
+  do_overwrite_just_version
+}

pkgs/development/libraries/allegro/5.nix

···
   , kbproto, libjpeg, flac
   , ...}:
 builderDefsPackage
-(a :  
-let 
-  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++ 
+(a :
+let
+  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++
     [];
 
   buildInputs = map (n: builtins.getAttr n x)
···
     export NIX_LDFLAGS="$NIX_LDFLAGS -lXext -lX11 -lXpm -lXcursor -lXxf86vm"
     cmake -D CMAKE_INSTALL_PREFIX=$out -D CMAKE_SKIP_RPATH=ON .
   '') ["minInit" "doUnpack" "addInputs"];
-      
+
   makeFlags = [
   ];
 
···
     ];
     platforms = with a.lib.platforms;
       linux;
-  };
-  passthru = {
-    updateInfo = {
-      downloadPage = "http://sourceforge.net/projects/alleg/files/";
-    };
+    inherit version;
   };
 }) x
 

pkgs/development/libraries/allegro/5.upstream

···
+attribute_name allegro5
+url http://alleg.sourceforge.net/download.html
+version_link '[.]tar[.].*/download$'
+SF_redirect
+do_overwrite () {
+  do_overwrite_just_version
+}

pkgs/development/libraries/allegro/default.nix

···
   , xf86dgaproto, xf86miscproto, xf86vidmodeproto, libXxf86vm, openal, mesa
   , ...}:
 builderDefsPackage
-(a :  
-let 
-  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++ 
+(a :
+let
+  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++
     [];
 
   buildInputs = map (n: builtins.getAttr n x)
···
     export NIX_LDFLAGS="$NIX_LDFLAGS -lXext -lX11 -lXpm -lXcursor -lXxf86vm"
     cmake -D CMAKE_INSTALL_PREFIX=$out -D CMAKE_SKIP_RPATH=ON .
   '') ["minInit" "doUnpack" "addInputs"];
-      
+
   makeFlags = [
   ];
 
   meta = {
+    branch = "4";
     description = "A game programming library";
     license = "free-noncopyleft"; # giftware
     maintainers = with a.lib.maintainers;

pkgs/development/libraries/asio/default.nix

···
 {stdenv, fetchurl, boost, openssl}:
 
 stdenv.mkDerivation rec {
-  name = "asio-1.10.1";
+  name = "asio-1.10.2";
   
   src = fetchurl {
     url = "mirror://sourceforge/asio/${name}.tar.bz2";
-    sha256 = "16dxzkra0wmhm2vp2p9lb1h6qsdjk82sxfgj6zlz792n7jnms2l2";
+    sha256 = "1lqxm3gc8rzzjq0m843l59ggbw32bih7smm5spry1j5khfc86p41";
   };
 
   propagatedBuildInputs = [ boost ];

pkgs/development/libraries/botan/default.upstream

···
 url http://botan.randombit.net/download.html
 version_link 'Botan-[0-9]+[.][0-9]*[02468]([.][0-9]+)?[.](tbz|tbz2|tar[.]bz2)$'
 ensure_version
-ensure_hash
 do_overwrite(){
+  ensure_hash
   set_var_value hash $CURRENT_HASH
   set_var_value baseVersion ${CURRENT_VERSION%.*}
   set_var_value revision ${CURRENT_VERSION##*.}

pkgs/development/libraries/botan/unstable.nix

···
+x@{builderDefsPackage
+  , python
+  , bzip2, zlib, gmp, openssl
+  , boost
+  , ...}:
+builderDefsPackage
+(a :
+let
+  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++
+    [];
+
+  buildInputs = map (n: builtins.getAttr n x)
+    (builtins.attrNames (builtins.removeAttrs x helperArgNames));
+  sourceInfo = rec {
+    baseName="botan";
+    tarBaseName="Botan";
+    baseVersion = "1.11";
+    revision = "9";
+    version="${baseVersion}.${revision}";
+    name="${baseName}-${version}";
+    url="http://files.randombit.net/${baseName}/v${baseVersion}/${tarBaseName}-${version}.tbz";
+    hash = "0jgx5va042gmr6nc91p5dd59wnfxlz19mz2nnyv74pvwwmizs09m";
+  };
+in
+rec {
+  src = a.fetchurl {
+    url = sourceInfo.url;
+    sha256 = sourceInfo.hash;
+  };
+
+  inherit (sourceInfo) name version;
+  inherit buildInputs;
+
+  /* doConfigure should be removed if not needed */
+  phaseNames = ["doConfigure" "doMakeInstall" "fixPkgConfig"];
+  configureCommand = "python configure.py --with-gnump --with-bzip2 --with-zlib --with-openssl";
+
+  fixPkgConfig = a.fullDepEntry ''
+    cd "$out"/lib/pkgconfig
+    ln -s botan-*.pc botan.pc || true
+  '' ["minInit" "doMakeInstall"];
+
+  meta = {
+    description = "Cryptographic algorithms library";
+    maintainers = with a.lib.maintainers;
+    [
+      raskin
+    ];
+    platforms = with a.lib.platforms;
+      unix;
+    inherit version;
+  };
+  passthru = {
+    updateInfo = {
+      downloadPage = "http://files.randombit.net/botan/";
+    };
+  };
+}) x

pkgs/development/libraries/botan/unstable.upstream

···
+url http://botan.randombit.net/download.html
+version_link 'Botan-[0-9]+[.][0-9]+([.][0-9]+)?[.](tbz|tbz2|tar[.]bz2)$'
+ensure_version
+do_overwrite(){
+  ensure_hash
+  set_var_value hash $CURRENT_HASH
+  set_var_value baseVersion ${CURRENT_VERSION%.*}
+  set_var_value revision ${CURRENT_VERSION##*.}
+}

pkgs/development/libraries/box2d/default.nix

···
 x@{builderDefsPackage
   , unzip, cmake, mesa, freeglut, libX11, xproto
-  , inputproto, libXi
+  , inputproto, libXi, fetchsvn, pkgconfig
   , ...}:
 builderDefsPackage
 (a :  
···
 
   buildInputs = map (n: builtins.getAttr n x)
     (builtins.attrNames (builtins.removeAttrs x helperArgNames));
-  sourceInfo = rec {
-    baseName="box2d";
-    version="2.1.2";
-    name="${baseName}-${version}";
-    url="http://box2d.googlecode.com/files/Box2D_v${version}.zip";
-    hash="0m5szd74ig8yqazwk2g3zl4z7wwp08k52awawk1pigy6a4z1qd9v";
-  };
 in
 rec {
-  src = a.fetchurl {
-    url = sourceInfo.url;
-    sha256 = sourceInfo.hash;
+  version = "2.3.0";
+  name = "box2d-${version}";
+  srcDrv = a.fetchsvn {
+    url = "http://box2d.googlecode.com/svn/trunk";
+    rev = "277";
+    sha256 = "1xp93yw2zcqhmh999v7cwqaqxq1glgyg5r8kfm4yabc1ypba3in4";
   };
+  src = srcDrv + "/";
 
-  inherit (sourceInfo) name version;
   inherit buildInputs;
 
   phaseNames = ["changeSettings" "doCmake" "doMakeInstall"];
···
     platforms = with a.lib.platforms;
       linux;
     license = "bsd";
-  };
-  passthru = {
-    updateInfo = {
-      downloadPage = "http://code.google.com/p/box2d/downloads/list";
-    };
+    inherit version;
   };
 }) x
 

pkgs/development/libraries/glib/default.nix

···
 , libxml2, tzdata, desktop_file_utils, shared_mime_info, doCheck ? false
 }:
 
+with stdenv.lib;
+
 # TODO:
 # * Add gio-module-fam
 #     Problem: cyclic dependency on gamin
···
   ver_maj = "2.40";
   ver_min = "0";
 in
-with { inherit (stdenv.lib) optional optionals optionalString; };
 
 stdenv.mkDerivation rec {
   name = "glib-${ver_maj}.${ver_min}";

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

···
 
 cabal.mkDerivation (self: {
   pname = "Chart-cairo";
-  version = "1.2.2";
-  sha256 = "1bbi5bvrh8wmgzv5am5ndgdr68gd68ipparkkk9ld4majwf4vm6w";
+  version = "1.2.3";
+  sha256 = "1lbl1qvgm4yxslahlms6kzfrhh8s2fcdiwmvk1bs319k1fylia1b";
   buildDepends = [
     cairo Chart colour dataDefaultClass lens mtl operational time
   ];

pkgs/development/libraries/haskell/Chart-diagrams/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "Chart-diagrams";
-  version = "1.2.2";
-  sha256 = "144dy9vp3x04s03jrkyfqczpwayb8k7dq702w9wm3d8q4ysva62q";
+  version = "1.2.3";
+  sha256 = "08ps30vn9ljiyhgakwdbixn4csy504bsw3h5z9w1dxhn27wij772";
   buildDepends = [
     blazeSvg Chart colour dataDefaultClass diagramsCore diagramsLib
     diagramsPostscript diagramsSvg lens mtl operational SVGFonts text

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

···
 
 cabal.mkDerivation (self: {
   pname = "Chart-gtk";
-  version = "1.2.2";
-  sha256 = "1mg6nln0jwp6hals9vhhsfqiwix424fv1v1p4h99s0xwy5cna1z9";
+  version = "1.2.3";
+  sha256 = "0vl9nh48pa7sdrqh5a6smmfallf4mwzrvspc2v94cpnrcnickiyq";
   buildDepends = [ cairo Chart ChartCairo colour gtk mtl time ];
   jailbreak = true;
   meta = {

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

···
 
 cabal.mkDerivation (self: {
   pname = "Chart";
-  version = "1.2.2";
-  sha256 = "0yd3xca500lbzvlvhdsbrkiy53laikq6hc290rc061agvd535a7p";
+  version = "1.2.3";
+  sha256 = "067bahxig5xyd6zasi74k86qb7bxvbs3shjn9fbslhyckxg50q1j";
   buildDepends = [
     colour dataDefaultClass lens mtl operational time
   ];

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

···
-{ cabal, cpphs, JuicyPixels, linear, OpenGL, OpenGLRaw, vector }:
+{ cabal, cpphs, JuicyPixels, linear, OpenGL, OpenGLRaw
+, transformers, vector
+}:
 
 cabal.mkDerivation (self: {
   pname = "GLUtil";
-  version = "0.7.4";
-  sha256 = "0l1w0k3q5g22y90w5frljqh1v4jb7gjzb3scg79zp42pc9v3h4l5";
+  version = "0.7.5";
+  sha256 = "1rbnq1nrs2b06ph60lh0yvygk82vvnm8c4d0anhjrqw9i58nd3iz";
   buildDepends = [
-    cpphs JuicyPixels linear OpenGL OpenGLRaw vector
+    cpphs JuicyPixels linear OpenGL OpenGLRaw transformers vector
   ];
   buildTools = [ cpphs ];
   meta = {

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

···
 
 cabal.mkDerivation (self: {
   pname = "HFuse";
-  version = "0.2.4.1";
-  sha256 = "12k04dvh92kk2i68bcb70xnk378qxmh46f241k06di5rkcgwyg1k";
+  version = "0.2.4.2";
+  sha256 = "043f5x807h1dajd0bvmhln9pjkviszx1279m298w711mrszapqrq";
   extraLibraries = [ fuse ];
   preConfigure = ''
     sed -i -e "s@  Extra-Lib-Dirs:         /usr/local/lib@  Extra-Lib-Dirs:         ${fuse}/lib@" HFuse.cabal
-    sed -i -e "s@  Include-Dirs:           /usr/include, /usr/local/include, .@  Include-Dirs:           ${fuse}/include@" HFuse.cabal
     sed -i -e "s/LANGUAGE FlexibleContexts/LANGUAGE FlexibleContexts, RankNTypes/" System/Fuse.hsc
     sed -i -e "s/E(Exception/E(catch, Exception, IOException/" System/Fuse.hsc
     sed -i -e "s/IO(catch,/IO(/" System/Fuse.hsc
···
     sed -i -e "s/const exitFailure/\\\\(_ :: IOException) -> exitFailure/" System/Fuse.hsc
   '';
   meta = {
-    homepage = "https://github.com/toothbrush/hfuse";
+    homepage = "https://github.com/m15k/hfuse";
     description = "HFuse is a binding for the Linux FUSE library";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.stdenv.lib.platforms.linux;

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

···
-{ cabal, aeson, cpphs, Diff, filepath, haskellSrcExts, HUnit
-, liftedBase, monadControl, mtl, QuickCheck, random, regexCompat
-, temporary, text, unorderedContainers, xmlgen
+{ cabal, aeson, base64Bytestring, cpphs, Diff, filepath
+, haskellSrcExts, HUnit, liftedBase, monadControl, mtl, QuickCheck
+, random, regexCompat, temporary, text, unorderedContainers, xmlgen
 }:
 
 cabal.mkDerivation (self: {
   pname = "HTF";
-  version = "0.11.3.4";
-  sha256 = "0db47fvp33k83dnhvpygprm06p3z397f5ci154vqk7krjpxb2ynx";
+  version = "0.11.4.0";
+  sha256 = "0bg84x6xk359zby04xw62yy227fk85mgs7x5nkdbsxcajm7j0bs9";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
-    aeson cpphs Diff haskellSrcExts HUnit liftedBase monadControl mtl
-    QuickCheck random regexCompat text xmlgen
+    aeson base64Bytestring cpphs Diff haskellSrcExts HUnit liftedBase
+    monadControl mtl QuickCheck random regexCompat text xmlgen
   ];
   testDepends = [
     aeson filepath mtl random regexCompat temporary text

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

···
-{ cabal, aes, monadsTf, transformers }:
+{ cabal, AES, monadsTf, transformers }:
 
 cabal.mkDerivation (self: {
   pname = "SHA2";
   version = "0.2.5";
   sha256 = "1zs79a327x6myfam3p2vr8lmszcaqnkll2qz8n4sy835vz328j40";
-  buildDepends = [ aes monadsTf transformers ];
+  buildDepends = [ AES monadsTf transformers ];
   meta = {
     description = "Fast, incremental SHA hashing for bytestrings";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
   };
 })
-

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

···
+{ cabal, binary, HTTP, network }:
+
+cabal.mkDerivation (self: {
+  pname = "Thrift";
+  version = "0.6.0.1";
+  sha256 = "0yk496zql0jpyj83ybdzffc03sylf5pwn093k831m99j54l2r5yv";
+  buildDepends = [ binary HTTP network ];
+  meta = {
+    homepage = "http://thrift.apache.org";
+    description = "Haskell bindings for the Apache Thrift RPC system";
+    license = "unknown";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/alsa-pcm/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "alsa-pcm";
-  version = "0.6.0.2";
-  sha256 = "0zckp83wdqb6nl2k63fapa5h4vf1xyvbaycd0ixwr9k7mw75q7b9";
+  version = "0.6.0.3";
+  sha256 = "0rq0i17xhd0x7dnlhdf3i1fdvmyxrsbm0w0k9lrx20xpy4gw2zfs";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "binary-conduit";
-  version = "1.2.1.1";
-  sha256 = "0f6ki793fbgxpsqadfj796b4rbv6zhn4v4rrd48r48zzw9hmxmzd";
+  version = "1.2.2";
+  sha256 = "12dgqydc4zj1ffrcfqpd1dg40dc9hpynj1j69611kzpcqbj275pf";
   buildDepends = [ binary conduit resourcet vector ];
   testDepends = [
     binary conduit hspec QuickCheck quickcheckAssertions resourcet

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

···
 
 cabal.mkDerivation (self: {
   pname = "boomerang";
-  version = "1.4.2";
-  sha256 = "0vy70anwnh7649za6nzb65fx09vqkf50a961da6gzwvbaf526rd0";
+  version = "1.4.3";
+  sha256 = "1i72mrl8n2cbrdi05zn37y1339r13vzvmrcc1zbkcak4c7r004zw";
   buildDepends = [ mtl text ];
   meta = {
     description = "Library for invertible parsing and printing";

pkgs/development/libraries/haskell/cipher-aes/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "cipher-aes";
-  version = "0.2.7";
-  sha256 = "1a5viy2frkdqhzzlipd2ik89a04gv95v4b98lgpsas2958r9c9yp";
+  version = "0.2.8";
+  sha256 = "13hg8gxhs7hmni72kp14hmhvfv1kj7fnl83i72bz3aq15vx3z61z";
   buildDepends = [ byteable cryptoCipherTypes securemem ];
   testDepends = [
     byteable cryptoCipherTests cryptoCipherTypes QuickCheck

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

···
 
 cabal.mkDerivation (self: {
   pname = "conduit-combinators";
-  version = "0.2.5.2";
-  sha256 = "00zvai14cgh2g9wa436kfdgyfzm3pksnhzy365y1yn96dwbbh1ih";
+  version = "0.2.6.1";
+  sha256 = "01q585fwfl7qw5yr7ry1zfwm0lbmizyidifk9jzxdfxppbccfxfc";
   buildDepends = [
     base16Bytestring base64Bytestring chunkedData conduit conduitExtra
     monadControl monoTraversable mwcRandom primitive resourcet

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

···
 
 cabal.mkDerivation (self: {
   pname = "conduit-extra";
-  version = "1.1.0.4";
-  sha256 = "0l1cv65p8nvvb9qgcj87a682wh9xim0rbk2xzhdkd0r123csb118";
+  version = "1.1.1";
+  sha256 = "1876kg7zb0gasl7ijmx48r5r2jv3c5xxa1xb6g6iqfysx0qsv6z2";
   buildDepends = [
     attoparsec blazeBuilder conduit filepath monadControl network
     primitive resourcet streamingCommons text transformers

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

···
-{ cabal, attoparsec, hashable, text, unixCompat
-, unorderedContainers
+{ cabal, attoparsec, filepath, hashable, HUnit, testFramework
+, testFrameworkHunit, text, unixCompat, unorderedContainers
 }:
 
 cabal.mkDerivation (self: {
   pname = "configurator";
-  version = "0.2.0.2";
-  sha256 = "011rgd48gv4idkh2dwg4mlyx3s6pgm1263xq5ixsa4sg3jqh9d8b";
+  version = "0.3.0.0";
+  sha256 = "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf";
   buildDepends = [
     attoparsec hashable text unixCompat unorderedContainers
+  ];
+  testDepends = [
+    filepath HUnit testFramework testFrameworkHunit text
   ];
   meta = {
     homepage = "http://github.com/bos/configurator";

pkgs/development/libraries/haskell/data-accessor/data-accessor-mtl.nix

···
 
 cabal.mkDerivation (self: {
   pname = "data-accessor-mtl";
-  version = "0.2.0.3";
-  sha256 = "1aksmm4ykb96khgq5y4vd40zbn4c73hgl21xvyc295cwxsyrbvbk";
+  version = "0.2.0.4";
+  sha256 = "1i8lk0vy04giixng5addgj740cbvwlc7g62qgrmhfip0w9k93kqh";
   buildDepends = [ dataAccessor mtl ];
   meta = {
     homepage = "http://www.haskell.org/haskellwiki/Record_access";

pkgs/development/libraries/haskell/data-accessor/data-accessor-transformers.nix

···
 
 cabal.mkDerivation (self: {
   pname = "data-accessor-transformers";
-  version = "0.2.1.4";
-  sha256 = "1bf1j8g5q81zw51bri89hj3i9jnlmhdggw8rhw3n2v103399pf7d";
+  version = "0.2.1.6";
+  sha256 = "1iawhp1h68ynr2axj12jrn47nf08mss0ar8blagp59yi8j7170fa";
   buildDepends = [ dataAccessor transformers ];
   meta = {
     homepage = "http://www.haskell.org/haskellwiki/Record_access";

pkgs/development/libraries/haskell/data-accessor/data-accessor.nix

···
 
 cabal.mkDerivation (self: {
   pname = "data-accessor";
-  version = "0.2.2.5";
-  sha256 = "0z63fv41cnpk3h404gprk2f5jl7rrpyv97xmsgac9zgdm5zkkhm6";
+  version = "0.2.2.6";
+  sha256 = "0668qgllmp2911ppsb0g9z95nq2x0h2cvzyyjlb6iwhnjzyyg7gf";
   buildDepends = [ transformers ];
   jailbreak = true;
   meta = {

pkgs/development/libraries/haskell/dependent-sum/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "dependent-sum";
-  version = "0.2.0.2";
-  sha256 = "06amnc50j246f2za0ri49j6vyq6admx03w3xxjhhfnfx9lp6zmhm";
+  version = "0.2.1.0";
+  sha256 = "1h6wsrh206k6q3jcfdxvlsswbm47x30psp6x30l2z0j9jyf7jpl3";
   meta = {
     homepage = "https://github.com/mokus0/dependent-sum";
     description = "Dependent sum type";

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

···
 
 cabal.mkDerivation (self: {
   pname = "dlist";
-  version = "0.7.0.1";
-  sha256 = "197k608ja69xc531r7h3gmy1mf6dsk27b3mkpgp4zdw46z6lcb5l";
+  version = "0.7.1";
+  sha256 = "13ka30bn742ldacfgj2lhxvhwf769d0ziy2358vmd5xaq6fn1xfr";
   buildDepends = [ deepseq ];
   testDepends = [ Cabal QuickCheck ];
   meta = {

pkgs/development/libraries/haskell/explicit-exception/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "explicit-exception";
-  version = "0.1.7.2";
-  sha256 = "0zncj57mpngszl7jz3khhd4dajzis7aag0ad62hc8rkrv2j8f5q4";
+  version = "0.1.7.3";
+  sha256 = "0f1p1llz6z4ag1wnf57mgm861cbw7va0g0m8klp6f6pnirdhlwz1";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ transformers ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "fb";
-  version = "1.0.1";
-  sha256 = "0xhwv8fmhb1an15fnfjxzq0ijnhxxmfjwzd99dq1lsm0f7gd4hfi";
+  version = "1.0.2";
+  sha256 = "1xgldk690dpbmhzmjlngpbalmbs0xrc7265zc7frphpsbbw3cnqc";
   buildDepends = [
     aeson attoparsec base16Bytestring base64Bytestring cereal conduit
     conduitExtra cryptoApi cryptohash cryptohashCryptoapi dataDefault
···
   jailbreak = true;
   doCheck = false;
   meta = {
-    homepage = "https://github.com/meteficha/fb";
+    homepage = "https://github.com/prowdsponsor/fb";
     description = "Bindings to Facebook's API";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

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

···
-{ cabal, base64Bytestring, blazeHtml, cgi, ConfigFile, feed
-, filepath, filestore, ghcPaths, happstackServer, highlightingKate
-, hslogger, HStringTemplate, HTTP, json, mtl, network, pandoc
-, pandocTypes, parsec, random, recaptcha, safe, SHA, syb, tagsoup
-, text, time, url, utf8String, xhtml, xml, xssSanitize, zlib, fetchpatch
+{ cabal, base64Bytestring, blazeHtml, ConfigFile, feed, filepath
+, filestore, ghcPaths, happstackServer, highlightingKate, hslogger
+, HStringTemplate, HTTP, json, mtl, network, pandoc, pandocTypes
+, parsec, random, recaptcha, safe, SHA, split, syb, tagsoup, text
+, time, uri, url, utf8String, xhtml, xml, xssSanitize, zlib
 }:
 
 cabal.mkDerivation (self: {
   pname = "gitit";
-  version = "0.10.3.1";
-  sha256 = "1sm6rryfyqr0nd4flbc5d520xyw2ajnkylvqf4fi4dhl6fnbpam5";
+  version = "0.10.4";
+  sha256 = "1z06v1pamrpm70zisrw3z3kv0d19dsjkmm75pvj5yxkacxv7qk7n";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
-    base64Bytestring blazeHtml cgi ConfigFile feed filepath filestore
+    base64Bytestring blazeHtml ConfigFile feed filepath filestore
     ghcPaths happstackServer highlightingKate hslogger HStringTemplate
     HTTP json mtl network pandoc pandocTypes parsec random recaptcha
-    safe SHA syb tagsoup text time url utf8String xhtml xml xssSanitize
-    zlib
+    safe SHA split syb tagsoup text time uri url utf8String xhtml xml
+    xssSanitize zlib
   ];
   jailbreak = true;
-  patches = [ (fetchpatch {
-      url = "https://github.com/jgm/gitit/commit/48155008397bdaed4f97c5678d83c70d4bc3f0ff.patch";
-      sha256 = "16n372wrikwb3g4pb3zljxnp19in0828wp40diqgkplhlnwww6nw";
-    })
-  ];
-  preConfigure = ''
-    sed -i -e 's|network .*< 2.5|network|' gitit.cabal
-  '';
   meta = {
     homepage = "http://gitit.net";
     description = "Wiki using happstack, git or darcs, and pandoc";

pkgs/development/libraries/haskell/gitlib-libgit2/default.nix

···
+{ cabal, conduit, conduitCombinators, exceptions, fastLogger
+, filepath, gitlib, gitlibTest, hlibgit2, hspec, hspecExpectations
+, HUnit, liftedAsync, liftedBase, missingForeign, mmorph
+, monadControl, monadLogger, monadLoops, mtl, resourcet, stm
+, stmConduit, tagged, text, textIcu, time, transformers
+, transformersBase
+}:
+
+cabal.mkDerivation (self: {
+  pname = "gitlib-libgit2";
+  version = "3.1.0";
+  sha256 = "1kjwc36fd14j2ipw53j8hdsy29gxir1qrm54wxgpp5n4q2kcs9pq";
+  buildDepends = [
+    conduit conduitCombinators exceptions fastLogger filepath gitlib
+    hlibgit2 liftedAsync liftedBase missingForeign mmorph monadControl
+    monadLogger monadLoops mtl resourcet stm stmConduit tagged text
+    textIcu time transformers transformersBase
+  ];
+  testDepends = [
+    exceptions gitlib gitlibTest hspec hspecExpectations HUnit
+    monadLogger transformers
+  ];
+  meta = {
+    description = "Libgit2 backend for gitlib";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ianwookim ];
+  };
+})

pkgs/development/libraries/haskell/gitlib-test/default.nix

···
+{ cabal, conduit, conduitCombinators, exceptions, gitlib, hspec
+, hspecExpectations, HUnit, monadControl, tagged, text, time
+, transformers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "gitlib-test";
+  version = "3.1.0";
+  sha256 = "0hnwx5r9fdkxvx0zmqffpym921dvf1x2lky8w11y3rfhk9i1g7l4";
+  buildDepends = [
+    conduit conduitCombinators exceptions gitlib hspec
+    hspecExpectations HUnit monadControl tagged text time transformers
+  ];
+  meta = {
+    description = "Test library for confirming gitlib backend compliance";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ianwookim ];
+  };
+})

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

···
+{ cabal, base16Bytestring, conduit, conduitCombinators, exceptions
+, filepath, hashable, liftedAsync, liftedBase, monadControl
+, monadLogger, mtl, resourcet, semigroups, systemFilepath, tagged
+, text, time, transformers, unorderedContainers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "gitlib";
+  version = "3.1.0";
+  sha256 = "0zyym7m8bdhc4wi2jrhcmipmlq106qkd61c4y9iisgk73v2pg9f4";
+  buildDepends = [
+    base16Bytestring conduit conduitCombinators exceptions filepath
+    hashable liftedAsync liftedBase monadControl monadLogger mtl
+    resourcet semigroups systemFilepath tagged text time transformers
+    unorderedContainers
+  ];
+  meta = {
+    description = "API library for working with Git repositories";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ianwookim ];
+  };
+})

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

···
-{ pkgs, cabal, gtk, gtk2hsBuildtools, pangox_compat }:
+{ cabal, glib, gtk, gtk2hsBuildtools, gtkglext, pango
+, pangox_compat
+}:
 
 cabal.mkDerivation (self: {
   pname = "gtkglext";
   version = "0.12.5.0";
   sha256 = "1xhalcb85cpswdpqxx64fxpmyqq7iakgaczjrbr25fp0h1glshhk";
-  buildDepends = [ gtk ];
+  buildDepends = [ glib gtk pango ];
   buildTools = [ gtk2hsBuildtools ];
-  pkgconfigDepends = [ pkgs.gnome2.gtkglext pangox_compat ];
+  pkgconfigDepends = [ gtkglext pangox_compat ];
   meta = {
     homepage = "http://projects.haskell.org/gtk2hs/";
     description = "Binding to the GTK+ OpenGL Extension";

pkgs/development/libraries/haskell/happstack/happstack-lite.nix

···
 
 cabal.mkDerivation (self: {
   pname = "happstack-lite";
-  version = "7.3.3";
-  sha256 = "0iv60cch0fiy9kh21wcpk3s4nvd4j2p50pqr3y56bsqwxk53hhv8";
+  version = "7.3.4";
+  sha256 = "06ndqfd4x49yi17kgiz5xr05l1k6sj5g1f6kir10wgsqhmd0q811";
   buildDepends = [ happstackServer mtl text ];
   meta = {
     homepage = "http://www.happstack.com/";

pkgs/development/libraries/haskell/happstack/happstack-server.nix

···
 
 cabal.mkDerivation (self: {
   pname = "happstack-server";
-  version = "7.3.6";
-  sha256 = "0js1rzg1zpqg9mbi0kdzb5i8ggsrq4l8p0c05k85ppw6h5lwkayd";
+  version = "7.3.7";
+  sha256 = "1phw3hpnklcdav3wv10kwjsmrg8gshnsgd564p459pc4k2zffgh1";
   buildDepends = [
     base64Bytestring blazeHtml extensibleExceptions filepath hslogger
     html monadControl mtl network parsec sendfile syb systemFilepath

pkgs/development/libraries/haskell/haste-compiler/default.nix

···
+{ cabal, binary, blazeBuilder, bzlib, dataBinaryIeee754
+, dataDefault, executablePath, filepath, ghcPaths, HTTP, monadsTf
+, mtl, network, random, shellmate, systemFileio, tar, temporary
+, time, transformers, utf8String, websockets, zipArchive
+}:
+
+cabal.mkDerivation (self: {
+  pname = "haste-compiler";
+  version = "0.3";
+  sha256 = "0a0hyra1h484c404d95d411l7gddaazy1ikwzlgkgzaqzd7j7dbd";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    binary blazeBuilder bzlib dataBinaryIeee754 dataDefault
+    executablePath filepath ghcPaths HTTP monadsTf mtl network random
+    shellmate systemFileio tar temporary time transformers utf8String
+    websockets zipArchive
+  ];
+  meta = {
+    homepage = "http://github.com/valderman/haste-compiler";
+    description = "Haskell To ECMAScript compiler";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/haste-perch/default.nix

···
+{ cabal, hasteCompiler, mtl }:
+
+cabal.mkDerivation (self: {
+  pname = "haste-perch";
+  version = "0.1.0.0";
+  sha256 = "0g2ijb0mzqs2iq4i47biaxbsg4v15w9ky6yyz6wmngwf06rg4iwj";
+  buildDepends = [ hasteCompiler mtl ];
+  jailbreak = true;
+  meta = {
+    homepage = "https://github.com/agocorona/haste-perch";
+    description = "Create dynamic HTML in the browser using blaze-html-style notation with Haste";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, bindingsDSL, git, openssl, zlib }:
+
+cabal.mkDerivation (self: {
+  pname = "hlibgit2";
+  version = "0.18.0.13";
+  sha256 = "1bslg51kkhnwm48kxaad4izq3xmzv6dpqy10a5kh16vr5zy3w5hz";
+  buildDepends = [ bindingsDSL zlib ];
+  testDepends = [ git ];
+  extraLibraries = [ openssl ];
+  meta = {
+    description = "Low-level bindings to libgit2";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+    maintainers = [ self.stdenv.lib.maintainers.ianwookim ];
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "hoauth2";
-  version = "0.4.0";
-  sha256 = "1499rgcn3h4921x21s6l0spnjf3wvmsaa07pimgjgb4rjib3z2d5";
+  version = "0.4.1";
+  sha256 = "145lgy9bxx1xdljbkvi6s97n2z1k5fd0idp415r71ydw8h3i8ppx";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "http-client";
-  version = "0.3.3.2";
-  sha256 = "02q2zph6clff0k86wkyf19j5dhfglqi3zvbs52hw8lygpkycpkk7";
+  version = "0.3.4";
+  sha256 = "0y4va0xfriv3qv31hbh7kbzmf61rr3ffr4z4vlfdlzacfv8307y4";
   buildDepends = [
     base64Bytestring blazeBuilder caseInsensitive cookie
     dataDefaultClass deepseq exceptions filepath httpTypes mimeTypes

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

···
 
 cabal.mkDerivation (self: {
   pname = "http-kit";
-  version = "0.5.0";
-  sha256 = "0djg2gg12w9sd598hx959cgr5027ghza3m6aaym9ipb43w6mds5p";
+  version = "0.5.1";
+  sha256 = "1swnvsbaabk946pys9q9kr0bgdvalnznd59dw981sg7cywqdcz28";
   buildDepends = [ caseInsensitive httpTypes ];
   testDepends = [ hspec httpTypes QuickCheck quickcheckInstances ];
   meta = {

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

···
 
 cabal.mkDerivation (self: {
   pname = "http-streams";
-  version = "0.7.1.1";
-  sha256 = "0wh07gdb9w48mwsjvg07dq6gjvdm8ls654ki180r7p38v93rsmfx";
+  version = "0.7.2.0";
+  sha256 = "0h7fjnpday34skhafv2v0ybhfv0x915prfb4qa0ld4gm50scsinz";
   buildDepends = [
     aeson attoparsec base64Bytestring blazeBuilder caseInsensitive
     HsOpenSSL httpCommon ioStreams mtl network opensslStreams text

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

···
 
 cabal.mkDerivation (self: {
   pname = "jack";
-  version = "0.7.0.2";
-  sha256 = "06mf1sw1lp81b3d4hsgc199m30drdnxzzlmsxg4p1yvydjfdk4gj";
+  version = "0.7.0.3";
+  sha256 = "12ap7xcgzmp5zwmqkwsgxplh5li21m7xngijr4mhnn9y33xc1lrk";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/lens-family-core/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "lens-family-core";
-  version = "1.0.0";
-  sha256 = "149wfxddw58h5q42r3nknmac8wsc9c8xzsw6vrlfb4yasg7bhw53";
+  version = "1.1.0";
+  sha256 = "0pvc7iv7y5s3496w7ic9qzdw3l76ldnrg0my0jxi1dyn0vm9xwm3";
   buildDepends = [ transformers ];
   meta = {
     description = "Haskell 98 Lens Families";

pkgs/development/libraries/haskell/lifted-base/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "lifted-base";
-  version = "0.2.2.2";
-  sha256 = "02qjagh4a3zvad7xyvwjd6nkh44c41bqj32ddpn7ms1fv4sl0mam";
+  version = "0.2.3.0";
+  sha256 = "0wbh9l7hsbgvfplxyamvpb8nq6w147zsd2yskylfmpw7kyz6yp9n";
   buildDepends = [ monadControl transformersBase ];
   testDepends = [
     HUnit monadControl testFramework testFrameworkHunit transformers

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

···
 
 cabal.mkDerivation (self: {
   pname = "midi";
-  version = "0.2.1.2";
-  sha256 = "077cxdazr97hjpq42l7hjn905pfhyshvaiwqjdfnzhjv6r48q4zk";
+  version = "0.2.1.3";
+  sha256 = "0mqf6q7686zdxljkz3bqa2zhkgirqz5c1fkbd3n4wyipzhjc773a";
   buildDepends = [
     binary eventList explicitException monoidTransformer nonNegative
     QuickCheck random transformers utilityHt

pkgs/development/libraries/haskell/monad-loops/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "monad-loops";
-  version = "0.4.2";
-  sha256 = "08sz08p4z1p78dv7rmsqvin59h19i6i07sp7jg3zwxwjxa76fds8";
+  version = "0.4.2.1";
+  sha256 = "1dprwndc0bxzpmrkj1xb9kzjrg3i06zsg43yaabn5x5gcaj8is56";
   meta = {
     homepage = "https://github.com/mokus0/monad-loops";
     description = "Monadic loops";

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

···
+{ cabal, blazeBuilder, cassava, HUnit, pipes, pipesBytestring
+, testFramework, testFrameworkHunit, unorderedContainers, vector
+}:
+
+cabal.mkDerivation (self: {
+  pname = "pipes-csv";
+  version = "1.4.0";
+  sha256 = "1q1gnfnkvlkk8lwllhyar7323k3jynh9rl6x9yks7lc3nqr1n16j";
+  buildDepends = [
+    blazeBuilder cassava pipes unorderedContainers vector
+  ];
+  testDepends = [
+    cassava HUnit pipes pipesBytestring testFramework
+    testFrameworkHunit vector
+  ];
+  meta = {
+    description = "Fast, streaming csv parser";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, httpClient, httpClientTls, pipes }:
+
+cabal.mkDerivation (self: {
+  pname = "pipes-http";
+  version = "1.0.1";
+  sha256 = "15jmhf6lgqxv9zn08dky8biiv8cp4s3vf0xmp78pbllaqkvm4z9w";
+  buildDepends = [ httpClient httpClientTls pipes ];
+  meta = {
+    description = "HTTP client with pipes interface";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 { cabal, pipes, pipesBytestring, pipesGroup, pipesParse, pipesSafe
-, profunctors, streamingCommons, text, transformers
+, streamingCommons, text, transformers
 }:
 
 cabal.mkDerivation (self: {
   pname = "pipes-text";
-  version = "0.0.0.11";
-  sha256 = "0c56gxm17bapdjgbp2f55z3f6vq8ryvsljqp3bcjjj18xv5pf1ls";
+  version = "0.0.0.12";
+  sha256 = "18xf0rhshbl03js50n98k96692w98j0j0dfyi67780i08c39dq6m";
   buildDepends = [
-    pipes pipesBytestring pipesGroup pipesParse pipesSafe profunctors
+    pipes pipesBytestring pipesGroup pipesParse pipesSafe
     streamingCommons text transformers
   ];
   jailbreak = true;

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

···
 
 cabal.mkDerivation (self: {
   pname = "purescript";
-  version = "0.5.2.4";
-  sha256 = "19k8kggmmy75qgg9xcvvd194s1vf5qx15ljx82zdscvks2j1r1sd";
+  version = "0.5.2.5";
+  sha256 = "17qbgdfhq9k4y7z3c879hkw22jcq86myd9xhs4saaa4xh3ix50x0";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/random-fu/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "random-fu";
-  version = "0.2.5.0";
-  sha256 = "1yfq7mvplzdk64i7z5ip8vjynn48a65z28xrhcv91qi0yjxsxdm0";
+  version = "0.2.6.0";
+  sha256 = "1mi1hr3hxlnyjf01hgn7xinr1m0rax26759zbkhf5xn04ps0g01p";
   buildDepends = [
     erf mathFunctions monadLoops mtl randomShuffle randomSource rvar
     syb transformers vector

pkgs/development/libraries/haskell/resource-pool-catchio/default.nix

···
+{ cabal, hashable, MonadCatchIOTransformers, stm, time
+, transformers, transformersBase, vector
+}:
+
+cabal.mkDerivation (self: {
+  pname = "resource-pool-catchio";
+  version = "0.2.1.0";
+  sha256 = "0g9r6hnn01n3p2ikcfkfc4afh83pzam29zal3k2ivajpl3kramsw";
+  buildDepends = [
+    hashable MonadCatchIOTransformers stm time transformers
+    transformersBase vector
+  ];
+  meta = {
+    homepage = "http://github.com/norm2782/pool";
+    description = "Fork of resource-pool, with a MonadCatchIO constraint";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "safe";
-  version = "0.3.4";
-  sha256 = "0mwdaj0sjvqkgg077x1d896xphx64yrjvwbdhv7khdk3rh0vfl64";
+  version = "0.3.5";
+  sha256 = "0xv409ps1h1b28v8rkg59a09z001nmpvqvwf3mdkzkyzmxfgq30j";
   meta = {
     homepage = "http://community.haskell.org/~ndm/safe/";
-    description = "Library for safe (pattern match free) functions";
+    description = "Library of safe (exception free) functions";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     maintainers = [ self.stdenv.lib.maintainers.andres ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "semigroups";
-  version = "0.15";
-  sha256 = "1fkinmjyx7r39c8hf8f6n9zgn6m7c2y7l0san43s4g2cfg8pxn5s";
+  version = "0.15.1";
+  sha256 = "1vacnw598pl9acbcjjblrpdmjhmj3wz1ifrn9ki4q7yrsh4ml7mc";
   buildDepends = [ hashable nats text unorderedContainers ];
   meta = {
     homepage = "http://github.com/ekmett/semigroups/";

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

···
 
 cabal.mkDerivation (self: {
   pname = "shakespeare";
-  version = "2.0.0.3";
-  sha256 = "12dmhcv404bh7kn04d175bj2b0fadz4sjypwsq151mlhakr13x85";
+  version = "2.0.1";
+  sha256 = "1h1b7p4czdzrxb77515vqnck3rj3yw35h2ds6gzxzp7pdxprds27";
   buildDepends = [
     aeson blazeHtml blazeMarkup exceptions parsec systemFileio
     systemFilepath text time transformers

pkgs/development/libraries/haskell/snap-web-routes/default.nix

···
+{ cabal, heist, mtl, snap, snapCore, text, webRoutes, xmlhtml }:
+
+cabal.mkDerivation (self: {
+  pname = "snap-web-routes";
+  version = "0.5.0.0";
+  sha256 = "1ml0b759k2n9bd2x4akz4dfyk8ywnpgrdlcymng4vhjxbzngnniv";
+  buildDepends = [ heist mtl snap snapCore text webRoutes xmlhtml ];
+  meta = {
+    homepage = "https://github.com/lukerandall/snap-web-routes";
+    description = "Type safe URLs for Snap";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, clientsession, configurator, errors
+, MonadCatchIOTransformers, mtl, postgresqlSimple
+, resourcePoolCatchio, snap, text, transformers
+, unorderedContainers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "snaplet-postgresql-simple";
+  version = "0.5";
+  sha256 = "0pzn0lg1slrllrrx1n9s1kp1pmq2ahrkjypcwnnld8zxzvz4g5jm";
+  buildDepends = [
+    clientsession configurator errors MonadCatchIOTransformers mtl
+    postgresqlSimple resourcePoolCatchio snap text transformers
+    unorderedContainers
+  ];
+  meta = {
+    homepage = "https://github.com/mightybyte/snaplet-postgresql-simple";
+    description = "postgresql-simple snaplet for the Snap Framework";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/storable-record/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "storable-record";
-  version = "0.0.2.5";
-  sha256 = "078vwwcr47d3dmzkhxr7ggjkq9d5rnxv4z8p049kdnmzfbcmisn3";
+  version = "0.0.3";
+  sha256 = "1mv2s4r7dqkl2fy0wjnywyr2zi2g53nkn0z72mgr8drkzdszzxx1";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ transformers utilityHt ];

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

···
-{ cabal, constraints, dataHash, mtl, QuickCheck, tasty, tastyGolden
-, tastyQuickcheck, tastyTh, transformers, treeView, tuple
+{ cabal, constraints, dataHash, mtl, QuickCheck, safe, tagged
+, tasty, tastyGolden, tastyQuickcheck, tastyTh, treeView
 , utf8String
 }:
 
 cabal.mkDerivation (self: {
   pname = "syntactic";
-  version = "1.13";
-  sha256 = "1d5mb7ss6xr7rj93mwrdvkxkx1dlmywxx9sxsmqy7l6gaxs6gq8l";
-  buildDepends = [
-    constraints dataHash mtl transformers treeView tuple
-  ];
+  version = "2.0";
+  sha256 = "0b90afdfymsbgllk8np3xfkgrn2b5ry3n2wbpkn660rknsayw94x";
+  buildDepends = [ constraints dataHash mtl safe tagged treeView ];
   testDepends = [
-    mtl QuickCheck tasty tastyGolden tastyQuickcheck tastyTh utf8String
+    QuickCheck tagged tasty tastyGolden tastyQuickcheck tastyTh
+    utf8String
   ];
   meta = {
     homepage = "https://github.com/emilaxelsson/syntactic";
-    description = "Generic abstract syntax, and utilities for embedded languages";
+    description = "Generic representation and manipulation of abstract syntax";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
   };

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

···
 { cabal, deepseq, filepath, mtl, optparseApplicative, tagged, tasty
-, temporaryRc
+, tastyHunit, temporaryRc
 }:
 
 cabal.mkDerivation (self: {
   pname = "tasty-golden";
-  version = "2.2.1.2";
-  sha256 = "107c6i1abw6dsd3cx1bgiyk8dnih7i9x4bl4kw6dfnva2kjkp4d1";
+  version = "2.2.2.3";
+  sha256 = "0vphim4qbx0g53xvh8x90k0l5r6afivbb4y31nvbq2avmrm1i82w";
   buildDepends = [
     deepseq filepath mtl optparseApplicative tagged tasty temporaryRc
   ];
+  testDepends = [ filepath tasty tastyHunit temporaryRc ];
   meta = {
     homepage = "https://github.com/feuerbach/tasty-golden";
     description = "Golden tests support for tasty";

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

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

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

···
 
 cabal.mkDerivation (self: {
   pname = "tasty";
-  version = "0.8.1.1";
-  sha256 = "04vzq5gwyd5zb6lsf8nbr5dypgf07b4aq70i1jghkg12v8h529dr";
+  version = "0.8.1.2";
+  sha256 = "07pxnm9cx28vlfypa4psnnxcfx1i4qwimkf0nkfzqkhzqb85a58s";
   buildDepends = [
     ansiTerminal async deepseq mtl optparseApplicative regexTdfa stm
     tagged unboundedDelays

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

···
 
 cabal.mkDerivation (self: {
   pname = "th-desugar";
-  version = "1.4.0";
-  sha256 = "0jadwqhk9dqnicg3p958a6cyfvl70amjc1hl7bhlygpxpdfffwad";
+  version = "1.4.1";
+  sha256 = "1pjv301bshdmn3s5nrmmcx5d1b80c410lml73sai68dhx7v64vw2";
   buildDepends = [ mtl syb ];
   testDepends = [ hspec HUnit mtl syb ];
   meta = {

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

···
 
 cabal.mkDerivation (self: {
   pname = "twitter-conduit";
-  version = "0.0.4";
-  sha256 = "0fv2m3sy1gklch4v3sarvq4xk9p7pdz1s3ssl52riy3mg076ab09";
+  version = "0.0.5.1";
+  sha256 = "0wmr5124s6n0xdilzh2cd693ar2i0mwkgsik9ns1d34ibnvfibgv";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "vty-ui";
-  version = "1.7";
-  sha256 = "1wd7ada3x7d5rhl4z3h29m9h42513vbz6dp49xhn4j806mi164nd";
+  version = "1.7.1";
+  sha256 = "1xgv2psbqcqpzgj1f1pis6hr7yvny8y9ajimllam7zsk6kbhngzz";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "web-routes";
-  version = "0.27.5";
-  sha256 = "1jx5wwmlylwrf45wy3w29ck1p7509mgy8m02vipd8apibx6ghp22";
+  version = "0.27.6";
+  sha256 = "16jmiwnwmq9bkifk14dfs88a2kyy7rqybyq68ybrjq1x84x6pkkp";
   buildDepends = [
     blazeBuilder httpTypes mtl parsec split text utf8String
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "webdriver";
-  version = "0.5.4";
-  sha256 = "0839vw7drjn5iray4ma17f0pfgwx44q10ad8m564jvjgcml4yhvq";
+  version = "0.5.5";
+  sha256 = "1k656ghkaqlnp4a9dd99s3l2vm21zsqpqxwfg2lq5rx2yw402nga";
   buildDepends = [
     aeson attoparsec base64Bytestring cond dataDefault directoryTree
     exceptions filepath HTTP liftedBase monadControl mtl network

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

···
 
 cabal.mkDerivation (self: {
   pname = "websockets";
-  version = "0.8.2.4";
-  sha256 = "09mq04vhi53isj8z5930ibyai7bv634lnmhl4xl2d3fzz2afvff0";
+  version = "0.8.2.5";
+  sha256 = "1d8r9mrkwvac05gblxrnxdnnyqqidjcfv5j3njbb9dgzdj56gb1y";
   buildDepends = [
     attoparsec base64Bytestring binary blazeBuilder caseInsensitive
     entropy ioStreams mtl network random SHA text

pkgs/development/libraries/libmm-qt/default.nix

···
+{ stdenv, fetchurl, cmake, pkgconfig, qt4, doxygen, modemmanager }:
+
+let
+  pname = "libmm-qt";
+  version = "1.0.1";
+  name = "${pname}-${version}";
+in
+stdenv.mkDerivation {
+  inherit name;
+
+  buildInputs = [
+    cmake
+    pkgconfig
+    qt4
+    doxygen
+  ];
+
+  propagatedBuildInputs = [ modemmanager ];
+
+  src = fetchurl {
+    url = "mirror://kde/unstable/modemmanager-qt/${version}/src/${name}-1.tar.xz";
+    sha256 = "0ad57815a904ddb2660a7327c0bda5da47a2a60ce57b2b12f4aaff99b174f74a";
+  };
+
+  meta = with stdenv.lib; {
+    homepage = "https://projects.kde.org/projects/extragear/libs/libmm-qt";
+    description = "Qt wrapper for ModemManager DBus API";
+    license = licenses.lgpl21;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.jgeerds ];
+  };
+}

pkgs/development/libraries/libnm-qt/default.nix

···
+{ stdenv, fetchurl, cmake, pkgconfig, qt4, networkmanager, libmm-qt }:
+
+let
+  pname = "libnm-qt";
+  version = "0.9.8.1";
+  name = "${pname}-${version}";
+in
+stdenv.mkDerivation {
+  inherit name;
+
+  buildInputs = [
+    cmake
+    pkgconfig
+    qt4
+    networkmanager
+  ];
+
+  propagatedBuildInputs = [ libmm-qt ];
+
+  src = fetchurl {
+    url = "mirror://kde/unstable/networkmanager-qt/${version}/src/${name}.tar.xz";
+    sha256 = "cde8bed2beb57015cb5f6772c1fe0843aab299b9529578c5406ba7fe614af23d";
+  };
+
+  meta = with stdenv.lib; {
+    homepage = "https://projects.kde.org/projects/extragear/libs/libnm-qt";
+    description = "Qt wrapper for NetworkManager DBus API";
+    license = licenses.lgpl21;
+    platforms = platforms.linux;
+    maintainer = [ maintainers.jgeerds ];
+  };
+}

pkgs/development/libraries/lightning/default.nix

···
-{ fetchurl, stdenv }:
+{ fetchurl, stdenv, binutils }:
 
 stdenv.mkDerivation rec {
-  name = "lightning-1.2c";
+  name = "lightning-2.0.4";
 
   src = fetchurl {
     url = "ftp://alpha.gnu.org/gnu/lightning/${name}.tar.gz";
-    sha256 = "00ss2b75msj4skkda9fs5df3bfpi8bwbckci8g0pwd3syppb3qdl";
+    sha256 = "1lrckrx51d5hrv66bc99fd4b7g2wwn4vr304hwq3glfzhb8jqcdy";
   };
+
+  # Needs libopcodes.so  from binutils for 'make check'
+  buildInputs = [ binutils ];
 
   doCheck = true;
 
···
 
     license = "LGPLv3+";
   };
-}
+}

pkgs/development/libraries/php-apc/default.nix

···
-{stdenv, fetchurl, php, autoconf, automake, libtool }:
-
-stdenv.mkDerivation rec {
-  name = "php-apc-3.1.7";
-  
-  src = fetchurl {
-    url = http://pecl.php.net/get/APC-3.1.7.tgz;
-    sha256 = "0xlvhw5398sl5zzkjm4rkk1m3fcra30zkq0k4i6fij0ylpd6nlls";
-  };
-
-  preConfigure = ''
-    phpize
-
-    sed -i 's,^EXTENSION_DIR.*,'EXTENSION_DIR=$out/lib/php/extensions, configure
-  '';
-
-  configureFlags = [ "--enable-apc" "--enable-apc-mmap" ];
-
-  buildInputs = [ php autoconf automake libtool ];
-
-  meta = {
-    description = "Alternative PHP Cache";
-    homepage = "http://pecl.php.net/package/APC";
-    license = "PHP+";
-  };
-}

pkgs/development/libraries/php-xcache/default.nix

···
-{stdenv, fetchurl, php, autoconf, automake, libtool, m4 }:
-
-stdenv.mkDerivation rec {
-  name = "php-xcache-3.0.1";
-  
-  src = fetchurl {
-    url = http://xcache.lighttpd.net/pub/Releases/3.0.1/xcache-3.0.1.tar.bz2;
-    md5 = "45086010bc4f82f506c08be1c556941b";
-  };
-
-  preConfigure = ''
-    phpize
-
-    sed -i 's,^EXTENSION_DIR.*,'EXTENSION_DIR=$out/lib/php/extensions, configure
-  '';
-
-  configureFlags = [
-    "--enable-xcache" 
-    "--enable-xcache-coverager" 
-    "--enable-xcache-optimizer" 
-    "--enable-xcache-assembler"
-    "--enable-xcache-encoder"
-    "--enable-xcache-decoder"
-  ];
-
-  buildInputs = [ php autoconf automake libtool m4 ];
-
-  meta = {
-    description = "Fast, stable PHP opcode cacher";
-    homepage = http://xcache.lighttpd.net/;
-    license = "BSD";
-  };
-}

pkgs/development/libraries/sqlcipher/default.nix

···
+{ stdenv, fetchurl, openssl, tcl, readline ? null, ncurses ? null }:
+
+assert readline != null -> ncurses != null;
+
+stdenv.mkDerivation {
+  name = "sqlcipher-3.1.0";
+
+  src = fetchurl {
+    url = "https://github.com/sqlcipher/sqlcipher/archive/v3.1.0.tar.gz";
+    sha256 = "1h54hsl7g6ra955aaqid5wxm93fklx2pxz8abcdwf9md3bpfcn18";
+  };
+
+  buildInputs = [ readline ncurses openssl tcl ];
+
+  configureFlags = "--enable-threadsafe --disable-tcl";
+
+  CFLAGS = "-DSQLITE_ENABLE_COLUMN_METADATA=1 -DSQLITE_SECURE_DELETE=1 -DSQLITE_ENABLE_UNLOCK_NOTIFY=1 -DSQLITE_HAS_CODEC";
+  LDFLAGS = if readline != null then "-lncurses" else "";
+
+  meta = {
+    homepage = http://sqlcipher.net/;
+    description = "Full Database Encryption for SQLite";
+    platforms = stdenv.lib.platforms.unix;
+  };
+}

pkgs/development/libraries/szip/default.nix

···
 { stdenv, fetchurl }:
     
 stdenv.mkDerivation {
-    name = "szip-2.1";
-    src = fetchurl {
-        url = ftp://ftp.hdfgroup.org/lib-external/szip/2.1/src/szip-2.1.tar.gz;
-        sha256 = "1vym7r4by02m0yqj10023xyps5b21ryymnxb4nb2gs32arfxj5m8";
-    };
+  name = "szip-2.1";
+  src = fetchurl {
+    url = ftp://ftp.hdfgroup.org/lib-external/szip/2.1/src/szip-2.1.tar.gz;
+    sha256 = "1vym7r4by02m0yqj10023xyps5b21ryymnxb4nb2gs32arfxj5m8";
+  };
+
+  meta = {
+    description = "
+      Szip is a compression library that can be used with the hdf5 library.
+    ";
+    homepage = http://www.hdfgroup.org/doc_resource/SZIP/;
+    license = stdenv.lib.licenses.unfree;
+  };
 }

pkgs/development/ocaml-modules/biniou/default.nix

···
+{stdenv, fetchurl, ocaml, findlib, easy-format}:
+let
+  pname = "biniou";
+  version = "1.0.9";
+  webpage = "http://mjambon.com/${pname}.html";
+in
+stdenv.mkDerivation rec {
+
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "http://mjambon.com/releases/${pname}/${name}.tar.gz";
+    sha256 = "14j3hrhbjqxbizr1pr8fcig9dmfzhbjjwzwyc99fcsdic67w8izb";
+  };
+
+  buildInputs = [ ocaml findlib easy-format ];
+
+  createFindlibDestdir = true;
+
+  makeFlags = "PREFIX=$(out)";
+
+  preBuild = ''
+    mkdir $out/bin
+  '';
+
+  meta = {
+    description = "A binary data format designed for speed, safety, ease of use and backward compatibility as protocols evolve";
+    homepage = "${webpage}";
+    license = stdenv.lib.licenses.bsd3;
+    platforms = ocaml.meta.platforms;
+  };
+}

pkgs/development/ocaml-modules/easy-format/default.nix

···
+{stdenv, fetchurl, ocaml, findlib}:
+let
+  pname = "easy-format";
+  version = "1.0.2";
+  webpage = "http://mjambon.com/${pname}.html";
+in
+stdenv.mkDerivation rec {
+
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "http://mjambon.com/releases/${pname}/${name}.tar.gz";
+    sha256 = "07wlgprqvk92z0p2xzbnvh312ca6gvhy3xc6hxlqfawnnnin7rzi";
+  };
+
+  buildInputs = [ ocaml findlib ];
+
+  createFindlibDestdir = true;
+
+  meta = {
+    description = "A high-level and functional interface to the Format module of the OCaml standard library";
+    homepage = "${webpage}";
+    license = "bsd";
+  };
+}
+
+

pkgs/development/ocaml-modules/yojson/default.nix

···
+{stdenv, fetchurl, ocaml, findlib, cppo, easy-format, biniou}:
+let
+  pname = "yojson";
+  version = "1.1.8";
+  webpage = "http://mjambon.com/${pname}.html";
+in
+stdenv.mkDerivation rec {
+
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "http://mjambon.com/releases/${pname}/${name}.tar.gz";
+    sha256 = "0ayx17dimnpavdfyq6dk9xv2x1fx69by85vc6vl3nqxjkcv5d2rv";
+  };
+
+  buildInputs = [ ocaml findlib cppo easy-format biniou ];
+
+  createFindlibDestdir = true;
+
+  makeFlags = "PREFIX=$(out)";
+
+  preBuild = ''
+    mkdir $out/bin
+  '';
+
+  meta = {
+    description = "An optimized parsing and printing library for the JSON format";
+    homepage = "${webpage}";
+    license = stdenv.lib.licenses.bsd3;
+    platforms = ocaml.meta.platforms;
+  };
+}

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

···
   meta = {
     description = "Hierarchical datasets for Python";
     homepage = "http://www.pytables.org/";
+    license = stdenv.lib.licenses.bsd2;
   };
 }

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

···
 
 cabal.mkDerivation (self: {
   pname = "hlint";
-  version = "1.8.61";
-  sha256 = "08y8ny6dv14gxnzzr5f1hvs22m7y62yffyq2pzvw2aja8fbj5d2z";
+  version = "1.9";
+  sha256 = "1c8qpfrivsxx6raqnrz40li73hng4z0ygc1hl70qixbmsmv2a830";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

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

pkgs/development/tools/misc/d-feet/default.nix

···
 { stdenv, pkgconfig, fetchurl, itstool, intltool, libxml2, glib, gtk3
-, pango, gdk_pixbuf, atk, pep8, python, makeWrapper
-, pygobject3, gobjectIntrospection, libwnck3
-, gnome_icon_theme }:
+, pango, gdk_pixbuf, atk, pep8, python, makeWrapper, gnome3
+, pygobject3, gobjectIntrospection, libwnck3 }:
 
 let
   version = "${major}.8";
···
 
   buildInputs = [
     pkgconfig libxml2 itstool intltool glib gtk3 pep8 python
+    gnome3.gnome_icon_theme gnome3.gnome_icon_theme_symbolic
     makeWrapper pygobject3 libwnck3
   ];
 
-  postInstall =
+  preFixup =
     ''
       wrapProgram $out/bin/d-feet \
         --prefix PYTHONPATH : "$(toPythonPath $out):$(toPythonPath ${pygobject3})" \
         --prefix GI_TYPELIB_PATH : "$GI_TYPELIB_PATH" \
         --prefix LD_LIBRARY_PATH : "${gtk3}/lib:${atk}/lib:${libwnck3}/lib" \
-        --prefix XDG_DATA_DIRS : "${gnome_icon_theme}/share:$out/share"
+        --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:$out/share"
+
+      rm $out/share/icons/hicolor/icon-theme.cache
     '';
 
   meta = {

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

···
 
   postInstall = ''
     mkdir -p "$out/etc/udev/rules.d"
-    ln -s "$out/share/openocd/contrib/99-openocd.udev" "$out/etc/udev/rules.d/99-openocd.rules"
+    ln -s "$out/share/openocd/contrib/99-openocd.rules" "$out/etc/udev/rules.d/99-openocd.rules"
   '';
 
   meta = with stdenv.lib; {

pkgs/development/tools/watchman/default.nix

···
+{ stdenv, lib, config, fetchFromGitHub, autoconf, automake, pcre
+, confFile ? config.watchman.confFile or null
+}:
+
+stdenv.mkDerivation rec {
+  name = "watchman-${version}";
+
+  version = "2.9.8";
+
+  src = fetchFromGitHub {
+    owner = "facebook";
+    repo = "watchman";
+    rev = "v${version}";
+    sha256 = "196d71ci7ki4p6xx49w55cqd0bqrx19nf79na3a91mrfa6f22sp6";
+  };
+
+  buildInputs = [ autoconf automake pcre ];
+
+  configureFlags = [
+      "--enable-conffile=${if confFile == null then "no" else confFile}"
+      "--with-pcre=yes"
+  ];
+
+  preConfigure = ''
+    ./autogen.sh
+  '';
+
+  meta = with lib; {
+    description = "Watches files and takes action when they change";
+    homepage    = https://facebook.github.io/watchman;
+    maintainers = with maintainers; [ cstrahan ];
+    platforms   = with platforms; linux ++ darwin;
+    license     = licenses.asl20;
+  };
+}

pkgs/games/atanks/default.nix

···
     (builtins.attrNames (builtins.removeAttrs x helperArgNames));
   sourceInfo = rec {
     baseName="atanks";
-    version="4.9";
+    version = "6.0";
     name="${baseName}-${version}";
     project="${baseName}";
     url="mirror://sourceforge/project/${project}/${baseName}/${name}/${name}.tar.gz";
-    hash="015nwh8jk4k24ci6ilihii8idkyf6g266r4vl50csvykc82slrvd";
+    sha256 = "0460zwzd800vcgsmd1dzb7j5wcy3lf9hsdw152f6p2mbd0nq5pds";
   };
 in
 rec {
   src = a.fetchurl {
     url = sourceInfo.url;
-    sha256 = sourceInfo.hash;
+    sha256 = sourceInfo.sha256;
   };
 
   inherit (sourceInfo) name version;
···
   fixInstall = a.fullDepEntry (''
     sed -e "s@INSTALL=.*bin/install @INSTALL=install @" -i Makefile
     sed -e "s@-g 0 -m ... -o 0@@" -i Makefile
+    sed -e 's@/usr/@'"$out"'@g' -i Makefile
   '') ["doUnpack" "minInit"];
       
   meta = {
···
     ];
     platforms = with a.lib.platforms;
       linux;
-  };
-  passthru = {
-    updateInfo = {
-      downloadPage = "http://sourceforge.net/projects/atanks/files/atanks/";
-    };
+    downloadPage = "http://sourceforge.net/projects/atanks/files/atanks/";
+    inherit version;
   };
 }) x
 

pkgs/games/atanks/default.upstream

···
+url http://sourceforge.net/projects/atanks/files/atanks/
+version_link 'atanks[-][0-9.]+/$'
+version_link '[.]tar[.][a-z0-9]+/download'
+SF_redirect
+do_overwrite () { do_overwrite_just_version; }

pkgs/misc/maven/default.nix

···
 assert jdk != null;
 
 stdenv.mkDerivation {
-  name = "apache-maven-3.0.4";
+  name = "apache-maven-3.1.1";
 
   builder = ./builder.sh;
 
   src = fetchurl {
-    url = mirror://apache/maven/binaries/apache-maven-3.0.4-bin.tar.gz;
-    sha256 = "0bxa7x8ifm8590nxifhsh3sxzm6aicbczyx21vibg3606ih8fnnk";
+    url = mirror://apache/maven/binaries/apache-maven-3.1.1-bin.tar.gz;
+    sha256 = "06ymc5y8bp5crcz74z2m9pf58aid5q11v2klnjmxb4ar8mkd8zh7";
   };
 
   buildInputs = [ makeWrapper ];

pkgs/misc/my-env/loadenv.sh

···
 
 PATH="$PATH:$OLDPATH"
 export PS1="\n@name@:[\u@\h:\w]\$ "
+export NIX_MYENV_NAME="@name@"
 export buildInputs
 export NIX_STRIP_DEBUG=0
 export TZ="$OLDTZ"

pkgs/os-specific/linux/acpi-call/default.nix

···
 
   src = fetchgit {
     url = "git://github.com/mkottman/acpi_call.git";
-    rev = "46dd97e115ddc7219c88b0818c4d5b235162fe6e";
-    sha256 = "1bi0azd7xxhrivjhnmxllj2sfj12br56mxii20mnqdpqwyz0rhni";
+    rev = "ac67445bc75ec4fcf46ceb195fb84d74ad350d51";
+    sha256 = "0jl19irz9x9pxab2qp4z8c3jijv2m30zhmnzi6ygbrisqqlg4c75";
   };
   
   preBuild = ''

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

···
     longDescription = ''
       Atop is an ASCII full-screen performance monitor that is capable of reporting the activity of all processes (even if processes have finished during the interval), daily logging of system and process activity for long-term analysis, highlighting overloaded system resources by using colors, etc. At regular intervals, it shows system-level activity related to the CPU, memory, swap, disks and network layers, and for every active process it shows the CPU utilization, memory growth, disk utilization, priority, username, state, and exit code.
     '';
+    inherit version;
+    downloadPage = http://atoptool.nl/downloadatop.php;
+    updateWalker = true;
   };
 }

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.14.9";
+  version = "3.14.10";
   extraMeta.branch = "3.14";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "0rm68hzkxzzh6a1nw6fsxbg43d4b88957ail7b9ga589cagf3p94";
+    sha256 = "10gf1r3xnix4v2az7i9dxnddmi377hhlbyblgm0nz9sxddgmk36z";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.15.2";
+  version = "3.15.3";
   extraMeta.branch = "3.15";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "09nq8q84xn6lwzdnn36pzfiqhn1lapi60yxn4hifb7v9ymhc5sv6";
+    sha256 = "0i8dmx1yiaraxb7gsjm7wpy0rv8038nbrwl2slzq749pgm4bd5bf";
   };
 
   features.iwlwifi = true;

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

···
   };
 
   grsecurity_stable = grsecPatch
-    { kversion  = "3.14.9";
-      revision  = "201406262057";
+    { kversion  = "3.14.10";
+      revision  = "201407012152";
       branch    = "stable";
-      sha256    = "0rrcmlaz69028fwl45xnif1dc9wnl7lnrry1280mdg764wrc6g0n";
+      sha256    = "1119044lzkr9wpr1gpl1g0bz67c2xpdd9bkddllij7ja24jv8sx1";
     };
 
   grsecurity_unstable = grsecPatch
-    { kversion  = "3.15.2";
-      revision  = "201406262058";
+    { kversion  = "3.15.3";
+      revision  = "201407012153";
       branch    = "test";
-      sha256    = "02r9xasg1hiw3bynwh50r9cqjzwffmhsyg4gmiyzs58izivl1hvd";
+      sha256    = "0bccayakprc77530crxfr9v2hbs6hlcf290pj1ywlh1p861ljgbm";
     };
 
   grsec_fix_path =

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

···
     substituteInPlace ./cmd/ztest/ztest.c          --replace "/usr/sbin/zdb"     "$out/sbin/zdb"
   '';
 
-  configureFlags = ''
-    --disable-systemd
-    --with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source
-    --with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build
-    --with-spl=${spl}/libexec/spl
-    --with-dracutdir=$$out/lib/dracut
-    --with-udevdir=$$out/lib/udev
-  '';
+  configureFlags = [
+    "--disable-systemd"
+    "--with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source"
+    "--with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
+    "--with-spl=${spl}/libexec/spl"
+    "--with-dracutdir=$(out)/lib/dracut"
+    "--with-udevdir=$(out)/lib/udev"
+  ];
 
   enableParallelBuilding = true;
 

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

···
     substituteInPlace ./cmd/ztest/ztest.c          --replace "/usr/sbin/zdb"     "$out/sbin/zdb"
   '';
 
-  configureFlags = ''
-    --disable-systemd
-    --with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source
-    --with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build
-    --with-spl=${spl_git}/libexec/spl
-    --with-dracutdir=$$out/lib/dracut
-    --with-udevdir=$$out/lib/udev
-  '';
+  configureFlags = [
+    "--disable-systemd"
+    "--with-linux=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source"
+    "--with-linux-obj=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
+    "--with-spl=${spl_git}/libexec/spl"
+    "--with-dracutdir=$(out)/lib/dracut"
+    "--with-udevdir=$(out)/lib/udev"
+  ];
 
   enableParallelBuilding = true;
 

pkgs/servers/http/couchdb/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "couchdb-${version}";
-  version = "1.5.1";
+  version = "1.6.0";
 
   src = fetchurl {
     url = "mirror://apache/couchdb/source/${version}/apache-${name}.tar.gz";
-    sha256 = "0isddp29zh72idgwjaswqy887c1fwx5g1lwlbzscwcv6q70xrmfr";
+    sha256 = "0m4k7i3gibzzcabssysv42rmdr89myppc6765xr0jggwkwdxgxmx";
   };
 
   buildInputs = [ erlang icu openssl spidermonkey curl help2man sphinx which

pkgs/tools/X11/autocutsel/default.nix

···
 {stdenv, fetchurl, libX11, libXaw}:
 
-let
-  name = "autocutsel-0.9.0";
-in
-stdenv.mkDerivation {
-  inherit name;
+stdenv.mkDerivation rec {
+  version = "0.10.0";
+  name = "autocutsel-${version}";
  
   src = fetchurl {
-    url = "mirror://savannah/autocutsel/${name}.tar.gz";
-    sha256 = "0hp335qq57l0kp58pfwb0bk930zx5497frq8y0lzr4icvk1fpw5y";
+    url = "https://github.com/sigmike/autocutsel/releases/download/${version}/${name}.tar.gz";
+    sha256 = "0gsys2dzh4az51ndcsabhlbbrjn2nm75lnjr45kg6r8sm8q66dx2";
   };
  
   buildInputs = [ libX11 libXaw ];
···
   '';
 
   meta = {
+    inherit version;
     homepage = "http://www.nongnu.org/autocutsel/";
     description = "Tracks changes in the server's cutbuffer and CLIPBOARD selection";
     license = "GPLv2+";
     platforms = with stdenv.lib.platforms; all;
+    updateWalker = true;
   };
 }

pkgs/tools/networking/altermime/default.nix

···
     ];
     platforms = with a.lib.platforms;
       linux;
-  };
-  passthru = {
-    updateInfo = {
-      downloadPage = "http://www.pldaniels.com/altermime/";
-    };
+    downloadPage = "http://www.pldaniels.com/altermime/";
+    inherit version;
+    updateWalker = true;
   };
 }) x
 

pkgs/tools/networking/aria/default.nix

···
-
-args : with args; 
-let version="1.18.3"; in
-rec {
-  src = /* Here a fetchurl expression goes */
-  fetchurl {
-    url = "mirror://sourceforge/aria2/stable/aria2-${version}.tar.bz2";
-    sha256 = "0y5wv7llq5sdwrsxqkc67wzk8gpb1kl4l1c0zl6l7kr0bkidna9r";
-  };
-
-  buildInputs = [];
-  configureFlags = [];
-
-  /* doConfigure should be specified separately */
-  phaseNames = ["doConfigure" "doMakeInstall"];
-      
-  name = "aria-" + version;
-  meta = {
-    description = "Multiprotocol download manager";
-  };
-}

pkgs/tools/networking/aria2/default.nix

···
 { stdenv, fetchurl, pkgconfig, openssl, libxml2, sqlite, zlib }:
 
 stdenv.mkDerivation rec {
-  name = "aria2-1.18.1";
+  name = "aria2-1.18.5";
 
   src = fetchurl {
     url = "mirror://sourceforge/aria2/stable/${name}/${name}.tar.bz2";
-    sha256 = "0fwm5d0i4nr9yzckmd8yc80yj4h1acrv6jca3h1vjji0rbgk49zy";
+    sha256 = "0gyfp4zw7rlaxcxhb402azazf1fi83kk3qg4w0j8d2i7pfa1zqi5";
   };
 
   buildInputs = [ pkgconfig openssl libxml2 sqlite zlib ];

pkgs/tools/networking/babeld/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "babeld-1.4.3";
+  name = "babeld-1.5.0";
 
   src = fetchurl {
     url = "http://www.pps.univ-paris-diderot.fr/~jch/software/files/${name}.tar.gz";
-    sha256 = "18qb0g7pxxgl9j0jwpyzhxk2h8bf26sk5bwmnqxv34a5f6lhzf6h";
+    sha256 = "0lpm1zras74b71y01fxndrcvfjzb1ny2hh62pjw6idaqpyrp797s";
   };
 
   preBuild = ''

pkgs/tools/networking/dhcpcd/check-interface.patch

···
-Index: dhcpcd.c
-==================================================================
---- a/dhcpcd.c
-+++ b/dhcpcd.c
-@@ -747,14 +747,14 @@
- 			if (ifp->hwlen != 0)
- 				memcpy(ifl->hwaddr, ifp->hwaddr, ifl->hwlen);
+Fix a segfault in handle_interface: if we're adding an interface that
+we already knew about (in particular due to a udev event), then
+calling init_state/start_interface on ifp is bad because we later free
+ifp. This leads to messages like:
+
+  dhcpcd[1342]: eth0: IAID conflicts with one assigned to eth0
+
+and then a crash:
+
+  Invalid read of size 8
+    at 0x41CD07: dhcp_handlepacket (dhcp.c:2555)
+    by 0x408A74: eloop_start (eloop.c:399)
+    by 0x4073B6: main (dhcpcd.c:1537)
+
+  Address 0x54573d8 is 200 bytes inside a block of size 232 free'd
+    at 0x4C27507: free (in /nix/store/jafbjc2y6izmh3sk78fl65n55jll4mj8-valgrind-3.9.0/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
+    by 0x40F0A8: free_interface (net.c:153)
+    by 0x405443: handle_interface (dhcpcd.c:764) by 0x57E0F06: ??? (udev.c:97)
+    by 0x42EB62: dev_handle_data (dev.c:153)
+    by 0x408A74: eloop_start (eloop.c:399)
+    by 0x4073B6: main (dhcpcd.c:1537)
+
+So ignore interfaces that we already know about.
+
+diff -ru -x '*~' dhcpcd-6.4.0-orig/dhcpcd.c dhcpcd-6.4.0/dhcpcd.c
+--- dhcpcd-6.4.0-orig/dhcpcd.c	2014-06-14 22:13:12.000000000 +0200
++++ dhcpcd-6.4.0/dhcpcd.c	2014-07-03 11:13:39.133186533 +0200
+@@ -774,11 +774,11 @@
  		} else {
  			TAILQ_REMOVE(ifs, ifp, next);
  			TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next);
 -		}
--		if (action == 1) {
+-		if (action > 0) {
 -			init_state(ifp, ctx->argc, ctx->argv);
--			start_interface(ifp);
-+			if (action == 1) {
+-			run_preinit(ifp);
+-			dhcpcd_startinterface(ifp);
++			if (action > 0) {
 +				init_state(ifp, ctx->argc, ctx->argv);
-+				start_interface(ifp);
++				run_preinit(ifp);
++				dhcpcd_startinterface(ifp);
 +			}
  		}
  	}
  
- 	/* Free our discovered list */
- 	while ((ifp = TAILQ_FIRST(ifs))) {
-

pkgs/tools/networking/dhcpcd/default.nix

···
 { stdenv, fetchurl, pkgconfig, udev }:
 
 stdenv.mkDerivation rec {
-  name = "dhcpcd-6.3.2";
+  name = "dhcpcd-6.4.0";
 
   src = fetchurl {
     url = "http://roy.marples.name/downloads/dhcpcd/${name}.tar.bz2";
-    sha256 = "1v2m5wdr6x5cz6i0n1y63am9dhj5j7ylrk717scjgwwjdbq1x75n";
+    sha256 = "04whlqg1lik1c690kpgmw5hh6qzim64bw0l4fpr4vb8cj74aj4q4";
   };
 
-  patches = [ ./lxc_ro_promote_secondaries.patch ./reload.patch ./check-interface.patch ];
+  patches = [ /* ./lxc_ro_promote_secondaries.patch */ ./reload.patch ./check-interface.patch ];
 
   buildInputs = [ pkgconfig udev ];
 

pkgs/tools/networking/dhcpcd/reload.patch

···
+Fix segfault when reloading the configuration: free_globals() left the
+ifac/ifdc variables at -1 instead of 0, causing a crash later in
+splitv().
+
 --- a/dhcpcd.c
 +++ b/dhcpcd.c
 @@ -143,16 +143,18 @@

pkgs/tools/networking/mu/default.nix

···
-{ fetchurl, stdenv, sqlite, pkgconfig, xapian, glib, gmime, texinfo, emacs, guile
+{ fetchurl, stdenv, sqlite, pkgconfig, autoconf, automake
+, xapian, glib, gmime, texinfo , emacs, guile
 , gtk3, webkit, libsoup, icu, withMug ? false /* doesn't build with current gtk3 */ }:
 
 stdenv.mkDerivation rec {
-  version = "0.9.9.5";
+  version = "0.9.9.6";
   name = "mu-${version}";
 
   src = fetchurl {
-    url = "https://mu0.googlecode.com/files/mu-${version}.tar.gz";
-    sha256 = "1hwkliyb8fjrz5sw9fcisssig0jkdxzhccw0ld0l9a10q1l9mqhp";
+    url = "https://github.com/djcb/mu/archive/v${version}.tar.gz";
+    sha256 = "1jr9ss29yi6d62hd4ap07p2abgf12hwqfhasv3gwdkrx8dzwmr2a";
   };
 
   buildInputs =
-    [ sqlite pkgconfig xapian glib gmime texinfo emacs guile libsoup icu ]
+    [ sqlite pkgconfig autoconf automake xapian
+      glib gmime texinfo emacs guile libsoup icu ]
     ++ stdenv.lib.optional withMug [ gtk3 webkit ];
+
+  preConfigure = ''
+    autoreconf -i
+  '';
 
   preBuild = ''
     # Fix mu4e-builddir (set it to $out)

pkgs/tools/networking/openresolv/default.nix

···
 { stdenv, fetchurl, makeWrapper, coreutils }:
 
 stdenv.mkDerivation rec {
-  name = "openresolv-3.5.6";
+  name = "openresolv-3.5.7";
 
   src = fetchurl {
     url = "http://roy.marples.name/downloads/openresolv/${name}.tar.bz2";
-    sha256 = "1n3cw1vbm7mh5d95ykhzdn2mrrf3pm65sp61p8iwydz1gqkp2inv";
+    sha256 = "14n51wqnh49zdvx11l79s3fh1jhg7kg9cfny5vk7zsix78spmyx7";
   };
 
   buildInputs = [ makeWrapper ];

pkgs/tools/networking/plasma-nm/default.nix

···
+{ stdenv, fetchurl, pkgconfig, cmake, gettext, kdelibs, networkmanager, libnm-qt }:
+
+let
+  pname = "plasma-nm";
+  version = "0.9.3.3";
+  name = "${pname}-${version}";
+in
+stdenv.mkDerivation {
+  inherit name;
+
+  src = fetchurl {
+    url = "mirror://kde/unstable/${pname}/${name}.tar.xz";
+    sha256 = "099cbe86eb989c4fda8cdcc0f8721dc3350cc6735c3f50bcdd94661e5930e326";
+  };
+
+  buildInputs = [
+    cmake
+    pkgconfig
+    gettext
+    kdelibs
+    networkmanager
+    libnm-qt
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = "https://projects.kde.org/projects/kde/workspace/plasma-nm";
+    description = "Plasma applet written in QML for managing network connections";
+    license = licenses.lgpl21;
+    inherit (kdelibs.meta) platforms;
+    maintainers = [ maintainers.jgeerds ];
+  };
+}

pkgs/top-level/all-packages.nix

···
 
   inherit (androidenv) androidsdk_4_1;
 
-  aria = builderDefsPackage (import ../tools/networking/aria) { };
-
   aria2 = callPackage ../tools/networking/aria2 { };
+  aria = aria2;
 
   at = callPackage ../tools/system/at { };
 
···
 
   wal_e = callPackage ../tools/backup/wal-e { };
 
+  watchman = callPackage ../development/tools/watchman { };
+
   wbox = callPackage ../tools/networking/wbox {};
 
   welkin = callPackage ../tools/graphics/welkin {};
···
 
   cmucl_binary = callPackage ../development/compilers/cmucl/binary.nix { };
 
-  compcert = callPackage_i686 ../development/compilers/compcert {};
+  compcert = callPackage ../development/compilers/compcert {};
 
   cryptol1 = lowPrio (callPackage ../development/compilers/cryptol/1.8.x.nix {});
   cryptol2 = haskellPackages.cryptol;
···
       giflib = giflib_4_1;
     };
 
+    biniou = callPackage ../development/ocaml-modules/biniou { };
+
     ocaml_cairo = callPackage ../development/ocaml-modules/ocaml-cairo { };
 
     cppo = callPackage ../development/tools/ocaml/cppo { };
···
     cryptokit = callPackage ../development/ocaml-modules/cryptokit { };
 
     deriving = callPackage ../development/tools/ocaml/deriving { };
+
+    easy-format = callPackage ../development/ocaml-modules/easy-format { };
 
     findlib = callPackage ../development/tools/ocaml/findlib { };
 
···
     opam_1_0_0 = callPackage ../development/tools/ocaml/opam/1.0.0.nix { };
     opam_1_1 = callPackage ../development/tools/ocaml/opam/1.1.nix { };
     opam = opam_1_1;
+
+    yojson = callPackage ../development/ocaml-modules/yojson { };
 
     zarith = callPackage ../development/ocaml-modules/zarith { };
   };
···
     compat = true;
   };
   lua5 = lua5_1;
+  lua = lua5;
 
   lua5_sockets = callPackage ../development/interpreters/lua-5/sockets.nix {};
   lua5_expat = callPackage ../development/interpreters/lua-5/expat.nix {};
+  lua5_filesystem = callPackage ../development/interpreters/lua-5/filesystem.nix {};
 
   luarocks = callPackage ../development/tools/misc/luarocks {
      lua = lua5;
···
 
   php = php54;
 
-  phpPackages = import ./php-packages.nix {
+  phpPackages = recurseIntoAttrs (import ./php-packages.nix {
     inherit php pkgs;
-  };
+  });
 
   php53 = callPackage ../development/interpreters/php/5.3.nix { };
 
···
   };
 
   php54 = callPackage ../development/interpreters/php/5.4.nix { };
-
-  php_apc = callPackage ../development/libraries/php-apc { };
-
-  php_xcache = callPackage ../development/libraries/php-xcache { };
 
   picolisp = callPackage ../development/interpreters/picolisp {};
 
···
 
   dfeet = callPackage ../development/tools/misc/d-feet {
     inherit (pythonPackages) pep8;
-    inherit (gnome3) gnome_icon_theme;
   };
 
   dfu-programmer = callPackage ../development/tools/misc/dfu-programmer { };
···
 
   allegro = callPackage ../development/libraries/allegro {};
   allegro5 = callPackage ../development/libraries/allegro/5.nix {};
+  allegro5unstable = callPackage
+    ../development/libraries/allegro/5-unstable.nix {};
 
   amrnb = callPackage ../development/libraries/amrnb { };
 
···
   boostHeaders = callPackage ../development/libraries/boost/header-only-wrapper.nix { };
 
   botan = callPackage ../development/libraries/botan { };
+  botanUnstable = callPackage ../development/libraries/botan/unstable.nix { };
 
   box2d = callPackage ../development/libraries/box2d { };
   box2d_2_0_1 = callPackage ../development/libraries/box2d/2.0.1.nix { };
···
     inherit readline ncurses;
   });
 
+  sqlcipher = lowPrio (callPackage ../development/libraries/sqlcipher {
+    readline = null;
+    ncurses = null;
+  });
+
   stfl = callPackage ../development/libraries/stfl {
     stdenv = if stdenv.isDarwin
       then overrideGCC stdenv gccApple
···
 
   # The current default kernel / kernel modules.
   linux = linuxPackages.kernel;
-  linuxPackages = linuxPackages_3_12;
+  linuxPackages = linuxPackages_3_14;
 
   # Update this when adding the newest kernel major version!
   linux_latest = pkgs.linux_3_15;
···
     inherit (pythonPackages) pyopengl;
   };
 
+  inferno = callPackage_i686 ../applications/inferno { };
+
   inkscape = callPackage ../applications/graphics/inkscape {
     inherit (pythonPackages) lxml;
     lcms = lcms2;
···
 
   vbindiff = callPackage ../applications/editors/vbindiff { };
 
+  vcprompt = callPackage ../applications/version-management/vcprompt { };
+
   vdpauinfo = callPackage ../tools/X11/vdpauinfo { };
 
   veracity = callPackage ../applications/version-management/veracity {};
···
           ++ lib.optional (supportsJDK && cfg.jre or false && jrePlugin ? mozillaPlugin) jrePlugin
           ++ lib.optional (cfg.enableGoogleTalkPlugin or false) google_talk_plugin
           ++ lib.optional (cfg.enableFriBIDPlugin or false) fribid
+          ++ lib.optional (cfg.enableGnomeExtensions or false) gnome3.gnome_shell
          );
       libs = [ gstreamer gst_plugins_base ] ++ lib.optionals (cfg.enableQuakeLive or false)
              (with xlibs; [ stdenv.gcc libX11 libXxf86dga libXxf86vm libXext libXt alsaLib zlib ]);
···
 
       liblikeback = callPackage ../development/libraries/liblikeback { };
 
+      libmm-qt = callPackage ../development/libraries/libmm-qt { };
+
+      libnm-qt = callPackage ../development/libraries/libnm-qt { };
+
       networkmanagement = callPackage ../tools/networking/networkmanagement { };
 
       partitionManager = callPackage ../tools/misc/partition-manager { };
+
+      plasma-nm = callPackage ../tools/networking/plasma-nm { };
 
       polkit_kde_agent = callPackage ../tools/security/polkit-kde-agent { };
 

pkgs/top-level/haskell-packages.nix

···
 
   adjunctions = callPackage ../development/libraries/haskell/adjunctions {};
 
-  aes = callPackage ../development/libraries/haskell/aes {};
+  AES = callPackage ../development/libraries/haskell/AES {};
 
   aeson_0_7_0_4 = callPackage ../development/libraries/haskell/aeson/0.7.0.4.nix { blazeBuilder = null; };
   aeson_0_7_0_6 = callPackage ../development/libraries/haskell/aeson/0.7.0.6.nix { blazeBuilder = null; };
···
 
   gitit = callPackage ../development/libraries/haskell/gitit {};
 
+  gitlib = callPackage ../development/libraries/haskell/gitlib {};
+
+  gitlibLibgit2 = callPackage ../development/libraries/haskell/gitlib-libgit2 {};
+
+  gitlibTest = callPackage ../development/libraries/haskell/gitlib-test {};
+
   glade = callPackage ../development/libraries/haskell/glade {
     inherit (pkgs.gnome) libglade;
     gtkC = pkgs.gtk;
···
     libc = pkgs.stdenv.gcc.libc;
   };
 
-  gtkglext = callPackage ../development/libraries/haskell/gtkglext {};
+  gtkglext = callPackage ../development/libraries/haskell/gtkglext { gtkglext = pkgs.gnome2.gtkglext; };
 
   gtk2hsBuildtools = callPackage ../development/libraries/haskell/gtk2hs-buildtools {};
-  gtk2hsC2hs = self.gtk2hsBuildtools;
 
   gtksourceview2 = callPackage ../development/libraries/haskell/gtksourceview2 {
     inherit (pkgs.gnome) gtksourceview;
···
   haskore = callPackage ../development/libraries/haskell/haskore {};
 
   hastache = callPackage ../development/libraries/haskell/hastache {};
+
+  hasteCompiler = callPackage ../development/libraries/haskell/haste-compiler {};
+
+  hastePerch = callPackage ../development/libraries/haskell/haste-perch {};
 
   hcltest = callPackage ../development/libraries/haskell/hcltest {};
 
···
   hledgerIrr = callPackage ../applications/office/hledger-irr {};
   hledgerWeb = callPackage ../development/libraries/haskell/hledger-web {};
 
+  hlibgit2 = callPackage ../development/libraries/haskell/hlibgit2 {};
+
   HList = callPackage ../development/libraries/haskell/HList {};
 
   hmatrix = callPackage ../development/libraries/haskell/hmatrix {};
···
 
   pipesConcurrency = callPackage ../development/libraries/haskell/pipes-concurrency {};
 
+  pipesCsv = callPackage ../development/libraries/haskell/pipes-csv {};
+
+  pipesHttp = callPackage ../development/libraries/haskell/pipes-http {};
+
   pipesNetwork = callPackage ../development/libraries/haskell/pipes-network {};
 
   pipesGroup = callPackage ../development/libraries/haskell/pipes-group {};
···
   repr = callPackage ../development/libraries/haskell/repr {};
 
   resourcePool = callPackage ../development/libraries/haskell/resource-pool {};
+
+  resourcePoolCatchio = callPackage ../development/libraries/haskell/resource-pool-catchio {};
 
   resourcet = callPackage ../development/libraries/haskell/resourcet {};
 
···
 
   snapletAcidState = callPackage ../development/libraries/haskell/snaplet-acid-state {};
 
+  snapletPostgresqlSimple = callPackage ../development/libraries/haskell/snaplet-postgresql-simple {};
+
   snapletRedis = callPackage ../development/libraries/haskell/snaplet-redis {};
 
   snapletStripe = callPackage ../development/libraries/haskell/snaplet-stripe {};
···
   snapLoaderStatic = callPackage ../development/libraries/haskell/snap/loader-static.nix {};
 
   snapServer = callPackage ../development/libraries/haskell/snap/server.nix {};
+
+  snapWebRoutes = callPackage ../development/libraries/haskell/snap-web-routes {};
 
   snowball = callPackage ../development/libraries/haskell/snowball {};
 
···
   threadmanager = callPackage ../development/libraries/haskell/threadmanager {};
 
   threads = callPackage ../development/libraries/haskell/threads {};
+
+  Thrift = callPackage ../development/libraries/haskell/Thrift {};
 
   thyme = callPackage ../development/libraries/haskell/thyme {};
 

pkgs/top-level/php-packages.nix

···
 let self = with self; {
   buildPecl = import ../build-support/build-pecl.nix {
     inherit php;
-    inherit (pkgs) stdenv autoreconfHook;
+    inherit (pkgs) stdenv autoreconfHook fetchurl;
   };
 
   memcache = buildPecl {
     name = "memcache-3.0.8";
 
-    src = pkgs.fetchurl {
-      url = http://pecl.php.net/get/memcache-3.0.8.tgz;
-      sha256 = "04c35rj0cvq5ygn2jgmyvqcb0k8d03v4k642b6i37zgv7x15pbic";
-    };
+    sha256 = "04c35rj0cvq5ygn2jgmyvqcb0k8d03v4k642b6i37zgv7x15pbic";
 
     configureFlags = "--with-zlib-dir=${pkgs.zlib}";
   };
···
   memcached = buildPecl {
     name = "memcached-2.1.0";
 
-    src = pkgs.fetchurl {
-      url = http://pecl.php.net/get/memcached-2.1.0.tgz;
-      sha256 = "1by4zhkq4mbk9ja6s0vlavv5ng8aw5apn3a1in84fkz7bc0l0jdw";
-    };
+    sha256 = "1by4zhkq4mbk9ja6s0vlavv5ng8aw5apn3a1in84fkz7bc0l0jdw";
 
     configureFlags = [
       "--with-zlib-dir=${pkgs.zlib}"
···
     buildInputs = [ pkgs.cyrus_sasl ];
   };
 
-  xdebug = buildPecl rec {
+  xdebug = buildPecl {
     name = "xdebug-2.2.5";
-    src = pkgs.fetchurl {
-      url = "http://pecl.php.net/get/${name}.tgz";
-      sha256 = "0vss35da615709kdvqji8pblckfvmabmj2njjjz6h8zzvj9gximd";
-    };
+
+    sha256 = "0vss35da615709kdvqji8pblckfvmabmj2njjjz6h8zzvj9gximd";
   };
 
-  apc = buildPecl rec {
+  apc = buildPecl {
     name = "apc-3.1.13";
-    src = pkgs.fetchurl {
-      url = "http://pecl.php.net/get/${name}.tgz";
-      sha256 = "1gcsh9iar5qa1yzpjki9bb5rivcb6yjp45lmjmp98wlyf83vmy2y";
-    };
+
+    sha256 = "1gcsh9iar5qa1yzpjki9bb5rivcb6yjp45lmjmp98wlyf83vmy2y";
   };
 
-  zmq = buildPecl rec {
+  zmq = buildPecl {
     name = "zmq-1.1.2";
+
+    sha256 = "0ccz73p8pkda3y9p9qbr3m19m0yrf7k2bvqgbaly3ibgh9bazc69";
+
+    configureFlags = [
+      "--with-zmq=${pkgs.zeromq2}"
+    ];
+
+    buildInputs = [ pkgs.pkgconfig ];
+  };
+
+  xcache = buildPecl rec {
+    name = "xcache-${version}";
+
+    version = "3.1.0";
+
     src = pkgs.fetchurl {
-      url = "http://pecl.php.net/get/${name}.tgz";
-      sha256 = "0ccz73p8pkda3y9p9qbr3m19m0yrf7k2bvqgbaly3ibgh9bazc69";
+      url = "http://xcache.lighttpd.net/pub/Releases/${version}/${name}.tar.bz2";
+      md5 = "e5816d47d52be200b959bf69a673ff74";
     };
 
     configureFlags = [
-      "--with-zmq=${pkgs.zeromq2}"
+      "--enable-xcache"
+      "--enable-xcache-coverager"
+      "--enable-xcache-optimizer"
+      "--enable-xcache-assembler"
+      "--enable-xcache-encoder"
+      "--enable-xcache-decoder"
     ];
 
-    buildInputs = [ pkgs.pkgconfig ];
+    buildInputs = [ pkgs.m4 ];
   };
 }; in self

pkgs/top-level/python-packages.nix

···
   });
 
 
+  click = buildPythonPackage {
+    name = "click-2.1";
+    src = fetchurl {
+      url = https://pypi.python.org/packages/source/c/click/click-2.1.tar.gz;
+      md5 = "0ba97ba09af82c56e2d35f3412d0aa6e";
+    };
+    meta = {
+      homepage = "http://click.pocoo.org/";
+      description = "Click is a Python package for creating beautiful command line interfaces in a composable way with as little code as necessary.";
+      license = "bsd, 3-clause";
+    };
+  };
+
+
   clepy = buildPythonPackage rec {
     name = "clepy-0.3.20";
 
···
     meta = {
       description = "Fast numerical array expression evaluator for NumPy";
       homepage = "https://github.com/pydata/numexpr";
+      license = licenses.mit;
     };
   };
 
···
   };
 
   pip = buildPythonPackage rec {
-    version = "1.5";
+    version = "1.5.6";
     name = "pip-${version}";
     src = fetchurl {
       url = "http://pypi.python.org/packages/source/p/pip/pip-${version}.tar.gz";
-      sha256 = "0j700f70mj0brdlvs2cz4a7h4jwmzgymgp8qk1qb3lsm1qd1vy15";
+      md5 = "01026f87978932060cc86c1dc527903e";
     };
     buildInputs = [ mock scripttest virtualenv pytest ];
   };
···
   };
 
   plumbum = buildPythonPackage rec {
-    name = "plumbum-1.2.0";
+    name = "plumbum-1.4.2";
 
     buildInputs = [ pythonPackages.six ];
 
     src = fetchurl {
-      url = "https://pypi.python.org/packages/source/p/plumbum/plumbum-1.2.0.tar.gz";
-      md5 = "18b7f888dfaf62a48df937abffe07897";
+      url = "https://pypi.python.org/packages/source/p/plumbum/${name}.tar.gz";
+      md5 = "38b526af9012a5282ae91dfe372cefd3";
     };
   };