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

lib/licenses.nix

···
     fullName = "Common Development and Distribution License 1.0";
   };
 
+  cecill20 = spdx {
+    shortName = "CECILL-2.0";
+    fullName = "CeCILL Free Software License Agreement v2.0";
+  };
+
   cecill-b = spdx {
     shortName = "CECILL-B";
     fullName  = "CeCILL-B Free Software License Agreement";

lib/maintainers.nix

···
   aszlig = "aszlig <[e-mail]>";
   auntie = "Jonathan Glines <[e-mail]>";
   aycanirican = "Aycan iRiCAN <[e-mail]>";
+  balajisivaraman = "Balaji Sivaraman<[e-mail]>";
   bbenoist = "Baptist BENOIST <[e-mail]>";
   bennofs = "Benno Fünfstück <[e-mail]>";
   berdario = "Dario Bertini <[e-mail]>";
···
   jagajaga = "Arseniy Seroka <[e-mail]>";
   jcumming = "Jack Cummings <[e-mail]>";
   jgeerds = "Jascha Geerds <[e-mail]>";
+  jirkamarsik = "Jirka Marsik <[e-mail]>";
   joamaki = "Jussi Maki <[e-mail]>";
   joelteon = "Joel Taylor <[e-mail]>";
   jwiegley = "John Wiegley <[e-mail]>";
···
   rszibele = "Richard Szibele <[e-mail]>";
   rycee = "Robert Helgesson <[e-mail]>";
   sander = "Sander van der Burg <[e-mail]>";
+  schristo = "Scott Christopher <[e-mail]>";
   sepi = "Raffael Mancini <[e-mail]>";
   shell = "Shell Turner <[e-mail]>";
   shlevy = "Shea Levy <[e-mail]>";
···
   tomberek = "Thomas Bereknyei <[e-mail]>";
   tstrobel = "Thomas Strobel <[e-mail]>";
   ttuegel = "Thomas Tuegel <[e-mail]>";
+  twey = "James ‘Twey’ Kay <[e-mail]>";
   tv = "Tomislav Viljetić <[e-mail]>";
   urkud = "Yury G. Kudryashov <[e-mail]>";
   vandenoever = "Jos van den Oever <[e-mail]>";

nixos/maintainers/scripts/ec2/amazon-hvm-install-config.nix

···
 {
   imports = [ ./amazon-base-config.nix ];
   ec2.hvm = true;
-  boot.loader.grub.device = lib.mkOverride 0 "nodev";
+  boot.loader.grub.device = lib.mkOverride 0 "/dev/xvdg";
+  boot.kernelParams = [ "console=ttyS0" ];
 
   boot.initrd.extraUtilsCommands = ''
     cp -v ${pkgs.gawk}/bin/gawk $out/bin/gawk

nixos/maintainers/scripts/ec2/create-ebs-amis.py

···
 args = parser.parse_args()
 
 instance_type = "m3.medium" if args.hvm else "m1.small"
-ebs_size = 8 if args.hvm else 20
+
+if args.hvm:
+    virtualization_type = "hvm"
+    root_block = "/dev/sda1"
+    image_type = 'hvm'
+else:
+    virtualization_type = "paravirtual"
+    root_block = "/dev/sda"
+    image_type = 'ebs'
 
+ebs_size = 20
 
 # Start a NixOS machine in the given region.
 f = open("ebs-creator-config.nix", "w")
···
     m.upload_file("./amazon-hvm-config.nix", "/mnt/etc/nixos/configuration.nix")
     m.upload_file("./amazon-hvm-install-config.nix", "/mnt/etc/nixos/amazon-hvm-install-config.nix")
     m.run_command("NIXOS_CONFIG=/etc/nixos/amazon-hvm-install-config.nix nixos-install")
-    m.run_command('nix-env -iA nixos.pkgs.grub')
-    m.run_command('cp /nix/store/*-grub-0.97*/lib/grub/i386-pc/* /mnt/boot/grub')
-    m.run_command('echo "(hd1) /dev/xvdg" > device.map')
-    m.run_command('echo -e "root (hd1,0)\nsetup (hd1)" | grub --device-map=device.map --batch')
 else:
     m.upload_file("./amazon-base-config.nix", "/mnt/etc/nixos/configuration.nix")
     m.run_command("nixos-install")
···
 m.run_command("umount /mnt")
 
 if args.hvm:
-    ami_name = "nixos-{0}-x86_64-ebs-hvm".format(version)
+    ami_name = "nixos-{0}-x86_64-hvm".format(version)
     description = "NixOS {0} (x86_64; EBS root; hvm)".format(version)
 else:
     ami_name = "nixos-{0}-x86_64-ebs".format(version)
···
 
 m.connect()
 volume = m._conn.get_all_volumes([], filters={'attachment.instance-id': m.resource_id, 'attachment.device': "/dev/sdg"})[0]
-if args.hvm:
-    instance = m._conn.run_instances( image_id="ami-5f491f36"
-                                    , instance_type=instance_type
-                                    , key_name=args.key_name
-                                    , placement=m.zone
-                                    , security_groups=["eelco-test"]).instances[0]
-    nixops.util.check_wait(lambda: instance.update() == 'running', max_tries=120)
-    instance.stop()
-    nixops.util.check_wait(lambda: instance.update() == 'stopped', max_tries=120)
-    old_root_volume = m._conn.get_all_volumes([], filters={'attachment.instance-id': instance.id, 'attachment.device': "/dev/sda1"})[0]
-    old_root_volume.detach()
-    volume.detach()
-    nixops.util.check_wait(lambda: volume.update() == 'available', max_tries=120)
-    nixops.util.check_wait(lambda: old_root_volume.update() == 'available', max_tries=120)
-    volume.attach(instance.id, '/dev/sda1')
-    nixops.util.check_wait(lambda: volume.update() == 'in-use', max_tries=120)
 
-    ami_id = m._conn.create_image(instance.id, ami_name, description)
-    time.sleep(5)
-    image = m._conn.get_all_images([ami_id])[0]
-    nixops.util.check_wait(lambda: image.update() == 'available', max_tries=120)
-    instance.terminate()
-
-else:
-    # Create a snapshot.
-    snapshot = volume.create_snapshot(description=description)
-    print >> sys.stderr, "created snapshot {0}".format(snapshot.id)
+# Create a snapshot.
+snapshot = volume.create_snapshot(description=description)
+print >> sys.stderr, "created snapshot {0}".format(snapshot.id)
 
-    nixops.util.check_wait(check, max_tries=120)
+nixops.util.check_wait(check, max_tries=120)
 
-    m._conn.create_tags([snapshot.id], {'Name': ami_name})
+m._conn.create_tags([snapshot.id], {'Name': ami_name})
 
-    if not args.keep: depl.destroy_resources()
+if not args.keep: depl.destroy_resources()
 
-     # Register the image.
-    aki = m._conn.get_all_images(filters={'manifest-location': '*pv-grub-hd0_1.03-x86_64*'})[0]
-    print >> sys.stderr, "using kernel image {0} - {1}".format(aki.id, aki.location)
+# Register the image.
+aki = m._conn.get_all_images(filters={'manifest-location': 'ec2*pv-grub-hd0_1.03-x86_64*'})[0]
+print >> sys.stderr, "using kernel image {0} - {1}".format(aki.id, aki.location)
 
-    block_map = BlockDeviceMapping()
-    block_map['/dev/sda'] = BlockDeviceType(snapshot_id=snapshot.id, delete_on_termination=True)
-    block_map['/dev/sdb'] = BlockDeviceType(ephemeral_name="ephemeral0")
-    block_map['/dev/sdc'] = BlockDeviceType(ephemeral_name="ephemeral1")
-    block_map['/dev/sdd'] = BlockDeviceType(ephemeral_name="ephemeral2")
-    block_map['/dev/sde'] = BlockDeviceType(ephemeral_name="ephemeral3")
+block_map = BlockDeviceMapping()
+block_map[root_block] = BlockDeviceType(snapshot_id=snapshot.id, delete_on_termination=True, size=ebs_size, volume_type="gp2")
+block_map['/dev/sdb'] = BlockDeviceType(ephemeral_name="ephemeral0")
+block_map['/dev/sdc'] = BlockDeviceType(ephemeral_name="ephemeral1")
+block_map['/dev/sdd'] = BlockDeviceType(ephemeral_name="ephemeral2")
+block_map['/dev/sde'] = BlockDeviceType(ephemeral_name="ephemeral3")
 
-    ami_id = m._conn.register_image(
+common_args = dict(
         name=ami_name,
         description=description,
         architecture="x86_64",
-        root_device_name="/dev/sda",
-        kernel_id=aki.id,
-        block_device_map=block_map)
+        root_device_name=root_block,
+        block_device_map=block_map,
+        virtualization_type=virtualization_type,
+        delete_root_volume_on_termination=True
+        )
+if not args.hvm:
+    common_args['kernel_id']=aki.id
+ami_id = m._conn.register_image(**common_args)
 
 print >> sys.stderr, "registered AMI {0}".format(ami_id)
 
···
 test_depl.deploy(create_only=True)
 test_depl.machines['machine'].run_command("nixos-version")
 
-if args.hvm:
-    image_type = 'hvm'
-else:
-    image_type = 'ebs'
-
 # Log the AMI ID.
 f = open("{0}.{1}.ami-id".format(args.region, image_type), "w")
 f.write("{0}".format(ami_id))
 f.close()
 
-for dest in [ 'us-east-1', 'us-west-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', 'sa-east-1']:
+for dest in [ 'us-east-1', 'us-west-1', 'us-west-2', 'eu-west-1', 'eu-central-1', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', 'sa-east-1']:
     if args.region != dest:
         print >> sys.stderr, "copying image from region {0} to {1}".format(args.region, dest)
         conn = boto.ec2.connect_to_region(dest)

nixos/modules/installer/cd-dvd/installation-cd-base.nix

···
   # Get a console as soon as the initrd loads fbcon on EFI boot.
   boot.initrd.kernelModules = [ "fbcon" ];
 
+  # Add support for cow filesystems and their utilities
+  boot.supportedFilesystems = [ "zfs" "btrfs" ];
+
   # Allow the user to log in as root without a password.
   security.initialRootPassword = "";
 }

nixos/modules/installer/cd-dvd/installation-cd-graphical.nix

···
   # Provide wicd for easy wireless configuration.
   #networking.wicd.enable = true;
 
+  # Include gparted for partitioning disks
+  environment.systemPackages = [ pkgs.gparted ];
+  
   # KDE complains if power management is disabled (to be precise, if
   # there is no power management backend such as upower).
   powerManagement.enable = true;
···
       AutoLoginUser=root
       AutoLoginPass=""
     '';
+
+  # Custom kde-workspace adding some icons on the desktop
+
+  system.activationScripts.installerDesktop = let
+    openManual = pkgs.writeScript "nixos-manual.sh" ''
+      #!${pkgs.stdenv.shell}
+      cd ${config.system.build.manual.manual}/share/doc/nixos/
+      konqueror ./index.html
+    '';
+
+    desktopFile = pkgs.writeText "nixos-manual.desktop" ''
+      [Desktop Entry]
+      Version=1.0
+      Type=Application
+      Name=NixOS Manual
+      Exec=${openManual}
+      Icon=konqueror
+    '';
+
+  in ''
+    mkdir -p /root/Desktop
+    ln -sfT ${desktopFile} /root/Desktop/nixos-manual.desktop
+    ln -sfT ${pkgs.kde4.konsole}/share/applications/kde4/konsole.desktop /root/Desktop/konsole.desktop
+    ln -sfT ${pkgs.gparted}/share/applications/gparted.desktop /root/Desktop/gparted.desktop
+  '';
+
+  services.xserver.desktopManager.kde4.kdeWorkspacePackage = let
+    pkg = pkgs.kde4.kde_workspace;
+
+    plasmaInit = pkgs.writeText "00-defaultLayout.js" ''
+      loadTemplate("org.kde.plasma-desktop.defaultPanel")
+
+      for (var i = 0; i < screenCount; ++i) {
+      	var desktop = new Activity
+        desktop.name = i18n("Desktop")
+        desktop.screen = i
+        desktop.wallpaperPlugin = 'image'
+        desktop.wallpaperMode = 'SingleImage'
+
+        var folderview = desktop.addWidget("folderview");
+        folderview.writeConfig("url", "desktop:/");
+        
+        //Create more panels for other screens
+        if (i > 0){
+          var panel = new Panel
+          panel.screen = i
+          panel.location = 'bottom'
+          panel.height = screenGeometry(i).height > 1024 ? 35 : 27
+          var tasks = panel.addWidget("tasks")
+          tasks.writeConfig("showOnlyCurrentScreen", true);
+        }
+      }
+    '';
+
+  in
+    pkgs.stdenv.mkDerivation {
+      inherit (pkg) name meta;
+
+      buildCommand = ''
+        mkdir -p $out
+        cp -prf ${pkg}/* $out/
+        chmod a+w $out/share/apps/plasma-desktop/init
+        cp -f ${plasmaInit} $out/share/apps/plasma-desktop/init/00-defaultLayout.js
+      '';
+    };
+
 }

nixos/modules/rename.nix

···
 ++ obsolete' [ "programs" "bash" "enable" ]
 ++ obsolete' [ "services" "samba" "defaultShare" ]
 ++ obsolete' [ "services" "syslog-ng" "serviceName" ]
+++ obsolete' [ "services" "syslog-ng" "listenToJournal" ]
 
 )

nixos/modules/services/backup/rsnapshot.nix

···
           as retain options.
         '';
       };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.rsnapshot;
+        example = literalExample "pkgs.rsnapshotGit";
+        description = ''
+          RSnapshot package to use.
+        '';
+      };
     };
   };
 
   config = mkIf cfg.enable (let
-    myRsnapshot = pkgs.rsnapshot.override { configFile = rsnapshotCfg; };
+    myRsnapshot = cfg.package.override { configFile = rsnapshotCfg; };
     rsnapshotCfg = with pkgs; writeText "gen-rsnapshot.conf" (''
         config_version	1.2
         cmd_cp	${coreutils}/bin/cp

nixos/modules/services/logging/logstash.nix

···
   pluginPath = lib.concatStringsSep ":" cfg.plugins;
   havePluginPath = lib.length cfg.plugins > 0;
   ops = lib.optionalString;
+  verbosityFlag = {
+    debug = "--debug";
+    info  = "--verbose";
+    warn  = ""; # intentionally empty
+    error = "--quiet";
+    fatal = "--silent";
+  }."${cfg.logLevel}";
 
 in
 
···
         default = [ ];
         example = literalExample "[ pkgs.logstash-contrib ]";
         description = "The paths to find other logstash plugins in.";
+      };
+
+      logLevel = mkOption {
+        type = types.enum [ "debug" "info" "warn" "error" "fatal" ];
+        default = "warn";
+        description = "Logging verbosity level.";
       };
 
       watchdogTimeout = mkOption {
···
           "${cfg.package}/bin/logstash agent " +
           "-w ${toString cfg.filterWorkers} " +
           ops havePluginPath "--pluginpath ${pluginPath} " +
+          "${verbosityFlag} " +
           "--watchdog-timeout ${toString cfg.watchdogTimeout} " +
           "-f ${writeText "logstash.conf" ''
             input {

nixos/modules/services/logging/syslog-ng.nix

···
           The package providing syslog-ng binaries.
         '';
       };
-      listenToJournal = mkOption {
-        type = types.bool;
-        default = true;
-        description = ''
-          Whether syslog-ng should listen to the syslog socket used
-          by journald, and therefore receive all logs that journald
-          produces.
-        '';
-      };
       extraModulePaths = mkOption {
         type = types.listOf types.str;
         default = [];
···
       configHeader = mkOption {
         type = types.lines;
         default = ''
-          @version: 3.5
+          @version: 3.6
           @include "scl.conf"
         '';
         description = ''
···
   };
 
   config = mkIf cfg.enable {
-    systemd.sockets.syslog = mkIf cfg.listenToJournal {
-      wantedBy = [ "sockets.target" ];
-      socketConfig.Service = "syslog-ng.service";
-    };
     systemd.services.syslog-ng = {
       description = "syslog-ng daemon";
       preStart = "mkdir -p /{var,run}/syslog-ng";
-      wantedBy = optional (!cfg.listenToJournal) "multi-user.target";
+      wantedBy = [ "multi-user.target" ];
       after = [ "multi-user.target" ]; # makes sure hostname etc is set
       serviceConfig = {
         Type = "notify";
-        Sockets = if cfg.listenToJournal then "syslog.socket" else null;
         StandardOutput = "null";
         Restart = "on-failure";
         ExecStart = "${cfg.package}/sbin/syslog-ng ${concatStringsSep " " syslogngOptions}";

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

···
   xcfg = config.services.xserver;
   cfg = xcfg.desktopManager.kde4;
   xorg = pkgs.xorg;
+  kde_workspace = config.services.xserver.desktopManager.kde4.kdeWorkspacePackage;
 
   # Disable Nepomuk and Strigi by default.  As of KDE 4.7, they don't
   # really work very well (e.g. searching files often fails to find
···
         example = ["gstreamer" "vlc"];
         description = "Which phonon multimedia backend kde should use";
       };
+
+      kdeWorkspacePackage = mkOption {
+        internal = true;
+        default = pkgs.kde4.kde_workspace;
+        type = types.package;
+        description = "Custom kde-workspace, used for NixOS rebranding.";
+      };
     };
 
     environment.kdePackages = mkOption {
···
             fi
 
             # Start KDE.
-            exec ${pkgs.kde4.kdebase_workspace}/bin/startkde
+            exec ${kde_workspace}/bin/startkde
           '';
       };
 
     security.setuidOwners = singleton
       { program = "kcheckpass";
-        source = "${pkgs.kde4.kdebase_workspace}/lib/kde4/libexec/kcheckpass";
+        source = "${kde_workspace}/lib/kde4/libexec/kcheckpass";
         owner = "root";
         group = "root";
         setuid = true;
···
         [ pkgs.kde4.kdelibs
 
           pkgs.kde4.kde_baseapps # Splitted kdebase
-          pkgs.kde4.kde_workspace
+          kde_workspace
           pkgs.kde4.kde_runtime
           pkgs.kde4.konsole
           pkgs.kde4.kate

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

···
       # Start PulseAudio if enabled.
       ${optionalString (config.hardware.pulseaudio.enable) ''
         ${optionalString (!config.hardware.pulseaudio.systemWide)
-          "${pkgs.pulseaudio}/bin/pulseaudio --start"
+          "${config.hardware.pulseaudio.package}/bin/pulseaudio --start"
         }
 
         # Publish access credentials in the root window.
-        ${pkgs.pulseaudio}/bin/pactl load-module module-x11-publish "display=$DISPLAY"
+        ${config.hardware.pulseaudio.package}/bin/pactl load-module module-x11-publish "display=$DISPLAY"
 
         # Keep track of devices.  Mostly useful for Phonon/KDE.
-        ${pkgs.pulseaudio}/bin/pactl load-module module-device-manager "do_routing=1"
+        ${config.hardware.pulseaudio.package}/bin/pactl load-module module-device-manager "do_routing=1"
       ''}
 
       # Load X defaults.

nixos/modules/services/x11/hardware/synaptics.nix

···
     services.xserver.synaptics = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         example = true;
         description = "Whether to enable touchpad support.";
       };
 
       dev = mkOption {
+        type = types.nullOr types.str;
         default = null;
         example = "/dev/input/event0";
         description =
···
       };
 
       twoFingerScroll = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable two-finger drag-scrolling.";
       };
 
       vertEdgeScroll = mkOption {
+        type = types.bool;
         default = ! cfg.twoFingerScroll;
         description = "Whether to enable vertical edge drag-scrolling.";
       };
 
       tapButtons = mkOption {
+        type = types.bool;
         default = true;
         example = false;
         description = "Whether to enable tap buttons.";
       };
 
       buttonsMap = mkOption {
+        type = types.listOf types.int;
         default = [1 2 3];
         example = [1 3 2];
         description = "Remap touchpad buttons.";
         apply = map toString;
       };
 
+      fingersMap = mkOption {
+        type = types.listOf types.int;
+        default = [1 2 3];
+        example = [1 3 2];
+        description = "Remap several-fingers taps.";
+        apply = map toString;
+      };
+
       palmDetect = mkOption {
+        type = types.bool;
         default = false;
         example = true;
         description = "Whether to enable palm detection (hardware support required)";
       };
 
       horizontalScroll = mkOption {
+        type = types.bool;
         default = true;
         example = false;
         description = "Whether to enable horizontal scrolling (on touchpad)";
       };
 
       additionalOptions = mkOption {
+        type = types.str;
         default = "";
         example = ''
           Option "RTCornerButton" "2"
···
           Option "ClickFinger1" "${builtins.elemAt cfg.buttonsMap 0}"
           Option "ClickFinger2" "${builtins.elemAt cfg.buttonsMap 1}"
           Option "ClickFinger3" "${builtins.elemAt cfg.buttonsMap 2}"
+          Option "TapButton1" "${builtins.elemAt cfg.fingersMap 0}"
+          Option "TapButton2" "${builtins.elemAt cfg.fingersMap 1}"
+          Option "TapButton3" "${builtins.elemAt cfg.fingersMap 2}"
           Option "VertTwoFingerScroll" "${if cfg.twoFingerScroll then "1" else "0"}"
           Option "HorizTwoFingerScroll" "${if cfg.twoFingerScroll then "1" else "0"}"
           Option "VertEdgeScroll" "${if cfg.vertEdgeScroll then "1" else "0"}"

nixos/release-small.nix

···
       mysql51
       mysql55
       nginx
+      nodejs
       openjdk
       openssh
       php

pkgs/applications/audio/cantata/default.nix

···
 assert withReplaygain -> withTaglib;
 
 let
-  version = "1.4.2";
+  version = "1.5.0";
   pname = "cantata";
   fstat = x: fn: "-DENABLE_" + fn + "=" + (if x then "ON" else "OFF");
   fstats = x: map (fstat x);
···
 
   src = fetchurl {
     inherit name;
-    url = "https://drive.google.com/uc?export=download&id=0Bzghs6gQWi60UDFOeU1qSkIzaVE";
-    sha256 = "0ycwx75f1jlsaca170bz82av06bnlknl3q0df001rhmhb7wh4j6c";
+    url = "https://drive.google.com/uc?export=download&id=0Bzghs6gQWi60c0pFbEtldEk1UnM";
+    sha256 = "0gnqfp3ps79d500hrivxj2xkkia042knhg86md6w8ycl3945611p";
   };
 
   buildInputs =

pkgs/applications/audio/chuck/darwin-limits.patch

···
+--- a/src/util_string.cpp	2014-10-27 22:52:11.875981552 +0100
++++ b/src/util_string.cpp	2014-10-27 22:54:18.613001994 +0100
+@@ -40,6 +40,10 @@
+ #include <linux/limits.h>
+ #endif // __PLATFORM_LINUX__
+ 
++#ifdef __PLATFORM_MACOSX__
++#include <limits.h>
++#endif // __PLATFORM_MACOSX__
++
+ #include <stdio.h>
+ using namespace std;
+ 

pkgs/applications/audio/chuck/default.nix

···
+{ stdenv, fetchurl, alsaLib, bison, flex, libsndfile, which }:
+
+stdenv.mkDerivation rec {
+  version = "1.3.4.0";
+  name = "chuck-${version}";
+
+  src = fetchurl {
+    url = "http://chuck.cs.princeton.edu/release/files/chuck-${version}.tgz";
+    sha256 = "0cwbk8b1i18nkh2nxwzk2prranw83lgglxw7ccnp6b0r2b2yfpmn";
+  };
+
+  buildInputs = [ bison flex libsndfile which ]
+    ++ stdenv.lib.optional (!stdenv.isDarwin) alsaLib;
+
+  patches = [ ./darwin-limits.patch ];
+
+  postPatch = ''
+    substituteInPlace src/makefile --replace "/usr/bin" "$out/bin"
+    substituteInPlace src/makefile.osx --replace "xcodebuild" "/usr/bin/xcodebuild"
+    substituteInPlace src/makefile.osx --replace "weak_framework" "framework"
+  '';
+
+  buildPhase =
+    stdenv.lib.optionals stdenv.isLinux  ["make -C src linux-alsa"] ++
+    stdenv.lib.optionals stdenv.isDarwin ["make -C src osx"];
+
+  installPhase = ''
+    install -Dm755 ./src/chuck $out/bin/chuck
+  '';
+
+  meta = {
+    description = "Programming language for real-time sound synthesis and music creation";
+    homepage = http://chuck.cs.princeton.edu;
+    license = stdenv.lib.licenses.gpl2;
+    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    maintainers = with stdenv.lib.maintainers; [ ftrvxmtrx ];
+  };
+}

pkgs/applications/audio/gmpc/default.nix

···
 { stdenv, fetchurl, libtool, intltool, pkgconfig, glib
 , gtk, curl, mpd_clientlib, libsoup, gob2, vala, libunique
+, libSM, libICE
 }:
 
 stdenv.mkDerivation rec {
···
 
   buildInputs = [
     libtool intltool pkgconfig glib gtk curl mpd_clientlib libsoup
-    libunique libmpd gob2 vala
+    libunique libmpd gob2 vala libSM libICE
   ];
 
   meta = with stdenv.lib; {

pkgs/applications/audio/hydrogen/default.nix

···
 , liblrdf, libsndfile, pkgconfig, qt4 }:
 
 stdenv.mkDerivation rec {
-  version = "0.9.6";
+  version = "0.9.6.1";
   name = "hydrogen-${version}";
 
   src = fetchurl {
     url = "https://github.com/hydrogen-music/hydrogen/archive/${version}.tar.gz";
-    sha256 = "1z7j8aq158mp41iv78j0w6fyx98y1y51z592b4x5hkvicabgck5w";
+    sha256 = "0vxnaqfmcv7hhk0cj67imdcqngspnck7f0wfmvhfgfqa7x1xznll";
   };
 
   buildInputs = [ 

pkgs/applications/audio/qjackctl/default.nix

···
 { stdenv, fetchurl, qt4, alsaLib, jack2, dbus }:
 
 stdenv.mkDerivation rec {
-  version = "0.3.11";
+  version = "0.3.12";
   name = "qjackctl-${version}";
 
   # some dependencies such as killall have to be installed additionally
 
   src = fetchurl {
     url = "mirror://sourceforge/qjackctl/${name}.tar.gz";
-    sha256 = "1wjzrgx3n2asyxk6cnfcm34msaw84qvsqy08bd4qnghrgpl96hwl";
+    sha256 = "14yvnc4k3hwsjflg8b2d04bc63pdl0gyqjc7vl6rdn29nbr23zwc";
   };
 
   buildInputs = [ qt4 alsaLib jack2 dbus ];

pkgs/applications/editors/atom/default.nix

···
   };
 in stdenv.mkDerivation rec {
   name = "atom-${version}";
-  version = "0.135.0";
+  version = "0.139.0";
 
   src = fetchurl {
     url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "0dh8vjhr31y2ibnf4s7adskbx115w8ns9xgrb0md9xc9gm92h405";
+    sha256 = "0732s4r9qx0sgsnz415z5r9685scly2084q80kz2xw0d2gfx04xr";
     name = "${name}.deb";
   };
 

pkgs/applications/editors/bvi/default.nix

···
 { stdenv, fetchurl, ncurses }:
 
-stdenv.mkDerivation {
-  name = "bvi-1.3.2";
+stdenv.mkDerivation rec {
+  name = "bvi-${version}";
+  version = "1.4.0";
 
   src = fetchurl {
-    url = mirror://sourceforge/bvi/bvi-1.3.2.src.tar.gz;
-    sha256 = "110wxqnyianqamxq4y53drqqxb9vp4k2fcvic45qggvlqkqhlfgz";
+    url = "mirror://sourceforge/bvi/${name}.src.tar.gz";
+    sha256 = "00pq9rv7s8inqxq2m3xshxi58691i3pxw9smibcrgh6768l3qnh1";
   };
 
   buildInputs = [ ncurses ];
 
-  meta = { 
+  meta = with stdenv.lib; {
     description = "Hex editor with vim style keybindings";
     homepage = http://bvi.sourceforge.net/download.html;
-    license = stdenv.lib.licenses.gpl2;
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ pSub ];
+    platforms = platforms.linux;
   };
 }

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

···
         [ "--with-x-toolkit=lucid" "--with-xft" ]
       else
         [ "--with-x=no" "--with-xpm=no" "--with-jpeg=no" "--with-png=no"
-          "--with-gif=no" "--with-tiff=no" ] ) )
-    # On NixOS, help Emacs find `crt*.o'.
-    ++ stdenv.lib.optional (stdenv ? glibc)
-         [ "--with-crt-dir=${stdenv.glibc}/lib" ];
+          "--with-gif=no" "--with-tiff=no" ] ) );
 
   NIX_CFLAGS_COMPILE = stdenv.lib.optionalString (stdenv.isDarwin && withX)
     "-I${cairo}/include/cairo";

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

···
+{ stdenv, fetchurl, emacs }:
+
+# this package installs the emacs-mode which
+# resides in the hsc3 sources.
+
+let version = "0.15";
+
+in stdenv.mkDerivation {
+  name = "hsc3-mode-${version}";
+  src = fetchurl {
+    url = http://hackage.haskell.org/package/hsc3-0.15/hsc3-0.15.tar.gz;
+    sha256 = "2f3b15655419cf8ebe25ab1c6ec22993b2589b4ffca7c3a75ce478ca78a0bde6";
+  }; 
+
+  buildInputs = [ emacs ];
+
+  installPhase = ''
+    mkdir -p "$out/share/emacs/site-lisp"
+    cp "emacs/hsc3.el" "$out/share/emacs/site-lisp"
+  '';
+
+  meta = {
+    homepage = http://rd.slavepianos.org/?t=hsc3;
+    description = "hsc3 mode package for Emacs";
+    platforms = stdenv.lib.platforms.unix;
+  };
+}

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

···
 , texLiveAggregationFun }:
 
 stdenv.mkDerivation rec {
-  name = "org-8.2.8";
+  name = "org-8.2.10";
 
   src = fetchurl {
     url = "http://orgmode.org/${name}.tar.gz";
-    sha256 = "0f63w6d1yjiv46ac7d9rqn2wks6sxmldrqmijd9j25qvsc8dcsd8";
+    sha256 = "1xm8n8zwr3676rl4pd32k61rd7rimlihhrw5a7r4z7r154c4a2fz";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/editors/idea/default.nix

···
 let
 
   mkIdeaProduct =
-  { name, product, version, build, src, meta }:
+  { name, product, version, build, src, meta, patchSnappy ? true }:
 
   let loName = stdenv.lib.toLower product;
       hiName = stdenv.lib.toUpper product; in
···
 
     buildInputs = [ makeWrapper patchelf p7zip unzip ];
 
-    patchPhase = ''
-
-      get_file_size() {
+    patchPhase = lib.concatStringsSep "\n" [
+      ''
+        get_file_size() {
           local fname="$1"
           echo $(ls -l $fname | cut -d ' ' -f5)
-      }
+        }
 
-      munge_size_hack() {
+        munge_size_hack() {
           local fname="$1"
           local size="$2"
           strip $fname
           truncate --size=$size $fname
-      }
+        }
 
-      interpreter=$(echo ${stdenv.glibc}/lib/ld-linux*.so.2)
-      snappyPath="lib/snappy-java-1.0.5"
+        interpreter=$(echo ${stdenv.glibc}/lib/ld-linux*.so.2)
+        if [ "${stdenv.system}" == "x86_64-linux" ]; then
+          target_size=$(get_file_size bin/fsnotifier64)
+          patchelf --set-interpreter "$interpreter" bin/fsnotifier64
+          munge_size_hack bin/fsnotifier64 $target_size
+        else
+          target_size=$(get_file_size bin/fsnotifier)
+          patchelf --set-interpreter "$interpreter" bin/fsnotifier
+          munge_size_hack bin/fsnotifier $target_size
+        fi
+      ''
 
-      7z x -o"$snappyPath" "$snappyPath.jar"
-      if [ "${stdenv.system}" == "x86_64-linux" ]; then
-        target_size=$(get_file_size bin/fsnotifier64)
-        patchelf --set-interpreter "$interpreter" bin/fsnotifier64
-        patchelf --set-rpath ${stdenv.gcc.gcc}/lib64/ "$snappyPath/org/xerial/snappy/native/Linux/amd64/libsnappyjava.so"
-        munge_size_hack bin/fsnotifier64 $target_size
-      else
-        target_size=$(get_file_size bin/fsnotifier)
-        patchelf --set-interpreter "$interpreter" bin/fsnotifier
-        patchelf --set-rpath ${stdenv.gcc.gcc}/lib/ "$snappyPath/org/xerial/snappy/native/Linux/i386/libsnappyjava.so"
-        munge_size_hack bin/fsnotifier $target_size
-      fi
-      7z a -tzip "$snappyPath.jar" ./"$snappyPath"/*
-      rm -vr "$snappyPath"
-    '';
+      (lib.optionalString patchSnappy ''
+        snappyPath="lib/snappy-java-1.0.5"
+        7z x -o"$snappyPath" "$snappyPath.jar"
+        if [ "${stdenv.system}" == "x86_64-linux" ]; then
+          patchelf --set-rpath ${stdenv.gcc.gcc}/lib64 "$snappyPath/org/xerial/snappy/native/Linux/amd64/libsnappyjava.so"
+        else
+          patchelf --set-rpath ${stdenv.gcc.gcc}/lib "$snappyPath/org/xerial/snappy/native/Linux/i386/libsnappyjava.so"
+        fi
+        7z a -tzip "$snappyPath.jar" ./"$snappyPath"/*
+        rm -vr "$snappyPath"
+      '')
+    ];
 
     installPhase = ''
       mkdir -vp "$out/bin" "$out/$name" "$out/share/pixmaps"
···
       [ -d ${jdk}/lib/openjdk ] \
         && jdk=${jdk}/lib/openjdk \
         || jdk=${jdk}
+
+      if [ "${stdenv.system}" == "x86_64-linux" ]; then
+        makeWrapper "$out/$name/bin/fsnotifier64" "$out/bin/fsnotifier64"
+      else
+        makeWrapper "$out/$name/bin/fsnotifier" "$out/bin/fsnotifier"
+      fi
 
       makeWrapper "$out/$name/bin/${loName}.sh" "$out/bin/${loName}" \
         --prefix PATH : "${jdk}/bin:${coreutils}/bin:${gnugrep}/bin:${which}/bin:${git}/bin" \
···
       };
     });
 
+  buildPhpStorm = { name, version, build, src, license, description }:
+    (mkIdeaProduct {
+      inherit name version build src;
+      product = "PhpStorm";
+      patchSnappy = false;
+      meta = with stdenv.lib; {
+        homepage = "https://www.jetbrains.com/phpstorm/";
+        inherit description license;
+        longDescription = ''
+          PhpStorm provides an editor for PHP, HTML and JavaScript
+          with on-the-fly code analysis, error prevention and
+          automated refactorings for PHP and JavaScript code.
+        '';
+        maintainers = with maintainers; [ schristo ];
+        platforms = platforms.linux;
+      };
+    });
+
 in
 
 {
···
     src = fetchurl {
       url = "http://download.jetbrains.com/python/${name}.tar.gz";
       sha256 = "e4f85f3248e8985ac9f8c326543f979b47ba1d7ac6b128a2cf2b3eb8ec545d2b";
+    };
+  };
+
+  phpstorm = buildPhpStorm rec {
+    name = "phpstorm-${version}";
+    version = "8.0.1";
+    build = "PS-138.2001";
+    description = "Professional IDE for Web and PHP developers";
+    license = stdenv.lib.licenses.unfree;
+    src = fetchurl {
+      url = "http://download.jetbrains.com/webide/PhpStorm-${version}.tar.gz";
+      sha256 = "0d46442aa32174fe16846c3c31428178ab69b827d2e0ce31f633f13b64c01afc";
     };
   };
 

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

···
 
   postInstall = ''
     makeWrapper ${yi}/bin/yi $out/bin/yi \
-      --prefix PATH : ${wrappedGhc}/bin \
-      --suffix GHC_PACKAGE_PATH : $(find ${wrappedGhc} -name '*installedconf' | tr \\n :)
+      --set NIX_GHC ${wrappedGhc}/bin/ghc \
+      --set NIX_GHC_LIBDIR ${wrappedGhc}/lib/ghc-${self.ghc.version}
   '';
   meta = {
     homepage = "http://haskell.org/haskellwiki/Yi";

pkgs/applications/editors/yi/yi.nix

···
 
 cabal.mkDerivation (self: {
   pname = "yi";
-  version = "0.10.1";
-  sha256 = "1vj4ndp43w7xlji4p2px79a8g90p64g54sr3hx4pzimwrlpmifk8";
+  version = "0.11.0";
+  sha256 = "1da5wnqx1z8d809dydqr97jh8n5g9phh06lvkgc32hib2rybh5yx";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/applications/misc/calibre/default.nix

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

pkgs/applications/misc/doomseeker/default.nix

···
+{ stdenv, cmake, fetchurl, pkgconfig, qt4, zlib, bzip2 }:
+
+stdenv.mkDerivation rec {
+  name = "doomseeker-0.12.1b";
+  src = fetchurl {
+    url = "http://doomseeker.drdteam.org/files/${name}_src.tar.bz2";
+    sha256 = "110yg3w3y1x8p4gqpxb6djxw348caj50q5liq8ssb5mf78v8gk6b";
+  };
+
+  cmakeFlags = ''
+    -DCMAKE_BUILD_TYPE=Release
+  '';
+
+  buildInputs = [ cmake pkgconfig qt4 zlib bzip2 ];
+
+  enableParallelBuilding = true;
+
+  patchPhase = ''
+    sed -e 's#/usr/share/applications#$out/share/applications#' -i src/core/CMakeLists.txt
+  '';
+
+  meta = {
+    homepage = http://doomseeker.drdteam.org/;
+    description = "Multiplayer server browser for many Doom source ports";
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = with stdenv.lib.maintainers; [ MP2E ];
+  };
+}
+

pkgs/applications/misc/rtl-sdr/default.nix

···
 
   buildInputs = [ cmake pkgconfig libusb1 ];
 
-  # Building with -DINSTALL_UDEV_RULES=ON tries to install udev rules to
-  # /etc/udev/rules.d/, and there is no option to install elsewhere. So install
-  # rules manually.
+  # TODO: get these fixes upstream:
+  # * Building with -DINSTALL_UDEV_RULES=ON tries to install udev rules to
+  #   /etc/udev/rules.d/, and there is no option to install elsewhere. So install
+  #   rules manually.
+  # * Propagate libusb-1.0 dependency in pkg-config file.
   postInstall = ''
     mkdir -p "$out/etc/udev/rules.d/"
     cp ../rtl-sdr.rules "$out/etc/udev/rules.d/99-rtl-sdr.rules"
+
+    pcfile="$out"/lib/pkgconfig/librtlsdr.pc
+    grep -q "Requires:" "$pcfile" && { echo "Upstream has added 'Requires:' in $(basename "$pcfile"); update nix expression."; exit 1; }
+    echo "Requires: libusb-1.0" >> "$pcfile"
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/misc/taskwarrior/default.nix

···
-{ stdenv, fetchurl, cmake, libuuid }:
+{ stdenv, fetchurl, cmake, libuuid, gnutls }:
 
 stdenv.mkDerivation rec {
   name = "taskwarrior-${version}";
···
     sha256 = "0wxcfq0n96vmcbwrlk2x377k8cc5k4i64ca6p02y74g6168ji6ib";
   };
 
-  nativeBuildInputs = [ cmake libuuid ];
+  nativeBuildInputs = [ cmake libuuid gnutls ];
 
   meta = {
     description = "GTD (getting things done) implementation";

pkgs/applications/misc/termite/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "termite-${version}";
-  version = "v7";
+  version = "v8";
 
   src = fetchgit {
     url = "https://github.com/thestinger/termite";
-    rev = "f0ff025c1bb6a1e3fd83072f00c2dc42a0701f46";
-    sha256 = "057yzlqvp84fkmhn4bz9071glj4rh4187xhg48cdppf2w6phcbxp";
+    rev = "7f03ded7308ad0e26b72b150080e4f3e70401815";
+    sha256 = "1yj4jvjwv73a02p8a0yip8q39znlhfc9zdr19zm1zik2k4h62c2l";
   };
 
-  makeFlags = "VERSION=${version}";
+  makeFlags = "VERSION=v${version}";
 
   buildInputs = [pkgconfig vte gtk ncurses];
 

pkgs/applications/networking/bittorrentsync/default.nix

···
     else if stdenv.system == "i686-linux" then "i386"
     else throw "Bittorrent Sync for: ${stdenv.system} not supported!";
 
-  sha256 = if stdenv.system == "x86_64-linux" then "115xsbi5z8ll0z07vx4rzzsgr6qba43f3z3nzx33pva5dpdr3ci9"
-    else if stdenv.system == "i686-linux" then "110k6cq6l3nr1gak2ri6i1kwis78r3zc1ilbipgcccdczf9fnx7p"
+  sha256 = if stdenv.system == "x86_64-linux" then "c4b100bbf8cda0334e20793e02bf400d15266cb9d089917bd2b6b9d49dd37d19"
+    else if stdenv.system == "i686-linux" then "5760471fcea396efd158758aa350b1c48a9d0633765a5e3b059baf8aeab615fa"
     else throw "Bittorrent Sync for: ${stdenv.system} not supported!";
 
   libPath = stdenv.lib.makeLibraryPath [ stdenv.gcc.libc ];
 in
 stdenv.mkDerivation rec {
   name = "btsync-${version}";
-  version = "1.4.82";
+  version = "1.4.93";
 
   src  = fetchurl {
     url  = "http://syncapp.bittorrent.com/${version}/btsync_${arch}-${version}.tar.gz";

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

···
 
 assert stdenv.gcc ? libc && stdenv.gcc.libc != null;
 
-let version = "33.0"; in
+let version = "33.0.1"; in
 
 stdenv.mkDerivation rec {
   name = "firefox-${version}";
 
   src = fetchurl {
     url = "http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/${version}/source/firefox-${version}.source.tar.bz2";
-    sha1 = "ad10e8fefcd9687d2b67bacafa4ecb5f5ca4af66";
+    sha1 = "09b9ca1f6af1e0ff8716d559ccf55801ae1a8f2d";
   };
 
   buildInputs =

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

···
-/**
- * Possible missing configuration:
- *
- * - silcclient
- * - libebook-1.2
- * - libedata-book-1.2
- * - checking for XScreenSaverRegister in -lXext... no
- * - checking for XScreenSaverRegister in -lXss... no
- * - ao
- * - audiofile-config
- * - doxygen
- */
-{ stdenv, fetchurl, pkgconfig, gtk, gtkspell, aspell,
-  gstreamer, gst_plugins_base, startupnotification, gettext,
-  perl, perlXMLParser, libxml2, nss, nspr, farsight2,
-  libXScrnSaver, ncurses, avahi, dbus, dbus_glib, intltool, libidn
-  , lib, python
-  , openssl ? null
-  , gnutls ? null
-  , libgcrypt ? null
-} :
+{ stdenv, fetchurl, pkgconfig, gtk, gtkspell, aspell
+, gstreamer, gst_plugins_base, startupnotification, gettext
+, perl, perlXMLParser, libxml2, nss, nspr, farsight2
+, libXScrnSaver, ncurses, avahi, dbus, dbus_glib, intltool, libidn
+, lib, python, libICE, libXext, libSM
+, openssl ? null
+, gnutls ? null
+, libgcrypt ? null
+}:
 
 # FIXME: clean the mess around choosing the SSL library (nss by default)
 
 stdenv.mkDerivation rec {
-  majorVersion = "2";
-  name = "pidgin-${majorVersion}.10.10";
+  name = "pidgin-${version}";
+  version = "2.10.10";
+
   src = fetchurl {
     url = "mirror://sourceforge/pidgin/${name}.tar.bz2";
     sha256 = "0bc2bk2g3w90mpz9sn9j95c71z4i2i3wxaqa2zpmmixf5r8rasyw";
   };
 
   inherit nss ncurses;
+
   buildInputs = [
     gtkspell aspell
     gstreamer gst_plugins_base startupnotification
-    libxml2] 
-  ++ (lib.optional (openssl != null) openssl)
-  ++ (lib.optional (gnutls != null) gnutls)
-  ++ (lib.optional (libgcrypt != null) libgcrypt)
-  ++
-  [nss nspr farsight2
+    libxml2 nss nspr farsight2
     libXScrnSaver ncurses python
     avahi dbus dbus_glib intltool libidn
+    libICE libXext libSM
   ]
-  ;
+  ++ (lib.optional (openssl != null) openssl)
+  ++ (lib.optional (gnutls != null) gnutls)
+  ++ (lib.optional (libgcrypt != null) libgcrypt);
 
   propagatedBuildInputs = [
     pkgconfig gtk perl perlXMLParser gettext
···
 
   patches = [./pidgin-makefile.patch ./add-search-path.patch ];
 
-  configureFlags="--with-nspr-includes=${nspr}/include/nspr --with-nspr-libs=${nspr}/lib --with-nss-includes=${nss}/include/nss --with-nss-libs=${nss}/lib --with-ncurses-headers=${ncurses}/include --disable-meanwhile --disable-nm --disable-tcl"
-  + (lib.optionalString (gnutls != null) " --enable-gnutls=yes --enable-nss=no")
-  ;
+  configureFlags = [
+    "--with-nspr-includes=${nspr}/include/nspr"
+    "--with-nspr-libs=${nspr}/lib"
+    "--with-nss-includes=${nss}/include/nss"
+    "--with-nss-libs=${nss}/lib"
+    "--with-ncurses-headers=${ncurses}/include"
+    "--disable-meanwhile"
+    "--disable-nm"
+    "--disable-tcl"
+  ]
+  ++ (lib.optionals (gnutls != null) ["--enable-gnutls=yes" "--enable-nss=no"]);
+
   meta = with stdenv.lib; {
     description = "Multi-protocol instant messaging client";
     homepage = http://pidgin.im;

pkgs/applications/networking/instant-messengers/pidgin/wrapper.nix

···
 { stdenv, buildEnv, pidgin, makeWrapper, plugins }:
 
 let drv = buildEnv {
-  name = "${pidgin.name}-with-plugins";
+  name = "pidgin-with-plugins-" + (builtins.parseDrvName pidgin.name).version;
 
   paths = [ pidgin ] ++ plugins;
 
···
       done
     fi
     wrapProgram $out/bin/pidgin \
-      --suffix-each PURPLE_PLUGIN_PATH ':' "$out/lib/purple-${pidgin.majorVersion} $out/lib/pidgin"
+      --suffix-each PURPLE_PLUGIN_PATH ':' "$out/lib/purple-${pidgin.version} $out/lib/pidgin"
   '';
   };
-in stdenv.lib.overrideDerivation drv (x : { buildInputs = x.buildInputs ++ [ makeWrapper ]; })
+in stdenv.lib.overrideDerivation drv (x : { buildInputs = x.buildInputs ++ [ makeWrapper ]; })

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

···
 , ssl ? true # enable SSL support
 , previews ? false # enable webpage previews on hovering over URLs
 , tag ? "" # tag added to the package name
-, stdenv, fetchurl, cmake, makeWrapper, qt4, kdelibs, automoc4, phonon, dconf }:
+, stdenv, fetchurl, cmake, makeWrapper, qt, kdelibs, automoc4, phonon, dconf }:
+
+assert monolithic -> !client && !daemon;
+assert client || daemon -> !monolithic;
 
 let
   edf = flag: feature: [("-D" + feature + (if flag then "=ON" else "=OFF"))];
 
 in with stdenv; mkDerivation rec {
 
-  version = "0.10.0";
+  version = "0.11.0";
   name = "quassel${tag}-${version}";
 
   src = fetchurl {
     url = "http://quassel-irc.org/pub/quassel-${version}.tar.bz2";
-    sha256 = "08vwxkwnzlgnxn0wi6ga9fk8qgc6nklb236hsfnr5ad37bi8q8k8";
+    sha256 = "01251y5i1fvm6s2g9acxaczk2jdyw1byr45q41q0yh9apjw938cr";
   };
 
   enableParallelBuilding = true;
 
-  buildInputs = [ cmake makeWrapper qt4 ]
+  buildInputs = [ cmake makeWrapper qt ]
     ++ lib.optional withKDE kdelibs
     ++ lib.optional withKDE automoc4
     ++ lib.optional withKDE phonon;
···
     license = stdenv.lib.licenses.gpl3;
     maintainers = [ maintainers.phreedom ];
     repositories.git = https://github.com/quassel/quassel.git;
-    inherit (qt4.meta) platforms;
+    inherit (qt.meta) platforms;
   };
 }

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

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "notmuch-0.18.1";
+  name = "notmuch-0.18.2";
 
   src = fetchurl {
     url = "http://notmuchmail.org/releases/${name}.tar.gz";
-    sha256 = "1pdp9l7yv71d3fjb30qyccva8h03hvg88q4a00yi50v2j70kvmgj";
+    sha256 = "175wzrw1mfpl4h72n9ims66zn5l34zn2dn857vraj2i5w7z7p7z9";
   };
 
   buildInputs = [ bash emacs gdb glib gmime gnupg pkgconfig talloc xapian ]

pkgs/applications/networking/mailreaders/thunderbird-bin/default.nix

···
 assert stdenv.isLinux;
 
 let
-  version = "31.1.2";
+  version = "31.2.0";
   sources = [
-    { locale = "id"; arch = "linux-i686"; sha256 = "210f0037279ec373d5d189a8724962fec3237900c343ca93d2421ca93a35f201"; }
-    { locale = "id"; arch = "linux-x86_64"; sha256 = "7436275f73a1292567cc587bd41439ecb724fac5e092f0b0f2af932bf39805f7"; }
-    { locale = "he"; arch = "linux-i686"; sha256 = "14b878d70f96e60e3a73134c3cbb35cc6d468446b588510ae5f2e8934d8fbb3b"; }
-    { locale = "he"; arch = "linux-x86_64"; sha256 = "6edabe4a5bf81274cb117bdf7ec7d0b89f3759b9f31e1b9e03c0c603cda2e91f"; }
-    { locale = "el"; arch = "linux-i686"; sha256 = "9f65b45570f83d41b856f99b3077e6e112fa65b3762eb51277269fdbf07cfdb2"; }
-    { locale = "el"; arch = "linux-x86_64"; sha256 = "6a500164772c004d851f13d77a7a9b84428b5c372fdba6f0936c1ddd398d9087"; }
-    { locale = "tr"; arch = "linux-i686"; sha256 = "fb5f9ab606101cfebe86f64f64b9e46ecd73a704c1a2a993e4b4d68129d84484"; }
-    { locale = "tr"; arch = "linux-x86_64"; sha256 = "54517217aa8cf4d715dd2c7d5cf7c4b96bd5f0add2dda9d9d9412ea10b4210a4"; }
-    { locale = "ast"; arch = "linux-i686"; sha256 = "2ff66a151f4003b5dc0432b43e1038e0c69645c58fc5d6015cab3e493a8ed9a7"; }
-    { locale = "ast"; arch = "linux-x86_64"; sha256 = "e34c892ff3fe761c2707036c5ea3453fe411dca2ad2e474ead7ef0c209558e06"; }
-    { locale = "nl"; arch = "linux-i686"; sha256 = "46154b1fab58e9040e4e67b01ae2c5865b644ccf8f2239c396725bf063eae640"; }
-    { locale = "nl"; arch = "linux-x86_64"; sha256 = "271f169763271582698b8ec23d9ca463b41a7d2b373b56d9c170179e15f0fc34"; }
-    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "2b3f2e9933bcda04abc5785b77630cedcba2d85a73a9d535d895ed7910c97d54"; }
-    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "e4878b6ec24d75cba9e991f6b852ec280992b205bca0e82a2aecfd9a607cdbb4"; }
-    { locale = "eu"; arch = "linux-i686"; sha256 = "b2ff2e8b6c9b7ee81d0965380d15e080c204ffac35b687ca29ca41b51804b491"; }
-    { locale = "eu"; arch = "linux-x86_64"; sha256 = "7afd4c4618f4e7758875ae58295e340289eb994723d3eea13c388751878e0b4e"; }
-    { locale = "fr"; arch = "linux-i686"; sha256 = "41f07408eaec108a28f03917820329c801a386ad3628ebdeb7abd852e579ae72"; }
-    { locale = "fr"; arch = "linux-x86_64"; sha256 = "ea667afbfeba6901a56cc44751d6bf202ef978ce7e39719e56c1fe31a622922b"; }
-    { locale = "br"; arch = "linux-i686"; sha256 = "cea91b552b14e4a417d288d93b4db10b787a1a15316ed7de0b3016be359ddcc5"; }
-    { locale = "br"; arch = "linux-x86_64"; sha256 = "8d72d7cca4885f527a8e8d2b8e2950d0ea0e5d1a840bcde38c08a77e3b6a69a7"; }
-    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "92a28502463e92e6bb9cf7854358c13757222433f9931703a2df4d1ef93bdcbb"; }
-    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "6b61650491252bb441a13b2fa550d9bdd76e6f23a0e5da641fde4372637c451c"; }
-    { locale = "gd"; arch = "linux-i686"; sha256 = "4d35dfe5c9d66ea8f81fa0e5957152296f9af31968b8ed4975563c480abf2da8"; }
-    { locale = "gd"; arch = "linux-x86_64"; sha256 = "3647b5345ac4fa5cc6cd301fefbe538d2442110f93cccb5e8eca4227bcbcd661"; }
-    { locale = "bg"; arch = "linux-i686"; sha256 = "b06afea38900f268b95787c257d960de8c0174f582e51434aa97a9535fac43a4"; }
-    { locale = "bg"; arch = "linux-x86_64"; sha256 = "c4ae2aebdd91543cf3c64ea25931327f6e8d2113b59d0b2fbb19561b4f935134"; }
-    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "854d4c53fd22c5c1f4635ed41e7dadc6f0603439380e3d3f15ea7a5db5721941"; }
-    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "64842c6606e2102434ed0b33bcb53d0cdef08e4b55e67e85b3c1244a7dab32d5"; }
-    { locale = "ja"; arch = "linux-i686"; sha256 = "6632eec0a8bf14a77590fae44113d417589634a97cd0b57ef4ede7623cd5b632"; }
-    { locale = "ja"; arch = "linux-x86_64"; sha256 = "727c25136106eca05d4c0bbddbe01672decc4a9f55b3246290c1c6e41cbef946"; }
-    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "986ae49f92e2bab52cc3a4da4f9ca9bce34c01e96126d4fd9fe41d39d16a8ee3"; }
-    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "c208dc5adb8bbe39535ec28836425d66d557d4ebb111aca9c0d025750ad0d3c4"; }
-    { locale = "is"; arch = "linux-i686"; sha256 = "ee8b101070f820849ec2bde48b76e102cf750bbcee106f47238259bb3cb791bb"; }
-    { locale = "is"; arch = "linux-x86_64"; sha256 = "19471d5e13856f85fc395b825fb297f88805bba5d1d6c2999c49c4947cc6ed43"; }
-    { locale = "es-AR"; arch = "linux-i686"; sha256 = "b21ec0c7e2ee24b971828ae02419f06e3d9447c5e30b1c8257a1d8e1b5ac383e"; }
-    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "6f8eda76fe19bd590e4f8e23e491edc93b870b72064814eb0d6352c99513397f"; }
-    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "217a6b195255c841ff42f181aa4fa54bd76a91de61662098d96c4fb9e7d6b79a"; }
-    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "f11ce6f7ef22cb99674668bfcd0f3614a4a9e162f9608fa1290ae26c6c199560"; }
-    { locale = "sr"; arch = "linux-i686"; sha256 = "85f32820095ee3b50716731b2b369378cf530fd1f3ef3522a5cd55e00fb4ce5e"; }
-    { locale = "sr"; arch = "linux-x86_64"; sha256 = "d67b98991de46de52f84627ccb7f2888551343eef94a5d7562e587fcd8d968ec"; }
-    { locale = "si"; arch = "linux-i686"; sha256 = "14914642dc540c6a0fa0df5816eb35b39b822dac4da58a79d9cfe1c3bf7ed1c0"; }
-    { locale = "si"; arch = "linux-x86_64"; sha256 = "c0421803b2be6704151177c0d13557a9d828e3b3333cd214734e2ed4aafce105"; }
-    { locale = "ro"; arch = "linux-i686"; sha256 = "9226cd799114fcec9c1b53b403708e62ca9f151d43bb53167b822cd3ca779171"; }
-    { locale = "ro"; arch = "linux-x86_64"; sha256 = "05e13ad7c9a53a123c3a50e858285f730a4a5ec95e93074cfda990f4466a1c4f"; }
-    { locale = "it"; arch = "linux-i686"; sha256 = "ed9b4f3bfd457d00792795584bf17bebf4b42967c111cf4f778aa7e88b437407"; }
-    { locale = "it"; arch = "linux-x86_64"; sha256 = "301dbc22a9af014aeb6f151ac1f6ff67ef667dabe31c5e487681f682bf8d567b"; }
-    { locale = "pl"; arch = "linux-i686"; sha256 = "9894e91593b3d825d2572af8c520c8be5dd791a267bb056180dc4415d55f4dc1"; }
-    { locale = "pl"; arch = "linux-x86_64"; sha256 = "0531f815bc4325f150465c753ffe849577931e47eb9528df3b58e666155856f0"; }
-    { locale = "sk"; arch = "linux-i686"; sha256 = "4633afa9f32f6aa1bc91c1ca2e6d1b5622192c9a82fd4c591e0f6a3095ab0baf"; }
-    { locale = "sk"; arch = "linux-x86_64"; sha256 = "2121bd74ce76a0ec1734e3171c8da8ac4d935c99f6c16344639ff7e60de9a860"; }
-    { locale = "vi"; arch = "linux-i686"; sha256 = "d10a856d94c790281500cf1c41683255a858eecc43afaa74819ef2d3559216e9"; }
-    { locale = "vi"; arch = "linux-x86_64"; sha256 = "964343e1ee3209dea0a90dcb1f5371cb0f949b68e059aa23fe80d53747a4699c"; }
-    { locale = "rm"; arch = "linux-i686"; sha256 = "f28ce0029dc5fb3212bd020065c2d453d36db53c98df1806f0e4192ef3d8c5da"; }
-    { locale = "rm"; arch = "linux-x86_64"; sha256 = "fb532732406c8338bfb947e20ee6a95ff1bb18b1d6eadcd7525153393894bdf9"; }
-    { locale = "ar"; arch = "linux-i686"; sha256 = "5e05b156179978920c4c7ed995ef018ddaa6332c5fe1898d94314412d11567b0"; }
-    { locale = "ar"; arch = "linux-x86_64"; sha256 = "acba5a042588731e8b1af0dcc7e075577551969d7c1081c23df6feae7f4d107d"; }
-    { locale = "es-ES"; arch = "linux-i686"; sha256 = "92c6f00a0e014617b5fb53167c821f17f550e8307fcd4af831cde04891f00b40"; }
-    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "191c531621e961b25bf8f16c2aad2ac57357d3456f84fc5efb4f7b7e9becc202"; }
-    { locale = "fi"; arch = "linux-i686"; sha256 = "2f061035a0b6b07bb81d9f84f1bad9a7fd50b0546417fc047102e684683241c5"; }
-    { locale = "fi"; arch = "linux-x86_64"; sha256 = "ee7b57cfbc15104568e12d0cc81a14118c7b0f2708963fbe2ba8ca7a2ce30a0b"; }
-    { locale = "hu"; arch = "linux-i686"; sha256 = "a493b0d327f608a815654a74b22f0ab3237b139998b8720c197468fc624754b6"; }
-    { locale = "hu"; arch = "linux-x86_64"; sha256 = "2b9e87e794e6ac423fd7e6c5500b8a63dc2f8a6a4bdf39de2bbfa5c06a2a8f67"; }
-    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "d272ea7a87f15a649c8d6089b6a5eac91ca732b760163e36ee6634ac2a186313"; }
-    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "2b71cab0bfd437a6c79125cbe0ccb82bc1fe257c6aa24b0b63c1a8456334e6e0"; }
-    { locale = "uk"; arch = "linux-i686"; sha256 = "56a04b6a6a27d9eea98bb5539c927870a3a43aaace14d31faf54dd56b8ef128b"; }
-    { locale = "uk"; arch = "linux-x86_64"; sha256 = "99e33539eff6a48d944f47fc86a98e07ab4395e90e509c050403e70820b11db4"; }
-    { locale = "ko"; arch = "linux-i686"; sha256 = "4c7a67b83db3c15cb8385ec057eff849e59841d2c6e82f6839f76c747c09fd02"; }
-    { locale = "ko"; arch = "linux-x86_64"; sha256 = "5e54ad0316c905a2fc137365e34ba24391ec3a12c638f1947d8048b9747b2a21"; }
-    { locale = "cs"; arch = "linux-i686"; sha256 = "735d14680ba5108d9d422fda161d0cd1cf31ffb2d29d66b33671c58504436290"; }
-    { locale = "cs"; arch = "linux-x86_64"; sha256 = "031b6f8a2f9a14689e91d887754221a972d4c9aa02807209126aa0d26be18b04"; }
-    { locale = "be"; arch = "linux-i686"; sha256 = "604db8cb078699262bf01f81a97bb745bda26efdb7e81bdae66ae5fe9f546c48"; }
-    { locale = "be"; arch = "linux-x86_64"; sha256 = "62a3ed654691720ff2cb2402efb450dcbe395baecd6c20dcba3d45455bfb68d1"; }
-    { locale = "ru"; arch = "linux-i686"; sha256 = "81b2a2eab496824d109faf49b6df93adc9dce838058f3f70c9e9c99ad251baf3"; }
-    { locale = "ru"; arch = "linux-x86_64"; sha256 = "6cdf95dd941475554630709d89fb802e8744bae7645ad9164dc2e8af701d195e"; }
-    { locale = "ta-LK"; arch = "linux-i686"; sha256 = "422f2173eae85a95611ba14a9945aac7b44076764b7c67d2c4198b3e6fe2fad7"; }
-    { locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "d3d3dfc439bcb26cdb8d8f1ef0a9a24e804a6928aa6ac4f9ea2c0994c3e6e2c4"; }
-    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "6d0e3db5748fa2bce8ebc3b51098241ba80971afea629836a37e4f84feeb0c85"; }
-    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "4dd79725f91c163cd5a2073d52f3f599c2e0e95281e8235df0a20c9f8717fa07"; }
-    { locale = "de"; arch = "linux-i686"; sha256 = "7b1fb8c036729ee18507e0c3529cbaf93e8776801fba9bd8c93fa7b56dcf460e"; }
-    { locale = "de"; arch = "linux-x86_64"; sha256 = "926b0ad5e817af337b2f2f7416f98e935b5a6b90171816207275413c04dffb2c"; }
-    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "a0c9e3abe9f3835166237a9ee12dffdc1e3255b59a47e3ed0f19ecf5a6f41ba8"; }
-    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "173c030e3bba69c1634587a4032e4d0b49f37e0a94ba75c4deda7f23d25b21cc"; }
-    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "25f3ca3328c99421db81e4d88b8fe51e913b01430e0db412699b11fef0c81240"; }
-    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "df9f7737dddd56fb233d029c83c46a18470f992bc2b0222b54e1c4c36bde135b"; }
-    { locale = "sq"; arch = "linux-i686"; sha256 = "181bbb3808b28a5dc170db90db69a99137ce5d49c559c59c4a185b1ee48bea3d"; }
-    { locale = "sq"; arch = "linux-x86_64"; sha256 = "8b06fb2d2e4027aaa3ca5032823b203f5e2628c7673dd956103636916cf28a32"; }
-    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "e7679ef7d467aeaa796af37e62a48fb08e60299cdeb6cea07fcbd8253cda7288"; }
-    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "83a4b3a22de8be841be0967cda71dcc05958dddb690b7f90d80f1f6235555a49"; }
-    { locale = "da"; arch = "linux-i686"; sha256 = "b7db83686a2e9bf5e501ae32b608189af09eca9f4996b975960fcab3a97a10d2"; }
-    { locale = "da"; arch = "linux-x86_64"; sha256 = "aa081115593e5225f5fb47a9ba5bcd983da1c9e088f1a9f5cea3710afda75cd9"; }
-    { locale = "hr"; arch = "linux-i686"; sha256 = "99698f7259b1c3fa21600c43aa2a946376547a852e04f5a20478282bdbbb99d8"; }
-    { locale = "hr"; arch = "linux-x86_64"; sha256 = "bb2958eea731689b4fa48e98604233ef03b4de89107d801f72b12843cbc6fc70"; }
-    { locale = "ca"; arch = "linux-i686"; sha256 = "988e95cda1b412663bcbf1c1b552ad24b889fdfc30e7228bc47ac7f14aa43b31"; }
-    { locale = "ca"; arch = "linux-x86_64"; sha256 = "ac1f417ddc5b62f674f86f25a248d1434d996453892b4825ffb38852436d2df5"; }
-    { locale = "en-US"; arch = "linux-i686"; sha256 = "9209fa7bdada6245717dbfaf517d68cef04719812504bc0c988def6adc7baab5"; }
-    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "6e2f046dae0a6fa80de190b95667340abcb0ddaddf1ecee813099a89142c56e1"; }
-    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "f4acc2f18f55d7578555ac0b189aeb834adb6c3911ee665790fe4799774c8fe4"; }
-    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "2dc24f408fc801df266f2b890109c2e7d4a0d47bc2db7f541d371037ffad8ff8"; }
-    { locale = "gl"; arch = "linux-i686"; sha256 = "b9e89373d2d1b0123095cd45867014f87bc2696093127448e7b7b9cf72d294e6"; }
-    { locale = "gl"; arch = "linux-x86_64"; sha256 = "191f8f5327e8a7607497b990dce09e6219c444cbe9261fdbf709cdd07d6cd57f"; }
-    { locale = "lt"; arch = "linux-i686"; sha256 = "80cb0818fce6c8130c9344d3259a7bbc1722c1e7896853d365ad06cc4ccddd82"; }
-    { locale = "lt"; arch = "linux-x86_64"; sha256 = "347027a7c82330f5bc1989a19afb6dde415c260ad4de6c312bd1bda30d4f7651"; }
-    { locale = "en-GB"; arch = "linux-i686"; sha256 = "94f2742fd3a88826eab8712e77a503fb340437ed0a2c1657b64f13b8522c0ad6"; }
-    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "8319f02f751d0683e5d015d32da3e12c94cb8a8fd27f8cdf5cd583e6e594bdfd"; }
-    { locale = "sl"; arch = "linux-i686"; sha256 = "076ed4c9c2ed99769e278ed0965ca5da7efd00bc9fb225e36cffb712b7cedca5"; }
-    { locale = "sl"; arch = "linux-x86_64"; sha256 = "e37bf18f4e32f050ac97b1a20cfa44832d4438524e2ef9c4ca82e7ed8c1307cb"; }
-    { locale = "et"; arch = "linux-i686"; sha256 = "afc9aef58f08bf8f4b300308a5a4e527ba93e1bae024983063efd82e96c36703"; }
-    { locale = "et"; arch = "linux-x86_64"; sha256 = "d46257893e5e1f17757f0b53c9201b12bc4e5b27bde1eecb007a858f61c49fab"; }
-    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "8a1cbc00e4e6cffb3a225d9334e9c2372050203a0cba3b31c6537e02404efedb"; }
-    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "ae17a6fb60f27bb95a11501a061c7ab9deb0a6ba89b17e6cf01394e18710a831"; }
+    { locale = "tr"; arch = "linux-i686"; sha256 = "02dc838606507040c73ddff4a1b60fec7d6e613aa08da2ce1c76e9c367bc29e5"; }
+    { locale = "tr"; arch = "linux-x86_64"; sha256 = "a93243ab5b1d64a94bf10833d6b8985a65906d0be24bdcdd7b5babfb1d466bcd"; }
+    { locale = "nl"; arch = "linux-i686"; sha256 = "d675da8358bf4ed519ee49dcc2c2162075b5e9e0fca244b474322a7614f535da"; }
+    { locale = "nl"; arch = "linux-x86_64"; sha256 = "4e8f9e3f9fe851dc38deae42443cf884776e1d93abf34ce6963651a85afdc4a9"; }
+    { locale = "he"; arch = "linux-i686"; sha256 = "8a769559e73abfdb610891a23538ef38df3852ffb39d02cba96e6a8ec914f94a"; }
+    { locale = "he"; arch = "linux-x86_64"; sha256 = "e53b95914753b8640b69e104fbf5efb2fddcecc17eded23974c08274378105c2"; }
+    { locale = "bg"; arch = "linux-i686"; sha256 = "60deb9deb678c9e5233d9c0146aa4fc8a74b9ba9b5be43ed8c5a452039b8307d"; }
+    { locale = "bg"; arch = "linux-x86_64"; sha256 = "73e5c984d5d3fa17f93cb947fd63671fba66bab94117db84e187cb9260500101"; }
+    { locale = "si"; arch = "linux-i686"; sha256 = "669d825940712d7f10c7303e3e0a0ed9c48e9e5c26b0c035ed58bf8694d5ddc3"; }
+    { locale = "si"; arch = "linux-x86_64"; sha256 = "e60e048af0c965ac6f2adedb58e192d6d4208bf7f57dcef13b899da04ca14420"; }
+    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "f5f5b653e17b495c3cb4b1a26b39d3fdbeedb22c8d733cb2f3b6e57d46269949"; }
+    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "653cc18216f5fc156feef73170f903471480612a4de6df4efa3cce79b58fee28"; }
+    { locale = "ro"; arch = "linux-i686"; sha256 = "5cc87c9c84c205f99dc3fa58be8fedd72b9afccb69c91616f11929e2a7e075fd"; }
+    { locale = "ro"; arch = "linux-x86_64"; sha256 = "dc6e8f5dd30a7e2dcfebabfcc508de89cde3754c036811df7168f4f1e53c1477"; }
+    { locale = "ast"; arch = "linux-i686"; sha256 = "653025d1260db10310f8d689cb4554acf7a6388a99bac977b6f59b683d7e5983"; }
+    { locale = "ast"; arch = "linux-x86_64"; sha256 = "1a4623f94b4c68b6b89ec53c512f860388965dc36f2d06272341a194dc85eef6"; }
+    { locale = "pl"; arch = "linux-i686"; sha256 = "0e0ae13028d5f65a54398c634ed5b4a6685e2dc84b05121e71a0c0ca7a04053e"; }
+    { locale = "pl"; arch = "linux-x86_64"; sha256 = "2589909994cfa059d55a75b7d8f756c09f67994034f7f45c7b5b8805302645bf"; }
+    { locale = "gl"; arch = "linux-i686"; sha256 = "155e79bad6226eb2231a08856415b5e4a15cb02235b0b17ff7c0378c38d2dc93"; }
+    { locale = "gl"; arch = "linux-x86_64"; sha256 = "688d3c51645061fda283e2d486de1306f0b457149c82cbd20c7c019e76ed98b2"; }
+    { locale = "ja"; arch = "linux-i686"; sha256 = "90b3bbc31046daada0ce995108fb9542aeb878220579836ed0e5b14088199795"; }
+    { locale = "ja"; arch = "linux-x86_64"; sha256 = "ebd172d4a74ef757ceace8799c752e34fa0fb41dd5f4083d2aad2df4efd0329b"; }
+    { locale = "ca"; arch = "linux-i686"; sha256 = "c1502e310fd4b0a682fef147b4f5a97db972ed49916012a145ce6d5c4afd6452"; }
+    { locale = "ca"; arch = "linux-x86_64"; sha256 = "bac8bfe883d35f3624bae8cd4d831694a8e3f2b319a912ad5007e39483a22e70"; }
+    { locale = "fr"; arch = "linux-i686"; sha256 = "d0315db23af439e736e02d93d2467c86fe2a186c849aef32e928adb5059fa7fd"; }
+    { locale = "fr"; arch = "linux-x86_64"; sha256 = "8d5c5c4ac8865ee233ea10d2c4b153bb47cf4df4047dfae9aa7b5722c293e5cc"; }
+    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "9bbac5b2d4ada74e6cdc8730997d47043d319a79a61636322038584265001fed"; }
+    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "ac828318d8ce07332af73b3146f77825e51e8df8e858c0596589dbdfb2c8718f"; }
+    { locale = "sl"; arch = "linux-i686"; sha256 = "16276607ffd4fa9fac4077cfc6da91ced5d5a4b08d804726d9d4b7e870cc25f2"; }
+    { locale = "sl"; arch = "linux-x86_64"; sha256 = "7e1c2f2aaa973b7a19518c62beb43130d7fb95d4c5aecd3370d7ab2fb59f37c5"; }
+    { locale = "be"; arch = "linux-i686"; sha256 = "48b27779e6ee95971d72a6be14e69ac1e724f5450126ad2627a9b2f0511b663c"; }
+    { locale = "be"; arch = "linux-x86_64"; sha256 = "ebd551829f7a66b47a82cad5db79a27126719af71ada250dbaedf292077e9c8e"; }
+    { locale = "ko"; arch = "linux-i686"; sha256 = "8f92e772ce7c54d6210c83fee257c9cc0b2a3542f41ac2059ea377c64d4f59ed"; }
+    { locale = "ko"; arch = "linux-x86_64"; sha256 = "b2cec9901318ec0754e8caca2d56e6e4d08deb4aa21db7fb04c555062b84b9be"; }
+    { locale = "hr"; arch = "linux-i686"; sha256 = "c5a1da56142398fc79b6d356d600f8228b0a4f1ac40d04df4ff5c25564b77a6f"; }
+    { locale = "hr"; arch = "linux-x86_64"; sha256 = "5d0308e1c08960a26ac3328eb5be4c237e2320a38a6db077186f1d1a278feb8d"; }
+    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "d0abb5c4657a4a04999a44f96d00271e8dc3ad79ae0e78cf4b820fc2fd29b266"; }
+    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "fdde99be62fe6a911711e1ba69a2babcdba53216a5942494ab7e52cada8bf893"; }
+    { locale = "vi"; arch = "linux-i686"; sha256 = "d0420a7ccd8f4fcd7f56497636baa701c71576d3b88440b609cbb3ebf245d4e4"; }
+    { locale = "vi"; arch = "linux-x86_64"; sha256 = "5657eb2a99f7c2cf32297bbb45fab4c0eb2dd48ba4ba98487beed18aa5e85ada"; }
+    { locale = "es-AR"; arch = "linux-i686"; sha256 = "fe60d3b13e964bd99730e8082b742729084e87f6a285deb8cd2383dccf881f1c"; }
+    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "76faee1fd8da11731ece128832997de0f10501040921e6abb46fc0ae4922d568"; }
+    { locale = "el"; arch = "linux-i686"; sha256 = "c1ad068c565abb7b3f16c843f6974fcec6f46714c3f9afb193d10ffa3773cbff"; }
+    { locale = "el"; arch = "linux-x86_64"; sha256 = "b5cd4fb82525b67ef199b9eadaebe25f70a29e1dc43b2ad0f0074bf7d01a05f0"; }
+    { locale = "is"; arch = "linux-i686"; sha256 = "195cb61263c4c01c345a5effcb5f4f6741a1ee10f716006a614d55721b013e48"; }
+    { locale = "is"; arch = "linux-x86_64"; sha256 = "42447cb7c7689623a34607a0aa1a9866552756576932d45a4721c5fe8541070f"; }
+    { locale = "ru"; arch = "linux-i686"; sha256 = "6c0f45046e4d1910a20e245f0b69af5b4fb2a9507abd99217bffe68bf213061e"; }
+    { locale = "ru"; arch = "linux-x86_64"; sha256 = "408f3b38fc416cc12640af0928fbea1506eae3f4a65b6b3b889bca54bb0a1521"; }
+    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "330f4546fe50d717fc66b8417405d3c1eef8ca4f312b21563c426739eee4724a"; }
+    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "283d3e581ebb84059985aad40f72338a77b068e27b8247e0ac16b915ed16f797"; }
+    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "8068738dbfc0ed5f5a08b1b4a65a5e9e1ac780de43fc5f27c269dcd5e9998f97"; }
+    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "a101856b6151cae9d33a909d1a0fc11eb26439ca161db55dc262bf86bb457c29"; }
+    { locale = "sk"; arch = "linux-i686"; sha256 = "5a790cc811d8e392daa83b11feb232092ab97dc8c9fc0bb47b4013751a30f76e"; }
+    { locale = "sk"; arch = "linux-x86_64"; sha256 = "7842ceeab524c98387ca6319735bf7c331d34bcfde395078cc32c443e69962ef"; }
+    { locale = "sr"; arch = "linux-i686"; sha256 = "06ded63a3d09af09ac68b318f79f07e924addb30d4c11903b6a86ba3ef476761"; }
+    { locale = "sr"; arch = "linux-x86_64"; sha256 = "53a99f98398b2044866422ca44b496d489c0b78724f28afb4f919eca656d528a"; }
+    { locale = "en-US"; arch = "linux-i686"; sha256 = "4c4da90f383d7b43e97e471656a6cfbbd44d1b80d57b8b2405497678aced46b5"; }
+    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "41ff22bc9a41aa0e71deebce4894e99f3e3737a57279a1488bf9d2f869cd56ad"; }
+    { locale = "es-ES"; arch = "linux-i686"; sha256 = "e11451297f17febcf0057ae02dc15a298aacc865146e1aac363300dac6de57c5"; }
+    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "0e5d389a2c5b673b423dd2afad375eb6a7e05c8eb0b07ceb4975d658827d6cf5"; }
+    { locale = "gd"; arch = "linux-i686"; sha256 = "5fc40508e7a6228065084fc91431af3b9231c6ce46ae3e88ef249ad67bf1b545"; }
+    { locale = "gd"; arch = "linux-x86_64"; sha256 = "ef365e27b05f4bd0c8211ed9e54ecfa4983111be74261303870a8d22e6093c08"; }
+    { locale = "fi"; arch = "linux-i686"; sha256 = "9461f7d3953dc6aa5c9d2406331138a5e34d114eb5b48b09b562dade25a38ab7"; }
+    { locale = "fi"; arch = "linux-x86_64"; sha256 = "6a0310cc0e0a5d9e1590c735e91e8c1bb85358687f4a6a59219de05bb0cf9d1d"; }
+    { locale = "de"; arch = "linux-i686"; sha256 = "b4fd29c1bd06c5d6b85aeb6434746f1fa0af627c5795ce2ebc7d3dddcf78e9e6"; }
+    { locale = "de"; arch = "linux-x86_64"; sha256 = "b24afec0b5de5e872848dfcd609f1cf81fe2eed96cc9ee1a5f17fd1b68750d34"; }
+    { locale = "sq"; arch = "linux-i686"; sha256 = "a78274174c8c26426d9f7e85589f6143f47fab9ce8eb9bbb91fc6c9444c1470d"; }
+    { locale = "sq"; arch = "linux-x86_64"; sha256 = "18c6ee5a732d777d9326593a4edfc30f11acdfef2397aa55c436d54a99de9c3a"; }
+    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "3e12328500db45ecfb4572c3cad8b75a46d930ec57a426c8fbe6dd8e033f3cfc"; }
+    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "a76f785c8c0b17f3962a94d4cee5bce9be7b91fd2805133f490ad516ba2d5ad8"; }
+    { locale = "hu"; arch = "linux-i686"; sha256 = "72e1d888516119a6aa21d077fbe8faefc5cf13e8e422ae26aeed4416700f16af"; }
+    { locale = "hu"; arch = "linux-x86_64"; sha256 = "962f0b046ab3f385348022d78ffffdae6137b351c5031453f62b5fa1dd44a9b3"; }
+    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "b5b11886e19a03e219bb803c7853bded9c5e4a2cde0a33abba4c0665a44ec8f4"; }
+    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "faa18298e02ecd0eca77f4e68e88ebb91ca8ea3abb6241f53d82e1db7db95076"; }
+    { locale = "cs"; arch = "linux-i686"; sha256 = "03b23597d55f1db442f8147bcff7108e3b520e0b5d05d819df07915ba6baa35f"; }
+    { locale = "cs"; arch = "linux-x86_64"; sha256 = "3dea9adb367958babb54dce3102d43d316088aa6140101d18a59cda20522d78f"; }
+    { locale = "br"; arch = "linux-i686"; sha256 = "7b1814286847188ca68b3f24457b3a6ee5cd967833bf789104db0fedd2993941"; }
+    { locale = "br"; arch = "linux-x86_64"; sha256 = "7605776d4a72d82fc65280df0cf9812f134a1dc790e0f60f089f287f38ed5db0"; }
+    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "da8177ab1912d5a0047dd2f6848a421c8fe32d39bacb64e76e0633ddaca5f4de"; }
+    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "60b1c2f1f209c5e16c6f29c0a5bcaf46c04bb2ae289925761193387ae65fe18d"; }
+    { locale = "rm"; arch = "linux-i686"; sha256 = "29e073a8068f7d060cf2818d85d465df3f606aba95e867dc9aa67533d09e4b55"; }
+    { locale = "rm"; arch = "linux-x86_64"; sha256 = "8d8ac419650a9cd0b138aa823dcfb67e47f8522a5d51625090c26c45a5c577a7"; }
+    { locale = "lt"; arch = "linux-i686"; sha256 = "9d537ff70f06a5189296a99126a57ab8664266ec2da673671e60e97678d3ed9d"; }
+    { locale = "lt"; arch = "linux-x86_64"; sha256 = "77f30fb2b94fa7cb690c5c0f2fff0ec89c1aa8f8915891d17a66357ddd10d462"; }
+    { locale = "eu"; arch = "linux-i686"; sha256 = "1b613c1cf303a65c3065fc3edf15c6a051c1a7e347512e39cce425ef02828c3c"; }
+    { locale = "eu"; arch = "linux-x86_64"; sha256 = "a02a04bc88efca8523b4af8e4962b205ad13d9eb9879405db57356966b12202b"; }
+    { locale = "it"; arch = "linux-i686"; sha256 = "baede1707cca4ff149956884f855fa0077c372275f6be6f59d32e47cc6509b5b"; }
+    { locale = "it"; arch = "linux-x86_64"; sha256 = "e49f0b02d323e2f83d0da2a5ec2e4585693362545e50bfba51e273d0edf52813"; }
+    { locale = "id"; arch = "linux-i686"; sha256 = "31691ec0b51d19bdab2efe2ab1813bd3363e71ad62bc4f5a860e017516509ad5"; }
+    { locale = "id"; arch = "linux-x86_64"; sha256 = "c6241fb8cd1d83ac5753518c2cc215ee831fa24b816a5a522029d14cea24b15b"; }
+    { locale = "da"; arch = "linux-i686"; sha256 = "aa6c91c15ff9f1769d727883c17720a2732ede4b786c4bff7d42fe25c129246b"; }
+    { locale = "da"; arch = "linux-x86_64"; sha256 = "b940f8ab5b2ad50faedc4520f4a7bd5936debfd70b2fa86b2abf955a22557b20"; }
+    { locale = "ta-LK"; arch = "linux-i686"; sha256 = "cc70eb04cbab5bcd674e40c4d58760c07353726c968f766fc749fcd7154fddd9"; }
+    { locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "948172b68287b1cd8a1d7a32b3e7fd5494390aefea1683cbad34f12ba5d241a7"; }
+    { locale = "uk"; arch = "linux-i686"; sha256 = "6b45d36abc8fe1c731baf855866000ffa08671d025ab97b5301b22079765d70c"; }
+    { locale = "uk"; arch = "linux-x86_64"; sha256 = "9d619639157c645bc34628b7c31ccfb4e8223b891cf8e99118e7b767f7f5e24b"; }
+    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "a9176628228c3f3e07d2929caa872b4a24d9f620de79a148c01f0716c9dd058f"; }
+    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "f067e1f516d639b2cc997019a39b568d6377437d2d6810fb87d23a64e72995a0"; }
+    { locale = "ar"; arch = "linux-i686"; sha256 = "7b016747c9e9066a8e4383303ee22e600d3b00716c53755c95067dc8b6267046"; }
+    { locale = "ar"; arch = "linux-x86_64"; sha256 = "f798804c9aa0eb8fd9cde80acf8a2ebc3b4855588ff14092da935cd77bbc660a"; }
+    { locale = "en-GB"; arch = "linux-i686"; sha256 = "7a19e07c52de321f8f182bd14fdaf137b120167d9d2ab4929476f7cf9a94a744"; }
+    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "b66b2ff31cc778f52ce9e987f38a93f973c04dacbf04559b1872537a083cb98e"; }
+    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "7599ba2b65fcac92464c2ee480c4c823cd0f35661fa30982575e6f87069d3e58"; }
+    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "e81f157f75f2eb94f28dc7f2da5c1d0fbb8f8077c28c3afdb2144dd906ce773f"; }
+    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "bdcafd77469b70a8e02cacab63503e4ba085e3b4230e012313f743a130448cb1"; }
+    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "2f57c5353e75ec9dd56abf4c4f197af64648e3e2e927b7c868db6f664abb2e14"; }
+    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "f9d8a77df3e4718260e9235ce09008a224e02bde12efe5a88c9341432637f0c4"; }
+    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "46a4ae81ecd6fb22aed54a0ca40ddf292adc94b37b38a57e9ab64f5bed8b0a39"; }
+    { locale = "et"; arch = "linux-i686"; sha256 = "f03136ad26eb1d5ead82e26e8620e3cd1b7f30ceb552329d008a33bcb2e930c4"; }
+    { locale = "et"; arch = "linux-x86_64"; sha256 = "d2e446dea1db14210da9e1556614a92954c61ce00b24958ea4c2a61b597c0b13"; }
   ];
 
   arch = if stdenv.system == "i686-linux"

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

···
-{ stdenv, fetchurl,
-slang, ncurses
-}:
+{ stdenv, fetchurl
+, slang, ncurses }:
 
-let version = "1.0.1"; in
+let version = "1.0.2"; in
 
 stdenv.mkDerivation {
   name = "slrn-${version}";
 
   src = fetchurl {
-    url = "http://www.jedsoft.org/slrn/download/slrn-1.0.1.tar.gz";
-    sha256 = "1rmaprfwvshzkv0c5vi43839cz3laqjpl306b9z0ghwyjdha1d06";
+    url = "http://www.jedsoft.org/releases/slrn/slrn-${version}.tar.gz";
+    sha256 = "1gn6m2zha2nnnrh9lz3m3nrqk6fgfij1wc53pg25j7sdgvlziv12";
   };
 
   preConfigure = ''
···
 
   buildInputs = [ slang ncurses ];
 
-  meta = {
-    description = "Text-based newsreader";
+  meta = with stdenv.lib; {
+    description = "The slrn (S-Lang read news) newsreader";
     homepage = http://slrn.sourceforge.net/index.html;
-    license = stdenv.lib.licenses.gpl2;
+    maintainers = with maintainers; [ emery ];
+    license = licenses.gpl2;
   };
 }

pkgs/applications/networking/remote/teamviewer/9.nix

···
+{ stdenv, fetchurl, libX11, libXtst, libXext, libXdamage, libXfixes, wineUnstable, makeWrapper, libXau
+, bash, patchelf }:
+
+let
+  topath = "${wineUnstable}/bin";
+
+  toldpath = stdenv.lib.concatStringsSep ":" (map (x: "${x}/lib") 
+    [ stdenv.gcc.gcc libX11 libXtst libXext libXdamage libXfixes wineUnstable ]);
+in
+stdenv.mkDerivation {
+  name = "teamviewer-9.0.32150";
+  src = fetchurl {
+    url = "http://download.teamviewer.com/download/version_9x/teamviewer_linux_x64.deb";
+    sha256 = "0wpwbx0xzn3vlzavszxhfvfcaj3pijlpwvlz5m7w19mb6cky3q13";
+  };
+
+  buildInputs = [ makeWrapper patchelf ];
+
+  unpackPhase = ''
+    ar x $src
+    tar xf data.tar.gz
+  '';
+
+  installPhase = ''
+    mkdir -p $out/share/teamviewer9 $out/bin
+    cp -a opt/teamviewer9/* $out/share/teamviewer9
+    rm -R $out/share/teamviewer9/tv_bin/wine/{bin,lib,share}
+
+    cat > $out/bin/teamviewer << EOF
+    #!${bash}/bin/sh
+    export LD_LIBRARY_PATH=${toldpath}\''${LD_LIBRARY_PATH:+:\$LD_LIBRARY_PATH}
+    export PATH=${topath}\''${PATH:+:\$PATH}
+    $out/share/teamviewer9/tv_bin/script/teamviewer "\$@"
+    EOF
+    chmod +x $out/bin/teamviewer
+
+    patchelf --set-rpath "${stdenv.gcc.gcc}/lib64:${stdenv.gcc.gcc}/lib:${libX11}/lib:${libXext}/lib:${libXau}/lib:${libXdamage}/lib:${libXfixes}/lib" $out/share/teamviewer9/tv_bin/teamviewerd
+    patchelf --set-interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" $out/share/teamviewer9/tv_bin/teamviewerd
+    ln -s $out/share/teamviewer9/tv_bin/teamviewerd $out/bin/
+  '';
+
+  meta = {
+    homepage = "http://www.teamviewer.com";
+    license = stdenv.lib.licenses.unfree;
+    description = "Desktop sharing application, providing remote support and online meetings";
+  };
+}

pkgs/applications/science/electronics/qucs/default.nix

···
-{stdenv, fetchurl, qt3, libX11}:
+{stdenv, fetchurl, flex, bison, qt4, libX11 }:
 
 stdenv.mkDerivation rec {
-  name = "qucs-0.0.16";
+  name = "qucs-0.0.18";
 
   src = fetchurl {
     url = "mirror://sourceforge/qucs/${name}.tar.gz";
-    sha256 = "1h8ba84k06rix5zl5p9p414zj2facbnlf1vxwh4a1sp4h9dbfnzy";
+    sha256 = "3609a18b57485dc9f19886ac6694667f3251702175bd1cbbbea37981b2c482a7";
   };
 
-  patches = [ ./tr1-complex.patch ];
-  patchFlags = "-p0";
+  QTDIR=qt4;
 
-  buildInputs = [ qt3 libX11 ];
+  buildInputs = [ flex bison qt4 libX11 ];
 
   meta = {
     description = "Integrated circuit simulator";

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

···
+{ stdenv, fetchurl, ocaml, findlib, dypgen, bolt, ansiterminal,
+  buildBytecode ? true,
+  buildNative ? true,
+  installExamples ? true,
+  installEmacsMode ? true }:
+
+let inherit (stdenv.lib) getVersion versionAtLeast
+                         optionals optionalString; in
+
+assert versionAtLeast (getVersion ocaml) "3.07";
+assert versionAtLeast (getVersion dypgen) "20080925";
+assert versionAtLeast (getVersion bolt) "1.4";
+
+assert buildBytecode || buildNative;
+
+stdenv.mkDerivation {
+
+  name = "acgtk-1.1";
+
+  src = fetchurl {
+    url = "http://www.loria.fr/equipes/calligramme/acg/software/acg-1.1-20140905.tar.gz";
+    sha256 = "1k1ldqg34bwmgdpmi9gry9czlsk85ycjxnkd25fhlf3mmgg4n9p6";
+  };
+
+  buildInputs = [ ocaml findlib dypgen bolt ansiterminal ];
+
+  patches = [ ./install-emacs-to-site-lisp.patch
+              ./use-nix-ocaml-byteflags.patch ];
+
+  # The bytecode executable is dependent on the dynamic library provided by
+  # ANSITerminal. We can use the -dllpath flag of ocamlc (analogous to
+  # -rpath) to make sure that ocamlrun is able to link the library at
+  # runtime and that Nix detects a runtime dependency.
+  NIX_OCAML_BYTEFLAGS = "-dllpath ${ansiterminal}/lib/ocaml/${getVersion ocaml}/site-lib/ANSITerminal";
+
+  buildFlags = optionalString buildBytecode "byte"
+             + " "
+             + optionalString buildNative "opt";
+
+  installTargets = "install"
+                 + " " + optionalString installExamples "install-examples"
+                 + " " + optionalString installEmacsMode "install-emacs";
+
+  meta = with stdenv.lib; {
+    homepage = "http://www.loria.fr/equipes/calligramme/acg";
+    description = "A toolkit for developing ACG signatures and lexicon";
+    license = licenses.cecill20;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

pkgs/applications/science/logic/acgtk/install-emacs-to-site-lisp.patch

···
+--- acg-1.1-20140905/Makefile.in	2014-10-24 15:21:39.442287208 +0200
++++ acg-1.1-20140905/Makefile.in.new	2014-10-24 15:24:58.557117228 +0200
+@@ -35,6 +35,7 @@
+ ACGC_DIR=src/acg-data
+ 
+ DATA_DIR=@datarootdir@/acgtk
++EMACS_DIR=@prefix@/share/emacs/site-lisp
+ 
+ 
+ 
+@@ -82,10 +83,10 @@
+ 	rm -r $(DATA_DIR)
+ 
+ install-emacs:
+-	mkdir -p $(DATA_DIR) && cp -r emacs $(DATA_DIR)/.
++	mkdir -p $(EMACS_DIR) && cp emacs/acg.el $(EMACS_DIR)
+ 
+ uninstall-emacs:
+-	rm -rf $(DATA_DIR)/emacs
++	rm -rf $(EMACS_DIR)/emacs
+ 
+ install-examples:
+ 	mkdir -p $(DATA_DIR) && cp -r examples $(DATA_DIR)/.

pkgs/applications/science/logic/acgtk/use-nix-ocaml-byteflags.patch

···
+--- acg-1.1-20140905/src/Makefile.master.in	2014-10-27 10:59:42.263382081 +0100
++++ acg-1.1-20140905/src/Makefile.master.in.new	2014-10-27 10:59:59.683597972 +0100
+@@ -23,7 +23,7 @@
+ # All warnings are treated as errors
+ WARNINGS = @OCAML09WARNINGS@ -warn-error A
+ COMMONFLAGS= $(WARNINGS) @TYPES@
+-BYTEFLAGS = $(COMMONFLAGS) $(DEBUGFLAG)
++BYTEFLAGS = $(COMMONFLAGS) $(DEBUGFLAG) $(NIX_OCAML_BYTEFLAGS)
+ OPTFLAGS = $(COMMONFLAGS)
+ LFLAGS= -a
+ 

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

···
 
 cabal.mkDerivation (self: {
   pname = "git-annex";
-  version = "5.20141013";
-  sha256 = "1p2hvw2x0rm9nhk176mzwisl75xphqxv7mhd43mvwlb3q9f57lnc";
+  version = "5.20141024";
+  sha256 = "065b181m76a9w3jznrmb087gccwnpgmyzyndgf8krg28g85y0bq5";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

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

···
 
 let
 
-  version = "2.1.2";
+  version = "2.1.3";
 
   svn = subversionClient.override { perlBindings = true; };
 
···
 
   src = fetchurl {
     url = "https://www.kernel.org/pub/software/scm/git/git-${version}.tar.xz";
-    sha256 = "12x1qycc0rii6fqpiizp9v9ysdmj6lpi9imqqbrkdx6cifbwh9vv";
+    sha256 = "0mvgvr2hz25p49dhhizcw9591f2h17y2699mpmndis3kzap0c6zy";
   };
 
   patches = [ ./docbook2texi.patch ./symlinks-in-bin.patch ./cert-path.patch ];

pkgs/applications/video/makemkv/builder.sh

···
 lib=" \
   makemkv-oss-${ver}/out/libdriveio.so.0 \
   makemkv-oss-${ver}/out/libmakemkv.so.1 \
+  makemkv-oss-${ver}/out/libmmbd.so.0 \
   "
 
 bin=" \
···
 
 (
   cd makemkv-oss-${ver}
-  make -f makefile.linux
+  ./configure --prefix=$out
+  make
 )
 
 chmod +x ${bin}

pkgs/applications/video/makemkv/default.nix

···
 { stdenv, fetchurl
-, openssl, qt4, mesa, zlib
+, openssl, qt4, mesa, zlib, pkgconfig, libav
 }:
 
 stdenv.mkDerivation rec {
   name = "makemkv-${ver}";
-  ver = "1.8.0";
+  ver = "1.8.14";
   builder = ./builder.sh;
 
   src_bin = fetchurl {
     url = "http://www.makemkv.com/download/makemkv-bin-${ver}.tar.gz";
-    sha256 = "1f465rdv5ibnh5hnfmvmlid0yyzkansjw8l1mi5qd3bc6ca4k30c";
+    sha256 = "1kjxawqh6xnjcgvaqy7idg8k0g3zqrr1w5r2r3bf11pg0h1ys5l5";
   };
 
   src_oss = fetchurl { 
     url = "http://www.makemkv.com/download/makemkv-oss-${ver}.tar.gz";
-    sha256 = "0kj1mpkzz2cvi0ibdgdzfwbh9k2jfj3ra5m3hd7iyc5ng21v4sk3";
+    sha256 = "0cq3h45yyqma0kzi594dz0gbgjf3gyjcgxkiynifz3hacrbxbnd5";
   };
 
-  buildInputs = [openssl qt4 mesa zlib];
+  buildInputs = [openssl qt4 mesa zlib pkgconfig libav];
 
   libPath = stdenv.lib.makeLibraryPath [stdenv.gcc.gcc openssl mesa qt4 zlib ] 
           + ":" + stdenv.gcc.gcc + "/lib64";

pkgs/applications/video/mkvtoolnix/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "7.2.0";
+  version = "7.3.0";
   name = "mkvtoolnix-${version}";
 
   src = fetchurl {
     url = "http://www.bunkus.org/videotools/mkvtoolnix/sources/${name}.tar.xz";
-    sha256 = "1bpmd37y2v4icv9iqjv3p4kr62jbdng2ar8vpiij3bdgwrjc6gv1";
+    sha256 = "086lg64pki6mz00h0a735hgvz4347zbcp3wz384sigqndn99zc1c";
   };
 
   buildInputs = [

pkgs/applications/video/mpv/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mpv-${version}";
-  version = "0.5.4";
+  version = "0.6.1";
 
   src = fetchurl {
     url = "https://github.com/mpv-player/mpv/archive/v${version}.tar.gz";
-    sha256 = "1n992nvylnh27jc6425daasq0nsxjfc1mxhhlhvlwzxm724x94xp";
+    sha256 = "03vzsvvb1dvm4rn70m97fdbzhlqj9crk7zpvcp00bcl956xjfc9s";
   };
 
   buildInputs = with stdenv.lib;

pkgs/applications/video/xbmc/default.nix

···
 # TODO: librtmp
 , libvdpau ? null, vdpauSupport ? true
 , pulseaudio ? null, pulseSupport ? true
+, libcec ? null, cecSupport ? true
 }:
 
 assert dbusSupport  -> dbus_libs != null;
···
 assert sambaSupport -> samba != null;
 assert vdpauSupport -> libvdpau != null && ffmpeg.vdpauSupport;
 assert pulseSupport -> pulseaudio != null;
+assert cecSupport   -> libcec != null;
 
 stdenv.mkDerivation rec {
     name = "xbmc-13.2";
···
     ++ lib.optional usbSupport libusb
     ++ lib.optional sambaSupport samba
     ++ lib.optional vdpauSupport libvdpau
-    ++ lib.optional pulseSupport pulseaudio;
+    ++ lib.optional pulseSupport pulseaudio
+    ++ lib.optional cecSupport libcec;
 
     dontUseCmakeConfigure = true;
 
···
           --prefix LD_LIBRARY_PATH ":" "${curl}/lib" \
           --prefix LD_LIBRARY_PATH ":" "${systemd}/lib" \
           --prefix LD_LIBRARY_PATH ":" "${libmad}/lib" \
-          --prefix LD_LIBRARY_PATH ":" "${libvdpau}/lib"
+          --prefix LD_LIBRARY_PATH ":" "${libvdpau}/lib" \
+          --prefix LD_LIBRARY_PATH ":" "${libcec}/lib"
       done
     '';
 

pkgs/applications/video/zdfmediathk/default.nix

···
+{ stdenv, fetchurl, unzip, jre }:
+
+with stdenv;
+
+mkDerivation rec {
+
+  version = "8";
+  name = "zdfmediathk";
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/project/zdfmediathk/Mediathek/Mediathek%208/MediathekView_${version}.zip";
+    sha256 = "1sglzk8zh6cyijyw82k49yqzjv0ywglp03w09s7wr4mzk48mfjj9";
+  };
+
+  buildInputs = [ unzip ];
+
+  unpackPhase = "unzip $src";
+
+  installPhase = ''
+    mkdir -p $out/{lib,bin,share/{doc,licenses}}
+    install -m644 MediathekView.jar $out/
+    install -m644 -t $out/lib lib/*
+    install -m755 bin/flv.sh $out/bin/
+    install -m644 -t $out/share/doc Anleitung/*.pdf
+    install -m644 -t $out/share/licenses Copyright/{*.*,_copyright}
+    bin="$out/bin/mediathek"
+    cat >> "$bin" << EOF
+    #!/bin/sh
+    exec ${jre}/bin/java -cp "$out/lib/*" -Xms128M -Xmx1G -jar "$out/MediathekView.jar" "\$@"
+    EOF
+    chmod +x "$bin"
+    '';
+
+  meta = with stdenv.lib; {
+    description = "Offers access to the Mediathek of different tv stations (ARD, ZDF, Arte, etc.)";
+    homepage = "http://zdfmediathk.sourceforge.net/";
+    license = licenses.gpl3;
+    maintainers = [ maintainers.flosse ];
+    platforms = platforms.all;
+  };
+
+}

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

···
  '';
 
  configurePhase = ''
-   ./configure --prefix=$out --with-contrib-dir=${pkgs.stumpwmContrib}/contrib
+   ./configure --prefix=$out --with-contrib-dir=${stumpwmContrib}/contrib
  '';
 
  installPhase = ''
    make
    make install
+   # For some reason, stumpwmContrib is not retained as a runtime
+   # dependency (probably because $out/bin/stumpwm is compressed or
+   # obfuscated in some way). Thus we add an explicit reference here.
+   mkdir $out/nix-support
+   echo ${stumpwmContrib} > $out/nix-support/stumpwm-contrib
  '';
 
   meta = with stdenv.lib; {

pkgs/applications/window-managers/xmonad-log-applet/default.nix

···
+{ stdenv, fetchFromGitHub, pkgconfig, autoreconfHook, glib, dbus_glib
+, desktopSupport
+, gtk2, gnome2_panel, GConf2
+, libxfce4util, xfce4panel
+}:
+
+assert desktopSupport == "gnome2" || desktopSupport == "gnome3" || desktopSupport == "xfce4";
+
+stdenv.mkDerivation rec {
+  version = "2.1.0";
+  pname = "xmonad-log-applet";
+  name = "${pname}-${version}-${desktopSupport}";
+
+  src = fetchFromGitHub {
+    owner = "alexkay";
+    repo = pname;
+    rev = "${version}";
+    sha256 = "1g1fisyaw83v72b25fxfjln8f4wlw3rm6nyk27mrqlhsc1spnb5p";
+  };
+
+  buildInputs =  with stdenv.lib;
+                 [ glib dbus_glib ]
+              ++ optionals (desktopSupport == "gnome2") [ gtk2 gnome2_panel GConf2 ]
+              # TODO: no idea where to find libpanelapplet-4.0
+              ++ optionals (desktopSupport == "gnome3") [ ]
+              ++ optionals (desktopSupport == "xfce4") [ gtk2 libxfce4util xfce4panel ]
+              ;
+  
+  nativeBuildInputs = [ autoreconfHook pkgconfig ];
+  
+  configureFlags =  [ "--with-panel=${desktopSupport}" ];
+  
+  patches = [ ./fix-paths.patch ];
+
+  meta = with stdenv.lib; {
+    homepage = http://github.com/alexkay/xmonad-log-applet;
+    license = licenses.bsd3;
+    description = "An applet that will display XMonad log information (${desktopSupport} version)";
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ abbradar ];
+
+    broken = desktopSupport == "gnome3";
+  };
+}
+

pkgs/applications/window-managers/xmonad-log-applet/fix-paths.patch

···
+diff --git a/Makefile.am b/Makefile.am
+index 619012d..dcc6d3c 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -1,4 +1,5 @@
+ plugindir = $(PLUGIN_DIR)
++SESSION_BUS_SERVICES_DIR = $(prefix)/share/dbus-1/services
+ plugin_PROGRAMS = xmonad-log-applet
+ 
+ xmonad_log_applet_SOURCES = main.c
+diff --git a/configure.ac b/configure.ac
+index ad4cffb..110c953 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -27,28 +27,28 @@ AC_ARG_WITH(
+ AS_IF(
+     [test "x$panel" = xgnome2],
+         [PKG_CHECK_MODULES(LIBPANEL, libpanelapplet-3.0 >= 2.32.0)]
+-        LIBPANEL_APPLET_DIR=`$PKG_CONFIG --variable=prefix libpanelapplet-3.0`/share/gnome-panel/applets
+-        PLUGIN_DIR=`$PKG_CONFIG --variable=prefix libpanelapplet-3.0`/libexec
++        LIBPANEL_APPLET_DIR=${prefix}/share/gnome-panel/applets
++        PLUGIN_DIR=${prefix}/libexec
+         [AC_DEFINE(PANEL_GNOME, 1, [panel type])]
+         [AC_DEFINE(PANEL_GNOME2, 1, [panel type])]
+         ,
+     [test "x$panel" = xgnome3],
+         [PKG_CHECK_MODULES(LIBPANEL, libpanelapplet-4.0 >= 3.0.0)]
+         LIBPANEL_APPLET_DIR=`$PKG_CONFIG --variable=libpanel_applet_dir libpanelapplet-4.0`
+-        PLUGIN_DIR=`$PKG_CONFIG --variable=prefix libpanelapplet-4.0`/libexec
++        PLUGIN_DIR=${prefix}/libexec
+         [AC_DEFINE(PANEL_GNOME, 1, [panel type])]
+         [AC_DEFINE(PANEL_GNOME3, 1, [panel type])]
+         ,
+     [test "x$panel" = xmate],
+         [PKG_CHECK_MODULES(LIBPANEL, libmatepanelapplet-3.0 >= 1.4.0)]
+-        LIBPANEL_APPLET_DIR=`$PKG_CONFIG --variable=prefix libmatepanelapplet-3.0`/share/mate-panel/applets
+-        PLUGIN_DIR=`$PKG_CONFIG --variable=prefix libmatepanelapplet-3.0`/libexec
++        LIBPANEL_APPLET_DIR=${prefix}/share/mate-panel/applets
++        PLUGIN_DIR=${prefix}/libexec
+         [AC_DEFINE(PANEL_MATE, 1, [panel type])]
+         ,
+     [test "x$panel" = xxfce4],
+         [PKG_CHECK_MODULES(LIBPANEL, libxfce4panel-1.0 >= 4.6.0)]
+-        LIBPANEL_APPLET_DIR=`$PKG_CONFIG --variable=prefix libxfce4panel-1.0`/share/xfce4/panel-plugins
+-        PLUGIN_DIR=`$PKG_CONFIG --variable=libdir libxfce4panel-1.0`/xfce4/panel/plugins
++        LIBPANEL_APPLET_DIR=${prefix}/share/xfce4/panel-plugins
++        PLUGIN_DIR=${prefix}/lib/xfce4/panel/plugins
+         [AC_DEFINE(PANEL_XFCE4, 1, [panel type])]
+         ,
+     [AC_MSG_ERROR([Unknown panel type, use gnome2, gnome3, mate or xfce4])]

pkgs/build-support/fetchegg/builder.sh

···
+source $stdenv/setup
+
+header "exporting egg ${eggName} (version $version) into $out"
+
+mkdir -p $out
+chicken-install -r "${eggName}:${version}"
+cp -r ${eggName}/* $out/
+
+stopNest

pkgs/build-support/fetchegg/default.nix

···
+# Fetches a chicken egg from henrietta using `chicken-install -r'
+# See: http://wiki.call-cc.org/chicken-projects/egg-index-4.html
+
+{ stdenv, chicken }:
+{ name, version, md5 ? "", sha256 ? "" }:
+
+stdenv.mkDerivation {
+  name = "chicken-${name}-export";
+  builder = ./builder.sh;
+  buildInputs = [ chicken ];
+
+  outputHashAlgo = if sha256 == "" then "md5" else "sha256";
+  outputHashMode = "recursive";
+  outputHash = if sha256 == "" then md5 else sha256;
+
+  inherit version;
+
+  eggName = name;
+
+  impureEnvVars = [
+    # We borrow these environment variables from the caller to allow
+    # easy proxy configuration.  This is impure, but a fixed-output
+    # derivation like fetchurl is allowed to do so since its result is
+    # by definition pure.
+    "http_proxy" "https_proxy" "ftp_proxy" "all_proxy" "no_proxy"
+  ];
+}
+

pkgs/build-support/fetchurl/mirrors.nix

···
     ftp://ftp.nl.debian.org/debian/
     ftp://ftp.ru.debian.org/debian/
     ftp://ftp.debian.org/debian/
+    http://ftp.debian.org/debian/
     http://archive.debian.org/debian-archive/debian/
     ftp://ftp.funet.fi/pub/mirrors/ftp.debian.org/debian/
   ];

pkgs/data/documentation/man-pages/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "man-pages-3.74";
+  name = "man-pages-3.75";
 
   src = fetchurl {
     url = "mirror://kernel/linux/docs/man-pages/${name}.tar.xz";
-    sha256 = "10c6jra95ccdhz22xhmpskxcn29xvirkxzwr8dhz3jazyqwhq58y";
+    sha256 = "1xnja13a3zb7gzcsdn7sx962lk6mj8m3rz1w7fpgvhsq745cmah6";
   };
 
   preBuild =

pkgs/data/fonts/meslo-lg/default.nix

···
+{ stdenv, fetchurl, unzip }:
+
+stdenv.mkDerivation rec {
+  version = "1.2.1";
+
+  name = "meslo-lg";
+
+  meslo-lg = fetchurl {
+    url="https://github.com/andreberg/Meslo-Font/blob/master/dist/v${version}/Meslo%20LG%20v${version}.zip?raw=true";
+    name="${name}";
+    sha256="1l08mxlzaz3i5bamnfr49s2k4k23vdm64b8nz2ha33ysimkbgg6h";
+  };
+
+  meslo-lg-dz = fetchurl {
+    url="https://github.com/andreberg/Meslo-Font/blob/master/dist/v${version}/Meslo%20LG%20DZ%20v${version}.zip?raw=true";
+    name="${name}-dz";
+    sha256="0lnbkrvcpgz9chnvix79j6fiz36wj6n46brb7b1746182rl1l875";
+  };
+
+  buildInputs = [ unzip ];
+
+  sourceRoot = ".";
+
+  phases = [ "unpackPhase" "installPhase" ];
+  unpackPhase = ''
+    unzip -j ${meslo-lg}
+    unzip -j ${meslo-lg-dz}
+  '';
+
+  installPhase = ''
+    mkdir -p $out/share/fonts/truetype
+    cp *.ttf $out/share/fonts/truetype
+  '';
+
+  meta = {
+    description = "A customized version of Apple’s Menlo-Regular font";
+    homepage = https://github.com/andreberg/Meslo-Font/;
+    license = stdenv.lib.licenses.asl20;
+    maintainers = with stdenv.lib.maintainers; [ balajisivaraman ];
+    platforms = with stdenv.lib.platforms; all;
+  };
+}

pkgs/data/misc/tzdata/default.nix

···
 { stdenv, fetchurl }:
 
-let version = "2014g"; in
+let version = "2014i"; in
 
 stdenv.mkDerivation rec {
   name = "tzdata-${version}";
···
   srcs =
     [ (fetchurl {
         url = "http://www.iana.org/time-zones/repository/releases/tzdata${version}.tar.gz";
-        sha256 = "0w52hafnf82vy678rm8p39ckymcj6shv5376zwzzbxw2m6vxaism";
+        sha256 = "0lv1i3ikibf9yn1l3hcy00x5ghwxn87k1myyp1cyr55psayk3wra";
       })
       (fetchurl {
         url = "http://www.iana.org/time-zones/repository/releases/tzcode${version}.tar.gz";
-        sha256 = "0ymg0cscpbfj9jpnx4g9apmfrixq6z8dch99h6a77k2pmnj5ymfz";
+        sha256 = "10s7x24lh2vm3magl7dq2xs9pw47hhyaq6xpi6c4aiqdzdsi0nb2";
       })
     ];
 
···
   meta = {
     homepage = http://www.iana.org/time-zones;
     description = "Database of current and historical time zones";
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/desktops/gnome-2/desktop/scrollkeeper/default.nix

···
   ";
 
   buildInputs = [pkgconfig perl perlXMLParser libxml2 libxslt gettext];
-  configureFlags = "--with-xml-catalog=${docbook_xml_dtd_42}/xml/dtd/docbook/docbook.cat";
+  configureFlags = "--with-xml-catalog=${docbook_xml_dtd_42}/xml/dtd/docbook/catalog.xml";
 }

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

···
 
   gucharmap = callPackage ./core/gucharmap { };
 
-  gvfs = pkgs.gvfs.override { gnome = pkgs.gnome3; lightWeight = false; };
+  gvfs = pkgs.gvfs.override { gnome = pkgs.gnome3; gnomeSupport = true; };
 
   eog = callPackage ./core/eog { };
 

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

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gnome-shell-pomodoro-0.10.2-11-gd5f5b69";
+  rev = "0.10.3";
+  name = "gnome-shell-pomodoro-${rev}-61df3fa";
 
   src = fetchFromGitHub {
       owner = "codito";
       repo = "gnome-shell-pomodoro";
-      rev = "0.10.2";
-      sha256 = "1jd4xmcx0fbcn57d1qj7b4xkj0dv4i75s367nifabm47akqzyn4f";
+      rev = "${rev}";
+      sha256 = "0i0glmijalppb5hdb1xd6xnmv824l2w831rpkqmhxi0iqbvaship";
   };
 
   configureScript = ''./autogen.sh'';

pkgs/desktops/gnome-3/3.12/core/vte/0.38.0.nix

···
+{ stdenv, fetchurl, intltool, pkgconfig, gnome3, ncurses, gobjectIntrospection, vala, libxml2
+, selectTextPatch ? false }:
+
+stdenv.mkDerivation rec {
+  versionMajor = "0.38";
+  versionMinor = "0";
+  moduleName   = "vte";
+
+  name = "${moduleName}-${versionMajor}.${versionMinor}";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${moduleName}/${versionMajor}/${name}.tar.xz";
+    sha256 = "1llg2xnjpn630vd86ci8csbjjacj3ia6syck2bsq4kinr66z5zsw";
+  };
+
+  patches = with stdenv.lib; optional selectTextPatch ./expose_select_text.0.38.0.patch;
+
+  buildInputs = [ gobjectIntrospection intltool pkgconfig gnome3.glib gnome3.gtk3 ncurses vala libxml2 ];
+
+  preConfigure = "patchShebangs .";
+
+  configureFlags = [ "--enable-introspection" ];
+
+  enableParallelBuilding = true;
+
+  postInstall = ''
+    substituteInPlace $out/lib/libvte2_90.la --replace "-lncurses" "-L${ncurses}/lib -lncurses"
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = http://www.gnome.org/;
+    description = "A library implementing a terminal emulator widget for GTK+";
+    longDescription = ''
+      VTE is a library (libvte) implementing a terminal emulator widget for
+      GTK+, and a minimal sample application (vte) using that.  Vte is
+      mainly used in gnome-terminal, but can also be used to embed a
+      console/terminal in games, editors, IDEs, etc. VTE supports Unicode and
+      character set conversion, as well as emulating any terminal known to
+      the system's terminfo database.
+    '';
+    license = licenses.lgpl2;
+    maintainers = with maintainers; [ astsmtl antono lethalman ];
+    platforms = platforms.linux;
+  };
+}

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

···
-{ stdenv, fetchurl, intltool, pkgconfig, gnome3, ncurses, gobjectIntrospection, vala, libxml2
+{ stdenv, fetchurl, intltool, pkgconfig, gnome3, ncurses, gobjectIntrospection
 , selectTextPatch ? false }:
 
 stdenv.mkDerivation rec {

pkgs/desktops/gnome-3/3.12/core/vte/expose_select_text.0.38.0.patch

···
+Only in vte-0.38.0.new: expose_select_text.patch
+diff -aur vte-0.38.0/src/vteaccess.c vte-0.38.0.new/src/vteaccess.c
+--- vte-0.38.0/src/vteaccess.c	2014-08-13 08:00:38.000000000 -0400
++++ vte-0.38.0.new/src/vteaccess.c	2014-09-21 17:05:23.934641193 -0400
+@@ -1427,7 +1427,7 @@
+ 	*start_offset = offset_from_xy (priv, start_x, start_y);
+ 	_vte_terminal_get_end_selection (terminal, &end_x, &end_y);
+ 	*end_offset = offset_from_xy (priv, end_x, end_y);
+-	return _vte_terminal_get_selection (terminal);
++	return vte_terminal_get_selection (terminal);
+ }
+ 
+ static gboolean
+diff -aur vte-0.38.0/src/vte.c vte-0.38.0.new/src/vte.c
+--- vte-0.38.0/src/vte.c	2014-09-13 03:23:47.000000000 -0400
++++ vte-0.38.0.new/src/vte.c	2014-09-21 17:03:04.671656749 -0400
+@@ -122,7 +122,6 @@
+ 						 gpointer data,
+ 						 GArray *attributes,
+ 						 gboolean include_trailing_spaces);
+-static void _vte_terminal_disconnect_pty_read(VteTerminal *terminal);
+ static void _vte_terminal_disconnect_pty_write(VteTerminal *terminal);
+ static void vte_terminal_stop_processing (VteTerminal *terminal);
+ 
+@@ -3267,9 +3266,10 @@
+ 	_vte_debug_print (VTE_DEBUG_IO, "removed poll of vte_terminal_io_read\n");
+ 	terminal->pvt->pty_input_source = 0;
+ }
+-static void
+-_vte_terminal_connect_pty_read(VteTerminal *terminal)
++void
++vte_terminal_connect_pty_read(VteTerminal *terminal)
+ {
++	g_return_if_fail(VTE_IS_TERMINAL(terminal));
+ 	if (terminal->pvt->pty_channel == NULL) {
+ 		return;
+ 	}
+@@ -3321,9 +3321,10 @@
+ 	}
+ }
+ 
+-static void
+-_vte_terminal_disconnect_pty_read(VteTerminal *terminal)
++void
++vte_terminal_disconnect_pty_read(VteTerminal *terminal)
+ {
++	g_return_if_fail(VTE_IS_TERMINAL(terminal));
+ 	if (terminal->pvt->pty_input_source != 0) {
+ 		_vte_debug_print (VTE_DEBUG_IO, "disconnecting poll of vte_terminal_io_read\n");
+ 		g_source_remove(terminal->pvt->pty_input_source);
+@@ -6154,6 +6155,28 @@
+ 	}
+ }
+ 
++/**
++ * vte_terminal_set_cursor_position:
++ * @terminal: a #VteTerminal
++ * @column: the new cursor column
++ * @row: the new cursor row
++ *
++ * Set the location of the cursor.
++ */
++void
++vte_terminal_set_cursor_position(VteTerminal *terminal,
++				 long column, long row)
++{
++	g_return_if_fail(VTE_IS_TERMINAL(terminal));
++
++	_vte_invalidate_cursor_once(terminal, FALSE);
++	terminal->pvt->screen->cursor_current.col = column;
++	terminal->pvt->screen->cursor_current.row = row;
++	_vte_invalidate_cursor_once(terminal, FALSE);
++	_vte_check_cursor_blink(terminal);
++	vte_terminal_queue_cursor_moved(terminal);
++}
++
+ static GtkClipboard *
+ vte_terminal_clipboard_get(VteTerminal *terminal, GdkAtom board)
+ {
+@@ -6319,7 +6342,7 @@
+         vte_terminal_extend_selection(terminal, x, y, FALSE, TRUE);
+ 
+ 	/* Temporarily stop caring about input from the child. */
+-	_vte_terminal_disconnect_pty_read(terminal);
++	vte_terminal_disconnect_pty_read(terminal);
+ }
+ 
+ static gboolean
+@@ -6336,7 +6359,7 @@
+ 		terminal->pvt->selecting = FALSE;
+ 
+ 		/* Reconnect to input from the child if we paused it. */
+-		_vte_terminal_connect_pty_read(terminal);
++		vte_terminal_connect_pty_read(terminal);
+ 
+ 		return TRUE;
+ 	}
+@@ -6834,6 +6857,50 @@
+ 	vte_terminal_deselect_all (terminal);
+ }
+ 
++/**
++ * vte_terminal_get_selection_block_mode:
++ * @terminal: a #VteTerminal
++ *
++ * Checks whether or not block selection is enabled.
++ *
++ * Returns: %TRUE if block selection is enabled, %FALSE if not
++ */
++gboolean
++vte_terminal_get_selection_block_mode(VteTerminal *terminal) {
++	g_return_val_if_fail(VTE_IS_TERMINAL(terminal), FALSE);
++	return terminal->pvt->selection_block_mode;
++}
++
++/**
++ * vte_terminal_set_selection_block_mode:
++ * @terminal: a #VteTerminal
++ * @block_mode: whether block selection is enabled
++ *
++ * Sets whether or not block selection is enabled.
++ */
++void
++vte_terminal_set_selection_block_mode(VteTerminal *terminal, gboolean block_mode) {
++	g_return_if_fail(VTE_IS_TERMINAL(terminal));
++	terminal->pvt->selection_block_mode = block_mode;
++}
++
++/**
++ * vte_terminal_select_text:
++ * @terminal: a #VteTerminal
++ * @start_col: the starting column for the selection
++ * @start_row: the starting row for the selection
++ * @end_col: the end column for the selection
++ * @end_row: the end row for the selection
++ *
++ * Sets the current selection region.
++ */
++void
++vte_terminal_select_text(VteTerminal *terminal,
++			 long start_col, long start_row,
++			 long end_col, long end_row) {
++	_vte_terminal_select_text(terminal, start_col, start_row, end_col, end_row, 0, 0);
++}
++
+ /* Autoscroll a bit. */
+ static gboolean
+ vte_terminal_autoscroll(VteTerminal *terminal)
+@@ -8476,7 +8543,7 @@
+ #endif
+ 		kill(terminal->pvt->pty_pid, SIGHUP);
+ 	}
+-	_vte_terminal_disconnect_pty_read(terminal);
++	vte_terminal_disconnect_pty_read(terminal);
+ 	_vte_terminal_disconnect_pty_write(terminal);
+ 	if (terminal->pvt->pty_channel != NULL) {
+ 		g_io_channel_unref (terminal->pvt->pty_channel);
+@@ -12533,7 +12600,7 @@
+         g_object_freeze_notify(object);
+ 
+         if (pvt->pty != NULL) {
+-                _vte_terminal_disconnect_pty_read(terminal);
++                vte_terminal_disconnect_pty_read(terminal);
+                 _vte_terminal_disconnect_pty_write(terminal);
+ 
+                 if (terminal->pvt->pty_channel != NULL) {
+@@ -12588,7 +12655,7 @@
+         _vte_terminal_setup_utf8 (terminal);
+ 
+         /* Open channels to listen for input on. */
+-        _vte_terminal_connect_pty_read (terminal);
++        vte_terminal_connect_pty_read (terminal);
+ 
+         g_object_notify(object, "pty");
+ 
+@@ -12623,7 +12690,7 @@
+ }
+ 
+ char *
+-_vte_terminal_get_selection(VteTerminal *terminal)
++vte_terminal_get_selection(VteTerminal *terminal)
+ {
+ 	g_return_val_if_fail(VTE_IS_TERMINAL(terminal), NULL);
+ 
+Only in vte-0.38.0.new/src: .vte.c.swp
+diff -aur vte-0.38.0/src/vteint.h vte-0.38.0.new/src/vteint.h
+--- vte-0.38.0/src/vteint.h	2014-05-16 13:51:26.000000000 -0400
++++ vte-0.38.0.new/src/vteint.h	2014-09-21 17:05:44.934589281 -0400
+@@ -25,7 +25,6 @@
+ G_BEGIN_DECLS
+ 
+ void _vte_terminal_accessible_ref(VteTerminal *terminal);
+-char* _vte_terminal_get_selection(VteTerminal *terminal);
+ void _vte_terminal_get_start_selection(VteTerminal *terminal, long *x, long *y);
+ void _vte_terminal_get_end_selection(VteTerminal *terminal, long *x, long *y);
+ void _vte_terminal_select_text(VteTerminal *terminal, long start_x, long start_y, long end_x, long end_y, int start_offset, int end_offset);
+diff -aur vte-0.38.0/src/vteterminal.h vte-0.38.0.new/src/vteterminal.h
+--- vte-0.38.0/src/vteterminal.h	2014-09-13 03:23:47.000000000 -0400
++++ vte-0.38.0.new/src/vteterminal.h	2014-09-21 17:03:39.094903032 -0400
+@@ -170,6 +170,18 @@
+ 
+ void vte_terminal_select_all(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
+ void vte_terminal_unselect_all(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
++gboolean vte_terminal_get_selection_block_mode(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
++void vte_terminal_set_selection_block_mode(VteTerminal *terminal,
++                                           gboolean block_mode) _VTE_GNUC_NONNULL(1);
++void vte_terminal_select_text(VteTerminal *terminal,
++                              long start_col, long start_row,
++                              long end_col, long end_row) _VTE_GNUC_NONNULL(1);
++char *
++vte_terminal_get_selection(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
++
++/* pause and unpause output */
++void vte_terminal_disconnect_pty_read(VteTerminal *vte);
++void vte_terminal_connect_pty_read(VteTerminal *vte);
+ 
+ /* Set the terminal's size. */
+ void vte_terminal_set_size(VteTerminal *terminal,
+@@ -276,6 +288,8 @@
+ void vte_terminal_get_cursor_position(VteTerminal *terminal,
+ 				      glong *column,
+                                       glong *row) _VTE_GNUC_NONNULL(1);
++void vte_terminal_set_cursor_position(VteTerminal *terminal,
++				      long column, long row) _VTE_GNUC_NONNULL(1);
+ 
+ /* Add a matching expression, returning the tag the widget assigns to that
+  * expression. */

pkgs/desktops/gnome-3/3.12/core/vte/expose_select_text.patch

···
-diff -aur vte-0.32.2-old/src/vte.c vte-0.32.2/src/vte.c
---- vte-0.32.2-old/src/vte.c	2012-07-13 21:09:04.003969877 -0400
-+++ vte-0.32.2/src/vte.c	2012-08-30 04:30:04.285924831 -0400
-@@ -129,7 +129,6 @@
+Only in vte-0.38.0.new: expose_select_text.patch
+diff -aur vte-0.38.0/src/vteaccess.c vte-0.38.0.new/src/vteaccess.c
+--- vte-0.38.0/src/vteaccess.c	2014-08-13 08:00:38.000000000 -0400
++++ vte-0.38.0.new/src/vteaccess.c	2014-09-21 17:05:23.934641193 -0400
+@@ -1427,7 +1427,7 @@
+ 	*start_offset = offset_from_xy (priv, start_x, start_y);
+ 	_vte_terminal_get_end_selection (terminal, &end_x, &end_y);
+ 	*end_offset = offset_from_xy (priv, end_x, end_y);
+-	return _vte_terminal_get_selection (terminal);
++	return vte_terminal_get_selection (terminal);
+ }
+ 
+ static gboolean
+diff -aur vte-0.38.0/src/vte.c vte-0.38.0.new/src/vte.c
+--- vte-0.38.0/src/vte.c	2014-09-13 03:23:47.000000000 -0400
++++ vte-0.38.0.new/src/vte.c	2014-09-21 17:03:04.671656749 -0400
+@@ -122,7 +122,6 @@
  						 gpointer data,
  						 GArray *attributes,
  						 gboolean include_trailing_spaces);
···
  static void _vte_terminal_disconnect_pty_write(VteTerminal *terminal);
  static void vte_terminal_stop_processing (VteTerminal *terminal);
  
-@@ -3508,8 +3507,8 @@
+@@ -3267,9 +3266,10 @@
  	_vte_debug_print (VTE_DEBUG_IO, "removed poll of vte_terminal_io_read\n");
  	terminal->pvt->pty_input_source = 0;
  }
···
 +void
 +vte_terminal_connect_pty_read(VteTerminal *terminal)
  {
++	g_return_if_fail(VTE_IS_TERMINAL(terminal));
  	if (terminal->pvt->pty_channel == NULL) {
  		return;
-@@ -3560,8 +3559,8 @@
+ 	}
+@@ -3321,9 +3321,10 @@
  	}
  }
  
···
 +void
 +vte_terminal_disconnect_pty_read(VteTerminal *terminal)
  {
++	g_return_if_fail(VTE_IS_TERMINAL(terminal));
  	if (terminal->pvt->pty_input_source != 0) {
  		_vte_debug_print (VTE_DEBUG_IO, "disconnecting poll of vte_terminal_io_read\n");
-@@ -3708,8 +3707,8 @@
-         return NULL;
- }
- 
--static char *
--_vte_terminal_get_user_shell_with_fallback (void)
-+char *
-+vte_terminal_get_user_shell_with_fallback (void)
- {
-         char *command;
-         const gchar *env;
-@@ -3744,7 +3743,7 @@
- 	char **argv2;
-         char *shell = NULL;
- 
--        argv2 = __vte_pty_get_argv(command ? command : (shell = _vte_terminal_get_user_shell_with_fallback ()),
-+        argv2 = __vte_pty_get_argv(command ? command : (shell = vte_terminal_get_user_shell_with_fallback ()),
-                                    argv,
-                                    flags);
-         g_free(shell);
-@@ -6545,6 +6544,28 @@
+ 		g_source_remove(terminal->pvt->pty_input_source);
+@@ -6154,6 +6155,28 @@
  	}
  }
  
···
  static GtkClipboard *
  vte_terminal_clipboard_get(VteTerminal *terminal, GdkAtom board)
  {
-@@ -6676,7 +6697,7 @@
- 			terminal->pvt->selection_start.row);
+@@ -6319,7 +6342,7 @@
+         vte_terminal_extend_selection(terminal, x, y, FALSE, TRUE);
  
  	/* Temporarily stop caring about input from the child. */
 -	_vte_terminal_disconnect_pty_read(terminal);
···
  }
  
  static gboolean
-@@ -6693,7 +6714,7 @@
+@@ -6336,7 +6359,7 @@
  		terminal->pvt->selecting = FALSE;
  
  		/* Reconnect to input from the child if we paused it. */
···
  
  		return TRUE;
  	}
-@@ -8994,7 +9015,7 @@
- #endif
- 		kill(terminal->pvt->pty_pid, SIGHUP);
- 	}
--	_vte_terminal_disconnect_pty_read(terminal);
-+	vte_terminal_disconnect_pty_read(terminal);
- 	_vte_terminal_disconnect_pty_write(terminal);
- 	if (terminal->pvt->pty_channel != NULL) {
- 		g_io_channel_unref (terminal->pvt->pty_channel);
-@@ -14384,7 +14405,7 @@
-         g_object_freeze_notify(object);
- 
-         if (pvt->pty != NULL) {
--                _vte_terminal_disconnect_pty_read(terminal);
-+                vte_terminal_disconnect_pty_read(terminal);
-                 _vte_terminal_disconnect_pty_write(terminal);
- 
-                 if (terminal->pvt->pty_channel != NULL) {
-@@ -14440,7 +14461,7 @@
-         _vte_terminal_setup_utf8 (terminal);
- 
-         /* Open channels to listen for input on. */
--        _vte_terminal_connect_pty_read (terminal);
-+        vte_terminal_connect_pty_read (terminal);
- 
-         g_object_notify(object, "pty");
-         g_object_notify(object, "pty-object");
-@@ -14567,6 +14588,50 @@
- 	}
+@@ -6834,6 +6857,50 @@
+ 	vte_terminal_deselect_all (terminal);
  }
  
 +/**
···
 +	_vte_terminal_select_text(terminal, start_col, start_row, end_col, end_row, 0, 0);
 +}
 +
- void
- _vte_terminal_select_text(VteTerminal *terminal,
- 			  long start_col, long start_row,
-diff -aur vte-0.32.2-old/src/vte.h vte-0.32.2/src/vte.h
---- vte-0.32.2-old/src/vte.h	2012-07-13 21:09:04.003969877 -0400
-+++ vte-0.32.2/src/vte.h	2012-08-30 04:30:09.695999432 -0400
-@@ -296,6 +296,15 @@
- /* simple manipulation of selection */
- void vte_terminal_select_all(VteTerminal *terminal);
- void vte_terminal_select_none(VteTerminal *terminal);
-+gboolean vte_terminal_get_selection_block_mode(VteTerminal *terminal);
-+void vte_terminal_set_selection_block_mode(VteTerminal *terminal, gboolean block_mode);
+ /* Autoscroll a bit. */
+ static gboolean
+ vte_terminal_autoscroll(VteTerminal *terminal)
+@@ -8476,7 +8543,7 @@
+ #endif
+ 		kill(terminal->pvt->pty_pid, SIGHUP);
+ 	}
+-	_vte_terminal_disconnect_pty_read(terminal);
++	vte_terminal_disconnect_pty_read(terminal);
+ 	_vte_terminal_disconnect_pty_write(terminal);
+ 	if (terminal->pvt->pty_channel != NULL) {
+ 		g_io_channel_unref (terminal->pvt->pty_channel);
+@@ -12533,7 +12600,7 @@
+         g_object_freeze_notify(object);
+ 
+         if (pvt->pty != NULL) {
+-                _vte_terminal_disconnect_pty_read(terminal);
++                vte_terminal_disconnect_pty_read(terminal);
+                 _vte_terminal_disconnect_pty_write(terminal);
+ 
+                 if (terminal->pvt->pty_channel != NULL) {
+@@ -12588,7 +12655,7 @@
+         _vte_terminal_setup_utf8 (terminal);
+ 
+         /* Open channels to listen for input on. */
+-        _vte_terminal_connect_pty_read (terminal);
++        vte_terminal_connect_pty_read (terminal);
+ 
+         g_object_notify(object, "pty");
+ 
+@@ -12623,7 +12690,7 @@
+ }
+ 
+ char *
+-_vte_terminal_get_selection(VteTerminal *terminal)
++vte_terminal_get_selection(VteTerminal *terminal)
+ {
+ 	g_return_val_if_fail(VTE_IS_TERMINAL(terminal), NULL);
+ 
+Only in vte-0.38.0.new/src: .vte.c.swp
+diff -aur vte-0.38.0/src/vteint.h vte-0.38.0.new/src/vteint.h
+--- vte-0.38.0/src/vteint.h	2014-05-16 13:51:26.000000000 -0400
++++ vte-0.38.0.new/src/vteint.h	2014-09-21 17:05:44.934589281 -0400
+@@ -25,7 +25,6 @@
+ G_BEGIN_DECLS
+ 
+ void _vte_terminal_accessible_ref(VteTerminal *terminal);
+-char* _vte_terminal_get_selection(VteTerminal *terminal);
+ void _vte_terminal_get_start_selection(VteTerminal *terminal, long *x, long *y);
+ void _vte_terminal_get_end_selection(VteTerminal *terminal, long *x, long *y);
+ void _vte_terminal_select_text(VteTerminal *terminal, long start_x, long start_y, long end_x, long end_y, int start_offset, int end_offset);
+diff -aur vte-0.38.0/src/vteterminal.h vte-0.38.0.new/src/vteterminal.h
+--- vte-0.38.0/src/vteterminal.h	2014-09-13 03:23:47.000000000 -0400
++++ vte-0.38.0.new/src/vteterminal.h	2014-09-21 17:03:39.094903032 -0400
+@@ -170,6 +170,18 @@
+ 
+ void vte_terminal_select_all(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
+ void vte_terminal_unselect_all(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
++gboolean vte_terminal_get_selection_block_mode(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
++void vte_terminal_set_selection_block_mode(VteTerminal *terminal,
++                                           gboolean block_mode) _VTE_GNUC_NONNULL(1);
 +void vte_terminal_select_text(VteTerminal *terminal,
 +                              long start_col, long start_row,
-+                              long end_col, long end_row);
++                              long end_col, long end_row) _VTE_GNUC_NONNULL(1);
++char *
++vte_terminal_get_selection(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
 +
 +/* pause and unpause output */
 +void vte_terminal_disconnect_pty_read(VteTerminal *vte);
···
  
  /* Set the terminal's size. */
  void vte_terminal_set_size(VteTerminal *terminal,
-@@ -435,6 +444,8 @@
- 				  GArray *attributes);
+@@ -276,6 +288,8 @@
  void vte_terminal_get_cursor_position(VteTerminal *terminal,
- 				      glong *column, glong *row);
+ 				      glong *column,
+                                       glong *row) _VTE_GNUC_NONNULL(1);
 +void vte_terminal_set_cursor_position(VteTerminal *terminal,
-+				      long column, long row);
- /* Display string matching:  clear all matching expressions. */
- void vte_terminal_match_clear_all(VteTerminal *terminal);
++				      long column, long row) _VTE_GNUC_NONNULL(1);
  
-@@ -484,6 +495,7 @@
- VtePty *vte_terminal_get_pty_object(VteTerminal *terminal);
- 
- char *vte_get_user_shell (void);
-+char *vte_terminal_get_user_shell_with_fallback(void);
- 
- /* Accessors for bindings. */
- #if !GTK_CHECK_VERSION (2, 91, 2)
+ /* Add a matching expression, returning the tag the widget assigns to that
+  * expression. */

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

···
 
   gucharmap = callPackage ./core/gucharmap { };
 
-  gvfs = pkgs.gvfs.override { gnome = gnome3; lightWeight = false; };
+  gvfs = pkgs.gvfs.override { gnome = gnome3; gnomeSupport = true; };
 
   eog = callPackage ./core/eog { };
 
···
 
   vte = callPackage ./core/vte { };
 
-  vte-select-text = callPackage ./core/vte { selectTextPatch = true; };
+  vte_038 = callPackage ./core/vte/0.38.0.nix { }; # To be moved in gnome 3.14 when available
+
+  vte-select-text = vte_038.override { selectTextPatch = true; };
 
   vino = callPackage ./core/vino { };
 

pkgs/development/arduino/arduino-core/default.nix

···
-{ stdenv, fetchFromGitHub, jdk, jre, ant, coreutils, gnugrep }:
+{ stdenv, fetchFromGitHub, jdk, jre, ant, coreutils, gnugrep, file }:
 
 stdenv.mkDerivation rec {
 
···
     sha256 = "0nr5b719qi03rcmx6swbhccv6kihxz3b8b6y46bc2j348rja5332";
   };
 
-  buildInputs = [ jdk ant ];
+  buildInputs = [ jdk ant file ];
 
   buildPhase = ''
     cd ./core && ant 
···
     cp -r ./build/linux/work/tools/ $out/share/arduino
     cp -r ./build/linux/work/lib/ $out/share/arduino
     echo ${version} > $out/share/arduino/lib/version.txt
+
+    # Fixup "/lib64/ld-linux-x86-64.so.2" like references in ELF executables.
+    echo "running patchelf on prebuilt binaries:"
+    find "$out" | while read filepath; do
+        if file "$filepath" | grep -q "ELF.*executable"; then
+            # skip target firmware files
+            if echo "$filepath" | grep -q "\.elf$"; then
+                continue
+            fi
+            echo "setting interpreter $(cat "$NIX_GCC"/nix-support/dynamic-linker) in $filepath"
+            patchelf --set-interpreter "$(cat "$NIX_GCC"/nix-support/dynamic-linker)" "$filepath"
+            test $? -eq 0 || { echo "patchelf failed to process $filepath"; exit 1; }
+        fi
+    done
   '';
 
   meta = {

pkgs/development/compilers/ats2/default.nix

···
 
 stdenv.mkDerivation rec {
   name    = "ats2-${version}";
-  version = "0.1.3";
+  version = "0.1.4";
 
   src = fetchurl {
     url = "mirror://sourceforge/ats2-lang/ATS2-Postiats-${version}.tgz";
-    sha256 = "157k703zsdf0gr7mwz08rdldfgwfsm5ipg36xcc8092fcjs5ryqp";
+    sha256 = "174kxdvdgp2rlb0qq7d854n6m9gzy0g8annk3bmbqb23m36n2g39";
   };
 
   buildInputs = [ gmp ];

pkgs/development/compilers/bigloo/default.nix

···
-{ fetchurl, stdenv }:
+{ fetchurl, stdenv, gmp }:
 
 stdenv.mkDerivation rec {
   name = "bigloo-${version}";
-  version = "3.7a";
+  version = "4.1a-2";
 
   src = fetchurl {
     url = "ftp://ftp-sop.inria.fr/indes/fp/Bigloo/bigloo${version}.tar.gz";
-    sha256 = "0y8i87c2bpqzap8rhzgpyfgdzq21py5xq6mgp0w6xv4rjcj9d0v1";
+    sha256 = "09yrz8r0jpj7bda39fdxzrrdyhi851nlfajsyf0b6jxanz6ygcjx";
   };
+
+  buildInputs = [ gmp ];
 
   preConfigure =
     # Help libgc's configure.
···
 
   meta = {
     description = "Efficient Scheme compiler";
+    homepage    = http://www-sop.inria.fr/indes/fp/Bigloo/;
+    license     = stdenv.lib.licenses.gpl2Plus;
+    platforms   = stdenv.lib.platforms.unix;
+    maintainers = with stdenv.lib.maintainers; [ ludo thoughtpolice ];
 
     longDescription = ''
       Bigloo is a Scheme implementation devoted to one goal: enabling
···
       Scheme and C programs, between Scheme and Java programs, and
       between Scheme and C# programs.
     '';
-
-    homepage = http://www-sop.inria.fr/indes/fp/Bigloo/;
-    license = stdenv.lib.licenses.gpl2Plus;
-
-    maintainers = [ stdenv.lib.maintainers.ludo ];
-    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
   };
 }

pkgs/development/compilers/chicken/0001-Introduce-CHICKEN_REPOSITORY_EXTRA.patch

···
+From 752dff853186dc334c519a86fa92f087795fea02 Mon Sep 17 00:00:00 2001
+From: Moritz Heidkamp <[e-mail]>
+Date: Wed, 1 Oct 2014 22:41:30 +0200
+Subject: [PATCH] Introduce CHICKEN_REPOSITORY_EXTRA
+
+This environment variable works like CHICKEN_REPOSITORY but supports
+multiple paths separated by `:'. Those paths are searched after
+CHICKEN_REPOSITORY when loading extensions via `require-library' and
+friends. It can be accessed and changed at runtime via the new procedure
+`repository-extra-paths' which is analog to `repository-path'.
+---
+ chicken-install.scm | 11 +++++++----
+ chicken.import.scm  |  1 +
+ eval.scm            | 37 +++++++++++++++++++++++++++++++------
+ 3 files changed, 39 insertions(+), 10 deletions(-)
+
+diff --git a/chicken-install.scm b/chicken-install.scm
+index 2ef6ef4..b5c6bf8 100644
+--- a/chicken-install.scm
++++ b/chicken-install.scm
+@@ -109,10 +109,10 @@
+   (define *show-foreign-depends* #f)
+   (define *hacks* '())
+ 
+-  (define (repo-path)
++  (define (repo-paths)
+     (if (and *cross-chicken* (not *host-extension*))
+-	(make-pathname C_TARGET_LIB_HOME (sprintf "chicken/~a" C_BINARY_VERSION))
+-	(repository-path)))
++	(list (make-pathname C_TARGET_LIB_HOME (sprintf "chicken/~a" C_BINARY_VERSION)))
++	(cons (repository-path) (repository-extra-paths))))
+ 
+   (define (get-prefix #!optional runtime)
+     (cond ((and *cross-chicken*
+@@ -757,7 +757,10 @@
+ 		  "installed extension has no information about which egg it belongs to"
+ 		  (pathname-file sf))
+ 		 #f))))
+-      (glob (make-pathname (repo-path) "*" "setup-info")))
++      (append-map
++       (lambda (path)
++	 (glob (make-pathname path "*" "setup-info")))
++       (repo-paths)))
+      equal?))
+ 
+   (define (list-available-extensions trans locn)
+diff --git a/chicken.import.scm b/chicken.import.scm
+index baa7316..2839b16 100644
+--- a/chicken.import.scm
++++ b/chicken.import.scm
+@@ -201,6 +201,7 @@
+    repl
+    repl-prompt
+    repository-path
++   repository-extra-paths
+    require
+    reset
+    reset-handler
+diff --git a/eval.scm b/eval.scm
+index bbcd86c..838588d 100644
+--- a/eval.scm
++++ b/eval.scm
+@@ -81,6 +81,7 @@
+ (define-constant source-file-extension ".scm")
+ (define-constant setup-file-extension "setup-info")
+ (define-constant repository-environment-variable "CHICKEN_REPOSITORY")
++(define-constant repository-extra-environment-variable "CHICKEN_REPOSITORY_EXTRA")
+ (define-constant prefix-environment-variable "CHICKEN_PREFIX")
+ 
+ ; these are actually in unit extras, but that is used by default
+@@ -1180,6 +1181,25 @@
+ 
+ (define repository-path ##sys#repository-path)
+ 
++(define ##sys#repository-extra-paths
++  (let* ((repaths (get-environment-variable repository-extra-environment-variable))
++	 (repaths (if repaths
++		      (let ((len (string-length repaths)))
++			(let loop ((i 0) (offset 0) (res '()))
++			  (cond ((> i len)
++				 (reverse res))
++				((or (= i len) (eq? #\: (string-ref repaths i)))
++				 (loop (+ i 1) (+ i 1) (cons (substring repaths offset i) res)))
++				(else
++				 (loop (+ i 1) offset res)))))
++		      '())))
++    (lambda (#!optional val)
++      (if val
++	  (set! repaths val)
++	  repaths))))
++
++(define repository-extra-paths ##sys#repository-extra-paths)
++
+ (define ##sys#setup-mode #f)
+ 
+ (define ##sys#find-extension
+@@ -1197,6 +1217,7 @@
+ 	(let loop ((paths (##sys#append
+ 			   (if ##sys#setup-mode '(".") '())
+ 			   (if rp (list rp) '())
++			   (##sys#repository-extra-paths)
+ 			   (if inc? ##sys#include-pathnames '())
+ 			   (if ##sys#setup-mode '() '("."))) ))
+ 	  (and (pair? paths)
+@@ -1256,12 +1277,16 @@
+ 	[string-append string-append]
+ 	[read read] )
+     (lambda (id loc)
+-      (and-let* ((rp (##sys#repository-path)))
+-	(let* ((p (##sys#canonicalize-extension-path id loc))
+-	       (rpath (string-append rp "/" p ".")) )
+-	  (cond ((file-exists? (string-append rpath setup-file-extension))
+-		 => (cut with-input-from-file <> read) )
+-		(else #f) ) ) ) ) ))
++      (let loop ((rpaths (cons (##sys#repository-path) (##sys#repository-extra-paths))))
++	(and (pair? rpaths)
++	     (let ((rp (car rpaths)))
++	       (if (not rp)
++		   (loop (cdr rpaths))
++		   (let* ((p (##sys#canonicalize-extension-path id loc))
++			  (rpath (string-append rp "/" p ".")) )
++		     (cond ((file-exists? (string-append rpath setup-file-extension))
++			    => (cut with-input-from-file <> read) )
++			   (else (loop (cdr rpaths))) ) )) ))) ) ))
+ 
+ (define (extension-information ext)
+   (##sys#extension-information ext 'extension-information) )
+-- 
+2.1.0
+

pkgs/development/compilers/chicken/default.nix

···
-{ stdenv, fetchurl }:
+{ stdenv, fetchurl, makeWrapper, bootstrap-chicken ? null }:
 
 let
   version = "4.9.0.1";
···
     else if isBSD then "bsd"
     else if isSunOS then "solaris"
     else "linux";               # Should be a sane default
+  lib = stdenv.lib;
 in
 stdenv.mkDerivation {
   name = "chicken-${version}";
 
+  binaryVersion = 7;
+
   src = fetchurl {
     url = "http://code.call-cc.org/releases/4.9.0/chicken-${version}.tar.gz";
     sha256 = "0598mar1qswfd8hva9nqs88zjn02lzkqd8fzdd21dz1nki1prpq4";
   };
 
+  setupHook = lib.ifEnable (bootstrap-chicken != null) ./setup-hook.sh;
+  
   buildFlags = "PLATFORM=${platform} PREFIX=$(out) VARDIR=$(out)/var/lib";
   installFlags = "PLATFORM=${platform} PREFIX=$(out) VARDIR=$(out)/var/lib";
+
+  # We need a bootstrap-chicken to regenerate the c-files after
+  # applying a patch to add support for CHICKEN_REPOSITORY_EXTRA
+  patches = lib.ifEnable (bootstrap-chicken != null) [
+    ./0001-Introduce-CHICKEN_REPOSITORY_EXTRA.patch
+  ];
+
+  buildInputs = [
+    makeWrapper
+  ] ++ (lib.ifEnable (bootstrap-chicken != null) [
+    bootstrap-chicken
+  ]);
+
+  preBuild = lib.ifEnable (bootstrap-chicken != null) ''
+    # Backup the build* files - those are generated from hostname,
+    # git-tag, etc. and we don't need/want that
+    mkdir -p build-backup
+    mv buildid buildbranch buildtag.h build-backup
+
+    # Regenerate eval.c after the patch
+    make spotless $buildFlags
+
+    mv build-backup/* .
+  '';
+
+  postInstall = ''
+    for f in $out/bin/*
+    do
+      wrapProgram $f \
+        --prefix PATH : ${stdenv.gcc}/bin
+    done
+  '';
+
+  # TODO: Assert csi -R files -p '(pathname-file (repository-path))' == binaryVersion
 
   meta = {
     homepage = http://www.call-cc.org/;

pkgs/development/compilers/chicken/eggDerivation.nix

···
+{ stdenv, fetchegg, chicken, makeWrapper }:
+{ name, src
+, buildInputs ? []
+, chickenInstallFlags ? []
+, cscOptions          ? []
+, ...} @ args:
+
+let
+  libPath = "${chicken}/var/lib/chicken/${toString chicken.binaryVersion}/";
+  overrides = import ./overrides.nix;
+  lib = stdenv.lib;
+  baseName = (builtins.parseDrvName name).name;
+  override = if builtins.hasAttr baseName overrides
+   then
+     builtins.getAttr baseName overrides
+   else
+     {};
+in
+stdenv.mkDerivation ({
+  name = "chicken-${name}";
+  propagatedBuildInputs = buildInputs ++ [ chicken ];
+  propagatedUserEnvPkgs = buildInputs ++ [ chicken ];
+  buildInputs = [ makeWrapper ];
+
+  CSC_OPTIONS = stdenv.lib.concatStringsSep " " cscOptions;
+
+  CHICKEN_REPOSITORY = libPath;
+  CHICKEN_INSTALL_PREFIX = "$out";
+
+  installPhase = ''
+    runHook preInstall
+
+    chicken-install -p $out ${stdenv.lib.concatStringsSep " " chickenInstallFlags}
+
+    for f in $out/bin/*
+    do
+      wrapProgram $f \
+        --set CHICKEN_REPOSITORY $CHICKEN_REPOSITORY \
+        --prefix CHICKEN_REPOSITORY_EXTRA : "$out/lib/chicken/${toString chicken.binaryVersion}/:$CHICKEN_REPOSITORY_EXTRA" \
+        --prefix CHICKEN_INCLUDE_PATH \; \"$CHICKEN_INCLUDE_PATH\;$out/share/\" \
+        --prefix PATH : "$out/bin:${chicken}/bin:$CHICKEN_REPOSITORY_EXTRA:$CHICKEN_REPOSITORY"
+    done
+
+    runHook postInstall
+  '';
+} // (builtins.removeAttrs args ["name" "buildInputs"]) // override)

pkgs/development/compilers/chicken/overrides.nix

···
+{
+  setup-helper = {
+    preBuild = ''
+      substituteInPlace setup-helper.setup \
+        --replace "(chicken-home)" \"$out/share/\"
+
+        cat setup-helper.setup
+    '';
+  };
+}

pkgs/development/compilers/chicken/setup-hook.sh

···
+addChickenRepositoryPath() {
+    addToSearchPathWithCustomDelimiter : CHICKEN_REPOSITORY_EXTRA "$1/lib/chicken/7/"
+    # addToSearchPathWithCustomDelimiter \; CHICKEN_INCLUDE_PATH "$1/share/"
+    export CHICKEN_INCLUDE_PATH="$1/share;$CHICKEN_INCLUDE_PATH"
+}
+
+envHooks=(${envHooks[@]} addChickenRepositoryPath)

pkgs/development/compilers/gambit/default.nix

···
-x@{stdenv, fetchurl, builderDefsPackage, ...}:
-builderDefsPackage
-(a :  
-let 
-  s = import ./src-for-default.nix;
-  helperArgNames = ["stdenv" "fetchurl" "builderDefsPackage"] ++ [];
-  buildInputs = map (n: builtins.getAttr n x)
-    (builtins.attrNames (builtins.removeAttrs x helperArgNames));
-in
-rec {
-  src = a.fetchUrlFromSrcInfo s;
+{ stdenv, fetchurl }:
 
-  inherit (s) name;
-  inherit buildInputs;
-  configureFlags = ["--enable-shared"];
+stdenv.mkDerivation rec {
+  name    = "gambit-${version}";
+  version = "4.7.3";
+  devver  = "4_7_3";
 
-  /* doConfigure should be removed if not needed */
-  phaseNames = ["doConfigure" "doMakeInstall"];
-      
+  src = fetchurl {
+    url    = "http://www.iro.umontreal.ca/~gambit/download/gambit/v4.7/source/gambc-v${devver}-devel.tgz";
+    sha256 = "12jbr6bc0zmc7vw07a9pliadbvqgwkpmw6cj8awz73clv1j7pxha";
+  };
+
+  configureFlags = [ "--enable-shared" "--enable-single-host" ];
+
   meta = {
-    description = "Scheme to C compiler";
-    maintainers = [
-      a.lib.maintainers.raskin
-    ];
-    platforms = with a.lib.platforms;
-      linux ++ freebsd;
+    description = "Optimizing Scheme to C compiler";
+    homepage    = "http://gambitscheme.org";
+    license     = stdenv.lib.licenses.lgpl2;
+    platforms   = stdenv.lib.platforms.linux;
+    maintainers = with stdenv.lib.maintainers; [ thoughtpolice raskin ];
   };
-}) x
+}

pkgs/development/compilers/gambit/src-for-default.nix

···
-rec {
-   version="v4_6_1";
-   name="gambit-v4_6_1";
-   hash="0ad6c63dg5ggaamixxinvlf3128mra8xzss5chh66lkii4dc3m7g";
-   url="http://www.iro.umontreal.ca/~gambit/download/gambit/v4.6/source/gambc-${version}-devel.tgz";
-   advertisedUrl="http://www.iro.umontreal.ca/~gambit/download/gambit/v4.6/source/gambc-v4_6_1-devel.tgz";
-  
-  
-}

pkgs/development/compilers/gambit/src-info-for-default.nix

···
-{
-  downloadPage = "http://dynamo.iro.umontreal.ca/~gambit/wiki/index.php/Main_Page";
-  baseName = "gambit";
-  sourceRegexp = "[.]tgz";
-  versionExtractorSedScript = ''s/.*-(v[_0-9]+)-devel[.].*/\1/'';
-  versionReferenceCreator = ''$(replaceAllVersionOccurences)'';
-}

pkgs/development/compilers/gcc-arm-embedded/default.nix

···
-{ stdenv, bzip2, patchelf, glibc, gcc, fetchurl, version, releaseType, sha256 }:
+{ stdenv, bzip2, patchelf, glibc, gcc, fetchurl, version, releaseType, sha256, ncurses }:
 with stdenv.lib;
 let
   versionParts = splitString "-" version; # 4.7 2013q3 20130916
···
     for f in $(find $out); do
       if [ -f "$f" ] && patchelf "$f" 2> /dev/null; then
         patchelf --set-interpreter ${glibc}/lib/ld-linux.so.2 \
-                 --set-rpath $out/lib:${gcc}/lib \
+                 --set-rpath $out/lib:${gcc}/lib:${ncurses}/lib \
                  "$f" || true
       fi
     done

pkgs/development/compilers/idris/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
 { cabal, annotatedWlPprint, ansiTerminal, ansiWlPprint
-, base64Bytestring, binary, blazeHtml, blazeMarkup, boehmgc, Cabal
+, base64Bytestring, binary, blazeHtml, blazeMarkup, boehmgc
 , cheapskate, deepseq, filepath, fingertree, gmp, happy, haskeline
-, languageJava, lens, libffi, llvmGeneral, llvmGeneralPure, mtl
-, network, optparseApplicative, parsers, split, text, time
-, transformers, trifecta, unorderedContainers, utf8String, vector
-, vectorBinaryInstances, xml, zlib
+, lens, libffi, mtl, network, optparseApplicative, parsers, split
+, text, time, transformers, trifecta, unorderedContainers
+, utf8String, vector, vectorBinaryInstances, xml, zlib
 }:
 
 cabal.mkDerivation (self: {
   pname = "idris";
-  version = "0.9.14.3";
-  sha256 = "03zppfqjamy4mdwcfx3x1wzxav67ha1zgnynrxhvdqw3zcsrwnlr";
+  version = "0.9.15.1";
+  sha256 = "0r31jcqs9kgknm66v7bbcgj9md7z49sgvn0nhk1dwg8jj2rmfll8";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
     annotatedWlPprint ansiTerminal ansiWlPprint base64Bytestring binary
-    blazeHtml blazeMarkup Cabal cheapskate deepseq filepath fingertree
-    haskeline languageJava lens libffi llvmGeneral llvmGeneralPure mtl
-    network optparseApplicative parsers split text time transformers
-    trifecta unorderedContainers utf8String vector
-    vectorBinaryInstances xml zlib
+    blazeHtml blazeMarkup cheapskate deepseq filepath fingertree
+    haskeline lens libffi mtl network optparseApplicative parsers split
+    text time transformers trifecta unorderedContainers utf8String
+    vector vectorBinaryInstances xml zlib
   ];
   buildTools = [ happy ];
   extraLibraries = [ boehmgc gmp ];
···
     description = "Functional Programming Language with Dependent Types";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    maintainers = with self.stdenv.lib.maintainers; [ aycanirican ];
   };
 })

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

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

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

···
+import ./jdk-linux-base.nix {
+  productVersion = "7";
+  patchVersion = "72";
+  downloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html;
+  sha256_i686 = "0376c8a0280752b4389b6cb193d463826c55c821587d0278b7fea665a140f407";
+  sha256_x86_64 = "dd1d438e1b7d4b9bb5ea4659f2103b577d1568da51b53f97b736b3232eeade8e";
+  jceName = "UnlimitedJCEPolicyJDK7.zip";
+  jceDownloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html;
+  sha256JCE = "7a8d790e7bd9c2f82a83baddfae765797a4a56ea603c9150c87b7cdb7800194d";
+}

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

···
 import ./jdk-linux-base.nix {
   productVersion = "8";
-  patchVersion = "20";
+  patchVersion = "25";
   downloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html;
-  sha256_i686 = "fa013b3fcbb1308040bf0e75bbd6ef7e8396b547cbc8dd79e3cb8153604bfd06";
-  sha256_x86_64 = "3e717622ae48af5ca7298e7797cb71d4d545238f362741a83e69c097ca055de4";
+  sha256_i686 = "17f396a541db09c732032185f10f9c6eb42ac7b5776814602342de9655b2e0e2";
+  sha256_x86_64 = "057f660799be2307d2eefa694da9d3fce8e165807948f5bcaa04f72845d2f529";
   jceName = "jce_policy-8.zip";
   jceDownloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html;
   sha256JCE = "f3020a3922efd6626c2fff45695d527f34a8020e938a49292561f18ad1320b59";

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

···
 }:
 
 let
-  version = "6.6.5";
+  version = "6.6.6";
 in
 stdenv.mkDerivation {
   name = "swi-prolog-${version}";
 
   src = fetchurl {
     url = "http://www.swi-prolog.org/download/stable/src/pl-${version}.tar.gz";
-    sha256 = "0lsa90sdnkd286xgm1amwkdhvnrpsz7imfzczrfdaw4arqk4bvkr";
+    sha256 = "0vcrfskm2hyhv30lxr6v261myb815jc3bgmcn1lgsc9g9qkvp04z";
   };
 
   buildInputs = [ gmp readline openssl libjpeg unixODBC libXinerama

pkgs/development/guile-modules/guile-opengl/default.nix

···
+{ stdenv, fetchurl, pkgconfig, guile }:
+
+stdenv.mkDerivation rec {
+  name = "guile-opengl-0.1.0";
+
+  meta = with stdenv.lib; {
+    description = "Guile binding for the OpenGL graphics API";
+    homepage    = "http://gnu.org/s/guile-opengl";
+    license     = licenses.gpl3Plus;
+    platforms   = platforms.linux;
+    maintainers = with maintainers; [ iyzsong ];
+  };
+
+  src = fetchurl {
+    url = "mirror://gnu/guile-opengl/${name}.tar.gz";
+    sha256 = "13qfx4xh8baryxqrv986l848ygd0piqwm6s2s90pxk9c0m9vklim";
+  };
+
+  nativeBuildInputs = [ pkgconfig guile ];
+}

pkgs/development/interpreters/eff/default.nix

···
+{ stdenv, fetchgit, ocaml, findlib, menhir, which }:
+
+let inherit (stdenv.lib) getVersion versionAtLeast; in
+
+assert versionAtLeast (getVersion ocaml) "3.12";
+
+stdenv.mkDerivation {
+
+  name = "eff-20140928";
+
+  src = fetchgit {
+    url = "https://github.com/matijapretnar/eff.git";
+    rev = "90f884a790fddddb51d4d1d3b7c2edf1e8aabb64";
+    sha256 = "28e389b35e6959072c245c2e79fe305885b1b2d44ff540a02a097e09e9f9698f";
+  };
+
+  buildInputs = [ ocaml findlib menhir which ];
+
+  doCheck = true;
+  checkTarget = "test";
+
+  meta = with stdenv.lib; {
+    homepage = "http://www.eff-lang.org";
+    description = "A functional programming language based on algebraic effects and their handlers";
+    longDescription = ''
+      Eff is a functional language with handlers of not only exceptions,
+      but also of other computational effects such as state or I/O. With
+      handlers, you can simply implement transactions, redirections,
+      backtracking, multi-threading, and much more...
+    '';
+    license = licenses.bsd2;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

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

···
-{ stdenv, fetchurl, pkgconfig, nix }: let
-  version = "1.1.0";
+{ stdenv, fetchurl, pkgconfig, nix, git }: let
+  version = "2.0.1";
 in stdenv.mkDerivation {
   name = "nix-exec-${version}";
 
   src = fetchurl {
     url = "https://github.com/shlevy/nix-exec/releases/download/v${version}/nix-exec-${version}.tar.xz";
 
-    sha256 = "0w1dq2svv1l8x18q5syraf80xpyyrcxbrab51cszc3v4m04b4saa";
+    sha256 = "1iyz19c15yw0p5lgfbfh8arja2cy3apx5697cm671j4qzjkws32p";
   };
 
-  buildInputs = [ pkgconfig nix ];
+  buildInputs = [ pkgconfig nix git ];
 
   meta = {
     description = "Run programs defined in nix expressions";

pkgs/development/interpreters/pure/default.nix

···
 stdenv.mkDerivation rec {
   baseName="pure";
   project="pure-lang";
-  version="0.62";
+  version="0.63";
   name="${baseName}-${version}";
   extension="tar.gz";
 
   src = fetchurl {
     url="https://bitbucket.org/purelang/${project}/downloads/${name}.${extension}";
-    sha256="77df64e8154ef6f8fac66f8bcc471dc8f994862d1ee77b7c98003607757a013b";
+    sha256="33acb2d560b21813f5e856973b493d9cfafba82bd6f539425ce07aa22f84ee29";
   };
 
   buildInputs = [ bison flex makeWrapper ];
   propagatedBuildInputs = [ llvm gmp mpfr readline ];
 
+  configureFlags = [ "--enable-release" ];
+  doCheck = true;
+  checkPhase = ''
+    LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${llvm}/lib make check
+  '';
   postInstall = ''
     wrapProgram $out/bin/pure --prefix LD_LIBRARY_PATH : ${llvm}/lib
   '';
···
     maintainers = with lib.maintainers;
     [
       raskin
+      asppsa
     ];
     platforms = with lib.platforms;
       linux;

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

···
 
       buildPhase =
         ''
-          # Fake the build environment that setup.py expects.
-          ln -s ${python}/include/python*/pyconfig.h .
-          ln -s ${python}/lib/python*/config/Setup Modules/
-          ln -s ${python}/lib/python*/config/Setup.local Modules/
-
           substituteInPlace setup.py --replace 'self.extensions = extensions' \
             'self.extensions = [ext for ext in self.extensions if ext.name in ["${internalName}"]]'
 

pkgs/development/interpreters/ruby/ruby-1.9.3.nix

···
 
   enableParallelBuilding = true;
 
+  # Fix a build failure on systems with nix store optimisation.
+  # (The build process attempted to copy file a overwriting file b, where a and
+  # b are hard-linked, which results in cp returning a non-zero exit code.)
+  # https://github.com/NixOS/nixpkgs/issues/4266
+  postUnpack = ''rm "$sourceRoot/enc/unicode/name2ctype.h"'';
+
   patches = [
     ./ruby19-parallel-install.patch
     ./bitperfect-rdoc.patch

pkgs/development/interpreters/ruby/ruby-2.0.0.nix

···
 , ncurses, readline, cursesSupport ? false
 , groff, docSupport ? false
 , libyaml, yamlSupport ? true
+, libffi, fiddleSupport ? true
 , ruby_2_0_0, autoreconfHook, bison, useRailsExpress ? true
 }:
 
···
   NROFF = "${groff}/bin/nroff";
 
   buildInputs = ops useRailsExpress [ autoreconfHook bison ]
+    ++ (op fiddleSupport libffi)
     ++ (ops cursesSupport [ ncurses readline ] )
     ++ (op docSupport groff )
     ++ (op zlibSupport zlib)
···
     ++ (op (!cursesSupport && stdenv.isDarwin) readline);
 
   enableParallelBuilding = true;
+
+  # Fix a build failure on systems with nix store optimisation.
+  # (The build process attempted to copy file a overwriting file b, where a and
+  # b are hard-linked, which results in cp returning a non-zero exit code.)
+  # https://github.com/NixOS/nixpkgs/issues/4266
+  postUnpack = ''rm "$sourceRoot/enc/unicode/name2ctype.h"'';
 
   patches = ops useRailsExpress [
     "${patchSet}/patches/ruby/2.0.0/p481/01-zero-broken-tests.patch"

pkgs/development/interpreters/ruby/ruby-2.1.0.nix

···
 , ncurses, readline, cursesSupport ? false
 , groff, docSupport ? false
 , libyaml, yamlSupport ? true
+, libffi, fiddleSupport ? true
 , ruby_2_1_0, autoreconfHook, bison, useRailsExpress ? true
 }:
 
···
   NROFF = "${groff}/bin/nroff";
 
   buildInputs = ops useRailsExpress [ autoreconfHook bison ]
+    ++ (op fiddleSupport libffi)
     ++ (ops cursesSupport [ ncurses readline ] )
     ++ (op docSupport groff )
     ++ (op zlibSupport zlib)
···
     ++ (op (!cursesSupport && stdenv.isDarwin) readline);
 
   enableParallelBuilding = true;
+
+  # Fix a build failure on systems with nix store optimisation.
+  # (The build process attempted to copy file a overwriting file b, where a and
+  # b are hard-linked, which results in cp returning a non-zero exit code.)
+  # https://github.com/NixOS/nixpkgs/issues/4266
+  postUnpack = ''rm "$sourceRoot/enc/unicode/name2ctype.h"'';
 
   patches = ops useRailsExpress [
     "${patchSet}/patches/ruby/2.1.0/railsexpress/01-current-2.1.1-fixes.patch"

pkgs/development/interpreters/ruby/ruby-2.1.1.nix

···
 , ncurses, readline, cursesSupport ? false
 , groff, docSupport ? false
 , libyaml, yamlSupport ? true
+, libffi, fiddleSupport ? true
 , ruby_2_1_1, autoreconfHook, bison, useRailsExpress ? true
 }:
 
···
   NROFF = "${groff}/bin/nroff";
 
   buildInputs = ops useRailsExpress [ autoreconfHook bison ]
+    ++ (op fiddleSupport libffi)
     ++ (ops cursesSupport [ ncurses readline ] )
     ++ (op docSupport groff )
     ++ (op zlibSupport zlib)
···
     ++ (op (!cursesSupport && stdenv.isDarwin) readline);
 
   enableParallelBuilding = true;
+
+  # Fix a build failure on systems with nix store optimisation.
+  # (The build process attempted to copy file a overwriting file b, where a and
+  # b are hard-linked, which results in cp returning a non-zero exit code.)
+  # https://github.com/NixOS/nixpkgs/issues/4266
+  postUnpack = ''rm "$sourceRoot/enc/unicode/name2ctype.h"'';
 
   patches = ops useRailsExpress [
     "${patchSet}/patches/ruby/2.1.0/railsexpress/01-zero-broken-tests.patch"

pkgs/development/interpreters/ruby/ruby-2.1.2.nix

···
 , ncurses, readline, cursesSupport ? false
 , groff, docSupport ? false
 , libyaml, yamlSupport ? true
+, libffi, fiddleSupport ? true
 , ruby_2_1_2, autoreconfHook, bison, useRailsExpress ? true
 }:
 
···
   NROFF = "${groff}/bin/nroff";
 
   buildInputs = ops useRailsExpress [ autoreconfHook bison ]
+    ++ (op fiddleSupport libffi)
     ++ (ops cursesSupport [ ncurses readline ] )
     ++ (op docSupport groff )
     ++ (op zlibSupport zlib)
···
     ++ (op (!cursesSupport && stdenv.isDarwin) readline);
 
   enableParallelBuilding = true;
+
+  # Fix a build failure on systems with nix store optimisation.
+  # (The build process attempted to copy file a overwriting file b, where a and
+  # b are hard-linked, which results in cp returning a non-zero exit code.)
+  # https://github.com/NixOS/nixpkgs/issues/4266
+  postUnpack = ''rm "$sourceRoot/enc/unicode/name2ctype.h"'';
 
   patches = ops useRailsExpress [
     "${patchSet}/patches/ruby/2.1.2/railsexpress/01-zero-broken-tests.patch"

pkgs/development/interpreters/ruby/ruby-2.1.3.nix

···
+{ stdenv, fetchurl, fetchgit, fetchFromGitHub
+, zlib, zlibSupport ? true
+, openssl, opensslSupport ? true
+, gdbm, gdbmSupport ? true
+, ncurses, readline, cursesSupport ? false
+, groff, docSupport ? false
+, libyaml, yamlSupport ? true
+, libffi, fiddleSupport ? true
+, ruby_2_1_3, autoreconfHook, bison, useRailsExpress ? true
+}:
+
+let
+  op = stdenv.lib.optional;
+  ops = stdenv.lib.optionals;
+  patchSet = import ./rvm-patchsets.nix { inherit fetchFromGitHub; };
+  config = import ./config.nix fetchgit;
+  baseruby = ruby_2_1_3.override { useRailsExpress = false; };
+in
+
+stdenv.mkDerivation rec {
+  version = with passthru; "${majorVersion}.${minorVersion}.${teenyVersion}-p${patchLevel}";
+
+  name = "ruby-${version}";
+
+  src = if useRailsExpress then fetchFromGitHub {
+    owner  = "ruby";
+    repo   = "ruby";
+    rev    = "v2_1_3";
+    sha256 = "1pnam9jry2l2mbji3gvrbb7jyisxl99xjz6l1qrccwnfinxxbmhv";
+  } else fetchurl {
+    url = "http://cache.ruby-lang.org/pub/ruby/2.1/ruby-2.1.3.tar.gz";
+    sha256 = "00bz6jcbxgnllplk4b9lnyc3w8yd3pz5rn11rmca1s8cn6vvw608";
+  };
+
+  # Have `configure' avoid `/usr/bin/nroff' in non-chroot builds.
+  NROFF = "${groff}/bin/nroff";
+
+  buildInputs = ops useRailsExpress [ autoreconfHook bison ]
+    ++ (op fiddleSupport libffi)
+    ++ (ops cursesSupport [ ncurses readline ])
+    ++ (op docSupport groff)
+    ++ (op zlibSupport zlib)
+    ++ (op opensslSupport openssl)
+    ++ (op gdbmSupport gdbm)
+    ++ (op yamlSupport libyaml)
+    # Looks like ruby fails to build on darwin without readline even if curses
+    # support is not enabled, so add readline to the build inputs if curses
+    # support is disabled (if it's enabled, we already have it) and we're
+    # running on darwin
+    ++ (op (!cursesSupport && stdenv.isDarwin) readline);
+
+  enableParallelBuilding = true;
+
+  # Fix a build failure on systems with nix store optimisation.
+  # (The build process attempted to copy file a overwriting file b, where a and
+  # b are hard-linked, which results in cp returning a non-zero exit code.)
+  # https://github.com/NixOS/nixpkgs/issues/4266
+  postUnpack = ''rm "$sourceRoot/enc/unicode/name2ctype.h"'';
+
+  patches = ops useRailsExpress [
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/01-zero-broken-tests.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/02-improve-gc-stats.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/03-display-more-detailed-stack-trace.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/04-show-full-backtrace-on-stack-overflow.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/05-funny-falcon-stc-density.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/06-funny-falcon-stc-pool-allocation.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/07-aman-opt-aset-aref-str.patch"
+    "${patchSet}/patches/ruby/2.1.3/railsexpress/08-funny-falcon-method-cache.patch"
+  ];
+
+  # Ruby >= 2.1.0 tries to download config.{guess,sub}
+  postPatch = ''
+    rm tool/config_files.rb
+    cp ${config}/config.guess tool/
+    cp ${config}/config.sub tool/
+  '';
+
+  configureFlags = ["--enable-shared" ]
+    ++ op useRailsExpress "--with-baseruby=${baseruby}/bin/ruby"
+    # on darwin, we have /usr/include/tk.h -- so the configure script detects
+    # that tk is installed
+    ++ ( if stdenv.isDarwin then [ "--with-out-ext=tk " ] else [ ]);
+
+  installFlags = stdenv.lib.optionalString docSupport "install-doc";
+  # Bundler tries to create this directory
+  postInstall = ''
+    # Bundler tries to create this directory
+    mkdir -pv $out/${passthru.gemPath}
+    mkdir -p $out/nix-support
+    cat > $out/nix-support/setup-hook <<EOF
+    addGemPath() {
+      addToSearchPath GEM_PATH \$1/${passthru.gemPath}
+    }
+
+    envHooks+=(addGemPath)
+    EOF
+  '';
+
+  meta = {
+    license = "Ruby";
+    homepage = "http://www.ruby-lang.org/en/";
+    description = "The Ruby language";
+    platforms = stdenv.lib.platforms.all;
+  };
+
+  passthru = rec {
+    majorVersion = "2";
+    minorVersion = "1";
+    teenyVersion = "3";
+    patchLevel = "0";
+    libPath = "lib/ruby/${majorVersion}.${minorVersion}";
+    gemPath = "lib/ruby/gems/${majorVersion}.${minorVersion}";
+  };
+}

pkgs/development/interpreters/ruby/rvm-patchsets.nix

···
 fetchFromGitHub {
   owner  = "skaes";
   repo   = "rvm-patchsets";
-  rev    = "13d535bbc060b1b8166673932fe7098abf4216b8";
-  sha256 = "0hf1m2bsdgdnyi4427gknvpd8cfribw77lf2k980flb1z9g5d7ib";
+  rev    = "fb6b427f71e756900184d1b6eaeb10245ec8405a";
+  sha256 = "10k7p3nymj7y5a0az8v1aks2w5w190zfqv9kiiafcx0a3qfswnck";
 }

pkgs/development/libraries/SDL_mixer/default.nix

···
-{ stdenv, fetchurl, SDL, libogg, libvorbis, enableNativeMidi ? false, fluidsynth ? null }:
+{ stdenv, fetchurl, SDL, libogg, libvorbis, smpeg, enableNativeMidi ? false, fluidsynth ? null }:
 
 stdenv.mkDerivation rec {
   pname   = "SDL_mixer";
···
     sha256 = "0alrhqgm40p4c92s26mimg9cm1y7rzr6m0p49687jxd9g6130i0n";
   };
 
-  buildInputs = [SDL libogg libvorbis fluidsynth];
+  buildInputs = [SDL libogg libvorbis fluidsynth smpeg];
 
   configureFlags = "--disable-music-ogg-shared" + stdenv.lib.optionalString enableNativeMidi " --enable-music-native-midi-gpl";
 

pkgs/development/libraries/accountsservice/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "accountsservice-${version}";
-  version = "0.6.38";
+  version = "0.6.39";
   
   src = fetchurl {
     url = "http://www.freedesktop.org/software/accountsservice/accountsservice-${version}.tar.xz";
-    sha256 = "1ad32qv57rx9yzrvzsw0d0lh0j7adlh664lachv621wb8ya22crn";
+    sha256 = "0p9kfnr1wvg1qwi6zsgxw031j1wqh41137xl0mv4rm6x2zas6f7r";
   };
 
   buildInputs = [ pkgconfig glib intltool libtool makeWrapper

pkgs/development/libraries/aspell/default.nix

···
     homepage = http://aspell.net/;
     license = stdenv.lib.licenses.lgpl2Plus;
     maintainers = [ ];
+    platforms = with stdenv.lib.platforms; all;
   };
 }

pkgs/development/libraries/freetds/default.nix

···
-{ stdenv, fetchurl }:
+{ stdenv, fetchurl
+, odbcSupport ? false, unixODBC ? null }:
+
+assert odbcSupport -> unixODBC != null;
 
 stdenv.mkDerivation {
   name = "freetds-0.91";
···
     url = ftp://ftp.astron.com/pub/freetds/stable/freetds-stable.tgz;
     sha256 = "0r946axzxs0czsmr7283w7vmk5jx3jnxxc32d2ncxsrsh2yli0ba";
   };
+
+  buildInputs = stdenv.lib.optional odbcSupport [ unixODBC ];
+
+  configureFlags = stdenv.lib.optionalString odbcSupport "--with-odbc=${unixODBC}";
 
   doDist = true;
 

pkgs/development/libraries/gvfs/default.nix

···
 { stdenv, fetchurl, pkgconfig, intltool, libtool
 , glib, dbus, udev, udisks2, libgcrypt
 , libgphoto2, avahi, libarchive, fuse, libcdio
-, libxml2, libxslt, docbook_xsl
-, lightWeight ? true, gnome, samba, libgnome_keyring, gconf, makeWrapper }:
+, libxml2, libxslt, docbook_xsl, samba
+, gnomeSupport ? false, gnome,libgnome_keyring, gconf, makeWrapper }:
 
 let
   ver_maj = "1.18";
···
   buildInputs =
     [ makeWrapper glib dbus.libs udev udisks2 libgcrypt
       libgphoto2 avahi libarchive fuse libcdio
-      libxml2 libxslt docbook_xsl
+      libxml2 libxslt docbook_xsl samba
       # ToDo: a ligther version of libsoup to have FTP/HTTP support?
-    ] ++ stdenv.lib.optionals (!lightWeight) (with gnome; [
-      gtk libsoup libgnome_keyring gconf samba
+    ] ++ stdenv.lib.optionals gnomeSupport (with gnome; [
+      gtk libsoup libgnome_keyring gconf
       # ToDo: not working and probably useless until gnome3 from x-updates
     ]);
 
···
   '';
 
   meta = {
-    description = "Virtual Filesystem support library" + stdenv.lib.optionalString lightWeight " (light-weight)";
+    description = "Virtual Filesystem support library" + stdenv.lib.optionalString gnomeSupport " (full GNOME support)";
     platforms = stdenv.lib.platforms.linux;
   };
 }

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

···
 
 cabal.mkDerivation (self: {
   pname = "HandsomeSoup";
-  version = "0.3.3";
-  sha256 = "0g2b3mw0asam005kz77zm3bsrjaa7q3n6wdj3ahr7hppivsdwizk";
+  version = "0.3.4";
+  sha256 = "0xpimys8pb0kzqnfxxf04dbxfmcrry5pzgmagyydcrmafacg0vjb";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
     HTTP hxt hxtHttp MaybeT mtl network networkUri parsec transformers
   ];
   testDepends = [ hspec hxt ];
+  jailbreak = true;
   doCheck = false;
   meta = {
     homepage = "https://github.com/egonSchiele/HandsomeSoup";

pkgs/development/libraries/haskell/HaskellNet-SSL/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "HaskellNet-SSL";
-  version = "0.2.5.1";
-  sha256 = "0qkc0bw0p201wi3v8ck348j8m32x9dn8lkf6r787sd1bxhrsd2z7";
+  version = "0.2.5.2";
+  sha256 = "0jhm43zd6jvhbahk4ki29ydg02qnjj4mw823rckqxk6f91q00qlp";
   buildDepends = [ connection dataDefault HaskellNet network tls ];
   meta = {
     homepage = "https://github.com/dpwright/HaskellNet-SSL";
     description = "Helpers to connect to SSL/TLS mail servers with HaskellNet";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    broken = true;
   };
 })

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

···
 
 cabal.mkDerivation (self: {
   pname = "ObjectName";
-  version = "1.0.0.0";
-  sha256 = "0yr1aa0ail2h9qsq2bslcwwq6cxl2lzajmc1laj19r7ks62p32rm";
+  version = "1.0.1.0";
+  sha256 = "1aw221i1cisk7jpgchs16f3br0ddllh0n0idhw5v6n6ysv4vv155";
   meta = {
-    homepage = "http://www.haskell.org/HOpenGL/";
+    homepage = "https://github.com/haskell-opengl/ObjectName";
     description = "Explicitly handled object names";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

pkgs/development/libraries/haskell/OpenGL/2.6.0.1.nix

···
   sha256 = "1fpabhpjfl1bj0dhlj2sg8zsn3l6py4zw1arplwmqalz3xbkkgdi";
   buildDepends = [ GLURaw ObjectName OpenGLRaw StateVar Tensor ];
   extraLibraries = [ libX11 mesa ];
+  jailbreak = true;
   meta = {
     homepage = "http://www.haskell.org/haskellwiki/Opengl";
     description = "A binding for the OpenGL graphics system";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     hydraPlatforms = self.stdenv.lib.platforms.none;
+    broken = true;
   };
 })

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

···
 
 cabal.mkDerivation (self: {
   pname = "StateVar";
-  version = "1.0.0.0";
-  sha256 = "1c1b6a6nn1cdnba08zzp0645wl482h7yaa69zw2l3wwyyyccjic4";
+  version = "1.0.1.0";
+  sha256 = "02n2sxxkr0ydc77dc3amwp5jrw289d2s2z55rhrmhxxg1c7lp5js";
   meta = {
-    homepage = "http://www.haskell.org/HOpenGL/";
+    homepage = "https://github.com/haskell-opengl/StateVar";
     description = "State variables";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

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

···
 
 cabal.mkDerivation (self: {
   pname = "Tensor";
-  version = "1.0.0.1";
-  sha256 = "10arhk5gkn5jxpb53r80bblpk0afdax1fc2mik40hj5g5g960cp9";
+  version = "1.1.0.0";
+  sha256 = "1vn409805p5b47v5mf7rk0gypqag5bn1pzlsmsp9blr3jyj6dgph";
   meta = {
-    homepage = "http://www.haskell.org/HOpenGL/";
+    homepage = "https://github.com/haskell-opengl/Tensor";
     description = "Tensor data types";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
   };
 })

pkgs/development/libraries/haskell/acme-lookofdisapproval/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal }:
+
+cabal.mkDerivation (self: {
+  pname = "acme-lookofdisapproval";
+  version = "0.1";
+  sha256 = "194xvcab14bs3b3nrayxp4z3da60afxa9cmip58mkms5016kwhis";
+  meta = {
+    homepage = "https://github.com/llelf/acme-lookofdisapproval";
+    description = "Express your disapproval";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/ansi-terminal/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ansi-terminal";
-  version = "0.6.1.1";
-  sha256 = "06pdcpp2z7wk9mkr5lzwk64lqhj09c7l1ah4s3vz7zwrdzfaccwi";
+  version = "0.6.2.1";
+  sha256 = "1xmp8wpcyvqys777qpyfx99bhlnvmr7jil7r78j5n6fx3mkkhnln";
   isLibrary = true;
   isExecutable = true;
   meta = {

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

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, bert, Cabal, haskellNames, haskellPackages, haskellSrcExts
-, mtl, utf8String
+{ cabal, async, bert, Cabal, dataLens, dataLensFd, dataLensTemplate
+, filepath, haskellNames, haskellPackages, haskellSrcExts, hseCpp
+, hslogger, mtl, stm, tagged, tasty, tastyHunit, transformers
+, utf8String
 }:
 
 cabal.mkDerivation (self: {
   pname = "ariadne";
-  version = "0.1.2.1";
-  sha256 = "1gx6jrv3s86h02cjx8pvqyklp445ljiysx29hg39qykyhi1q5a3z";
+  version = "0.1.2.2";
+  sha256 = "0dp2xs1g9cw27gwvw2qzyv1qk3z97mg8ab6rfx967r7ad76lkzx2";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [
-    bert Cabal haskellNames haskellPackages haskellSrcExts mtl
-    utf8String
+    async bert Cabal dataLens dataLensFd dataLensTemplate filepath
+    haskellNames haskellPackages haskellSrcExts hseCpp hslogger mtl stm
+    tagged transformers utf8String
   ];
+  testDepends = [
+    bert filepath haskellSrcExts tasty tastyHunit utf8String
+  ];
+  doCheck = false;
   meta = {
     homepage = "https://github.com/feuerbach/ariadne";
     description = "Go-to-definition for Haskell";
     license = self.stdenv.lib.licenses.mit;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ ocharles ];
-    broken = true;
   };
 })

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, deepseq, gmp, QuickCheck, tasty, tastyQuickcheck }:
+
+cabal.mkDerivation (self: {
+  pname = "bitset";
+  version = "1.4.8";
+  sha256 = "0h912i3wb6v8sx0c4mlp0j65l3yhpdsk3my8zhif2jls2sxns988";
+  buildDepends = [ deepseq ];
+  testDepends = [ QuickCheck tasty tastyQuickcheck ];
+  extraLibraries = [ gmp ];
+  doCheck = false;
+  meta = {
+    description = "A space-efficient set data structure";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

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

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

···
 
 cabal.mkDerivation (self: {
   pname = "conduit-extra";
-  version = "1.1.4";
-  sha256 = "117mzy0qm8w2kzjcshcwcfbx01ybbhn63vdgzllc7cb9x4cj2ibv";
+  version = "1.1.4.1";
+  sha256 = "18q2d9ga49gldw4i8a5vnncsr712b21ik0160gdw3czqilvf8nbr";
   buildDepends = [
     attoparsec blazeBuilder conduit filepath monadControl network
     primitive resourcet stm streamingCommons text transformers

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

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, byteable, cipherAes, cryptoRandom, random }:
+{ cabal, byteable, cipherAes, cryptoRandom }:
 
 cabal.mkDerivation (self: {
   pname = "cprng-aes";
-  version = "0.5.2";
-  sha256 = "1nf8dd83ywriq2ynv48f2s5lvc9s3srq4j5vbspmf0kc74kmq2pf";
-  buildDepends = [ byteable cipherAes cryptoRandom random ];
+  version = "0.6.0";
+  sha256 = "0d6m6mjkwvkg1cqq3q3hc64hp445kbcdf12lwm6k2scrpd2r7bhq";
+  buildDepends = [ byteable cipherAes cryptoRandom ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-cprng-aes";
     description = "Crypto Pseudo Random Number Generator using AES in counter mode";

pkgs/development/libraries/haskell/data-lens-fd/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, comonad, dataLens, mtl, transformers }:
+
+cabal.mkDerivation (self: {
+  pname = "data-lens-fd";
+  version = "2.0.5";
+  sha256 = "0r8cfgn6wx304b5ihmwgsxxjwalb7086wii655mgmb6cn3nirpyk";
+  buildDepends = [ comonad dataLens mtl transformers ];
+  meta = {
+    homepage = "http://github.com/roconnor/data-lens-fd/";
+    description = "Lenses";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/data-lens-template/default.nix

···
     description = "Utilities for Data.Lens";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
   };
 })

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

···
   version = "2.10.5";
   sha256 = "11na4wx0f0ihk87d00njwrfc430nb25dkkadv1n47yvcyfc60i90";
   buildDepends = [ comonad semigroupoids transformers ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/roconnor/data-lens/";
     description = "Used to be Haskell 98 Lenses";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     hydraPlatforms = self.stdenv.lib.platforms.none;
-    broken = true;
   };
 })

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

···
 
 cabal.mkDerivation (self: {
   pname = "esqueleto";
-  version = "2.1.0";
-  sha256 = "1qkxp12444wgf2hvhj3yw928sbd8y8rxpw90xpi2nx5jw5ws86qc";
+  version = "2.1.1";
+  sha256 = "0nr18wjih1rbkprr7cvacgnk0m05m79l0sd25fihy5fy7sqqh3yw";
   buildDepends = [
     conduit monadLogger persistent resourcet tagged text transformers
     unorderedContainers

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

···
 
 cabal.mkDerivation (self: {
   pname = "extra";
-  version = "0.3.2";
-  sha256 = "0in340mmbgqkafj60pas7dm6bn080nimxk8b9b6xzv0giih6dx66";
+  version = "0.4";
+  sha256 = "1wqhnfm297iwf6l4bkhnlbv4bb54b9y5qig7h5n7fjn88bxgwj1l";
   buildDepends = [ filepath time ];
   testDepends = [ QuickCheck time ];
   meta = {

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

···
 
 cabal.mkDerivation (self: {
   pname = "ghc-vis";
-  version = "0.7.2.5";
-  sha256 = "15dp34dvcqs3b0np1xpi3s6543svhgmxy1kzggw0rmflmq2whsd8";
+  version = "0.7.2.6";
+  sha256 = "12jyxcqyrqiai0fdfnpvsn1v64is7p8zixi745k29h54i0px1j89";
   buildDepends = [
     cairo deepseq fgl ghcHeapView graphviz gtk mtl svgcairo text
     transformers xdot

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, gloss, reactiveBanana }:
+
+cabal.mkDerivation (self: {
+  pname = "gloss-banana";
+  version = "0.1.0.4";
+  sha256 = "0zzpdryfcqvxpzv53ymsvkm2nza9ryvzqgf3n89pnvrni91avgj3";
+  buildDepends = [ gloss reactiveBanana ];
+  meta = {
+    homepage = "https://github.com/Twey/gloss-banana";
+    description = "An Interface for gloss in terms of a reactive-banana Behavior";
+    license = self.stdenv.lib.licenses.gpl3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ twey ];
+  };
+})

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

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

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

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

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

···
 
 { cabal, binary, blazeBuilder, bzlib, dataBinaryIeee754
 , dataDefault, either, filepath, ghcPaths, HTTP, monadsTf, mtl
-, network, random, shellmate, systemFileio, tar, transformers
-, utf8String, websockets
+, network, networkUri, random, shellmate, systemFileio, tar
+, transformers, utf8String, websockets
 }:
 
 cabal.mkDerivation (self: {
   pname = "haste-compiler";
-  version = "0.4.2";
-  sha256 = "0agbd21c7mgzxyg6lwjl3n8w2r7xcrv3811y0x86rg7q1m7z730m";
+  version = "0.4.3";
+  sha256 = "1wkb6a1jwmpjr0jlz5fjq652jz6a6agg0a5pfazyfpdznvd4mm62";
   isLibrary = true;
   isExecutable = true;
+  noHaddock = true;
   buildDepends = [
     binary blazeBuilder bzlib dataBinaryIeee754 dataDefault either
-    filepath ghcPaths HTTP monadsTf mtl network random shellmate
-    systemFileio tar transformers utf8String websockets
+    filepath ghcPaths HTTP monadsTf mtl network networkUri random
+    shellmate systemFileio tar transformers utf8String websockets
   ];
+  configureFlags = "-fportable";
   meta = {
-    homepage = "http://github.com/valderman/haste-compiler";
+    homepage = "http://haste-lang.org/";
     description = "Haskell To ECMAScript compiler";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

pkgs/development/libraries/haskell/hmatrix-special/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, hmatrix }:
+{ cabal, gsl, hmatrix }:
 
 cabal.mkDerivation (self: {
   pname = "hmatrix-special";
   version = "0.2.0";
   sha256 = "0lp8mvagbzayq3r08wgk498n6d9vgb1skb8wzrzi5a1fc5j8m0wj";
   buildDepends = [ hmatrix ];
+  extraLibraries = [ gsl ];
   meta = {
     homepage = "http://perception.inf.um.es/hmatrix";
     description = "Interface to GSL special functions";
     license = "GPL";
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-    broken = true;
   };
 })

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, binary, blazeBuilder, dataBinaryIeee754, network
+, QuickCheck, testFramework, testFrameworkQuickcheck2, time
+, transformers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "hosc";
+  version = "0.15";
+  sha256 = "1yp25n159p69r32y3x7iwc55l5q9qaamj2vyl1473x8ras5afdcf";
+  buildDepends = [
+    binary blazeBuilder dataBinaryIeee754 network time transformers
+  ];
+  testDepends = [
+    QuickCheck testFramework testFrameworkQuickcheck2
+  ];
+  meta = {
+    homepage = "http://rd.slavepianos.org/t/hosc";
+    description = "Haskell Open Sound Control";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/hsc3-db/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, hsc3, safe }:
+
+cabal.mkDerivation (self: {
+  pname = "hsc3-db";
+  version = "0.15";
+  sha256 = "0sj3hq0d8dl4m6fn75lvyr78sg283p6y13lg8yi2yrgz74kn4zbl";
+  buildDepends = [ hsc3 safe ];
+  noHaddock = true;
+  meta = {
+    homepage = "http://rd.slavepianos.org/t/hsc3-db";
+    description = "Haskell SuperCollider Unit Generator Database";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/hsc3-dot/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, filepath, hsc3 }:
+
+cabal.mkDerivation (self: {
+  pname = "hsc3-dot";
+  version = "0.15";
+  sha256 = "1ck2g15zw23smry1xvn9ida8ln57vnvkxvr3khhp5didwisgm90m";
+  buildDepends = [ filepath hsc3 ];
+  meta = {
+    homepage = "http://rd.slavepianos.org/t/hsc3-dot";
+    description = "haskell supercollider graph drawing";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/hsc3-lang/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, bifunctors, dataDefault, dataOrdlist, dlist, hashable
+, hmatrixSpecial, hosc, hsc3, MonadRandom, random, randomShuffle
+, split, transformers, vector
+}:
+
+cabal.mkDerivation (self: {
+  pname = "hsc3-lang";
+  version = "0.15";
+  sha256 = "09qn9kb8h40cwhnjf4pl70i2vi7cn4pa4wkdwjbn07hrdpvxgihf";
+  buildDepends = [
+    bifunctors dataDefault dataOrdlist dlist hashable hmatrixSpecial
+    hosc hsc3 MonadRandom random randomShuffle split transformers
+    vector
+  ];
+  meta = {
+    homepage = "http://rd.slavepianos.org/t/hsc3-lang";
+    description = "Haskell SuperCollider Language";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/hsc3-process/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, dataDefault, filepath, hosc, hsc3, time, timeCompat
+, transformers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "hsc3-process";
+  version = "0.10.0";
+  sha256 = "1h769akpd5gsmmlzmhya3dh56rhpf4fkj0vl6zngahc5hl4s7qxc";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    dataDefault filepath hosc hsc3 time timeCompat transformers
+  ];
+  meta = {
+    homepage = "https://github.com/kaoskorobase/hsc3-process";
+    description = "Create and control scsynth processes";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, binary, dataDefault, dataOrdlist, filepath, hashable, hosc
+, network, random, safe, split, transformers
+}:
+
+cabal.mkDerivation (self: {
+  pname = "hsc3";
+  version = "0.15";
+  sha256 = "1rmxl1wcly74bjkw79zw9ydmiclk5716w75b4nz8xkqraijiafrg";
+  buildDepends = [
+    binary dataDefault dataOrdlist filepath hashable hosc network
+    random safe split transformers
+  ];
+  meta = {
+    homepage = "http://rd.slavepianos.org/t/hsc3";
+    description = "Haskell SuperCollider";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "http-conduit";
-  version = "2.1.4.5";
-  sha256 = "0damsk83j52ndciybxiss0whd486i10ibawxj70z1c0h78f9wwrs";
+  version = "2.1.4.7";
+  sha256 = "1fr8vxv2xidysls9g8zh04qddg9s6i9vs1xr4zkwr6fw750547n3";
   buildDepends = [
     conduit httpClient httpClientTls httpTypes liftedBase monadControl
     mtl resourcet transformers

pkgs/development/libraries/haskell/mime-mail/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "mime-mail";
-  version = "0.4.5.2";
-  sha256 = "0s5fj20n3lc2hn1mqpsvai63pgrl7vhqv26psdzqdwl70w9c04zf";
+  version = "0.4.6";
+  sha256 = "051mqpzypg4r6rd06qb75pl3nq9p68r1sl73r0pwl1imcp158aw6";
   buildDepends = [
     base64Bytestring blazeBuilder filepath random text
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "network-carbon";
-  version = "1.0.1";
-  sha256 = "1q3b7vw80yw6fkmpwgazy8ikhbwjmmqmm4fry8c9f8ckkpzahj2b";
+  version = "1.0.2";
+  sha256 = "0r9riydwvmn8v9iih475agl4idb3z6v3djmn3pjlda28g3p0zw9h";
   buildDepends = [ network text time vector ];
   jailbreak = true;
   meta = {

pkgs/development/libraries/haskell/optparse-applicative/0.9.1.1.nix

···
-# This file was auto-generated by cabal2nix. Please do NOT edit manually!
-
-{ cabal, ansiWlPprint, HUnit, QuickCheck, testFramework
-, testFrameworkHunit, testFrameworkQuickcheck2
-, testFrameworkThPrime, transformers, transformersCompat
-}:
-
-cabal.mkDerivation (self: {
-  pname = "optparse-applicative";
-  version = "0.9.1.1";
-  sha256 = "1fy8839y9dg2a5pj7abjiqkm3qcz8faip32q3x1zi5mrz4v3q2g6";
-  buildDepends = [ ansiWlPprint transformers transformersCompat ];
-  testDepends = [
-    HUnit QuickCheck testFramework testFrameworkHunit
-    testFrameworkQuickcheck2 testFrameworkThPrime
-  ];
-  jailbreak = true;
-  meta = {
-    homepage = "https://github.com/pcapriotti/optparse-applicative";
-    description = "Utilities and combinators for parsing command line options";
-    license = self.stdenv.lib.licenses.bsd3;
-    platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-  };
-})

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, async, hspec, pipes, pipesBytestring, pipesSafe, stm
+, stmChans, text
+}:
+
+cabal.mkDerivation (self: {
+  pname = "pipes-shell";
+  version = "0.1.2";
+  sha256 = "18ikjkppds7k9fgjn39qvdp8avj8vv3csiqcrhgrpfqy1d0hgrlw";
+  buildDepends = [
+    async pipes pipesBytestring pipesSafe stm stmChans text
+  ];
+  testDepends = [
+    async hspec pipes pipesBytestring pipesSafe stm stmChans text
+  ];
+  doCheck = false;
+  meta = {
+    description = "Create proper Pipes from System.Process";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/protocol-buffers-descriptor/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "protocol-buffers-descriptor";
-  version = "2.0.14";
-  sha256 = "0xbpmm9a4fg42c9zbarawqdl4klfjjc233ilbsibb7asa3v7zmj3";
+  version = "2.0.17";
+  sha256 = "0jl041645d83iqqiw891d2k760jql6djvi2mmjh9lnmp48lwjy3p";
   buildDepends = [ protocolBuffers ];
   meta = {
     homepage = "http://code.haskell.org/protocol-buffers/";
     description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
   };
 })

pkgs/development/libraries/haskell/protocol-buffers/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, binary, filepath, mtl, syb, utf8String }:
+{ cabal, binary, filepath, mtl, parsec, syb, utf8String }:
 
 cabal.mkDerivation (self: {
   pname = "protocol-buffers";
-  version = "2.0.14";
-  sha256 = "1wihnpvc7kjq345a6v702s42gmrqd9cjm50safc7kigyvhr5vm1i";
-  buildDepends = [ binary filepath mtl syb utf8String ];
+  version = "2.0.17";
+  sha256 = "12aky44ssgdj6vsjg0yvr8350cym7n6kn7gdaax0nxzpfxrjfy1v";
+  buildDepends = [ binary filepath mtl parsec syb utf8String ];
   meta = {
     homepage = "http://code.haskell.org/protocol-buffers/";
     description = "Parse Google Protocol Buffer specifications";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-    broken = self.stdenv.lib.versionOlder "7.7" self.ghc.version;
   };
 })

pkgs/development/libraries/haskell/pure-cdb/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "pure-cdb";
-  version = "0.1";
-  sha256 = "0fxfhd73h5frnjpk617lspwf17wldsrd5a5cxar5y3a8wi0i4b8c";
+  version = "0.1.1";
+  sha256 = "1yjh7h02hkhx2vgvn7qfmfd3bp12ibpkf4znybsd2bfh0i1pzn0n";
   buildDepends = [ binary mtl vector ];
   testDepends = [ mtl testSimple Unixutils vector ];
-  doCheck = false;
   meta = {
     homepage = "https://github.com/bosu/pure-cdb";
     description = "Another pure-haskell CDB (Constant Database) implementation";

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

···
 
 cabal.mkDerivation (self: {
   pname = "purescript";
-  version = "0.5.6.3";
-  sha256 = "0f9jzv886dg9aphwaqgx17xk2j6j4v2n12y3yhkbs46icmlr8zxp";
+  version = "0.5.7.1";
+  sha256 = "1xjihv7lq5b2cw44jhxwzr21749gayqfiqjkryz6z9p820hg1zzv";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal }:
+
+cabal.mkDerivation (self: {
+  pname = "raw-strings-qq";
+  version = "1.0.2";
+  sha256 = "0wnifa97am2s9bqixlidw3nf8w14h2qkg3sn1rxzgvc3fws57jg9";
+  meta = {
+    homepage = "https://github.com/23Skidoo/raw-strings-qq";
+    description = "Raw string literals for Haskell";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "resource-pool";
-  version = "0.2.3.0";
-  sha256 = "15igbvnqs6ig1k30l3jngyi60ay7k15mwgza5smv8zbpx86vb1mh";
+  version = "0.2.3.1";
+  sha256 = "02fpw5jfzcdhijx8mfpb6j4c8sxl36f04i2nx3cbivh9yhbgqr92";
   buildDepends = [
     hashable monadControl stm time transformers transformersBase vector
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "rest-core";
-  version = "0.33";
-  sha256 = "05m8cvkm0nsi1yixk0dj5j6nvzzzs07i0pmyaj0ww6v5vkmcgmfb";
+  version = "0.33.1";
+  sha256 = "0vrxdfnv53f65nifvvjj961h9nj7dlbfwk5y21zy9cl5w0dbg5yy";
   buildDepends = [
     aeson aesonUtils either errors fclabels hxt hxtPickleUtils
     jsonSchema mtl multipart random restStringmap restTypes safe split

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

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

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

···
 
 cabal.mkDerivation (self: {
   pname = "rest-types";
-  version = "1.11";
-  sha256 = "16ki6sqi88s8ykwdhsk0xparvv90zzj4jidk0mhsd2wi3l4w1l6i";
+  version = "1.11.1";
+  sha256 = "1dqjch3h3hv4s1v0wkbd4spn26f068bqpsz6mr0vdacdbhjwnigg";
   buildDepends = [
     aeson genericAeson hxt jsonSchema mtl regular regularXmlpickler
     restStringmap text uuid

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, HUnit }:
+
+cabal.mkDerivation (self: {
+  pname = "serialport";
+  version = "0.4.7";
+  sha256 = "1z2drw7ighyws72wqms015n5hy0zxbrphdca7ldn34pz28122z07";
+  testDepends = [ HUnit ];
+  doCheck = false; # Test requires a connected Arduino...
+  meta = {
+    homepage = "https://github.com/jputcu/serialport";
+    description = "Cross platform serial port library";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/stm-containers/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "stm-containers";
-  version = "0.1.3";
-  sha256 = "0ir2b6y1sqr0i68j0fqmwyysk7x9z18n84dbjppyjzzidcsrkar0";
+  version = "0.1.4";
+  sha256 = "15h7qxxbr1ifkvmxsj30k0v3hp83m04iq25bvi3jmagvvk5hv5bj";
   buildDepends = [
     basePrelude focus hashable lochTh placeholders primitive
   ];

pkgs/development/libraries/haskell/tasty-ant-xml/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "tasty-ant-xml";
-  version = "1.0.0.11";
-  sha256 = "0cia8n31pyyax7v02xgpznanzd5wd32kps0dzx5ky1bmgbi9w4am";
+  version = "1.0.1";
+  sha256 = "1wb9lm9rbk46g9cm2lpcrzh59zpcy270p824agg61bj1xb9jymsc";
   buildDepends = [
     genericDeriving mtl stm tagged tasty transformers xml
   ];

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

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, QuickCheck, tagged, tasty }:
+{ cabal, pcreLight, QuickCheck, tagged, tasty, tastyHunit }:
 
 cabal.mkDerivation (self: {
   pname = "tasty-quickcheck";
-  version = "0.8.2";
-  sha256 = "16fdzdlvivrkhpg9nbfz9gamvlpb25fgcxnshzg7i7hkrgzhbrji";
+  version = "0.8.3";
+  sha256 = "0vfxdcsj92d5z3yx45ccymln7ikdvqryc64x33gkyv1yqk4h42r9";
   buildDepends = [ QuickCheck tagged tasty ];
+  testDepends = [ pcreLight tasty tastyHunit ];
   meta = {
     homepage = "http://documentup.com/feuerbach/tasty";
     description = "QuickCheck support for the Tasty test framework";

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

···
 
 cabal.mkDerivation (self: {
   pname = "tasty";
-  version = "0.10.0.2";
-  sha256 = "0d2lmdrhdcmpay1yj613ckmjhwnrmaazcy3xhbc3fjlmd0rma44q";
+  version = "0.10.0.4";
+  sha256 = "028i567qmfkgriqs5y7vp6g5lz557cy5awhblcp6y2ya0aj78w5r";
   buildDepends = [
     ansiTerminal async deepseq mtl optparseApplicative regexTdfaRc stm
     tagged time unboundedDelays

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

···
 
 cabal.mkDerivation (self: {
   pname = "wai-middleware-static";
-  version = "0.6.0";
-  sha256 = "1rsy8qkxcjqdpzqkar0smyy49p8vqapi47k8d24101lz3rym6018";
+  version = "0.6.0.1";
+  sha256 = "1ylf2nm535d3dw0ksa9dfz1b4b78mqzkdrpdfd5pxswcqbgs266d";
   buildDepends = [ filepath httpTypes mtl text wai ];
   jailbreak = true;
   meta = {
-    homepage = "https://github.com/scotty-web/scotty";
+    homepage = "https://github.com/scotty-web/wai-middleware-static";
     description = "WAI middleware that serves requests to static files";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

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

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-auth";
-  version = "1.4.0.1";
-  sha256 = "1d5rimp6jnxi8j518g3hg74a4g90rvgfhnxpz2kj6881v85avvh3";
+  version = "1.4.0.2";
+  sha256 = "15k30si28jj6ivazwxbcy15hplvbpwwgwf5zcvzchi2w56z8j5gn";
   buildDepends = [
     aeson authenticate base16Bytestring base64Bytestring binary
     blazeBuilder blazeHtml blazeMarkup byteable conduit conduitExtra

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

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

pkgs/development/libraries/haskell/yi-contrib/default.nix

···
-# This file was auto-generated by cabal2nix. Please do NOT edit manually!
-
-{ cabal, filepath, lens, mtl, ooPrototypes, split, text, time
-, transformersBase, yi, yiLanguage, yiRope
-}:
-
-cabal.mkDerivation (self: {
-  pname = "yi-contrib";
-  version = "0.10.1";
-  sha256 = "053hsahkxwg2mnf3h4j95gj18x5791dqqji43l310i4l7mliw91k";
-  buildDepends = [
-    filepath lens mtl ooPrototypes split text time transformersBase yi
-    yiLanguage yiRope
-  ];
-  meta = {
-    homepage = "http://haskell.org/haskellwiki/Yi";
-    description = "Add-ons to Yi, the Haskell-Scriptable Editor";
-    license = self.stdenv.lib.licenses.gpl2;
-    platforms = self.ghc.meta.platforms;
-    maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
-  };
-})

pkgs/development/libraries/haskell/yi-fuzzy-open/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, binary, dataDefault, filepath, mtl, text, transformersBase
+, vector, yi, yiLanguage, yiRope
+}:
+
+cabal.mkDerivation (self: {
+  pname = "yi-fuzzy-open";
+  version = "0.1.0";
+  sha256 = "03y7ddas8w380asx4ldafp1r3h4nlyjky7n4n5sdyvwbi0rix1gc";
+  buildDepends = [
+    binary dataDefault filepath mtl text transformersBase vector yi
+    yiLanguage yiRope
+  ];
+  meta = {
+    homepage = "https://github.com/yi-editor/yi-fuzzy-open";
+    description = "Fuzzy open plugin for Yi";
+    license = self.stdenv.lib.licenses.gpl2;
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
+  };
+})

pkgs/development/libraries/haskell/yi-monokai/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, yi }:
+
+cabal.mkDerivation (self: {
+  pname = "yi-monokai";
+  version = "0.1.1.2";
+  sha256 = "1nghfyiy8jdz144nbw0c2cdy8n6xyjmk31g6z24jk8dij7iwb60l";
+  buildDepends = [ yi ];
+  meta = {
+    homepage = "https://github.com/Fuuzetsu/yi-monokai";
+    description = "Monokai colour theme for the Yi text editor";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
+  };
+})

pkgs/development/libraries/haskell/yi-rope/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, binary, dataDefault, deepseq, fingertree, hspec
-, QuickCheck, quickcheckInstances, text
+{ cabal, binary, charsetdetectAe, dataDefault, deepseq, fingertree
+, hspec, QuickCheck, quickcheckInstances, text, textIcu
 }:
 
 cabal.mkDerivation (self: {
   pname = "yi-rope";
-  version = "0.4.1.0";
-  sha256 = "11k0fl2m6m7idvanfrgvl3h068i6yj6rzxmwpjylz4vdqq618rcq";
-  buildDepends = [ binary dataDefault deepseq fingertree text ];
+  version = "0.6.0.0";
+  sha256 = "1r52mybqzy28zsv6r6a0cfmi8qaiscc91q2dhfq8rlp63l7ghq36";
+  buildDepends = [
+    binary charsetdetectAe dataDefault deepseq fingertree text textIcu
+  ];
   testDepends = [ hspec QuickCheck quickcheckInstances text ];
   meta = {
     description = "A rope data structure used by Yi";

pkgs/development/libraries/haskell/yi-snippet/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, yi, yiRope }:
+
+cabal.mkDerivation (self: {
+  pname = "yi-snippet";
+  version = "0.1.0.0";
+  sha256 = "0qbn5x7lbvb9h6gdqgvldzyy7z5y5aa9a02ss48zkccss5p6939d";
+  buildDepends = [ yi yiRope ];
+  meta = {
+    homepage = "https://github.com/yi-editor/yi-snippet";
+    description = "Snippet support for Yi";
+    license = self.stdenv.lib.licenses.gpl2;
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
+  };
+})

pkgs/development/libraries/hidapi/default.nix

···
+{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, udev, libusb }:
+
+stdenv.mkDerivation rec {
+  name = "hidapi-0.8.0-rc1";
+
+  src = fetchFromGitHub {
+    owner = "signal11";
+    repo = "hidapi";
+    rev = name;
+    sha256 = "13d5jkmh9nh4c2kjch8k8amslnxapa9vkqzrk1z6rqmw8qgvzbkj";
+  };
+
+  buildInputs = [ autoreconfHook pkgconfig udev libusb ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/signal11/hidapi;
+    description = "for communicating with USB and Bluetooth HID devices";
+    license = licenses.bsd3;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ wkennington ];
+  };
+}

pkgs/development/libraries/libassuan/default.nix

···
 { fetchurl, stdenv, pth, libgpgerror }:
 
 stdenv.mkDerivation rec {
-  name = "libassuan-2.1.1";
+  name = "libassuan-2.1.2";
 
   src = fetchurl {
     url = "mirror://gnupg/libassuan/${name}.tar.bz2";
-    sha256 = "1783nb0b6nr9yjhb5wfh8ykc5w89f4anppz1kz9913mqg5vxdqi3";
+    sha256 = "0yxp3mdsxg75aj3h2r94vzad5i1y2mh0df9pv76ggals6k4sgy1r";
   };
 
   propagatedBuildInputs = [ libgpgerror pth ];

pkgs/development/libraries/libcec/default.nix

···
+{ stdenv, fetchurl, autoreconfHook, pkgconfig, udev }:
+
+let version = "2.1.4"; in
+
+stdenv.mkDerivation {
+  name = "libcec-${version}";
+
+  src = fetchurl {
+    url = "https://github.com/Pulse-Eight/libcec/archive/libcec-${version}.tar.gz";
+    sha256 = "0iz11zclbs3gk4ddq0pm4vyq015qmvy4nb9sra3vk6jw58izbgkr";
+  };
+
+  buildInputs = [ autoreconfHook pkgconfig udev ];
+
+  meta = {
+    description = "USB CEC adapter communication library";
+    homepage = "http://libcec.pulse-eight.com";
+    repositories.git = "https://github.com/Pulse-Eight/libcec.git";
+    license = "GPLv2+";
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/development/libraries/libgpg-error/default.nix

···
 { stdenv, fetchurl, bash, gettext }:
 
 stdenv.mkDerivation (rec {
-  name = "libgpg-error-1.16";
+  name = "libgpg-error-1.17";
 
   src = fetchurl {
     url = "mirror://gnupg/libgpg-error/${name}.tar.bz2";
-    sha256 = "16xv59zcr177gvgj97vg0rm4rixrpb4lz1q9fji3xay47i83gm62";
+    sha256 = "1dapxzxl1naghf342fwfc2w2f2c5hb9gr1a1s4n8dsqn26kybx1z";
   };
 
   # If architecture-dependent MO files aren't available, they're generated

pkgs/development/libraries/libksba/default.nix

···
 { stdenv, fetchurl, libgpgerror }:
 
 stdenv.mkDerivation rec {
-  name = "libksba-1.2.0";
+  name = "libksba-1.3.1";
 
   src = fetchurl {
     url = "mirror://gnupg/libksba/${name}.tar.bz2";
-    sha256 = "0jwk7hm3x3g4hd7l12z3d79dy7359x7lc88dq6z7q0ixn1jwxbq9";
+    sha256 = "1ya6mcd6pk2v1pylvlk6wv3869aslz2mr2xw2gs6faxx2ravk5mw";
   };
 
-  propagatedBuildInputs = [libgpgerror];
+  propagatedBuildInputs = [ libgpgerror ];
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://www.gnupg.org;
     description = "CMS and X.509 access library under development";
+    platforms = platforms.all;
+    license = licenses.lgpl3;
+    maintainers = with maintainers; [ wkennington ];
   };
 }

pkgs/development/libraries/libmsgpack/CMakeLists.patch

···
 diff -r 791a4edd7e1d CMakeLists.txt
 --- a/CMakeLists.txt	Sun Oct 05 13:14:14 2014 +0100
 +++ b/CMakeLists.txt	Sun Oct 05 13:20:12 2014 +0100
-@@ -158,7 +158,7 @@
+@@ -157,8 +157,9 @@
+ 
  INSTALL (TARGETS msgpack msgpack-static DESTINATION lib)
  INSTALL (DIRECTORY src/msgpack DESTINATION include)
++INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h DESTINATION include/msgpack)
  INSTALL (FILES src/msgpack.h src/msgpack.hpp DESTINATION include)
 -INSTALL (FILES msgpack.pc DESTINATION lib/pkgconfig)
 +INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION lib/pkgconfig)

pkgs/development/libraries/libpcap/default.nix

···
   
   nativeBuildInputs = [ flex bison ];
   
-  configureFlags = stdenv.lib.optionals stdenv.isLinux "--with-pcap=linux";
+  # We need to force the autodetection because detection doesn't
+  # work in pure build enviroments.
+  configureFlags =
+    if stdenv.isLinux then [ "--with-pcap=linux" ]
+    else if stdenv.isDarwin then [ "--with-pcap=bpf" ]
+    else [];
 
   preInstall = ''mkdir -p $out/bin'';
   

pkgs/development/libraries/libtorrent-rasterbar/default.nix

···
 { stdenv, fetchurl, boost, openssl, pkgconfig, zlib, python, libiconvOrNull, geoip }:
 
 stdenv.mkDerivation rec {
-  name = "libtorrent-rasterbar-${version}";
-  version = "0.16.16";
+  name = "libtorrent-rasterbar-1.0.2";
   
   src = fetchurl {
-    url = mirror://sourceforge/libtorrent/libtorrent-rasterbar-0.16.16.tar.gz;
-    sha256 = "1a3yxwjs4qb0rwx6cfpvar0a8jmavb6ik580b27md08jhvq80if7";
+    url = "mirror://sourceforge/libtorrent/${name}.tar.gz";
+    sha256 = "1ph4cb6nrk2hiy89j3kz1wj16ph0b9yixrf4f4935rnzhha8x31w";
   };
 
   buildInputs = [ boost boost.lib pkgconfig openssl zlib python libiconvOrNull geoip ];
···
     "--enable-python-binding"
     "--with-libgeoip=system"
     "--with-libiconv=yes"
+    "--with-boost=${boost.lib}"
  ];
   
   meta = with stdenv.lib; {

pkgs/development/libraries/libu2f-host/default.nix

···
+{ stdenv, fetchurl, pkgconfig, json_c, hidapi }:
+
+stdenv.mkDerivation rec {
+  name = "libu2f-host-0.0";
+
+  src = fetchurl {
+    url = "https://developers.yubico.com/libu2f-host/Releases/${name}.tar.xz";
+    sha256 = "02pjald2j6syvxm5pszxcpqhpp7c80hblnzh6wrafkmpkpzi3rq5";
+  };
+
+  buildInputs = [ pkgconfig json_c hidapi ];
+
+  meta = with stdenv.lib; {
+    homepage = https://developers.yubico.com/libu2f-host;
+    description = "a C library and command-line tool thati mplements the host-side of the U2F protocol";
+    license = licenses.bsd2;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ wkennington ];
+  };
+}

pkgs/development/libraries/libusb1/default.nix

···
-{ stdenv, fetchurl, pkgconfig, udev }:
+{ stdenv, fetchurl, pkgconfig, udev ? null }:
 
-let
-  version = "1.0.18";
-in
 stdenv.mkDerivation rec {
-  name = "libusb-${version}"; # at 1.0.18 libusb joined with libusbx
+  name = "libusb-1.0.19";
 
   src = fetchurl {
-    url = "mirror://sourceforge/libusb/libusb-${version}.tar.bz2";
-    sha256 = "081px0j98az0pjwwyjlq4qcmfn194fvm3qd4im0r9pm58pn5qgy7";
+    url = "mirror://sourceforge/libusb/${name}.tar.bz2";
+    sha256 = "0h38p9rxfpg9vkrbyb120i1diq57qcln82h5fr7hvy82c20jql3c";
   };
 
   buildInputs = [ pkgconfig ];
-  propagatedBuildInputs = stdenv.lib.optional (stdenv.isLinux) udev;
+  propagatedBuildInputs = stdenv.lib.optional stdenv.isLinux udev;
 
   NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isLinux "-lgcc_s";
 

pkgs/development/libraries/libvirt/default.nix

···
 { stdenv, fetchurl, pkgconfig, libxml2, gnutls, devicemapper, perl, python
 , iproute, iptables, readline, lvm2, utillinux, udev, libpciaccess, gettext
 , libtasn1, ebtables, libgcrypt, yajl, makeWrapper, pmutils, libcap_ng
-, dnsmasq, libnl
+, dnsmasq, libnl, libpcap
 , pythonPackages
 }:
 
···
     "--with-init-script=redhat"
     "--with-macvtap"
     "--with-virtualport"
+    "--with-libpcap"
   ];
 
   installFlags = [

pkgs/development/libraries/libxml2/default.nix

···
 #TODO: share most stuff between python and non-python builds, perhaps via multiple-output
 
 let
-  version = "2.9.1";
+  version = "2.9.2";
 in
 
 stdenv.mkDerivation (rec {
···
 
   src = fetchurl {
     url = "ftp://xmlsoft.org/libxml2/${name}.tar.gz";
-    sha256 = "1nqgd1qqmg0cg09mch78m2ac9klj9n87blilx4kymi7jcv5n8g7x";
+    sha256 = "1g6mf03xcabmk5ing1lwqmasr803616gb2xhn7pll10x2l5w6y2i";
   };
 
   buildInputs = stdenv.lib.optional pythonSupport python

pkgs/development/libraries/libxml2/setup-hook.sh

···
 if test -z "$libxmlHookDone"; then
     libxmlHookDone=1
 
-    # Set http_proxy and ftp_proxy to an invalid host to prevent
-    # xmllint and xsltproc from trying to download DTDs from the
-    # network even when --nonet is not given.  That would be impure.
-    # (Note that .invalid is a reserved domain guaranteed not to
-    # work.)
-    export http_proxy=http://nodtd.invalid/
-    export ftp_proxy=http://nodtd.invalid/
-
     # Set up XML_CATALOG_FILES.  An empty initial value prevents
     # xmllint and xsltproc from looking in /etc/xml/catalog.
     export XML_CATALOG_FILES

pkgs/development/libraries/libykneomgr/default.nix

···
+{ stdenv, fetchurl, pkgconfig, pcsclite, libzip, help2man }:
+
+stdenv.mkDerivation rec {
+  name = "libykneomgr-0.1.6";
+
+  src = fetchurl {
+    url = "https://developers.yubico.com/libykneomgr/Releases/${name}.tar.gz";
+    sha256 = "15fa4sslbzhzmkf0xik36as9lsmys1apqwjxv8sx7qlpacmxy3bw";
+  };
+
+  buildInputs = [ pkgconfig pcsclite libzip help2man ];
+
+  configureFlags = [
+    "--with-backend=pcsc"
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://developers.yubico.com/libykneomgr;
+    description = "a C library to interact with the CCID-part of the Yubikey NEO";
+    license = licenses.bsd3;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ wkennington ];
+  };
+}

pkgs/development/libraries/libyubikey/default.nix

···
-{stdenv, fetchurl}:
+{ stdenv, fetchurl }:
 
-stdenv.mkDerivation rec
-{
-  version = "1.12";
-  name = "libyubikey-${version}";
+stdenv.mkDerivation rec {
+  name = "libyubikey-1.12";
 
-  src = fetchurl
-  {
-    url = "http://opensource.yubico.com/yubico-c/releases/${name}.tar.gz";
+  src = fetchurl {
+    url = "https://developers.yubico.com/yubico-c/Releases/${name}.tar.gz";
     sha256 = "1f0plzmr1gwry4rfgq9q70v6qwqny009hac289ad5m6sj7vqflxr";
   };
 
-  meta =
-  {
+  meta = with stdenv.lib; {
     homepage = "http://opensource.yubico.com/yubico-c/";
     description = "C library for manipulating Yubico YubiKey One-Time Passwords (OTPs)";
-    license = "bsd";
-    maintainers = [ stdenv.lib.maintainers.calrama ];
+    license = licenses.bsd2;
+    maintainers = with maintainers; [ calrama wkennington ];
+    platforms = platforms.unix;
   };
 }

pkgs/development/libraries/npth/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "npth-0.91";
+  name = "npth-1.0";
 
   src = fetchurl {
     url = "ftp://ftp.gnupg.org/gcrypt/npth/${name}.tar.bz2";
-    sha256 = "1qgs1n70x83dyyysabg50dh8s3464jwsa63qi5if2cd3sk78dvya";
+    sha256 = "0vppr13821bkdv8348067l1aj3sb0n0rbmnsgymzy3iifvirvm4s";
   };
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "The New GNU Portable Threads Library";
     longDescription = ''
       This is a library to provide the GNU Pth API and thus a non-preemptive
···
       that this is a solid way to provide a co-routine based framework.
     '';
     homepage = http://www.gnupg.org;
-    license = stdenv.lib.licenses.lgpl3;
-    platforms = stdenv.lib.platforms.all;
+    license = licenses.lgpl3;
+    platforms = platforms.all;
   };
 }

pkgs/development/libraries/openldap/default.nix

···
 {stdenv, fetchurl, openssl, cyrus_sasl, db, groff}:
 
 stdenv.mkDerivation rec {
-  name = "openldap-2.4.39";
+  name = "openldap-2.4.40";
 
   src = fetchurl {
     url = "http://www.openldap.org/software/download/OpenLDAP/openldap-release/${name}.tgz";
-    sha256 = "19zq9dc7dl03wmqd11fbsdii1npyq1vlicl3nxbfygqh8xrwhrw2";
+    sha256 = "1nyslrgwxwilgv5sixc37svls5rbvhsv9drb7hlrjr2vqaji29ni";
   };
 
   buildInputs = [ openssl cyrus_sasl db groff ];

pkgs/development/libraries/smpeg/default.nix

···
-{ stdenv, fetchsvn, SDL, autoconf, automake, libtool, gtk, m4, pkgconfig, mesa }:
+{ stdenv, fetchsvn, SDL, autoconf, automake, libtool, gtk, m4, pkgconfig, mesa, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "smpeg-svn${version}";
···
 
   enableParallelBuilding = true;
 
-  buildInputs = [ SDL autoconf automake libtool gtk m4 pkgconfig mesa ];
+  buildInputs = [ SDL gtk mesa ];
+
+  nativeBuildInputs = [ autoconf automake libtool m4 pkgconfig makeWrapper ];
 
   preConfigure = ''
     touch NEWS AUTHORS ChangeLog
···
     -e 's,"SDL_thread.h",<SDL/SDL_thread.h>,' \
     -e 's,"SDL_types.h",<SDL/SDL_types.h>,' \
       $out/include/smpeg/*.h
+
+    wrapProgram $out/bin/smpeg-config \
+      --prefix PATH ":" "${pkgconfig}/bin" \
+      --prefix PKG_CONFIG_PATH ":" "${SDL}/lib/pkgconfig"
   '';
 
   meta = {

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

···
 {stdenv, androidsdk, titaniumsdk, titanium, xcodewrapper, jdk, python, which, xcodeBaseDir}:
 { name, src, target, androidPlatformVersions ? [ "8" ], androidAbiVersions ? [ "armeabi" "armeabi-v7a" ], tiVersion ? null
 , release ? false, androidKeyStore ? null, androidKeyAlias ? null, androidKeyStorePassword ? null
-, iosMobileProvisioningProfile ? null, iosCertificateName ? null, iosCertificate ? null, iosCertificatePassword ? null, iosVersion ? "8.0"
+, iosMobileProvisioningProfile ? null, iosCertificateName ? null, iosCertificate ? null, iosCertificatePassword ? null, iosVersion ? "8.0", iosWwdrCertificate ? null
 , enableWirelessDistribution ? false, installURL ? null
 }:
 
···
     useGoogleAPIs = true;
   };
   
-  deleteKeychain = "security delete-keychain $keychainName";
+  deleteKeychain = ''
+    security default-keychain -s login.keychain
+    security delete-keychain $keychainName
+  '';
 in
 stdenv.mkDerivation {
   name = stdenv.lib.replaceChars [" "] [""] name;
···
               security default-keychain -s $keychainName
               security unlock-keychain -p "" $keychainName
               security import ${iosCertificate} -k $keychainName -P "${iosCertificatePassword}" -A
-
+              ${stdenv.lib.optionalString (iosWwdrCertificate != null) ''
+                security import ${iosWwdrCertificate} -k $keychainName
+              ''}
               provisioningId=$(grep UUID -A1 -a ${iosMobileProvisioningProfile} | grep -o "[-A-Za-z0-9]\{36\}")
    
               # Ensure that the requested provisioning profile can be found

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

···
 , xcodeBaseDir ? "/Applications/Xcode.app"
 , tiVersion ? "3.4.0.GA"
 , rename ? false
-, newBundleId ? "com.example.kitchensink", iosMobileProvisioningProfile ? null, iosCertificate ? null, iosCertificateName ? "Example", iosCertificatePassword ? ""
+, newBundleId ? "com.example.kitchensink", iosMobileProvisioningProfile ? null, iosCertificate ? null, iosCertificateName ? "Example", iosCertificatePassword ? "", iosVersion ? "8.0", iosWwdrCertificate ? null
 , allowUnfree ? false
 , enableWirelessDistribution ? false, installURL ? null
 }:
···
   kitchensink_ios_development = import ./kitchensink {
     inherit (pkgs) fetchgit;
     titaniumenv = pkgs.titaniumenv.override { inherit xcodeVersion xcodeBaseDir tiVersion; };
-    inherit tiVersion;
+    inherit tiVersion iosVersion;
     target = "iphone";
   };
 
···
       inherit tiVersion;
       release = true;
       rename = true;
-      inherit newBundleId iosMobileProvisioningProfile iosCertificate iosCertificateName iosCertificatePassword;
+      inherit newBundleId iosMobileProvisioningProfile iosCertificate iosCertificateName iosCertificatePassword iosVersion iosWwdrCertificate;
       inherit enableWirelessDistribution installURL;
     };
   }

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

···
 { titaniumenv, fetchgit, target, androidPlatformVersions ? [ "14" ], tiVersion ? "3.2.3.GA", release ? false
-, rename ? false, stdenv ? null, newBundleId ? null, iosMobileProvisioningProfile ? null, iosCertificate ? null, iosCertificateName ? null, iosCertificatePassword ? null
+, rename ? false, stdenv ? null, newBundleId ? null, iosMobileProvisioningProfile ? null, iosCertificate ? null, iosCertificateName ? null, iosCertificatePassword ? null, iosVersion ? "8.0", iosWwdrCertificate ? null
 , enableWirelessDistribution ? false, installURL ? null
 }:
 
···
   androidKeyAlias = "myfirstapp";
   androidKeyStorePassword = "mykeystore";
   
-  inherit iosMobileProvisioningProfile iosCertificate iosCertificateName iosCertificatePassword;
+  inherit iosMobileProvisioningProfile iosCertificate iosCertificateName iosCertificatePassword iosVersion iosWwdrCertificate;
   inherit enableWirelessDistribution installURL;
 }

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

···
     else sdk;
 
   # The following is to prevent repetition
-  deleteKeychain = "security delete-keychain $keychainName";
+  deleteKeychain = ''
+    security default-keychain -s login.keychain
+    security delete-keychain $keychainName
+  '';
 in
 stdenv.mkDerivation {
   name = stdenv.lib.replaceChars [" "] [""] name;

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

···
+{ stdenv, fetchurl, ocaml, findlib }:
+
+stdenv.mkDerivation {
+
+  name = "ansiterminal-0.6.5";
+
+  src = fetchurl {
+    url = "https://forge.ocamlcore.org/frs/download.php/1206/ANSITerminal-0.6.5.tar.gz";
+    sha256 = "1j9kflv2i16vf9hy031cl6z8hv6791mjbhnd9bw07y1pswdlx1r6";
+  };
+
+  buildInputs = [ ocaml findlib ];
+
+  configurePhase = "ocaml setup.ml -configure --prefix $out";
+
+  buildPhase = "ocaml setup.ml -build";
+
+  installPhase = "ocaml setup.ml -install";
+
+  createFindlibDestdir = true;
+
+  meta = with stdenv.lib; {
+    homepage = "https://forge.ocamlcore.org/projects/ansiterminal";
+    description = "A module allowing to use the colors and cursor movements on ANSI terminals";
+    longDescription = ''
+      ANSITerminal is a module allowing to use the colors and cursor
+      movements on ANSI terminals. It also works on the windows shell (but
+      this part is currently work in progress).
+    '';
+    license = licenses.lgpl3;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

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

···
+{ stdenv, fetchurl, ocaml, findlib, which }:
+
+let inherit (stdenv.lib) getVersion versionAtLeast; in
+
+assert versionAtLeast (getVersion ocaml) "4.00.0";
+assert versionAtLeast (getVersion findlib) "1.3.3";
+
+stdenv.mkDerivation rec {
+
+  name = "bolt-1.4";
+
+  src = fetchurl {
+    url = "https://forge.ocamlcore.org/frs/download.php/1043/${name}.tar.gz";
+    sha256 = "1c807wrpxra9sbb34lajhimwra28ldxv04m570567lh2b04n38zy";
+  };
+
+  buildInputs = [ ocaml findlib which ];
+
+  # The custom `configure` script does not expect the --prefix
+  # option. Installation is handled by ocamlfind.
+  dontAddPrefix = true;
+
+  createFindlibDestdir = true;
+
+  buildFlags = "all";
+
+  doCheck = true;
+  checkTarget = "tests";
+
+  meta = with stdenv.lib; {
+    homepage = "http://bolt.x9c.fr";
+    description = "A logging tool for the OCaml language";
+    longDescription = ''
+      Bolt is a logging tool for the OCaml language. It is inspired by and
+      modeled after the famous log4j logging framework for Java.
+    '';
+    license = licenses.lgpl3;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

pkgs/development/pharo/vm/default.nix

···
 
 stdenv.mkDerivation rec {
 
-  version = "2014.09.20";
+  version = "2014.10.28";
 
   name = "pharo-vm-core-i386-${version}";
   system = "x86_32-linux";
   src = fetchurl {
     url = "http://files.pharo.org/vm/src/vm-unix-sources/blessed/pharo-vm-${version}.tar.bz2";
-    md5 = "f4183566aeeb7cb9d0d7832b4e40b573";
+    md5 = "c1d25d5beac15dc8e5bd3f84ab9b0ac3";
   };
 
   sources10Zip = fetchurl {

pkgs/development/python-modules/box2d/disable-test.patch

···
+Common subdirectories: Box2D-2.3b0/Box2D and Box2D-2.3b0.new/Box2D
+Common subdirectories: Box2D-2.3b0/examples and Box2D-2.3b0.new/examples
+Common subdirectories: Box2D-2.3b0/library and Box2D-2.3b0.new/library
+diff -u Box2D-2.3b0/setup.py Box2D-2.3b0.new/setup.py
+--- Box2D-2.3b0/setup.py	2013-02-02 18:09:34.000000000 +0100
++++ Box2D-2.3b0.new/setup.py	2014-10-25 13:32:07.136922343 +0200
+@@ -176,7 +176,6 @@
+     package_dir      = {'Box2D': library_path, 
+                         'Box2D.b2': os.path.join(library_path, 'b2'),
+                         'Box2D.tests' : 'tests'},
+-    test_suite       = 'tests',
+     options          = { 'build_ext': { 'swig_opts' : swig_arguments },
+                          'egg_info' : { 'egg_base' : library_base },
+                         },

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

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "5.7";
+  version = "6.0";
   name = "checkstyle-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/checkstyle/${version}/${name}-bin.tar.gz";
-    sha256 = "0kzj507ylynq6p7v097bjzsckkjny5i2fxwxyrlwi5samhi2m06x";
+    sha256 = "08qjx7yfx5p7ydbcm6lzm15qcwkgcf1jw27i9fnyr01wppz9yrsx";
   };
 
   installPhase = ''
···
     cp -R * $out/checkstyle
   '';
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "Checks Java source against a coding standard";
     longDescription = ''
       checkstyle is a development tool to help programmers write Java code that
···
       Conventions, but is highly configurable.
     '';
     homepage = http://checkstyle.sourceforge.net/;
-    license = stdenv.lib.licenses.lgpl21;
+    license = licenses.lgpl21;
+    maintainers = with maintainers; [ pSub ];
   };
 }

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

···
 { stdenv, fetchurl, unzip, jdk, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "gradle-1.11";
+  name = "gradle-2.1";
 
   src = fetchurl {
     url = "http://services.gradle.org/distributions/${name}-bin.zip";
-    sha256 = "14a0qdzjiar97l9a0i3ds2y48p1lrqkj7skkkvhz0r29hbgkbqh7";
+    sha256 = "0y7qifc61nng24zn73bdwh5d0m25dnllfiwfkyw220mblag4zviy";
   };
 
   installPhase = ''
···
 
     makeWrapper ${jdk}/bin/java $out/bin/gradle \
       --set JAVA_HOME ${jdk} \
-      --add-flags "-classpath $out/lib/gradle-launcher-1.11.jar org.gradle.launcher.GradleMain"
+      --add-flags "-classpath $out/lib/gradle-launcher-2.1.jar org.gradle.launcher.GradleMain"
   '';
 
   phases = "unpackPhase installPhase";

pkgs/development/tools/egg2nix/chicken-eggs.nix

···
+{ pkgs, stdenv }:
+rec {
+  inherit (pkgs) eggDerivation fetchegg;
+
+  base64 = eggDerivation {
+    name = "base64-3.3.1";
+
+    src = fetchegg {
+      name = "base64";
+      version = "3.3.1";
+      sha256 = "0wmldiwwg1jpcn07wb906nc53si5j7sa83wgyq643xzqcx4v4x1d";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  blob-utils = eggDerivation {
+    name = "blob-utils-1.0.3";
+
+    src = fetchegg {
+      name = "blob-utils";
+      version = "1.0.3";
+      sha256 = "17vdn02fnxnjx5ixgqimln93lqvzyq4y9w02fw7xnbdcjzqm0xml";
+    };
+
+    buildInputs = [
+      setup-helper
+      string-utils
+    ];
+  };
+
+  check-errors = eggDerivation {
+    name = "check-errors-1.13.0";
+
+    src = fetchegg {
+      name = "check-errors";
+      version = "1.13.0";
+      sha256 = "12a0sn82n98jybh72zb39fdddmr5k4785xglxb16750fhy8rmjwi";
+    };
+
+    buildInputs = [
+      setup-helper
+    ];
+  };
+
+  defstruct = eggDerivation {
+    name = "defstruct-1.6";
+
+    src = fetchegg {
+      name = "defstruct";
+      version = "1.6";
+      sha256 = "0lsgl32nmb5hxqiii4r3292cx5vqh50kp6v062nfiyid9lhrj0li";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  http-client = eggDerivation {
+    name = "http-client-0.7.1";
+
+    src = fetchegg {
+      name = "http-client";
+      version = "0.7.1";
+      sha256 = "1s03zgmb7kb99ld0f2ylqgicrab9qgza53fkgsqvg7bh5njmzhxr";
+    };
+
+    buildInputs = [
+      intarweb
+      uri-common
+      message-digest
+      md5
+      string-utils
+      sendfile
+    ];
+  };
+
+  intarweb = eggDerivation {
+    name = "intarweb-1.3";
+
+    src = fetchegg {
+      name = "intarweb";
+      version = "1.3";
+      sha256 = "0izlby78c25py29bdcbc0vapb6h7xgchqrzi6i51d0rb3mnwy88h";
+    };
+
+    buildInputs = [
+      defstruct
+      uri-common
+      base64
+    ];
+  };
+
+  lookup-table = eggDerivation {
+    name = "lookup-table-1.13.5";
+
+    src = fetchegg {
+      name = "lookup-table";
+      version = "1.13.5";
+      sha256 = "1nzly6rhynawlvzlyilk8z8cxz57cf9n5iv20glkhh28pz2izmrb";
+    };
+
+    buildInputs = [
+      setup-helper
+      check-errors
+      miscmacros
+      record-variants
+      synch
+    ];
+  };
+
+  matchable = eggDerivation {
+    name = "matchable-3.3";
+
+    src = fetchegg {
+      name = "matchable";
+      version = "3.3";
+      sha256 = "07y3lpzgm4djiwi9y2adc796f9kwkmdr28fkfkw65syahdax8990";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  md5 = eggDerivation {
+    name = "md5-3.1.0";
+
+    src = fetchegg {
+      name = "md5";
+      version = "3.1.0";
+      sha256 = "0bka43nx8x9b0b079qpvml2fl20km19ny0qjmhwzlh6rwmzazj2a";
+    };
+
+    buildInputs = [
+      message-digest
+    ];
+  };
+
+  message-digest = eggDerivation {
+    name = "message-digest-3.1.0";
+
+    src = fetchegg {
+      name = "message-digest";
+      version = "3.1.0";
+      sha256 = "1w6bax19dwgih78vcimiws0rja7qsd8hmbm6qqg2hf9cw3vab21s";
+    };
+
+    buildInputs = [
+      setup-helper
+      miscmacros
+      check-errors
+      variable-item
+      blob-utils
+      string-utils
+    ];
+  };
+
+  miscmacros = eggDerivation {
+    name = "miscmacros-2.96";
+
+    src = fetchegg {
+      name = "miscmacros";
+      version = "2.96";
+      sha256 = "1ajdgjrni10i2hmhcp4rawnxajjxry3kmq1krdmah4sf0kjrgajc";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  record-variants = eggDerivation {
+    name = "record-variants-0.5.1";
+
+    src = fetchegg {
+      name = "record-variants";
+      version = "0.5.1";
+      sha256 = "15wgysxkm8m4hx9nhhw9akchzipdnqc7yj3qd3zn0z7sxg4sld1h";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  sendfile = eggDerivation {
+    name = "sendfile-1.7.29";
+
+    src = fetchegg {
+      name = "sendfile";
+      version = "1.7.29";
+      sha256 = "1dc02cbkx5kixhbqjy26g6gs680vy7krc9qis1p1v4aa0b2lgj7k";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  setup-helper = eggDerivation {
+    name = "setup-helper-1.5.4";
+
+    src = fetchegg {
+      name = "setup-helper";
+      version = "1.5.4";
+      sha256 = "1k644y0md2isdcvazqfm4nyc8rh3dby6b0j3r4na4w8ryspqp6gj";
+    };
+
+    buildInputs = [
+      
+    ];
+  };
+
+  string-utils = eggDerivation {
+    name = "string-utils-1.2.4";
+
+    src = fetchegg {
+      name = "string-utils";
+      version = "1.2.4";
+      sha256 = "07alvghg0dahilrm4jg44bndl0x69sv1zbna9l20cbdvi35i0jp1";
+    };
+
+    buildInputs = [
+      setup-helper
+      miscmacros
+      lookup-table
+      check-errors
+    ];
+  };
+
+  synch = eggDerivation {
+    name = "synch-2.1.2";
+
+    src = fetchegg {
+      name = "synch";
+      version = "2.1.2";
+      sha256 = "1m9mnbq0m5jsxmd1a3rqpwpxj0l1b7vn1fknvxycc047pmlcyl00";
+    };
+
+    buildInputs = [
+      setup-helper
+      check-errors
+    ];
+  };
+
+  uri-common = eggDerivation {
+    name = "uri-common-1.4";
+
+    src = fetchegg {
+      name = "uri-common";
+      version = "1.4";
+      sha256 = "01ds1gixcn4rz657x3hr4rhw2496hsjff42ninw0k39l8i1cbh7c";
+    };
+
+    buildInputs = [
+      uri-generic
+      defstruct
+      matchable
+    ];
+  };
+
+  uri-generic = eggDerivation {
+    name = "uri-generic-2.41";
+
+    src = fetchegg {
+      name = "uri-generic";
+      version = "2.41";
+      sha256 = "1r5jbzjllbnmhm5n0m3fcx0g6dc2c2jzp1dcndkfmxz0cl99zxac";
+    };
+
+    buildInputs = [
+      matchable
+      defstruct
+    ];
+  };
+
+  variable-item = eggDerivation {
+    name = "variable-item-1.3.1";
+
+    src = fetchegg {
+      name = "variable-item";
+      version = "1.3.1";
+      sha256 = "19b3mhb8kr892sz9yyzq79l0vv28dgilw9cf415kj6aq16yp4d5n";
+    };
+
+    buildInputs = [
+      setup-helper
+      check-errors
+    ];
+  };
+}
+

pkgs/development/tools/egg2nix/chicken-eggs.scm

···
+;; Eggs used by egg2nix
+http-client
+intarweb
+matchable
+uri-common

pkgs/development/tools/egg2nix/default.nix

···
+{ stdenv, eggDerivation, fetchurl, chickenEggs }:
+
+# Note: This mostly reimplements the default.nix already contained in
+# the tarball. Is there a nicer way than duplicating code?
+
+let
+  version = "0.4";
+in
+eggDerivation {
+  src = fetchurl {
+    url = "https://github.com/the-kenny/egg2nix/archive/${version}.tar.gz";
+    sha256 = "1xn79fgqxg0i47asjah31zi56v60is1n8d0cy8w4gbj0i41z7pvm";
+  };
+
+  name = "egg2nix-${version}";
+  buildInputs = with chickenEggs; [
+    matchable http-client
+  ];
+
+  meta = {
+    description = "Generate nix-expression from CHICKEN scheme eggs";
+    homepage = https://github.com/the-kenny/egg2nix;
+    license = stdenv.lib.licenses.bsd3;
+    platforms = stdenv.lib.platforms.unix;
+    maintainers = [ stdenv.lib.maintainers.the-kenny ];
+  };
+}

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

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, cmdargs, filepath, tasty, tastyHunit, time }:
+
+cabal.mkDerivation (self: {
+  pname = "ghcid";
+  version = "0.2";
+  sha256 = "1g0jwj8s0rgwrdgyn6dwrqhf9v4kck5kfr4ggmp9c0mjjyfxq6pf";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [ cmdargs filepath time ];
+  testDepends = [ cmdargs filepath tasty tastyHunit time ];
+  doCheck = false;
+  meta = {
+    homepage = "https://github.com/ndmitchell/ghcid#readme";
+    description = "GHCi based bare bones IDE";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/tools/misc/autoconf/2.13.nix

···
 
 stdenv.mkDerivation rec {
   name = "autoconf-2.13";
-  
+
   src = fetchurl {
     url = "mirror://gnu/autoconf/${name}.tar.gz";
     sha256 = "07krzl4czczdsgzrrw9fiqx35xcf32naf751khg821g5pqv12qgh";
···
   # Don't fixup "#! /bin/sh" in Autoconf, otherwise it will use the
   # "fixed" path in generated files!
   dontPatchShebangs = true;
+
+  postInstall = ''ln -s autoconf "$out"/bin/autoconf-2.13'';
 
   meta = {
     homepage = http://www.gnu.org/software/autoconf/;

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

···
+{ stdenv, lib, fetchFromGitHub, runCommand, rubies ? null }:
+
+let
+  rubiesEnv = runCommand "chruby-env" { preferLocalBuild = true; } ''
+    mkdir $out
+    ${lib.concatStrings
+        (lib.mapAttrsToList (name: path: "ln -s ${path} $out/${name}\n") rubies)}
+  '';
+
+in stdenv.mkDerivation rec {
+  name = "chruby";
+
+  src = fetchFromGitHub {
+    owner = "postmodern";
+    repo = "chruby";
+    rev = "d5ae98410311aec1358d4cfcc1e3ec02de593c3b";
+    sha256 = "1iq9milnnj3189yw02hkly2pnnh4g0vn2fxq6dfx90kldjwpwxq5";
+  };
+
+  phases = [ "unpackPhase" "patchPhase" "installPhase" "fixupPhase" ];
+
+  patches = lib.optionalString (rubies != null) [
+    ./env.patch
+  ];
+
+  postPatch = lib.optionalString (rubies != null) ''
+    substituteInPlace share/chruby/chruby.sh --replace "@rubiesEnv@" ${rubiesEnv}
+  '';
+
+  installPhase = ''
+    mkdir $out
+    cp -r bin $out
+    cp -r share $out
+  '';
+
+  meta = with lib; {
+    description = "Changes the current Ruby";
+    homepage = https://github.com/postmodern/chruby;
+    license = licenses.mit;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}

pkgs/development/tools/misc/chruby/env.patch

···
+diff --git a/share/chruby/chruby.sh b/share/chruby/chruby.sh
+--- a/share/chruby/chruby.sh
++++ b/share/chruby/chruby.sh
+@@ -1,7 +1,7 @@
+ CHRUBY_VERSION="0.3.8"
+ RUBIES=()
+ 
+-for dir in "$PREFIX/opt/rubies" "$HOME/.rubies"; do
++for dir in @rubiesEnv@; do
+ 	[[ -d "$dir" && -n "$(ls -A "$dir")" ]] && RUBIES+=("$dir"/*)
+ done
+ unset dir

pkgs/development/tools/ocaml/cppo/default.nix

···
 {stdenv, fetchurl, ocaml, findlib}:
 let
   pname = "cppo";
-  version = "0.9.4";
+  version = "1.0.1";
   webpage = "http://mjambon.com/${pname}.html";
 in
 assert stdenv.lib.versionAtLeast (stdenv.lib.getVersion ocaml) "3.12";
···
 
   src = fetchurl {
     url = "http://mjambon.com/releases/${pname}/${name}.tar.gz";
-    sha256 = "1m7cbja7cf74l45plqnmjrjjz55v8x65rvx0ikk9mg1ak8lcmvxa";
+    sha256 = "1r71qv9sl6jpza1vi5kgmbi7iwbddh3f9j7yji063c9vimp9f25z";
   };
 
   buildInputs = [ ocaml findlib ];

pkgs/development/tools/ocaml/ocp-build/default.nix

···
+{ stdenv, fetchurl, ocaml, findlib, ncurses }:
+
+stdenv.mkDerivation {
+
+  name = "ocp-build-1.99.8-beta";
+
+  src = fetchurl {
+    url = "https://github.com/OCamlPro/ocp-build/archive/ocp-build.1.99.8-beta.tar.gz";
+    sha256 = "06qh8v7k5m52xbivas08lblspsnvdl0vd7ghfj6wvpnfl8qvqabn";
+  };
+
+  buildInputs = [ ocaml findlib ncurses ];
+
+  patches = [ ./fix-for-no-term.patch ];
+
+  # In the Nix sandbox, the TERM variable is unset and stty does not
+  # work. In such a case, ocp-build crashes due to a bug. The
+  # ./fix-for-no-term.patch fixes this bug in the source code and hence
+  # also in the final installed version of ocp-build. However, it does not
+  # fix the bug in the precompiled bootstrap version of ocp-build that is
+  # used during the compilation process. In order to bypass the bug until
+  # it's also fixed upstream, we simply set TERM to some valid entry in the
+  # terminfo database during the bootstrap.
+  TERM = "xterm";
+
+  meta = with stdenv.lib; {
+    homepage = "http://typerex.ocamlpro.com/ocp-build.html";
+    description = "A build tool for OCaml";
+    longDescription = ''
+      ocp-build is a build system for OCaml application, based on simple
+      descriptions of packages. ocp-build combines the descriptions of
+      packages, and optimize the parallel compilation of files depending on
+      the number of cores and the automatically-infered dependencies
+      between source files.
+    '';
+    license = licenses.gpl3;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

pkgs/development/tools/ocaml/ocp-build/fix-for-no-term.patch

···
+--- ocp-build-ocp-build.1.99.8-beta/src/ocp-build/buildTerm.ml	2014-10-27 13:54:37.532023502 +0100
++++ ocp-build-ocp-build.1.99.8-beta/src/ocp-build/buildTerm.ml.new	2014-10-27 13:54:43.397099033 +0100
+@@ -49,7 +49,7 @@
+           | _ -> failwith "stty"
+         end
+       | _ -> raise Not_found
+-    with Unix.Unix_error _ | End_of_file | Failure _ ->
++    with Unix.Unix_error _ | End_of_file | Failure _ | Not_found ->
+       try
+         (* shell envvar *)
+         int_of_string (Sys.getenv "COLUMNS")

pkgs/development/tools/ocaml/ocp-indent/default.nix

···
+{ stdenv, fetchurl, ocaml, findlib, ocpBuild, opam, cmdliner }:
+
+let inherit (stdenv.lib) getVersion versionAtLeast; in
+
+assert versionAtLeast (getVersion ocaml) "3.12.1";
+assert versionAtLeast (getVersion ocpBuild) "1.99.3-beta";
+
+stdenv.mkDerivation {
+
+  name = "ocp-indent-1.4.2b";
+
+  src = fetchurl {
+    url = "https://github.com/OCamlPro/ocp-indent/archive/1.4.2b.tar.gz";
+    sha256 = "1p0n2zcl5kf543x2xlqrz1aa51f0dqal8l392sa41j6wx82j0gpb";
+  };
+
+  buildInputs = [ ocaml findlib ocpBuild opam cmdliner ];
+
+  createFindlibDestdir = true;
+
+  # The supplied installer uses opam-installer which breaks when run
+  # normally since it tries to `mkdir $HOME`. However, we can use
+  # `opam-installer --script` to get the shell script that performs only
+  # the installation and just run that. Furthermore, we do the same that is
+  # done by pkgs/development/ocaml-modules/react and rename the paths meant
+  # for opam-installer so that they are in line with the other OCaml
+  # libraries in Nixpkgs.
+  installPhase = ''
+    opam-installer --script --prefix=$out ocp-indent.install \
+    | sed s!lib/ocp-indent!lib/ocaml/${getVersion ocaml}/site-lib/ocp-indent! \
+    | sh
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = "http://typerex.ocamlpro.com/ocp-indent.html";
+    description = "A customizable tool to indent OCaml code";
+    license = licenses.gpl3;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

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

···
+{ stdenv, fetchgit, glib, pkgconfig, python, scons, pythonPackages }:
+
+stdenv.mkDerivation rec {
+  name = "hammer-${version}";
+  version = "e7aa734";
+
+  src = fetchgit {
+    url = "git://github.com/UpstandingHackers/hammer";
+    sha256 = "1v8f2a6bgjgdkhbqz751bqjlwb9lmqn5x63xcskwcl2b9n36vqi9";
+    rev = "e7aa73446e23f4af2fce5f88572aae848f212c16";
+  };
+
+  buildInputs = [ glib pkgconfig python scons ];
+  buildPhase = "scons prefix=$out";
+  installPhase = "scons prefix=$out install";
+
+  meta = with stdenv.lib; {
+    description = "Hammer is a parsing library";
+    longDescription = "Hammer is a parsing library. Like many modern parsing libraries,
+	       it provides a parser combinator interface for writing grammars
+	       as inline domain-specific languages, but Hammer also provides a
+	       variety of parsing backends. It's also bit-oriented rather than
+	       character-oriented, making it ideal for parsing binary data such
+	       as images, network packets, audio, and executables.";
+    homepage = https://github.com/UpstandingHackers/hammer;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    };
+}

pkgs/development/tools/slimerjs/default.nix

···
     echo 'export SLIMERJSLAUNCHER=${xulrunner}/bin/xulrunner' >>  "$out/bin/slimerjs"
     echo "'$out/lib/slimerjs/slimerjs' \"\$@\"" >> "$out/bin/slimerjs"
     chmod a+x "$out/bin/slimerjs"
+    sed -e 's@MaxVersion=32[.]@MaxVersion=33.@' -i "$out/lib/slimerjs/application.ini"
   '';
   meta = {
     inherit (s) version;

pkgs/development/web/remarkjs/default.nix

···
 in stdenv.mkDerivation rec {
   name = "remarkjs-${version}";
 
-  version = "0.6.5";
+  version = "0.7.0";
 
   src = fetchurl {
     url = "https://github.com/gnab/remark/archive/v${version}.tar.gz";
-    sha256 = "1bh3hmhq99qqd3qg747xwjqkyppc9vf3b5nhi56556rwc02cn17p";
+    sha256 = "1a2il6aa0g9cnig56ykmq8lr626pbxlsllk6js41h6gcn214rw60";
   };
 
   buildInputs = with nodePackages; [

pkgs/games/hawkthorne/default.nix

···
 { fetchgit, stdenv, love, curl, zip }:
 
 stdenv.mkDerivation rec {
-  version = "0.9.1";
+  version = "0.12.1";
   name = "hawkthorne-${version}";
 
   src = fetchgit {
     url = "https://github.com/hawkthorne/hawkthorne-journey.git";
-    rev = "e48b5eef0058f63bb8ee746bc00b47b3e03f0854";
-    sha256 = "0rvcpv8fsi450xs2cglv4w6m5iqbhsr2n09pcvhh0krhg7xay538";
+    rev = "610b9b3907b2a1b21da2ae926e4c7c4c9e19959b";
+    sha256 = "0n2fkk34wr3kyzfhz2mbrzn94vjivblqk2xaid5mj7ls0ymxbmgd";
   };
 
   buildInputs = [

pkgs/games/odamex/default.nix

···
+{ stdenv, cmake, fetchurl, pkgconfig, SDL, SDL_mixer, SDL_net }:
+
+stdenv.mkDerivation rec {
+  name = "odamex-0.7.0";
+  src = fetchurl {
+    url = http://downloads.sourceforge.net/odamex/odamex-src-0.7.0.tar.bz2;
+    sha256 = "0cb6p58yv55kdyfj7s9n9xcwpvxrj8nyc6brw9jvwlc5n4y3cd5a";
+  };
+
+  cmakeFlags = ''
+    -DCMAKE_BUILD_TYPE=Release
+  '';
+
+  buildInputs = [ cmake pkgconfig SDL SDL_mixer SDL_net ];
+
+  enableParallelBuilding = true;
+
+  meta = {
+    homepage = http://odamex.net/;
+    description = "A client/server port for playing old-school Doom online";
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = with stdenv.lib.maintainers; [ MP2E ];
+  };
+}

pkgs/games/onscripter-en/default.nix

···
+{ stdenv, fetchurl
+, libpng, libjpeg, libogg, libvorbis, freetype, smpeg
+, SDL, SDL_image, SDL_mixer, SDL_ttf }:
+
+
+stdenv.mkDerivation rec {
+  name = "onscripter-en-20110930";
+
+  src = fetchurl {
+    url = "http://unclemion.com/dev/attachments/download/36/${name}-src.tar.bz2";
+    sha256 = "1kzm6d894c0ihgkwhd03x3kaqqz0sb6kf0r86xrrz12y309zfam6";
+  };
+
+  buildInputs = [ libpng libjpeg libogg libvorbis freetype smpeg
+                  SDL SDL_image SDL_mixer SDL_ttf
+                ];
+
+  configureFlags = [ "--no-werror" ];
+
+  # Without this libvorbisfile.so is not getting linked properly for some reason.
+  NIX_CFLAGS_LINK = [ "-lvorbisfile" ];
+
+  preBuild = ''
+    sed -i 's/.dll//g' Makefile
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Japanese visual novel scripting engine";
+    homepage = "http://dev.haeleth.net/onscripter.shtml";
+    license = licenses.gpl2;
+    platforms = platforms.unix;
+    maintainers = maintainers.abbradar;
+  };
+}

pkgs/misc/beep/default.nix

···
     description = "The advanced PC speaker beeper";
     homepage = http://www.johnath.com/beep/;
     license = stdenv.lib.licenses.gpl2;
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/misc/drivers/hplip/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "hplip-3.14.4";
+  name = "hplip-3.14.10";
 
   src = fetchurl {
     url = "mirror://sourceforge/hplip/${name}.tar.gz";
-    sha256 = "1j8h44f8igl95wqypj4rk9awcw513hlps980jmcnkx60xghc4l6f";
+    sha256 = "164mm30yb61psk5j4ziybxdd310y09fixgl09hmb59ny261wvcqi";
   };
 
   plugin = fetchurl {
     url = "http://www.openprinting.org/download/printdriver/auxfiles/HP/plugins/${name}-plugin.run";
-    sha256 = "0k1vpmy7babbm3c5v4dcbhq0jgyr8as722nylfs8zx0dy7kr8874";
+    sha256 = "10cvgy1h84fwh7xpw4x6cbkpisqbn3nbcqrgd9xz5fc6mn0b95dk";
   };
 
   hplip_state = ./hplip.state;
···
     homepage = http://hplipopensource.com/;
     license = if withPlugin then licenses.unfree else "free"; # MIT/BSD/GPL
     platforms = platforms.linux;
-    maintainers = with maintainers; [ ttuegel ];
+    maintainers = with maintainers; [ ttuegel jgeerds ];
   };
 }

pkgs/misc/emulators/retroarch/cores.nix

···
     description = "Enhanced Genesis Plus libretro port";
   };
 
+  mednafen-pce-fast = (mkLibRetroCore rec {
+    core = "mednafen-pce-fast";
+    src = fetchRetro {
+      repo = "beetle-pce-fast-libretro";
+      rev = "bef70147f73e8a4b5e8a9d535fc59a597843d657";
+      sha256 = "0kkj5g5kajz4mx5xsixd2f6qnx3p68p0px2m0i8045yih50gsilp";
+    };
+    description = "Port of Mednafen's PC Engine core to libretro";
+  }).override {
+    buildPhase = "make";
+  };
+
   mupen64plus = (mkLibRetroCore rec {
     core = "mupen64plus";
     src = fetchRetro {
···
     };
     description = "VBA-M libretro port with modifications for speed";
   };
-}
+}

pkgs/misc/frescobaldi/default.nix

···
+{ stdenv, fetchurl, pythonPackages, lilypond, pyqt4 }:
+
+pythonPackages.buildPythonPackage rec {
+  name = "frescobaldi-${version}";
+  version = "2.0.16";
+
+  src = fetchurl {
+    url = "https://github.com/wbsoft/frescobaldi/releases/download/"
+          + "v2.0.16/${name}.tar.gz";
+    sha256 = "12pabvq5b2lq84q3kx8lh02zh6ali6v4wnin2k2ycnm45mk9ms6q";
+  };
+
+  propagatedBuildInputs = with pythonPackages; [ lilypond
+    pyqt4 poppler-qt4 ];
+
+  patches = [ ./setup.cfg.patch ./python-path.patch ];
+
+  meta = with stdenv.lib; {
+    homepage = http://frescobaldi.org/;
+    description = ''Frescobaldi is a LilyPond sheet music text editor'';
+    longDescription = ''
+      Powerful text editor with syntax highlighting and automatic completion, 
+      Music view with advanced Point & Click, Midi player to proof-listen
+      LilyPond-generated MIDI files, Midi capturing to enter music,
+      Powerful Score Wizard to quickly setup a music score, Snippet Manager
+      to store and apply text snippets, templates or scripts, Use multiple
+      versions of LilyPond, automatically selects the correct version, Built-in
+      LilyPond documentation browser and built-in User Guide, Smart
+      layout-control functions like coloring specific objects in the PDF,
+      MusicXML import, Modern user iterface with configurable colors,
+      fonts and keyboard shortcuts
+    '';
+    license = licenses.gpl2Plus;
+    maintainers = [ maintainers.sepi ];
+    platforms = platforms.all;
+  };
+}

pkgs/misc/frescobaldi/python-path.patch

···
+diff -u frescobaldi-2.0.16.old/frescobaldi frescobaldi-2.0.16/frescobaldi
+--- frescobaldi-2.0.16/frescobaldi	2014-10-24 11:29:28.705687224 +0200
++++ frescobaldi-2.0.16.new/frescobaldi	2014-10-24 11:31:08.086444793 +0200
+@@ -1,4 +1,4 @@
+-#!/usr/bin/python
++#!/usr/bin/env python
+ import sys
+ import frescobaldi_app.main
+ import app
+Common subdirectories: frescobaldi-2.0.16/frescobaldi_app and frescobaldi-2.0.16.new/frescobaldi_app
+Common subdirectories: frescobaldi-2.0.16/macosx and frescobaldi-2.0.16.new/macosx

pkgs/misc/frescobaldi/setup.cfg.patch

···
+Common subdirectories: frescobaldi-2.0.16.old/build and frescobaldi-2.0.16/build
+Common subdirectories: frescobaldi-2.0.16.old/frescobaldi_app and frescobaldi-2.0.16/frescobaldi_app
+Common subdirectories: frescobaldi-2.0.16.old/macosx and frescobaldi-2.0.16/macosx
+diff -u frescobaldi-2.0.16.old/setup.cfg frescobaldi-2.0.16/setup.cfg
+--- frescobaldi-2.0.16.old/setup.cfg	2012-02-05 07:08:24.000000000 +0100
++++ frescobaldi-2.0.16/setup.cfg	2014-10-24 15:08:48.141335620 +0200
+@@ -1,6 +1,2 @@
+-[bdist_wininst]
+-bitmap=frescobaldi-wininst.bmp
+-install-script=frescobaldi-wininst.py
+-
+ [sdist]
+ force-manifest=1

pkgs/misc/themes/gtk2/oxygen-gtk/default.nix

···
   cmake, dbus_glib, glib, gtk, gdk_pixbuf, pkgconfig, xorg }:
 
 stdenv.mkDerivation rec {
-  version = "1.4.5";
+  version = "1.4.6";
   name = "oxygen-gtk2-${version}";
 
   src = fetchurl {
     url = "mirror://kde/stable/oxygen-gtk2/${version}/src/${name}.tar.bz2";
-    sha256 = "00ykq4aafakdkvww7kz84bvg9wc2gdji4m7z87f49hj1jxm84v2v";
+    sha256 = "09mz4szsz3yswbj0nbw6qzlc5bc4id0f9r6ifm60b5nc8x1l72d2";
   };
 
   buildInputs = [ cmake dbus_glib glib gtk gdk_pixbuf

pkgs/misc/themes/gtk3/oxygen-gtk3/default.nix

···
 , cmake, dbus_glib, glib, gtk3, gdk_pixbuf, pkgconfig, xorg }:
 
 stdenv.mkDerivation rec {
-  version = "1.4.0";
+  version = "1.4.1";
   name = "oxygen-gtk3-${version}";
 
   src = fetchurl {
     url = "mirror://kde/stable/oxygen-gtk3/${version}/src/${name}.tar.bz2";
-    sha256 = "d119bcc94ffc04b67e7d238fc922b37f2904447085a06758451b8c0b0302ab80";
+    sha256 = "0pd7wjzh5xgd24yg6b2avaiz1aq6rmh13d7c0jclffkmhmy24r0f";
   };
 
   buildInputs = [ cmake dbus_glib glib gtk3 gdk_pixbuf

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

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

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

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

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

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

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

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

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

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

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

···
 
   grsecurity_stable = grsecPatch
     { kversion  = "3.14.22";
-      revision  = "201410192047";
+      revision  = "201410250026";
       branch    = "stable";
-      sha256    = "0f6mdc0m89idlygm75x3z01rqacla4r26cgz1ai1c6sm5vp9yvw1";
+      sha256    = "1yvzdykg7dkza4iwhwlrjw8p5k6pyxy91z7xckbq46vbj8xikpk2";
     };
 
   grsecurity_unstable = grsecPatch
     { kversion  = "3.17.1";
-      revision  = "201410192051";
+      revision  = "201410281754";
       branch    = "test";
-      sha256    = "1ny8h6dd5mijg7lwi7zwqc6x5n5wkv19avl1d5qx8g2fs6qxbg0m";
+      sha256    = "0igpbk10j1iiwgc7v9rkq1hfg9nb98f0fw6zs2qs7d9j1gx3xks5";
     };
 
   grsec_fix_path =

pkgs/os-specific/linux/kernel/update.sh

···
+#!/usr/bin/env bash
+set -e
+
+# Get the latest versions from kernel.org
+LINUXSED='s/.*linux-\([0-9]\+\(.[0-9]\+\)*\).*/\1/p'
+KDATA="$(curl -s https://www.kernel.org | sed -n -e '/Download complete/p')"
+VERSIONS=($(sed -n -e $LINUXSED <<< "$KDATA" | sort -Vr))
+
+# Remove mainline version if there is a stable update
+# Note due to sorting these two will always exist at the bottom
+if grep -q "^${VERSIONS[1]}" <<< "${VERSIONS[0]}"; then
+  VERSIONS=(${VERSIONS[@]:0:1} ${VERSIONS[@]:2})
+fi
+
+# Inspect each file and see if it has the latest version
+NIXPKGS="$(git rev-parse --show-toplevel)"
+ls $NIXPKGS/pkgs/os-specific/linux/kernel | while read FILE; do
+  KERNEL="$(sed -n $LINUXSED <<< "$FILE")"
+  [ -z "$KERNEL" ] && continue
+
+  # Find the matching new kernel version
+  MATCHING=""
+  for V in "${VERSIONS[@]}"; do
+    if grep -q "^$KERNEL" <<< "$V"; then
+      MATCHING="$V"
+      break
+    fi
+  done
+  if [ -z "$MATCHING" ]; then
+    echo "Out-of-support $KERNEL"
+    continue
+  fi
+
+  # Inspect the nix expression to check for changes
+  DATA="$(<$NIXPKGS/pkgs/os-specific/linux/kernel/$FILE)"
+  URL="$(sed -n -e 's/.*url = "\(.*\)";.*/\1/p' <<< "$DATA" | sed -e "s/\${version}/$MATCHING/g")"
+  OLDVER=$(sed -n -e 's/.*version = "\(.*\)".*/\1/p' <<< "$DATA")
+  if [ "$OLDVER" = "$V" ]; then
+    echo "No updates for $KERNEL"
+    continue
+  fi
+
+  # Download the new file for the hash
+  if ! HASH="$(nix-prefetch-url $URL 2>/dev/null)"; then
+    echo "Failed to get hash of $URL"
+    continue
+  fi
+  sed -i "s/sha256 = \".*\"/sha256 = \"$HASH\"/g" $NIXPKGS/pkgs/os-specific/linux/kernel/$FILE
+
+  # Rewrite the expression
+  sed -i -e '/version = /d' -e '/modDirVersion = /d' $NIXPKGS/pkgs/os-specific/linux/kernel/$FILE
+  if grep -q '^[0-9]\+.[0-9]\+$' <<< "$V"; then
+    sed -i "\#import ./generic.nix (args // rec {#a \  modDirVersion = \"${V}.0\";" $NIXPKGS/pkgs/os-specific/linux/kernel/$FILE
+  fi
+  sed -i "\#import ./generic.nix (args // rec {#a \  version = \"$V\";" $NIXPKGS/pkgs/os-specific/linux/kernel/$FILE
+
+  # Commit the changes
+  git add -u $NIXPKGS/pkgs/os-specific/linux/kernel/$FILE
+  git commit -m "kernel: $OLDVER -> $V" >/dev/null 2>&1
+  
+  echo "Updated $OLDVER -> $V"
+done

pkgs/os-specific/linux/xf86-input-wacom/default.nix

···
 , ncurses, pkgconfig, randrproto, xorgserver, xproto, udev, libXinerama, pixman }:
 
 stdenv.mkDerivation rec {
-  name = "xf86-input-wacom-0.26.1";
+  name = "xf86-input-wacom-0.26.99.1";
 
   src = fetchurl {
     url = "mirror://sourceforge/linuxwacom/${name}.tar.bz2";
-    sha256 = "1qlls71k10igjx9c5lwqa6cdl31ncpdkzirpl85acpmqbqc63qh8";
+    sha256 = "00sclpsmimqfr79zkm8lvkd0b80x62rmcflbv558zy479bnsazav";
   };
 
   buildInputs = [ inputproto libX11 libXext libXi libXrandr libXrender

pkgs/servers/brickd/default.nix

···
+{ stdenv, fetchgit, libusb, pkgconfig, pmutils, udev} :
+
+let
+
+version = "2.1.1";
+daemonlib = fetchgit {
+    url = "https://github.com/Tinkerforge/daemonlib.git";
+    rev = "refs/tags/brickd-${version}";
+    sha256 = "097kaz7d0rzg0ijvcna3y620k3m5fgxpqsac5gbhah8pd7vlj1a4";
+  };
+
+in
+
+stdenv.mkDerivation rec {
+  name = "brickd-${version}";
+  
+  src = fetchgit {
+    url = "git://github.com/Tinkerforge/brickd.git";
+    rev = "refs/tags/v${version}";
+    sha256 = "08g587bgx628g5vykh482wxiw0z98fmq4lf5ka6aw0v8l9gim9yf";
+  };
+
+  buildInputs = [ libusb pkgconfig pmutils udev ];
+ 
+  # shell thing didn't work so i replaced it using nix
+  prePatch = ''
+    substituteInPlace src/brickd/Makefile --replace 'PKG_CONFIG := $(shell which pkg-config 2> /dev/null)' "PKG_CONFIG := $pkgconfig/bin/pkg_config";
+  '';
+
+  buildPhase = ''
+    export
+    # build the brickd binary
+    mkdir src/daemonlib
+    cp -r ${daemonlib}/* src/daemonlib
+    cd src/brickd
+    make
+
+    # build and execute the unit tests
+    cd ../tests
+    make
+    for i in array_test base58_test node_test putenv_test queue_test sha1_test; do
+      echo "running unit test $i:"
+      ./$i
+    done
+  '';
+
+  installPhase = ''
+    cd ../brickd
+    mkdir -p $out/bin
+    cp brickd $out/bin/brickd
+  '';
+
+  meta = {
+    homepage = http://www.tinkerforge.com/;
+    description = "The Brick Daemon is a daemon (or service on Windows) that acts as a bridge between the Bricks/Bricklets and the API bindings for the different programming languages.";
+    maintainers = [ stdenv.lib.maintainers.qknight ];
+    license = "GPLv2";
+    platforms = stdenv.lib.platforms.all;
+  };
+}

pkgs/servers/http/tomcat/recent.nix

···
   meta = {
     homepage = http://tomcat.apache.org/;
     description = "An implementation of the Java Servlet and JavaServer Pages technologies";
+    platforms = with stdenv.lib.platforms; all;
   };
 }

pkgs/servers/mail/dovecot/2.2.x.nix

···
 , inotifyTools, clucene_core_2, sqlite }:
 
 stdenv.mkDerivation rec {
-  name = "dovecot-2.2.14";
+  name = "dovecot-2.2.15";
 
   buildInputs = [perl openssl bzip2 zlib openldap clucene_core_2 sqlite]
     ++ stdenv.lib.optionals (stdenv.isLinux) [ systemd pam inotifyTools ];
 
   src = fetchurl {
     url = "http://dovecot.org/releases/2.2/${name}.tar.gz";
-    sha256 = "1w7bd2yhzk4jg1b5946r84yx10jrj7scr0zyl4li21660nhhzb38";
+    sha256 = "17rr7krfvyk706j12y9wy6nf7wh5vppqjrgxjdf66z9nw9lpf3ni";
   };
 
   preConfigure = ''

pkgs/servers/mail/postfix/2.11.nix

···
 
   name = "postfix-${version}";
 
-  version = "2.11.1";
+  version = "2.11.3";
 
   src = fetchurl {
     url = "ftp://ftp.cs.uu.nl/mirror/postfix/postfix-release/official/${name}.tar.gz";
-    sha256 = "1ql9cifjcfhfi81lrf6zvk0r3spgcp01xwna16a7k9cm7fkrhzs8";
+    sha256 = "1hq213s36wp94q72ciix5pi2rcd4901mjg7nx6m1n9jndrp19r84";
   };
 
   patches = [ ./postfix-2.11.0.patch ];

pkgs/servers/mediatomb/default.nix

···
-{ stdenv, fetchurl
-, sqlite, expat, spidermonkey, taglib, libexif, curl, ffmpeg, file }:
+{ stdenv, fetchgit
+, sqlite, expat, mp4v2, flac, spidermonkey, taglib, libexif, curl, ffmpeg, file
+, pkgconfig, autoreconfHook }:
 
 stdenv.mkDerivation rec {
 
   name = "mediatomb-${version}";
   version = "0.12.1";
 
-  src = fetchurl {
-    url = "mirror://sourceforge/mediatomb/${name}.tar.gz";
-    sha256 = "1k8i5zvgik7cad7znd8358grzwh62frpqww1a5rwkldrlws3q5ii";
+  src = fetchgit {
+    url = meta.repositories.git;
+    rev = "7ab761696354868bd5d67ff4f2d849994e4c98e2";
+    sha256 = "7b51d488ac0b93c7720f8f8373970884a55b0879b1f6941873e916f41177d062";
   };
 
-  patches = [ ./zmm_new.patch ];
-
-  buildInputs = [ sqlite expat spidermonkey taglib libexif curl ffmpeg file ];
-
-  configureFlags = [ "--enable-inotify" ];
+  buildInputs = [ sqlite expat spidermonkey taglib libexif curl ffmpeg file mp4v2 flac
+                  pkgconfig autoreconfHook ];
 
   meta = with stdenv.lib; {
     homepage = http://mediatomb.cc;
+    repositories.git = git://mediatomb.git.sourceforge.net/gitroot/mediatomb/mediatomb;
     description = "UPnP MediaServer with a web user interface";
     license = licenses.gpl2;
     maintainers = [ maintainers.phreedom ];
     platforms = platforms.linux;
-    broken = true;
   };
 }

pkgs/servers/mediatomb/zmm_new.patch

···
-diff -rc mediatomb-0.12.1.old/src/zmm/object.h mediatomb-0.12.1/src/zmm/object.h
-*** mediatomb-0.12.1.old/src/zmm/object.h	2010-03-25 07:58:08.000000000 -0700
---- mediatomb-0.12.1/src/zmm/object.h	2013-02-15 17:57:02.000000000 -0800
-***************
-*** 33,38 ****
---- 33,39 ----
-  #define __ZMM_OBJECT_H__
-  
-  #include <new> // for size_t
-+ #include <stddef.h>
-  #include "atomic.h"
-  
-  namespace zmm

pkgs/servers/xmpp/prosody/default.nix

···
 in
 
 stdenv.mkDerivation rec {
-  version = "0.9.5";
+  version = "0.9.6";
   name = "prosody-${version}";
   src = fetchurl {
     url = "http://prosody.im/downloads/source/${name}.tar.gz";
-    sha256 = "1gcvmdsyx3fjiqybgkp8vr847p9rlfz42lywxpph3jc14yh63z3n";
+    sha256 = "1rs0aqn1rkddgfq9pm7mi7xm5lbvxjpf8d8ijc085fc90zwqq8bm";
   };
 
   communityModules = fetchhg {

pkgs/tools/admin/awscli/default.nix

···
 
 pythonPackages.buildPythonPackage rec {
   name = "awscli-${version}";
-  version = "1.2.13";
+  version = "1.5.3";
   namePrefix = "";
 
   src = fetchurl {
     url = "https://github.com/aws/aws-cli/archive/${version}.tar.gz";
-    sha256 = "1mpy1q9y5qiq1fr2xc98sn1njx0p0b1g21p0rdh4ccsf9w7i0rpb";
+    sha256 = "058lc4qj4xkjha9d1b5wrk2ca3lqfb9b45sb7czv0k1nwc0fciq1";
   };
 
   propagatedBuildInputs = [ 

pkgs/tools/backup/rsnapshot/git.nix

···
+{ fetchFromGitHub, stdenv, writeText, perl, openssh, rsync, logger,
+  configFile ? "/etc/rsnapshot.conf" }:
+
+let patch = writeText "rsnapshot-config.patch" ''
+--- rsnapshot-program.pl	2013-10-05 20:31:08.715991442 +0200
++++ rsnapshot-program.pl	2013-10-05 20:31:42.496193633 +0200
+@@ -383,7 +383,7 @@
+ 	}
+ 	
+ 	# set global variable
+-	$config_file = $default_config_file;
++	$config_file = '${configFile}';
+ }
+ 
+ # accepts no args
+'';
+in
+stdenv.mkDerivation rec {
+  name = "rsnapshot-1.4git";
+  src = fetchFromGitHub {
+    owner = "DrHyde";
+    repo = "rsnapshot";
+    rev = "1047cbb57937c29233388e2fcd847fecd3babe74";
+    sha256 = "173y9q89dp4zf7nysqhjp3i2m086n7qdpawb9vx0ml5zha6mxf2p";
+  };
+
+  propagatedBuildInputs = [perl openssh rsync logger];
+
+  patchPhase = ''
+    substituteInPlace "Makefile.in" --replace \
+      "/usr/bin/pod2man" "${perl}/bin/pod2man"
+    patch -p0 <${patch}
+  '';
+
+  # I still think this is a good idea, but it currently fails in the chroot because it checks
+  # that things are writable and so on.
+  #checkPhase = ''
+  #  if [ -f "${configFile}" ]
+  #  then
+  #    ${perl}/bin/perl -w ./rsnapshot configtest
+  #  else
+  #    echo File "${configFile}" does not exist, not checking
+  #  fi
+  #'';
+
+  meta = with stdenv.lib; {
+    description = "A filesystem snapshot utility for making backups of local and remote systems";
+    homepage = http://rsnapshot.org/;
+    license = stdenv.lib.licenses.gpl2Plus;
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/filesystems/ifuse/default.nix

···
+{ stdenv, fetchurl, pkgconfig, usbmuxd, fuse, gnutls, libgcrypt,
+  libplist, libimobiledevice }:
+
+stdenv.mkDerivation rec {
+  name = "ifuse-1.1.3";
+
+  nativeBuildInputs = [ pkgconfig fuse libplist usbmuxd gnutls libgcrypt libimobiledevice ];
+
+  src = fetchurl {
+    url = "${meta.homepage}/downloads/${name}.tar.bz2";
+    sha256 = "1p9a4n36jb194cnp6v57cz2bggwbywaz8pbpb95ch83pzdkdx257";
+  };
+
+  meta = {
+    homepage = http://www.libimobiledevice.org;
+    license = stdenv.lib.licenses.lgpl21Plus;
+    description = "A fuse filesystem implementation to access the contents of iOS devices";
+    longDescription = ''
+    Mount directories of an iOS device locally using fuse. By default the media
+    directory is mounted, options allow to also mount the sandbox container of an
+    app, an app's documents folder or even the root filesystem on jailbroken
+    devices.'';
+    inherit (usbmuxd.meta) platforms maintainers;
+  };
+}

pkgs/tools/graphics/gifsicle/default.nix

···
 with stdenv.lib;
 
 stdenv.mkDerivation {
-  name = "gifsicle-1.84";
+  name = "gifsicle-1.86";
 
   src = fetchurl {
-    url = http://www.lcdf.org/gifsicle/gifsicle-1.84.tar.gz;
-    sha256 = "1ymk7lkk50fds6090icnjg69dswzz5zyiirq2ws23aagw3l46z86";
+    url = http://www.lcdf.org/gifsicle/gifsicle-1.86.tar.gz;
+    sha256 = "153knkff04wh1szbmqklyq371m9whib007j0lq0dwh4jc5g6s15h";
   };
 
   buildInputs = optional gifview [ xproto libXt libX11 ];

pkgs/tools/misc/parallel/default.nix

···
 { fetchurl, stdenv, perl }:
 
 stdenv.mkDerivation rec {
-  name = "parallel-20140922";
+  name = "parallel-20141022";
 
   src = fetchurl {
     url = "mirror://gnu/parallel/${name}.tar.bz2";
-    sha256 = "0hxx1h2ba6y2y1vy02r2hzndid2b469hj08f0vlmpjqw5g4f52a5";
+    sha256 = "1dpssybids6k6na4rh2gwv1m581h28rcmsvq0hs56hrrh7qpjmvp";
   };
 
   patchPhase =

pkgs/tools/misc/rcm/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "rcm-1.2.3";
+
+  src = fetchurl {
+    url = https://thoughtbot.github.io/rcm/dist/rcm-1.2.3.tar.gz;
+    sha256 = "0gwpclbc152jkclj3w83s2snx3dcgljwr75q1z8czl3yar7d8bsh";
+  };
+ 
+  meta = {
+    description = "Management Suite for Dotfiles";
+    homepage = https://github.com/thoughtbot/rcm;
+    license = stdenv.lib.licenses.bsd3;
+  };
+}

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

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

pkgs/tools/misc/yubico-piv-tool/default.nix

···
+{ stdenv, fetchurl, pkgconfig, openssl, pcsclite }:
+
+stdenv.mkDerivation rec {
+  name = "yubico-piv-tool-0.1.0";
+
+  src = fetchurl {
+    url = "https://developers.yubico.com/yubico-piv-tool/Releases/${name}.tar.gz";
+    sha256 = "1m573f0vn3xgzsl29ps679iykp5krwd0fnr4nhm1fw2hm5zahrhf";
+  };
+
+  buildInputs = [ pkgconfig openssl pcsclite ];
+
+  configureFlags = [ "--with-backend=pcsc" ];
+
+  meta = with stdenv.lib; {
+    homepage = https://developers.yubico.com/yubico-piv-tool/;
+    description = "";
+    maintainers = with maintainers; [ wkennington ];
+    license = licenses.bsd2;
+    platforms = platforms.all;
+  };
+}

pkgs/tools/misc/yubikey-personalization-gui/default.nix

···
+{ stdenv, fetchurl, pkgconfig, yubikey-personalization, qt, libyubikey }:
+
+stdenv.mkDerivation rec {
+  name = "yubikey-personalization-gui-3.1.16";
+
+  src = fetchurl {
+    url = "https://developers.yubico.com/yubikey-personalization-gui/Releases/${name}.tar.gz";
+    sha256 = "0sdiy2jn0anjvhnz47mrkblhh3paf0gmbgdmrkm21kws4f6sb4kh";
+  };
+
+  buildInputs = [ pkgconfig yubikey-personalization qt libyubikey ];
+  
+  configurePhase = ''
+    qmake
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp build/release/yubikey-personalization-gui $out/bin
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://developers.yubico.com/yubikey-personalization-gui;
+    description = "a QT based cross-platform utility designed to facilitate reconfiguration of the Yubikey";
+    license = licenses.bsd2;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ wkennington ];
+  };
+}

pkgs/tools/misc/yubikey-personalization/default.nix

···
+{ stdenv, fetchurl, pkgconfig, libusb, libyubikey, json_c }:
+
+stdenv.mkDerivation rec {
+  name = "yubikey-personalization-${version}";
+  version = "1.16.0";
+
+  src = fetchurl {
+    url = "https://developers.yubico.com/yubikey-personalization/Releases/ykpers-${version}.tar.gz";
+    sha256 = "1zspbb10k9x9mjv8hadmwwgzjlign372al3zshypj9ri55ky0xs3";
+  };
+
+  buildInputs = [ pkgconfig libusb libyubikey json_c ];
+
+  configureFlags = [
+    "--with-backend=libusb-1.0"
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://developers.yubico.com/yubikey-personalization;
+    description = "a library and command line tool to personalize YubiKeys";
+    license = licenses.bsd2;
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ wkennington ];
+  };
+}

pkgs/tools/networking/cjdns/builder.sh

···
-source $stdenv/setup
-
-unpackPhase
-cd git-export
-
-bash do
-
-mkdir -p $out/sbin
-cp cjdroute $out/sbin

pkgs/tools/networking/cjdns/default.nix

···
-{ stdenv, fetchFromGitHub, nodejs, which, python27 }:
+{ stdenv, fetchFromGitHub, nodejs, which, python27, utillinux }:
 
 let
-  date = "20140928";
-  rev = "e2b673698e471dbc82b4e9dbc04cb9e16f1f06a6";
+  date = "20141023";
+  rev = "c7eed6b14688458e16fab368f68904e530651a30";
 in
 stdenv.mkDerivation {
   name = "cjdns-${date}-${stdenv.lib.strings.substring 0 7 rev}";
···
     owner = "cjdelisle";
     repo = "cjdns";
     inherit rev;
-    sha256 = "0ql51845rni6678dda03zr18ary7xlqcs3khva9x80x815h1sy8v";
+    sha256 = "11z8dk7byxh9pfv7mhfvnk465qln1g7z8c8f822623d59lwjpbs1";
   };
 
-  patches = [ ./rfc5952.patch ];
-
-  buildInputs = [ which python27 nodejs];
+  buildInputs = [ which python27 nodejs ] ++
+    # for flock
+    stdenv.lib.optional stdenv.isLinux [ utillinux ];
 
   buildPhase = "bash do";
-  installPhase = "installBin cjdroute makekeys privatetopublic publictoip6";
+  installPhase = ''
+    installBin cjdroute makekeys privatetopublic publictoip6
+    sed -i 's,/usr/bin/env node,'$(type -P node), \
+      $(find contrib -name "*.js")
+    sed -i 's,/usr/bin/env python,'$(type -P python), \
+      $(find contrib -type f)
+    mkdir -p $out/share/cjdns
+    cp -R contrib node_build node_modules $out/share/cjdns/
+  '';
 
   meta = with stdenv.lib; {
     homepage = https://github.com/cjdelisle/cjdns;

pkgs/tools/networking/cjdns/rfc5952.patch

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

pkgs/tools/networking/fping/default.nix

···
     homepage = "http://fping.org/";
     description = "Send ICMP echo probes to network hosts";
     maintainers = with stdenv.lib.maintainers; [ the-kenny ];
+    platforms = with stdenv.lib.platforms; all;
   };
 }

pkgs/tools/networking/nc6/default.nix

···
   name = "nc6-1.0";
 
   src = fetchurl {
-    url = ftp://ftp.deepspace6.net/pub/ds6/sources/nc6/nc6-1.0.tar.bz2;
+    urls = [
+      ftp://ftp.deepspace6.net/pub/ds6/sources/nc6/nc6-1.0.tar.bz2
+      http://fossies.org/linux/privat/nc6-1.0.tar.bz2
+    ];
     sha256 = "01l28zv1yal58ilfnz6albdzqqxzsx3a58vmc14r9gv0bahffdgb";
   };
 

pkgs/tools/networking/openvpn/update-resolv-conf.nix

···
+{ stdenv, fetchgit, makeWrapper, openresolv, coreutils }:
+
+stdenv.mkDerivation rec {
+  name = "update-resolv-conf";
+
+  src = fetchgit {
+    url = https://github.com/masterkorp/openvpn-update-resolv-conf/;
+    rev = "dd968419373bce71b22bbd26de962e89eb470670";
+    sha256 = "dd0e3ea3661253d565bda876eb52a3f8461a3fc8237a81c40809c2071f83add1";
+  };
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  installPhase = ''
+    install -Dm555 update-resolv-conf.sh $out/libexec/openvpn/update-resolv-conf
+    sed -i 's,^\(RESOLVCONF=\).*,\1resolvconf,' $out/libexec/openvpn/update-resolv-conf
+
+    wrapProgram $out/libexec/openvpn/update-resolv-conf \
+        --prefix PATH : ${coreutils}/bin:${openresolv}/sbin
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Script to update your /etc/resolv.conf with DNS settings that come from the received push dhcp-options";
+    homepage = https://github.com/masterkorp/openvpn-update-resolv-conf/;
+    maintainer = maintainers.abbradar;
+    license = licenses.gpl2;
+    platforms = platforms.unix;
+  };
+}

pkgs/tools/networking/wget/default.nix

···
-{ stdenv, fetchurl, gettext, perl, LWP, gnutls ? null }:
+{ stdenv, fetchurl, gettext, libidn
+, perl, perlPackages, LWP, python3
+, gnutls ? null }:
 
 stdenv.mkDerivation rec {
-  name = "wget-1.15";
+  name = "wget-1.16";
 
   src = fetchurl {
     url = "mirror://gnu/wget/${name}.tar.xz";
-    sha256 = "1yw0sk4mrs7bvga3c79rkbhxivmw8cs3b5wq3cglp1f9ai1mz2ni";
+    sha256 = "1rxhr3jmgbwryzl51di4avqxw9m9j1z2aak8q1npns0p184xsqcj";
   };
-
-  patches = stdenv.lib.optional stdenv.isDarwin ./iri-test.patch;
 
   preConfigure = stdenv.lib.optionalString doCheck
-    '' for i in "doc/texi2pod.pl" "tests/run-px" "util/rmold.pl"
+    '' for i in "doc/texi2pod.pl" "util/rmold.pl"
        do
          sed -i "$i" -e 's|/usr/bin.*perl|${perl}/bin/perl|g'
        done
···
     '';
 
   nativeBuildInputs = [ gettext ];
-  buildInputs =
-    stdenv.lib.optionals doCheck [ perl LWP ]
+  buildInputs = [ libidn ]
+    ++ stdenv.lib.optionals doCheck [ perl perlPackages.IOSocketSSL LWP python3 ]
     ++ stdenv.lib.optional (gnutls != null) gnutls;
 
   configureFlags =
···
     then "--with-ssl=gnutls"
     else "--without-ssl";
 
-  doCheck = (perl != null);
+  doCheck = (perl != null && python3 != null);
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "Tool for retrieving files using HTTP, HTTPS, and FTP";
 
     longDescription =
···
          scripts, cron jobs, terminals without X-Windows support, etc.
       '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = licenses.gpl3Plus;
 
     homepage = http://www.gnu.org/software/wget/;
 
-    maintainers = [ ];
-    platforms = stdenv.lib.platforms.all;
+    maintainers = with maintainers; [ fpletz ];
+    platforms = platforms.all;
   };
 }

pkgs/tools/networking/wget/iri-test.patch

···
-diff -r --unified a/wget-1.14/tests/run-px b/wget-1.14/tests/run-px
---- a/tests/run-px	2012-06-16 11:58:11.000000000 +0100
-+++ b/tests/run-px	2013-11-02 14:06:14.000000000 +0000
-@@ -48,7 +48,7 @@
-     'Test-idn-robots-utf8.px',
-     'Test-iri.px',
-     'Test-iri-percent.px',
--    'Test-iri-disabled.px',
-+    #'Test-iri-disabled.px',
-     'Test-iri-forced-remote.px',
-     'Test-iri-list.px',
-     'Test-k.px',

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

···
 
   src = fetchgit {
     url = "git://github.com/madjar/nox.git";
-    rev = "088249aa766c9fa929aa08a60f1a7eb41008da40";
-    sha256 = "0dscnmhm1va2h0jz7hh60nvjwxv5a92n5pp8c0g7hz76g67mi5xs";
+    rev = "e5a4dbe5d11c3258e3038b4ae6f49d53f02d76cd";
+    sha256 = "25d0ae9eeb6387bb45cbda8da08760ffef6a1661ebd106c537b468c93e66c035";
     leaveDotGit = true; # required by pbr
   };
 

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

···
 { stdenv, fetchurl, pkgconfig, curl, gpgme }:
 
 stdenv.mkDerivation rec {
-  version = "0.2.2";
+  version = "0.2.3";
   name = "opkg-${version}";
   src = fetchurl {
     url = "http://downloads.yoctoproject.org/releases/opkg/opkg-${version}.tar.gz";
-    sha256 = "0ax10crp2grrpl20gl5iqfw37d5qz6h790lyyv2ali45agklqmda";
+    sha256 = "0qaczbw34az20vmh92h7fkswcgq7f6csajx35d4dljzfj85d8jcc";
   };
 
   buildInputs = [ pkgconfig curl gpgme ];

pkgs/tools/security/mbox/default.nix

···
+{ stdenv, fetchFromGitHub, openssl, which }:
+
+stdenv.mkDerivation {
+  name = "mbox-20140526";
+
+  src = fetchFromGitHub {
+    owner = "tsgates";
+    repo = "mbox";
+    rev = "a131424b6cb577e1c916bd0e8ffb2084a5f73048";
+    sha256 = "06qggqxnzcxnc34m6sbafxwr2p64x65m9zm5wp7pwyarcckhh2hd";
+  };
+
+  buildInputs = [ openssl which ];
+
+  preConfigure = ''
+    cd src
+    cp {.,}configsbox.h
+  '';
+  
+  doCheck = true;
+  checkPhase = ''
+    rm tests/test-*vim.sh tests/test-pip.sh
+
+    patchShebangs ./; dontPatchShebags=1
+    sed -i 's|^/bin/||' tests/test-fileops.sh
+
+    ./testall.sh
+  '';
+
+  meta = with stdenv.lib;
+    { description = "Lightweight sandboxing mechanism that any user can use without special privileges";
+      homepage = http://pdos.csail.mit.edu/mbox/;
+      maintainers = with maintainers; [ emery ];
+      license = licenses.bsd3;
+      platforms = platforms.linux;
+    };
+
+}

pkgs/tools/security/pinentry/default.nix

···
 assert useGtk || useNcurses || useQt4;
 
 stdenv.mkDerivation rec {
-  name = "pinentry-0.8.3";
+  name = "pinentry-0.8.4";
 
   src = fetchurl {
     url = "mirror://gnupg/pinentry/${name}.tar.bz2";
-    sha256 = "1bd047crf7xb8g61mval8v6qww98rddlsw2dz6j8h8qbnl4hp2sn";
+    sha256 = "04jnlfncj9d5rg0j4gmsi2l1q9q7c6gjbvxfnfh3nx6b8szv779m";
   };
 
   buildInputs = let opt = stdenv.lib.optional; in []

pkgs/tools/security/tor/default.nix

···
 { stdenv, fetchurl, libevent, openssl, zlib }:
 
 stdenv.mkDerivation rec {
-  name = "tor-0.2.4.23";
+  name = "tor-0.2.4.24";
 
   src = fetchurl {
     url = "https://archive.torproject.org/tor-package-archive/${name}.tar.gz";
-    sha256 = "0a8l6d82hk4wbn7nlphd3c1maxhgdli8338wbg5r9dk6zcy7k8q5";
+    sha256 = "1l8aczqz8injzcj3mabx4figl8ahkzb0vs9s3nir6kn0b1l5rccr";
   };
 
   buildInputs = [ libevent openssl zlib ];

pkgs/tools/system/logcheck/default.nix

···
 
 stdenv.mkDerivation rec {
   _name   = "logcheck";
-  version = "1.3.16";
+  version = "1.3.17";
   name    = "${_name}-${version}";
 
   src = fetchurl {
     url = "mirror://debian/pool/main/l/${_name}/${_name}_${version}.tar.xz";
-    sha256 = "1rmq4s2fj86226ncw2kdjvjbi29375gd7vdq62fsbjxm4m6nzsiy";
+    sha256 = "0fphzaljc9ddv1x6l3zdf9cbarqgzpdqaqwm3plmarcc7qrgrly2";
   };
 
   preConfigure = ''

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

···
-{ stdenv, fetchurl, eventlog, pkgconfig, glib, python, systemd, perl }:
+{ stdenv, fetchurl, eventlog, pkgconfig, glib, python, systemd, perl
+, riemann_c_client, protobufc, yacc }:
 
 stdenv.mkDerivation rec {
   name = "syslog-ng-${version}";
 
-  version = "3.5.6";
+  version = "3.6.1";
 
   src = fetchurl {
     url = "http://www.balabit.com/downloads/files?path=/syslog-ng/sources/${version}/source/syslog-ng_${version}.tar.gz";
-    sha256 = "19i1idklpgn6mz0mg7194by5fjgvvh5n4v2a0rr1z0778l2038kc";
+    sha256 = "1s3lsxk2pky3jkfamkw5ivpxq2kazikcvdgpmxiyn5w10dwkd0m7";
   };
 
-  buildInputs = [ eventlog pkgconfig glib python systemd perl ];
+  buildInputs = [ eventlog pkgconfig glib python systemd perl riemann_c_client protobufc yacc ];
 
   configureFlags = [
     "--enable-dynamic-linking"

pkgs/tools/text/enca/default.nix

···
 { stdenv, fetchurl, libiconvOrNull, recode }:
 
 stdenv.mkDerivation rec {
-  name = "enca-1.15";
+  name = "enca-1.16";
 
   src = fetchurl {
-    url = "http://dl.cihar.com/enca/${name}.tar.bz2";
-    sha256 = "1iibfl2s420x7bc1hvxr1ys4cpz579brg2m2ln4rp677azmrr8mv";
+    url = "http://dl.cihar.com/enca/${name}.tar.xz";
+    sha256 = "0hg7ggldam66l9j53nlrvi2lv1k99r2qfk6dh23vg6mi05cph7bw";
   };
 
   buildInputs = [ recode libiconvOrNull ];

pkgs/tools/text/sgml/opensp/setup-hook.sh

···
 if test -z "$sgmlHookDone"; then
     sgmlHookDone=1
 
-    # Set http_proxy and ftp_proxy to a invalid host to prevent
-    # xmllint and xsltproc from trying to download DTDs from the
-    # network even when --nonet is not given.  That would be impure.
-    # (Note that .invalid is a reserved domain guaranteed not to
-    # work.)
-    export http_proxy=http://nodtd.invalid/
-    export ftp_proxy=http://nodtd.invalid/
-
     export SGML_CATALOG_FILES
     envHooks+=(addSGMLCatalogs)
 fi

pkgs/top-level/all-packages.nix

···
   dolphinEmu = callPackage ../misc/emulators/dolphin-emu { };
   dolphinEmuMaster = callPackage ../misc/emulators/dolphin-emu/master.nix { };
 
+  doomseeker = callPackage ../applications/misc/doomseeker { };
+
   dropbear = callPackage ../tools/networking/dropbear { };
 
   dtach = callPackage ../tools/misc/dtach { };
···
 
   freetds = callPackage ../development/libraries/freetds { };
 
+  frescobaldi = callPackage ../misc/frescobaldi {};
+  
   ftgl = callPackage ../development/libraries/ftgl { };
 
   ftgl212 = callPackage ../development/libraries/ftgl/2.1.2.nix { };
···
   idle3tools = callPackage ../tools/system/idle3tools { };
 
   iftop = callPackage ../tools/networking/iftop { };
+
+  ifuse = callPackage ../tools/filesystems/ifuse/default.nix { };
 
   ihaskell = callPackage ../development/tools/haskell/ihaskell/wrapper.nix {
     inherit (pythonPackages) ipython;
···
 
   man_db = callPackage ../tools/misc/man-db { };
 
+  mbox = callPackage ../tools/security/mbox { };
+
   memtest86 = callPackage ../tools/misc/memtest86 { };
 
   memtest86plus = callPackage ../tools/misc/memtest86+ { };
···
 
   odt2txt = callPackage ../tools/text/odt2txt { };
 
+  odamex = callPackage ../games/odamex { };
+
   offlineimap = callPackage ../tools/networking/offlineimap {
     inherit (pythonPackages) sqlite3;
   };
 
   opencryptoki = callPackage ../tools/security/opencryptoki { };
 
+  onscripter-en = callPackage ../games/onscripter-en { };
+
   opendbx = callPackage ../development/libraries/opendbx { };
 
   opendkim = callPackage ../development/libraries/opendkim { };
···
   openvpn = callPackage ../tools/networking/openvpn { };
 
   openvpn_learnaddress = callPackage ../tools/networking/openvpn/openvpn_learnaddress.nix { };
+
+  update-resolv-conf = callPackage ../tools/networking/openvpn/update-resolv-conf.nix { };
 
   openvswitch = callPackage ../os-specific/linux/openvswitch { };
 
···
   pdfread = callPackage ../tools/graphics/pdfread { };
 
   briss = callPackage ../tools/graphics/briss { };
+ 
+  brickd = callPackage ../servers/brickd { 
+    libusb = libusb1; 
+  };
 
   bully = callPackage ../tools/networking/bully { };
 
···
     # GNU Inetutils.  The latter is more portable.
     logger = inetutils;
   };
+  rsnapshotGit = lowPrio (callPackage ../tools/backup/rsnapshot/git.nix {
+    # For the `logger' command, we can use either `utillinux' or
+    # GNU Inetutils.  The latter is more portable.
+    logger = inetutils;
+  });
 
   rlwrap = callPackage ../tools/misc/rlwrap { };
 
···
   # Work In Progress: it doesn't start unless running a daemon as root
   teamviewer8 = lowPrio (callPackage_i686 ../applications/networking/remote/teamviewer/8.nix { });
 
+  teamviewer9 = lowPrio (callPackage_i686 ../applications/networking/remote/teamviewer/9.nix { });
+
   telnet = callPackage ../tools/networking/telnet { };
 
   texmacs = callPackage ../applications/editors/texmacs {
···
   htmlTidy = callPackage ../tools/text/html-tidy { };
 
   html-xml-utils = callPackage ../tools/text/xml/html-xml-utils { };
+
+  rcm = callPackage ../tools/misc/rcm {};
 
   tftp_hpa = callPackage ../tools/networking/tftp-hpa {};
 
···
 
   xvfb_run = callPackage ../tools/misc/xvfb-run { inherit (texFunctions) fontsConf; };
 
-  youtubeDL = callPackage ../tools/misc/youtube-dl { };
+  youtube-dl = callPackage ../tools/misc/youtube-dl { };
 
   zbar = callPackage ../tools/graphics/zbar {
     pygtk = lib.overrideDerivation pygtk (x: {
···
 
   bigloo = callPackage ../development/compilers/bigloo { };
 
-  chicken = callPackage ../development/compilers/chicken { };
+  fetchegg = callPackage ../build-support/fetchegg { };
+
+  eggDerivation = callPackage ../development/compilers/chicken/eggDerivation.nix { };
+
+  chicken = callPackage ../development/compilers/chicken {
+    bootstrap-chicken = chicken.override { bootstrap-chicken = null; }; 
+  };
+
+  egg2nix = callPackage ../development/tools/egg2nix {
+    chickenEggs = callPackage ../development/tools/egg2nix/chicken-eggs.nix { };
+  };
 
   ccl = builderDefsPackage ../development/compilers/ccl {};
 
···
 
   oraclejdk7 = pkgs.oraclejdk7distro true false;
 
+  oraclejdk7psu = pkgs.oraclejdk7psu_distro true false;
+
   oraclejdk8 = pkgs.oraclejdk8distro true false;
 
   oraclejre = lowPrio (pkgs.jdkdistro false false);
 
   oraclejre7 = lowPrio (pkgs.oraclejdk7distro false false);
+
+  oraclejre7psu = lowPrio (pkgs.oraclejdk7psu_distro false false);
 
   oraclejre8 = lowPrio (pkgs.oraclejdk8distro false false);
 
···
     assert supportsJDK;
     (if pluginSupport then appendToName "with-plugin" else x: x)
       (callPackage ../development/compilers/oraclejdk/jdk7-linux.nix { inherit installjdk; });
+
+  oraclejdk7psu_distro = installjdk: pluginSupport:
+    assert supportsJDK;
+    (if pluginSupport then appendToName "with-plugin" else x: x)
+      (callPackage ../development/compilers/oraclejdk/jdk7psu-linux.nix { inherit installjdk; });
 
   oraclejdk8distro = installjdk: pluginSupport:
     assert supportsJDK;
···
     in rec {
     inherit ocaml;
 
+    acgtk = callPackage ../applications/science/logic/acgtk { };
+
+    ansiterminal = callPackage ../development/ocaml-modules/ansiterminal { };
+
+    bolt = callPackage ../development/ocaml-modules/bolt { };
+
     camlidl = callPackage ../development/tools/ocaml/camlidl { };
 
     camlp4 =
···
     deriving = callPackage ../development/tools/ocaml/deriving { };
 
     easy-format = callPackage ../development/ocaml-modules/easy-format { };
+
+    eff = callPackage ../development/interpreters/eff { };
 
     eliom = callPackage ../development/ocaml-modules/eliom { };
 
···
     ocaml_ssl = callPackage ../development/ocaml-modules/ssl { };
 
     ocaml_text = callPackage ../development/ocaml-modules/ocaml-text { };
+
+    ocpBuild = callPackage ../development/tools/ocaml/ocp-build { };
+
+    ocpIndent = callPackage ../development/tools/ocaml/ocp-indent { };
 
     ocsigen_server = callPackage ../development/ocaml-modules/ocsigen-server { };
 
···
 
   polyml = callPackage ../development/compilers/polyml { };
 
-  pure = callPackage ../development/interpreters/pure {
-    llvm = llvm_34 ;
-  };
-
+  pure = callPackage ../development/interpreters/pure { };
   pure-gsl = callPackage ../development/pure-modules/pure-gsl { };
 
   python = python2;
···
   ruby_2_1_0 = lowPrio (callPackage ../development/interpreters/ruby/ruby-2.1.0.nix { });
   ruby_2_1_1 = lowPrio (callPackage ../development/interpreters/ruby/ruby-2.1.1.nix { });
   ruby_2_1_2 = lowPrio (callPackage ../development/interpreters/ruby/ruby-2.1.2.nix { });
+  ruby_2_1_3 = lowPrio (callPackage ../development/interpreters/ruby/ruby-2.1.3.nix { });
 
   # Ruby aliases
   ruby = ruby_1_9;
   ruby_1_8 = ruby_1_8_7;
   ruby_1_9 = ruby_1_9_3;
   ruby_2_0 = ruby_2_0_0;
-  ruby_2_1 = ruby_2_1_2;
+  ruby_2_1 = ruby_2_1_3;
 
   rubyLibs = recurseIntoAttrs (callPackage ../development/interpreters/ruby/libs.nix { });
 
···
   guile_lib = callPackage ../development/guile-modules/guile-lib { };
 
   guile_ncurses = callPackage ../development/guile-modules/guile-ncurses { };
+
+  guile-opengl = callPackage ../development/guile-modules/guile-opengl { };
 
   guile-xcb = callPackage ../development/guile-modules/guile-xcb { };
 
···
 
   chrpath = callPackage ../development/tools/misc/chrpath { };
 
+  chruby = callPackage ../development/tools/misc/chruby { rubies = null; };
+
   "cl-launch" = callPackage ../development/tools/misc/cl-launch {};
 
   complexity = callPackage ../development/tools/misc/complexity { };
···
 
 
   ragel = callPackage ../development/tools/parsing/ragel { };
+
+  hammer = callPackage ../development/tools/parsing/hammer { };
 
   re2c = callPackage ../development/tools/parsing/re2c { };
 
···
 
   herqq = callPackage ../development/libraries/herqq { };
 
+  hidapi = callPackage ../development/libraries/hidapi {
+    libusb = libusb1;
+  };
+
   hspell = callPackage ../development/libraries/hspell { };
 
   hspellDicts = callPackage ../development/libraries/hspell/dicts.nix { };
···
   libcanberra_kde = if (config.kde_runtime.libcanberraWithoutGTK or true)
     then libcanberra.override { gtk = null; }
     else libcanberra;
+
+  libcec = callPackage ../development/libraries/libcec { };
 
   libcello = callPackage ../development/libraries/libcello {};
 
···
 
   libgeotiff = callPackage ../development/libraries/libgeotiff { };
 
+  libu2f-host = callPackage ../development/libraries/libu2f-host { };
+
   libunistring = callPackage ../development/libraries/libunistring { };
 
   libupnp = callPackage ../development/libraries/pupnp { };
···
 
   libyamlcpp = callPackage ../development/libraries/libyaml-cpp { };
 
-  libyubikey = callPackage ../development/libraries/libyubikey {};
+  libykneomgr = callPackage ../development/libraries/libykneomgr { };
+
+  libyubikey = callPackage ../development/libraries/libyubikey { };
 
   libzip = callPackage ../development/libraries/libzip { };
 
···
 
   yajl = callPackage ../development/libraries/yajl { };
 
+  yubico-piv-tool = callPackage ../tools/misc/yubico-piv-tool { };
+
+  yubikey-personalization = callPackage ../tools/misc/yubikey-personalization {
+    libusb = libusb1;
+  };
+
+  yubikey-personalization-gui = callPackage ../tools/misc/yubikey-personalization-gui {
+    qt = qt4;
+  };
+
   zangband = builderDefsPackage (import ../games/zangband) {
     inherit ncurses flex bison autoconf automake m4 coreutils;
   };
···
 
   mailman = callPackage ../servers/mail/mailman { };
 
-  mediatomb = callPackage ../servers/mediatomb { };
+  mediatomb = callPackage ../servers/mediatomb {
+    spidermonkey = spidermonkey_185;
+  };
 
   memcached = callPackage ../servers/memcached {};
 
···
   lohit-fonts = callPackage ../data/fonts/lohit-fonts { };
 
   manpages = callPackage ../data/documentation/man-pages { };
+
+  meslo-lg = callPackage ../data/fonts/meslo-lg {};
 
   miscfiles = callPackage ../data/misc/miscfiles { };
 
···
 
   chromiumDev = lowPrio (chromium.override { channel = "dev"; });
 
+  chuck = callPackage ../applications/audio/chuck { };
+
   cinelerra = callPackage ../applications/video/cinelerra { };
 
   clawsMail = callPackage ../applications/networking/mailreaders/claws-mail {
···
     gitModes = callPackage ../applications/editors/emacs-modes/git-modes { };
 
     haskellMode = callPackage ../applications/editors/emacs-modes/haskell { };
+
+    hsc3Mode = callPackage ../applications/editors/emacs-modes/hsc3 { };
 
     hol_light_mode = callPackage ../applications/editors/emacs-modes/hol_light { };
 
···
 
   gqview = callPackage ../applications/graphics/gqview { };
 
-  gmpc = callPackage ../applications/audio/gmpc { };
+  gmpc = callPackage ../applications/audio/gmpc {
+    inherit (xlibs) libSM libICE;
+  };
 
   gmtk = callPackage ../applications/networking/browsers/mozilla-plugins/gmtk {
     inherit (gnome) GConf;
···
     gnutls = if config.pidgin.gnutls or false then gnutls else null;
     libgcrypt = if config.pidgin.gnutls or false then libgcrypt else null;
     startupnotification = libstartup_notification;
+    inherit (xlibs) libXext libICE libSM;
   };
 
-  pidginWrapper = callPackage ../applications/networking/instant-messengers/pidgin/wrapper.nix {
+  pidgin-with-plugins = callPackage ../applications/networking/instant-messengers/pidgin/wrapper.nix {
     plugins = [];
   };
 
···
 
   stp = callPackage ../applications/science/logic/stp {};
 
-  stumpwm = callPackage ../applications/window-managers/stumpwm {};
-  stumpwmContrib = callPackage ../applications/window-managers/stumpwm/contrib.nix {};
+  stumpwm = callPackage ../applications/window-managers/stumpwm {
+    stumpwmContrib = callPackage ../applications/window-managers/stumpwm/contrib.nix { };
+  };
 
   sublime = callPackage ../applications/editors/sublime { };
 
···
       ++ optional (cfg.enableFceumm or false) fceumm
       ++ optional (cfg.enableGambatte or false) gambatte
       ++ optional (cfg.enableGenesisPlusGX or false) genesis-plus-gx
+      ++ optional (cfg.enableMednafenPCEFast or false) mednafen-pce-fast
       ++ optional (cfg.enableMupen64Plus or false) mupen64plus
       ++ optional (cfg.enableNestopia or false) nestopia
       ++ optional (cfg.enablePicodrive or false) picodrive
···
 
   xkb_switch = callPackage ../tools/X11/xkb-switch { };
 
+  xmonad_log_applet_gnome2 = callPackage ../applications/window-managers/xmonad-log-applet {
+    desktopSupport = "gnome2";
+    inherit (xfce) libxfce4util xfce4panel;
+    gnome2_panel = gnome2.gnome_panel;
+    GConf2 = gnome2.GConf;
+  };
+
+  xmonad_log_applet_gnome3 = callPackage ../applications/window-managers/xmonad-log-applet {
+    desktopSupport = "gnome3";
+    inherit (xfce) libxfce4util xfce4panel;
+    gnome2_panel = gnome2.gnome_panel;
+    GConf2 = gnome2.GConf;
+  };
+
+  xmonad_log_applet_xfce = callPackage ../applications/window-managers/xmonad-log-applet {
+    desktopSupport = "xfce4";
+    inherit (xfce) libxfce4util xfce4panel;
+    gnome2_panel = gnome2.gnome_panel;
+    GConf2 = gnome2.GConf;
+  };
+
   libxpdf = callPackage ../applications/misc/xpdf/libxpdf.nix { };
 
   xpra = callPackage ../tools/X11/xpra { };
···
 
       qtcurve = callPackage ../misc/themes/qtcurve { };
 
-      quassel = callPackage ../applications/networking/irc/quassel { dconf = gnome3.dconf; };
+      quassel = callPackage ../applications/networking/irc/quassel rec {
+        monolithic = true;
+        daemon = false;
+        client = false;
+        withKDE = stdenv.isLinux;
+        qt = if withKDE then qt4 else qt5; # KDE supported quassel cannot build with qt5 yet (maybe in 0.12.0)
+        dconf = gnome3.dconf;
+      };
 
       quasselWithoutKDE = (self.quassel.override {
+        monolithic = true;
+        daemon = false;
+        client = false;
         withKDE = false;
+        #qt = qt5;
         tag = "-without-kde";
       });
 
       quasselDaemon = (self.quassel.override {
         monolithic = false;
         daemon = true;
+        client = false;
+        withKDE = false;
+        #qt = qt5;
         tag = "-daemon";
       });
 
       quasselClient = (self.quassel.override {
         monolithic = false;
+        daemon = false;
         client = true;
         tag = "-client";
       });
 
       quasselClientWithoutKDE = (self.quasselClient.override {
+        monolithic = false;
+        daemon = false;
+        client = true;
         withKDE = false;
+        #qt = qt5;
         tag = "-client-without-kde";
       });
 
···
 
   yandex-disk = callPackage ../tools/filesystems/yandex-disk { };
 
+  zdfmediathk = callPackage ../applications/video/zdfmediathk { };
+
   myEnvFun = import ../misc/my-env {
     inherit substituteAll pkgs;
     inherit (stdenv) mkDerivation;
···
   lttngTools = lttng-tools;  # added 2014-07-31
   lttngUst = lttng-ust;  # added 2014-07-31
   jquery_ui = jquery-ui;  # added 2014-09-07
+  youtubeDL = youtube-dl;  # added 2014-10-26
 
 
 }; in self; in pkgs

pkgs/top-level/haskell-packages.nix

···
 
   accelerateIo = callPackage ../development/libraries/haskell/accelerate-io {};
 
+  acmeLookofdisapproval = callPackage ../development/libraries/haskell/acme-lookofdisapproval {};
+
   active = callPackage ../development/libraries/haskell/active {};
 
   ACVector = callPackage ../development/libraries/haskell/AC-Vector {};
···
   bitsAtomic = callPackage ../development/libraries/haskell/bits-atomic {};
 
   bitsExtras = callPackage ../development/libraries/haskell/bits-extras {};
+
+  bitset = callPackage ../development/libraries/haskell/bitset {};
 
   bktrees = callPackage ../development/libraries/haskell/bktrees {};
 
···
 
   dataLens = callPackage ../development/libraries/haskell/data-lens {};
 
+  dataLensFd = callPackage ../development/libraries/haskell/data-lens-fd {};
+
   dataLensLight = callPackage ../development/libraries/haskell/data-lens-light {};
 
   dataLensTemplate = callPackage ../development/libraries/haskell/data-lens-template {};
···
     cabal = self.cabal.override { enableLibraryProfiling = false; }; # pkg cannot be built with profiling enabled
   };
 
+  ghcid = callPackage ../development/tools/haskell/ghcid {};
 
   ghcServer = callPackage ../development/libraries/haskell/ghc-server {};
 
···
 
   gloss = callPackage ../development/libraries/haskell/gloss {};
 
+  glossBanana = callPackage ../development/libraries/haskell/gloss-banana {};
+
   glossAccelerate = callPackage ../development/libraries/haskell/gloss-accelerate {};
 
   glossRaster = callPackage ../development/libraries/haskell/gloss-raster {};
···
   hoogleLocal = callPackage ../development/libraries/haskell/hoogle/local.nix {};
 
   hopenssl = callPackage ../development/libraries/haskell/hopenssl {};
+
+  hosc = callPackage ../development/libraries/haskell/hosc {
+    binary = self.binary_0_7_2_2;
+    dataBinaryIeee754 = self.dataBinaryIeee754.override { binary = self.binary_0_7_2_2; };
+  };
 
   hostname = callPackage ../development/libraries/haskell/hostname {};
 
···
   hS3 = callPackage ../development/libraries/haskell/hS3 {};
 
   hsBibutils = callPackage ../development/libraries/haskell/hs-bibutils {};
+
+  hsc3 = callPackage ../development/libraries/haskell/hsc3 {};
+
+  hsc3-dot = callPackage ../development/libraries/haskell/hsc3-dot {};
+
+  hsc3-process = callPackage ../development/libraries/haskell/hsc3-process {};
+
+  hsc3-db = callPackage ../development/libraries/haskell/hsc3-db {};
+
+  hsc3-lang = callPackage ../development/libraries/haskell/hsc3-lang {
+    hmatrixSpecial = self.hmatrixSpecial.override {
+      hmatrix = self.hmatrix.override { binary = self.binary_0_7_2_2; };
+    };
+  };
 
   hsdns = callPackage ../development/libraries/haskell/hsdns {};
 
···
 
   options = callPackage ../development/libraries/haskell/options {};
 
-  #optparseApplicative_0_9_1_1 = callPackage ../development/libraries/haskell/optparse-applicative/0.9.1.1.nix {};
   optparseApplicative_0_10_0 = callPackage ../development/libraries/haskell/optparse-applicative/0.10.0.nix {};
   optparseApplicative_0_11_0_1 = callPackage ../development/libraries/haskell/optparse-applicative/0.11.0.1.nix {};
   optparseApplicative = self.optparseApplicative_0_11_0_1;
···
 
   pipesSafe = callPackage ../development/libraries/haskell/pipes-safe {};
 
+  pipesShell = callPackage ../development/libraries/haskell/pipes-shell {};
+
   pipesText = callPackage ../development/libraries/haskell/pipes-text {};
 
   pipesZlib = callPackage ../development/libraries/haskell/pipes-zlib {};
···
 
   punycode = callPackage ../development/libraries/haskell/punycode {};
 
-  pureCdb = callPackage ../development/libraries/haskell/pure-cdb { testSimple = null; };
+  pureCdb = callPackage ../development/libraries/haskell/pure-cdb {};
 
   primitive_0_5_0_1 = callPackage ../development/libraries/haskell/primitive/0.5.0.1.nix {};
   primitive_0_5_2_1 = callPackage ../development/libraries/haskell/primitive/0.5.2.1.nix {};
···
 
   Rasterific = callPackage ../development/libraries/haskell/Rasterific {};
 
+  rawStringsQq = callPackage ../development/libraries/haskell/rawStringsQq {};
+
   reserve = callPackage ../development/libraries/haskell/reserve {};
 
   rvar = callPackage ../development/libraries/haskell/rvar {};
···
   scottyHastache = callPackage ../development/libraries/haskell/scotty-hastache {};
 
   scrypt = callPackage ../development/libraries/haskell/scrypt {};
+
+  serialport = callPackage ../development/libraries/haskell/serialport {};
 
   securemem = callPackage ../development/libraries/haskell/securemem {};
 
···
 
   arbtt = callPackage ../applications/misc/arbtt {};
 
-  idris_plain = callPackage ../development/compilers/idris {
-    llvmGeneral = self.llvmGeneral_3_3_8_2;
-    llvmGeneralPure = self.llvmGeneralPure_3_3_8_2;
-    languageJava = self.languageJava_0_2_6;
-    optparseApplicative = self.optparseApplicative_0_10_0;
-  };
+  idris_plain = callPackage ../development/compilers/idris {};
 
   idris = callPackage ../development/compilers/idris/wrapper.nix {};
 
···
   # M-x or reload). Use ‘yiCustom’ instead.
   yi = callPackage ../applications/editors/yi/yi.nix { };
 
-  yiContrib = callPackage ../development/libraries/haskell/yi-contrib {};
-
   yiCustom = callPackage ../applications/editors/yi/yi-custom.nix {
     extraPackages = pkgs: [];
   };
 
+  yiFuzzyOpen = callPackage ../development/libraries/haskell/yi-fuzzy-open {};
+
+  yiMonokai = callPackage ../development/libraries/haskell/yi-monokai {};
+
   yiLanguage = callPackage ../development/libraries/haskell/yi-language {};
 
   yiRope = callPackage ../development/libraries/haskell/yi-rope {};
+
+  yiSnippet = callPackage ../development/libraries/haskell/yi-snippet {};
 
   # Tools.
 
···
       LANG = "en_US.UTF-8";
       LOCALE_ARCHIVE = "${nativePkgs.glibcLocales}/lib/locale/locale-archive";
     });
-  in callPackage cabalExpr {
+  in callPackage cabalExpr ({
     cabal = self.cabal.override {
       extension = eself: esuper: {
         buildDepends = [ self.cabalInstall ] ++ esuper.buildDepends;
       } // cabalDrvArgs;
     };
-  };
+  } // args);
 
   buildLocalCabal = src: name: self.buildLocalCabalWithArgs { inherit src name; };
 

pkgs/top-level/perl-packages.nix

···
   };
 
   Encode = buildPerlPackage {
-    name = "Encode-2.55";
+    name = "Encode-2.63";
     src = fetchurl {
-      url = mirror://cpan/authors/id/D/DA/DANKOGAI/Encode-2.55.tar.gz;
-      sha256 = "0bpnfan0034k644gz6yg9xfddmsqxr2p7vbavijwbxc5k2c2sarz";
+      url = mirror://cpan/authors/id/D/DA/DANKOGAI/Encode-2.63.tar.gz;
+      sha256 = "1wrqm6c194l5yjaifc6nxx2b768sph2pv4n86fgh4blls0pvs6z4";
     };
   };
 

pkgs/top-level/python-packages.nix

···
 
   boto = buildPythonPackage rec {
     name = "boto-${version}";
-    version = "2.32.0";
+    version = "2.34.0";
 
     src = pkgs.fetchurl {
       url = "https://github.com/boto/boto/archive/${version}.tar.gz";
-      sha256 = "0bl5y7m0m84rz4q7hx783kxpj1n9wcm7dhv54bnx8cnanyd13cxn";
+      sha256 = "08zavyn02qng9y0251a9mrlkb3aw33m7gx5kc97hwngl3xk3s777";
     };
 
     # The tests seem to require AWS credentials.
···
     };
   };
 
-
   botocore = buildPythonPackage rec {
-    version = "0.33.0";
+    version = "0.67.0";
     name = "botocore-${version}";
 
     src = pkgs.fetchurl {
       url = "https://pypi.python.org/packages/source/b/botocore/${name}.tar.gz";
-      md5 = "6743c73a2e148abaa9c487a6e2ee53a3";
+      md5 = "193fe828525af4ae58e04bd172dc355f";
     };
 
     propagatedBuildInputs =
···
     };
   };
 
+  box2d = buildPythonPackage rec {
+    name = "box2d-${version}";
+    version = "2.3b0";
+    disabled = (!isPy27);
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/B/Box2D/Box2D-2.3b0.zip";
+      md5="25fc4f69cd580bdca0022ac3ace53865";
+    };
+
+    patches = [ ../development/python-modules/box2d/disable-test.patch ];
+
+    propagatedBuildInputs = [ pkgs.swig pkgs.box2d ];
+
+    meta = with stdenv.lib; {
+      homepage = https://code.google.com/p/pybox2d/;
+      description = ''
+        A 2D game physics library for Python under
+        the very liberal zlib license
+      '';
+      license = licenses.zlib;
+      platforms = platforms.all;
+      maintainers = [ maintainers.sepi ];
+    };
+  };
 
   # bugz = buildPythonPackage (rec {
   #   name = "bugz-0.9.3";
···
     propagatedBuildInputs = with self; [ self.coverage ];
   };
 
+  crcmod = buildPythonPackage rec {
+    name = "crcmod-1.7";
+    src = pkgs.fetchurl {
+      url = https://pypi.python.org/packages/source/c/crcmod/crcmod-1.7.tar.gz;
+      sha256 = "07k0hgr42vw2j92cln3klxka81f33knd7459cn3d8aszvfh52w6w";
+    };
+    meta = {
+      description = "Python module for generating objects that compute the Cyclic Redundancy Check (CRC)";
+      homepage = http://crcmod.sourceforge.net/;
+      license = stdenv.lib.licenses.mit;
+    };
+  };
+
   cython = buildPythonPackage rec {
     name = "Cython-0.20.1";
 
···
 
 
   evdev = buildPythonPackage rec {
-    version = "0.4.5";
+    version = "0.4.6";
     name = "evdev-${version}";
     disabled = isPy34;  # see http://bugs.python.org/issue21121
 
     src = pkgs.fetchurl {
       url = "https://pypi.python.org/packages/source/e/evdev/${name}.tar.gz";
-      sha256 = "0w8ib3ab4mpfc1rvd335l8xkd41qbh3iyb0vfiiapgcfvqk74aq7";
+      sha256 = "08bzyr3zc8ijnv25bysmmvzircblh42ja15f6ijdzmqqw8vfaij8";
     };
 
     buildInputs = with self; [ pkgs.linuxHeaders ];
···
     };
   };
 
+  poppler-qt4 = buildPythonPackage rec {
+    name = "poppler-qt4-${version}";
+    version = "0.18.1";
+    disabled = isPy3k || isPyPy;
+    
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/python-poppler-qt4/" +
+            "python-poppler-qt4-${version}.tar.gz";
+      md5 = "9c4c5a59b878aed78e96a6ae58c6c185";
+    };
+
+    propagatedBuildInputs = [ pkgs.pyqt4 pkgs.sip pkgs.pkgconfig pkgs.popplerQt4 ];
+
+    preBuild = "${python}/bin/${python.executable} setup.py build_ext" +
+               " --include-dirs=${pkgs.popplerQt4}/include/poppler/";
+
+    meta = with stdenv.lib; {
+      description = "A Python binding to Poppler-Qt4";
+      longDescription = ''
+        A Python binding to Poppler-Qt4 that aims for completeness
+        and for being actively maintained.
+      '';
+      license = licenses.lgpl21Plus;
+      maintainers = [ maintainers.sepi ];
+      platforms = platforms.all;
+    };
+  };
 
   pudb = buildPythonPackage rec {
     name = "pudb-2013.3.6";
···
 
 
   jmespath = buildPythonPackage rec {
-    name = "jmespath-0.2.1";
+    name = "jmespath-0.4.1";
 
     src = pkgs.fetchurl {
-      url = "https://pypi.python.org/packages/source/j/jmespath/jmespath-0.2.1.tar.gz";
-      md5 = "7800775aa12c6303f9ad597b6a8fa03c";
+      url = "https://pypi.python.org/packages/source/j/jmespath/${name}.tar.gz";
+      md5 = "a11ae39472672a650dfb55feab7d65eb";
     };
 
     propagatedBuildInputs = with self; [ ply ];
···
     };
   });
 
+  pybfd = buildPythonPackage rec {
+    name = "pybfd-0.1.1";
+
+    disabled = isPyPy || isPy3k;
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/p/pybfd/${name}.tar.gz";
+      md5 = "79dd6e12c90ad0515d0ad7fb1bd2f571";
+    };
+
+    preConfigure = ''
+      substituteInPlace setup.py \
+        --replace '"/usr/include"' '"${pkgs.gdb}/include"' \
+        --replace '"/usr/lib"' '"${pkgs.binutils}/lib"'
+    '';
+
+    # --old-and-unmanageable not supported by this setup.py
+    installPhase = ''
+      mkdir -p "$out/lib/${python.libPrefix}/site-packages"
+
+      export PYTHONPATH="$out/lib/${python.libPrefix}/site-packages:$PYTHONPATH"
+
+      ${python}/bin/${python.executable} setup.py install \
+        --install-lib=$out/lib/${python.libPrefix}/site-packages \
+        --prefix="$out"
+    ''; 
+
+    meta = with stdenv.lib; {
+      homepage = https://github.com/Groundworkstech/pybfd;
+      description = "A Python interface to the GNU Binary File Descriptor (BFD) library";
+      license = licenses.gpl2;
+      platforms = platforms.linux;
+    };
+  };
 
   pyblock = stdenv.mkDerivation rec {
     name = "pyblock-${version}";
···
     };
   };
 
+  retry_decorator = buildPythonPackage rec {
+    name = "retry_decorator-1.0.0";
+    src = pkgs.fetchurl {
+      url = https://pypi.python.org/packages/source/r/retry_decorator/retry_decorator-1.0.0.tar.gz;
+      sha256 = "086zahyb6yn7ggpc58909c5r5h3jz321i1694l1c28bbpaxnlk88";
+    };
+    meta = {
+      homepage = https://github.com/pnpnpn/retry-decorator;
+      license = stdenv.lib.licenses.mit;
+    };
+  };
 
   quantities = buildPythonPackage rec {
     name = "quantities-0.10.1";
···
     };
   };
 
+  socksipy-branch = buildPythonPackage rec {
+    name = "SocksiPy-branch-1.01";
+    src = pkgs.fetchurl {
+      url = https://pypi.python.org/packages/source/S/SocksiPy-branch/SocksiPy-branch-1.01.tar.gz;
+      sha256 = "01l41v4g7fy9fzvinmjxy6zcbhgqaif8dhdqm4w90fwcw9h51a8p";
+    };
+    meta = {
+      homepage = http://code.google.com/p/socksipy-branch/;
+      description = "This Python module allows you to create TCP connections through a SOCKS proxy without any special effort";
+      license = stdenv.lib.licenses.bsd3;
+    };
+  };
+
   sorl_thumbnail = buildPythonPackage rec {
     name = "sorl-thumbnail-11.12";
 
···
     };
 
     buildInputs = [ pkgs.bash ];
+
+    doCheck = !isPyPy;
 
     preConfigure = ''
       substituteInPlace test_subprocess32.py \
···
     ] ++ optional isPy26 argparse;
 
     patchPhase = ''
-      substituteInPlace "virtualenvwrapper.sh" --replace "which" "${pkgs.which}/bin/which"
-      substituteInPlace "virtualenvwrapper_lazy.sh" --replace "which" "${pkgs.which}/bin/which"
+      for file in "virtualenvwrapper.sh" "virtualenvwrapper_lazy.sh"; do
+        substituteInPlace "$file" --replace "which" "${pkgs.which}/bin/which"
+
+        # We can't set PYTHONPATH in a normal way (like exporting in a wrapper
+        # script) because the user has to evaluate the script and we don't want
+        # modify the global PYTHONPATH which would affect the user's
+        # environment.
+        # Furthermore it isn't possible to just use VIRTUALENVWRAPPER_PYTHON
+        # for this workaround, because this variable is well quoted inside the
+        # shell script.
+        # (the trailing " -" is required to only replace things like these one:
+        # "$VIRTUALENVWRAPPER_PYTHON" -c "import os,[...] and not in
+        # if-statements or anything like that.
+        # ...and yes, this "patch" is hacky :)
+        substituteInPlace "$file" --replace '"$VIRTUALENVWRAPPER_PYTHON" -' 'env PYTHONPATH="$VIRTUALENVWRAPPER_PYTHONPATH" "$VIRTUALENVWRAPPER_PYTHON" -'
+      done
     '';
 
     postInstall = ''
···
         mv "$wrapper" "$wrapped"
 
         cat > "$wrapper" <<- EOF
-	export PATH=$PATH:\$PATH
-	export PYTHONPATH=$PYTHONPATH:$(toPythonPath $out):\$PYTHONPATH
+	export PATH="$PATH:\$PATH"
+	export VIRTUALENVWRAPPER_PYTHONPATH="$PYTHONPATH:$(toPythonPath $out)"
 	source "$wrapped"
 	EOF
 
···
   with self;
 
 {
+  boto-230 = buildPythonPackage rec {
+    name = "boto-2.30.0";
+    src = pkgs.fetchurl {
+      url = https://pypi.python.org/packages/source/b/boto/boto-2.30.0.tar.gz;
+      sha256 = "12gl8azmx1vv8dbv9jhnsbhjpc2dd1ng0jlbcg734k6ggwq1h6hh";
+    };
+    doCheck = false;
+    meta = {
+      homepage = https://github.com/boto/boto;
+      license = licenses.mit;
+      description = "Python interface to Amazon Web Services";
+    };
+  };
+
+  gcs-oauth2-boto-plugin = buildPythonPackage rec {
+    name = "gcs-oauth2-boto-plugin-1.8";
+    src = pkgs.fetchurl {
+      url = https://pypi.python.org/packages/source/g/gcs-oauth2-boto-plugin/gcs-oauth2-boto-plugin-1.8.tar.gz;
+      sha256 = "0jy62y5bmaf1mb735lqwry1s5nx2qqrxvl5sxip9yg4miih3qkyb";
+    };
+    propagatedBuildInputs = with self; [ boto-230 httplib2 google_api_python_client retry_decorator pkgs.pyopenssl socksipy-branch ];
+    meta = {
+      homepage = https://developers.google.com/storage/docs/gspythonlibrary;
+      description = "Provides OAuth 2.0 credentials that can be used with Google Cloud Storage";
+      license = stdenv.lib.licenses.asl20;
+    };
+  };
+
+  gsutil = buildPythonPackage rec {
+    name = "gsutil-4.6";
+    meta = {
+      homepage = https://developers.google.com/storage/docs/gsutil;
+      description = "Google Cloud Storage Tool";
+      maintainers = [ "Russell O'Connor <[e-mail]>" ];
+      license = stdenv.lib.licenses.asl20;
+    };
+    doCheck = false;
+
+    src = pkgs.fetchurl {
+      url = https://pypi.python.org/packages/source/g/gsutil/gsutil-4.6.tar.gz;
+      sha256 = "1i0clm60162rbk45ljr8nsw4ndkzjnwb7r440shcqjrvw8jq49mn";
+    };
+
+    propagatedBuildInputs = with self; [ boto-230 crcmod httplib2 gcs-oauth2-boto-plugin google_api_python_client gflags
+                                         retry_decorator pkgs.pyopenssl socksipy-branch ];
+  };
 
   pypi2nix = self.buildPythonPackage rec {
     rev = "04a68d8577acbceb88bdf51b1231a9dbdead7003";
···
   };
 
   weboob = buildPythonPackage rec {
-    name = "weboob-0.j";
+    name = "weboob-1.0";
 
     src = pkgs.fetchurl {
-      url = "https://symlink.me/attachments/download/271/${name}.tar.gz";
-      md5 = "9e11b1f376ccb87d35995ec87bba5b38";
+      url = "https://symlink.me/attachments/download/289/${name}.tar.gz";
+      md5 = "38f832f1b8654441adafe8558faa7109";
     };
 
     setupPyBuildFlags = ["--qt" "--xdg"];
 
-    propagatedBuildInputs = with self; [ pillow prettytable pyyaml dateutil gdata requests2 mechanize feedparser lxml pkgs.gnupg pyqt4 pkgs.libyaml simplejson cssselect ];
+    propagatedBuildInputs = with self; [ pillow prettytable pyyaml dateutil gdata requests2 mechanize feedparser lxml pkgs.gnupg pyqt4 pkgs.libyaml simplejson cssselect futures ];
 
     meta = {
       homepage = http://weboob.org;