Merge branch 'master' into staging

lib/attrsets.nix

···
   inherit (import ./default.nix) fold;
   inherit (import ./strings.nix) concatStringsSep;
   inherit (import ./lists.nix) concatMap concatLists all deepSeqList;
-  inherit (import ./misc.nix) maybeAttr;
 };
 
 rec {
···
        => { foo = 1; }
   */
   filterAttrs = pred: set:
-    listToAttrs (fold (n: ys: let v = set.${n}; in if pred n v then [(nameValuePair n v)] ++ ys else ys) [] (attrNames set));
+    listToAttrs (concatMap (name: let v = set.${name}; in if pred name v then [(nameValuePair name v)] else []) (attrNames set));
 
 
   /* foldAttrs: apply fold functions to values grouped by key. Eg accumulate values as list:
···
   foldAttrs = op: nul: list_of_attrs:
     fold (n: a:
         fold (name: o:
-          o // (listToAttrs [{inherit name; value = op n.${name} (maybeAttr name nul a); }])
+          o // (listToAttrs [{inherit name; value = op n.${name} (a.${name} or nul); }])
         ) a (attrNames n)
     ) {} list_of_attrs;
 

lib/default.nix

···
   types = import ./types.nix;
   meta = import ./meta.nix;
   debug = import ./debug.nix;
-  misc = import ./misc.nix;
+  misc = import ./deprecated.nix;
   maintainers = import ./maintainers.nix;
   platforms = import ./platforms.nix;
   systems = import ./systems.nix;

lib/lists.nix

···
     in foldl' (length list - 1);
 
 
+  # Strict version of foldl.
+  foldl' = builtins.foldl' or foldl;
+
+
   # map with index: `imap (i: v: "${v}-${toString i}") ["a" "b"] ==
   # ["a-1" "b-2"]'
   imap = f: list:
···
   # == [1 2 3 4 5]' and `flatten 1 == [1]'.
   flatten = x:
     if isList x
-    then fold (x: y: (flatten x) ++ y) [] x
+    then foldl' (x: y: x ++ (flatten y)) [] x
     else [x];
 
 
···
 
   # Return true iff function `pred' returns true for at least element
   # of `list'.
-  any = pred: fold (x: y: if pred x then true else y) false;
+  any = builtins.any or (pred: fold (x: y: if pred x then true else y) false);
 
 
   # Return true iff function `pred' returns true for all elements of
   # `list'.
-  all = pred: fold (x: y: if pred x then y else false) true;
+  all = builtins.all or (pred: fold (x: y: if pred x then y else false) true);
 
 
   # Count how many times function `pred' returns true for the elements
   # of `list'.
-  count = pred: fold (x: c: if pred x then c + 1 else c) 0;
+  count = pred: foldl' (c: x: if pred x then c + 1 else c) 0;
 
 
   # Return a singleton list or an empty list, depending on a boolean

lib/misc.nix lib/deprecated.nix

···
     in
       work startSet [] [];
 
-  genericClosure = builtins.genericClosure or lazyGenericClosure;
-
   innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else 
         innerModifySumArgs f x (a // b);
   modifySumArgs = f: x: innerModifySumArgs f x {};

lib/modules.nix

···
           else yieldConfig (prefix ++ [n]) v) set) ["_definedNames"];
         in
         if options._module.check.value && set ? _definedNames then
-          fold (m: res:
-            fold (name: res:
+          foldl' (res: m:
+            foldl' (res: name:
               if set ? ${name} then res else throw "The option `${showOption (prefix ++ [name])}' defined in `${m.file}' does not exist.")
               res m.names)
             res set._definedNames
···
         let
           loc = prefix ++ [name];
           # Get all submodules that declare ‘name’.
-          decls = concatLists (map (m:
+          decls = concatMap (m:
             if m.options ? ${name}
               then [ { inherit (m) file; options = m.options.${name}; } ]
               else []
-            ) options);
+            ) options;
           # Get all submodules that define ‘name’.
-          defns = concatLists (map (m:
+          defns = concatMap (m:
             if m.config ? ${name}
               then map (config: { inherit (m) file; inherit config; })
                 (pushDownProperties m.config.${name})
               else []
-            ) configs);
+            ) configs;
           nrOptions = count (m: isOption m.options) decls;
           # Extract the definitions for this loc
           defns' = map (m: { inherit (m) file; value = m.config.${name}; })
···
      'opts' is a list of modules.  Each module has an options attribute which
      correspond to the definition of 'loc' in 'opt.file'. */
   mergeOptionDecls = loc: opts:
-    fold (opt: res:
+    foldl' (res: opt:
       if opt.options ? default && res ? default ||
          opt.options ? example && res ? example ||
          opt.options ? description && res ? description ||
···
             else if opt.options ? options then map (coerceOption opt.file) options' ++ res.options
             else res.options;
         in opt.options // res //
-          { declarations = [opt.file] ++ res.declarations;
+          { declarations = res.declarations ++ [opt.file];
             options = submodules;
           }
     ) { inherit loc; declarations = []; options = []; } opts;
···
         in
           processOrder (processOverride (processIfAndMerge defs));
 
-        # Type-check the remaining definitions, and merge them
-        mergedValue = fold (def: res:
+        # Type-check the remaining definitions, and merge them.
+        mergedValue = foldl' (res: def:
           if type.check def.value then res
           else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}.")
           (type.merge loc defsFinal) defsFinal;
···
       defaultPrio = 100;
       getPrio = def: if def.value._type or "" == "override" then def.value.priority else defaultPrio;
       min = x: y: if x < y then x else y;
-      highestPrio = fold (def: prio: min (getPrio def) prio) 9999 defs;
+      highestPrio = foldl' (prio: def: min (getPrio def) prio) 9999 defs;
       strip = def: if def.value._type or "" == "override" then def // { value = def.value.content; } else def;
     in concatMap (def: if getPrio def == highestPrio then [(strip def)] else []) defs;
 

lib/options.nix

···
 
 with import ./trivial.nix;
 with import ./lists.nix;
-with import ./misc.nix;
 with import ./attrsets.nix;
 with import ./strings.nix;
 
···
     if length list == 1 then head list
     else if all isFunction list then x: mergeDefaultOption loc (map (f: f x) list)
     else if all isList list then concatLists list
-    else if all isAttrs list then fold lib.mergeAttrs {} list
-    else if all isBool list then fold lib.or false list
+    else if all isAttrs list then foldl' lib.mergeAttrs {} list
+    else if all isBool list then foldl' lib.or false list
     else if all isString list then lib.concatStrings list
     else if all isInt list && all (x: x == head list) list then head list
     else throw "Cannot merge definitions of `${showOption loc}' given in ${showFiles (getFiles defs)}.";
···
   /* "Merge" option definitions by checking that they all have the same value. */
   mergeEqualOption = loc: defs:
     if defs == [] then abort "This case should never happen."
-    else fold (def: val:
+    else foldl' (val: def:
       if def.value != val then
         throw "The option `${showOption loc}' has conflicting definitions, in ${showFiles (getFiles defs)}."
       else
···
   optionAttrSetToDocList = optionAttrSetToDocList' [];
 
   optionAttrSetToDocList' = prefix: options:
-    fold (opt: rest:
+    concatMap (opt:
       let
         docOption = rec {
           name = showOption opt.loc;
···
           let ss = opt.type.getSubOptions opt.loc;
           in if ss != {} then optionAttrSetToDocList' opt.loc ss else [];
       in
-        # FIXME: expensive, O(n^2)
-        [ docOption ] ++ subOptions ++ rest) [] (collect isOption options);
+        [ docOption ] ++ subOptions) (collect isOption options);
 
 
   /* This function recursively removes all derivation attributes from

lib/strings.nix

···
 
 rec {
 
-  inherit (builtins) stringLength substring head tail isString;
+  inherit (builtins) stringLength substring head tail isString replaceStrings;
 
 
   # Concatenate a list of strings.
-  concatStrings = lib.fold (x: y: x + y) "";
+  concatStrings =
+    if builtins ? concatStringsSep then
+      builtins.concatStringsSep ""
+    else
+      lib.foldl' (x: y: x + y) "";
 
 
   # Map a function over a list and concatenate the resulting strings.
···
   intersperse = separator: list:
     if list == [] || length list == 1
     then list
-    else [(head list) separator]
-         ++ (intersperse separator (tail list));
+    else tail (lib.concatMap (x: [separator x]) list);
 
 
   # Concatenate a list of strings with a separator between each element, e.g.
   # concatStringsSep " " ["foo" "bar" "xyzzy"] == "foo bar xyzzy"
-  concatStringsSep = separator: list:
-    concatStrings (intersperse separator list);
+  concatStringsSep = builtins.concatStringsSep or (separator: list:
+    concatStrings (intersperse separator list));
 
   concatMapStringsSep = sep: f: list: concatStringsSep sep (map f list);
   concatImapStringsSep = sep: f: list: concatStringsSep sep (lib.imap f list);
···
 
   # Determine whether a string has given prefix/suffix.
   hasPrefix = pref: str:
-    eqStrings (substring 0 (stringLength pref) str) pref;
+    substring 0 (stringLength pref) str == pref;
   hasSuffix = suff: str:
     let
       lenStr = stringLength str;
       lenSuff = stringLength suff;
     in lenStr >= lenSuff &&
-       eqStrings (substring (lenStr - lenSuff) lenStr str) suff;
+       substring (lenStr - lenSuff) lenStr str == suff;
 
 
   # Convert a string to a list of characters (i.e. singleton strings).
···
   # will likely be horribly inefficient; Nix is not a general purpose
   # programming language.  Complex string manipulations should, if
   # appropriate, be done in a derivation.
-  stringToCharacters = s: let l = stringLength s; in
-    if l == 0
-    then []
-    else map (p: substring p 1 s) (lib.range 0 (l - 1));
+  stringToCharacters = s:
+    map (p: substring p 1 s) (lib.range 0 (stringLength s - 1));
 
 
-  # Manipulate a string charcater by character and replace them by strings
-  # before concatenating the results.
+  # Manipulate a string charactter by character and replace them by
+  # strings before concatenating the results.
   stringAsChars = f: s:
     concatStrings (
       map f (stringToCharacters s)
     );
 
 
-  # same as vim escape function.
-  # Each character contained in list is prefixed by "\"
-  escape = list : string :
-    stringAsChars (c: if lib.elem c list then "\\${c}" else c) string;
+  # Escape occurrence of the elements of ‘list’ in ‘string’ by
+  # prefixing it with a backslash. For example, ‘escape ["(" ")"]
+  # "(foo)"’ returns the string ‘\(foo\)’.
+  escape = list: replaceChars list (map (c: "\\${c}") list);
 
 
-  # still ugly slow. But more correct now
-  # [] for zsh
+  # Escape all characters that have special meaning in the Bourne shell.
   escapeShellArg = lib.escape (stringToCharacters "\\ ';$`()|<>\t*[]");
 
 
-  # replace characters by their substitutes.  This function is equivalent to
-  # the `tr' command except that one character can be replace by multiple
-  # ones.  e.g.,
-  # replaceChars ["<" ">"] ["&lt;" "&gt;"] "<foo>" returns "&lt;foo&gt;".
-  replaceChars = del: new: s:
+  # Obsolete - use replaceStrings instead.
+  replaceChars = builtins.replaceStrings or (
+    del: new: s:
     let
       substList = lib.zipLists del new;
       subst = c:
···
         else
           found.snd;
     in
-      stringAsChars subst s;
+      stringAsChars subst s);
 
 
-  # Case conversion utilities
+  # Case conversion utilities.
   lowerChars = stringToCharacters "abcdefghijklmnopqrstuvwxyz";
   upperChars = stringToCharacters "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   toLower = replaceChars upperChars lowerChars;
   toUpper = replaceChars lowerChars upperChars;
 
-  # Appends string context from another string
-  addContextFrom = a: b: substring 0 0 a + b;
 
-  # Compares strings not requiring context equality
-  # Obviously, a workaround but works on all Nix versions
-  eqStrings = a: b: addContextFrom b a == addContextFrom a b;
+  # Appends string context from another string.
+  addContextFrom = a: b: substring 0 0 a + b;
 
 
-  # Cut a string with a separator and produces a list of strings which were
-  # separated by this separator. e.g.,
-  # `splitString "." "foo.bar.baz"' returns ["foo" "bar" "baz"].
+  # Cut a string with a separator and produces a list of strings which
+  # were separated by this separator; e.g., `splitString "."
+  # "foo.bar.baz"' returns ["foo" "bar" "baz"].
   splitString = _sep: _s:
     let
       sep = addContextFrom _s _sep;
···
       sufLen = stringLength suf;
       sLen = stringLength s;
     in
-      if sufLen <= sLen && eqStrings suf (substring (sLen - sufLen) sufLen s) then
+      if sufLen <= sLen && suf == substring (sLen - sufLen) sufLen s then
         substring 0 (sLen - sufLen) s
       else
         s;
···
 
 
   # Extract name with version from URL. Ask for separator which is
-  # supposed to start extension
-  nameFromURL = url: sep: let
-    components = splitString "/" url;
-    filename = lib.last components;
-    name = builtins.head (splitString sep filename);
-  in
-  assert ! eqStrings name filename;
-  name;
+  # supposed to start extension.
+  nameFromURL = url: sep:
+    let
+      components = splitString "/" url;
+      filename = lib.last components;
+      name = builtins.head (splitString sep filename);
+    in assert name !=  filename; name;
 
 
   # Create an --{enable,disable}-<feat> string that can be passed to
   # standard GNU Autoconf scripts.
   enableFeature = enable: feat: "--${if enable then "enable" else "disable"}-${feat}";
 
-  # Create a fixed width string with additional prefix to match required width
+
+  # Create a fixed width string with additional prefix to match
+  # required width.
   fixedWidthString = width: filler: str:
     let
       strw = lib.stringLength str;
···
       assert strw <= width;
       if strw == width then str else filler + fixedWidthString reqWidth filler str;
 
-  # Format a number adding leading zeroes up to fixed width
+
+  # Format a number adding leading zeroes up to fixed width.
   fixedWidthNumber = width: n: fixedWidthString width "0" (toString n);
 }

lib/trivial.nix

···
   inherit (builtins)
     pathExists readFile isBool isFunction
     isInt add sub lessThan
-    seq deepSeq;
+    seq deepSeq genericClosure;
 
   # Return the Nixpkgs version number.
   nixpkgsVersion =

lib/types.nix

···
     attrs = mkOptionType {
       name = "attribute set";
       check = isAttrs;
-      merge = loc: fold (def: mergeAttrs def.value) {};
+      merge = loc: foldl' (res: def: mergeAttrs res def.value) {};
     };
 
     # derivation is a reserved keyword.

nixos/doc/manual/installation/installing-usb.xml

···
 
 <title>Booting from a USB Drive</title>
 
-<para>For systems without CD drive, the NixOS livecd can be booted from
-a usb stick. For non-UEFI installations,
+<para>For systems without CD drive, the NixOS live CD can be booted from
+a USB stick. For non-UEFI installations,
 <link xlink:href="http://unetbootin.sourceforge.net/">unetbootin</link>
 will work. For UEFI installations, you should mount the ISO, copy its contents
 verbatim to your drive, then either:

nixos/modules/installer/cd-dvd/iso-image.nix

···
   #   * COM32 entries (chainload, reboot, poweroff) are not recognized. They
   #     result in incorrect boot entries.
 
-  baseIsolinuxCfg =
-    ''
+  baseIsolinuxCfg = ''
     SERIAL 0 38400
     TIMEOUT ${builtins.toString syslinuxTimeout}
     UI vesamenu.c32
···
     LINUX /boot/bzImage
     APPEND init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}
     INITRD /boot/initrd
-    '';
+  '';
 
   isolinuxMemtest86Entry = ''
     LABEL memtest
···
 
   isolinuxCfg = baseIsolinuxCfg + (optionalString config.boot.loader.grub.memtest86.enable isolinuxMemtest86Entry);
 
-  # The efi boot image
+  # The EFI boot image.
   efiDir = pkgs.runCommand "efi-directory" {} ''
     mkdir -p $out/EFI/boot
     cp -v ${pkgs.gummiboot}/lib/gummiboot/gummiboot${targetArch}.efi $out/EFI/boot/boot${targetArch}.efi
     mkdir -p $out/loader/entries
-    echo "title NixOS LiveCD" > $out/loader/entries/nixos-livecd.conf
+    echo "title NixOS Live CD" > $out/loader/entries/nixos-livecd.conf
     echo "linux /boot/bzImage" >> $out/loader/entries/nixos-livecd.conf
     echo "initrd /boot/initrd" >> $out/loader/entries/nixos-livecd.conf
     echo "options init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}" >> $out/loader/entries/nixos-livecd.conf
···
     system.boot.loader.kernelFile = "bzImage";
     environment.systemPackages = [ pkgs.grub2 pkgs.grub2_efi pkgs.syslinux ];
 
+    boot.consoleLogLevel = 7;
+
     # In stage 1 of the boot, mount the CD as the root FS by label so
     # that we don't need to know its device.  We pass the label of the
     # root filesystem on the kernel command line, rather than in
···
     boot.kernelParams =
       [ "root=LABEL=${config.isoImage.volumeID}"
         "boot.shell_on_fail"
+        "nomodeset"
       ];
 
     fileSystems."/" =
···
       };
 
     boot.initrd.availableKernelModules = [ "squashfs" "iso9660" "usb-storage" ];
+
+    boot.blacklistedKernelModules = [ "nouveau" ];
 
     boot.initrd.kernelModules = [ "loop" ];
 

nixos/modules/module-list.nix

···
   ./services/networking/gogoclient.nix
   ./services/networking/gvpe.nix
   ./services/networking/haproxy.nix
+  ./services/networking/heyefi.nix
   ./services/networking/hostapd.nix
   ./services/networking/i2pd.nix
   ./services/networking/i2p.nix

nixos/modules/services/databases/postgresql.nix

···
 
         serviceConfig =
           { ExecStart = "@${postgresql}/bin/postgres postgres ${toString flags}";
+            ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
             User = "postgres";
             Group = "postgres";
             PermissionsStartOnly = true;

nixos/modules/services/networking/copy-com.nix

···
-{ config, lib, pkgs, ... }:
-
-with lib;
-
-let
-  
-  cfg = config.services.copy-com;
-
-in 
-
-{
-  options = {
-
-    services.copy-com = {
-	  
-	  enable = mkOption {
-          default = false;
-          description = "
-            Enable the copy.com client.
-
-            The first time copy.com is run, it needs to be configured. Before enabling run 
-            copy_console manually.
-          ";
-      };
-
-      user = mkOption {
-        description = "The user for which copy should run.";
-      };
-
-      debug = mkOption {
-        default = false;
-        description = "Output more.";
-      };
-	  };
-  };
-
-  config = mkIf cfg.enable {
-    environment.systemPackages = [ pkgs.postfix ];
-
-    systemd.services."copy-com-${cfg.user}" = {
-      description = "Copy.com Client";
-      after = [ "network.target" "local-fs.target" ];
-      wantedBy = [ "multi-user.target" ];
-      serviceConfig = {
-        ExecStart = "${pkgs.copy-com}/bin/copy_console ${if cfg.debug then "-consoleOutput -debugToConsole=dirwatch,path-watch,csm_path,csm -debug -console" else ""}";
-        User = "${cfg.user}";
-      };
-
-    };
-  };
-
-}
-
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.services.copy-com;
+
+in
+
+{
+  options = {
+
+    services.copy-com = {
+
+	  enable = mkOption {
+          default = false;
+          description = "
+            Enable the Copy.com client.
+            NOTE: before enabling the client for the first time, it must be
+            configured by first running CopyConsole (command line) or CopyAgent
+            (graphical) as the appropriate user.
+          ";
+      };
+
+      user = mkOption {
+        description = "The user for which the Copy.com client should be run.";
+      };
+
+      debug = mkOption {
+        default = false;
+        description = "Output more (debugging) messages to the console.";
+      };
+	  };
+  };
+
+  config = mkIf cfg.enable {
+    environment.systemPackages = [ pkgs.postfix ];
+
+    systemd.services."copy-com-${cfg.user}" = {
+      description = "Copy.com client";
+      after = [ "network.target" "local-fs.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.copy-com}/bin/CopyConsole ${if cfg.debug then "-consoleOutput -debugToConsole=dirwatch,path-watch,csm_path,csm -debug -console" else ""}";
+        User = "${cfg.user}";
+      };
+
+    };
+  };
+
+}
+

nixos/modules/services/networking/heyefi.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.services.heyefi;
+in
+
+{
+
+  ###### interface
+
+  options = {
+
+    services.heyefi = {
+
+      enable = mkEnableOption "heyefi";
+
+      cardMacaddress = mkOption {
+        default = "";
+        description = ''
+          An Eye-Fi card MAC address.
+          '';
+      };
+
+      uploadKey = mkOption {
+        default = "";
+        description = ''
+          An Eye-Fi card's upload key.
+          '';
+      };
+
+      uploadDir = mkOption {
+        example = "/home/username/pictures";
+        description = ''
+          The directory to upload the files to.
+          '';
+      };
+
+      user = mkOption {
+        default = "root";
+        description = ''
+          heyefi will be run under this user (user must exist,
+          this can be your user name).
+        '';
+      };
+
+    };
+
+  };
+
+
+  ###### implementation
+
+  config = mkIf cfg.enable {
+
+    systemd.services.heyefi =
+      {
+        description = "heyefi service";
+        after = [ "network.target" ];
+        wantedBy = [ "multi-user.target" ];
+        serviceConfig = {
+          User = "${cfg.user}";
+          Restart = "always";
+          ExecStart = "${pkgs.heyefi}/bin/heyefi";
+        };
+
+      };
+
+    environment.etc."heyefi/heyefi.config".text =
+      ''
+        # /etc/heyefi/heyefi.conf: DO NOT EDIT -- this file has been generated automatically.
+        cards = [["${config.services.heyefi.cardMacaddress}","${config.services.heyefi.uploadKey}"]]
+        upload_dir = "${toString config.services.heyefi.uploadDir}"
+      '';
+
+    environment.systemPackages = [ pkgs.heyefi ];
+
+  };
+
+}

nixos/modules/services/scheduling/cron.nix

···
 
     { services.cron.enable = mkDefault (allFiles != []); }
 
-    (mkIf (config.services.cron.enable && allFiles != []) {
+    (mkIf (config.services.cron.enable) {
 
       security.setuidPrograms = [ "crontab" ];
 

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

···
       example = literalExample "[ pkgs.gnome3.gpaste ]";
       description = "Additional list of packages to be added to the session search path.
                      Useful for gnome shell extensions or gsettings-conditionated autostart.";
-      apply = list: list ++ [ gnome3.gnome_shell ]; 
+      apply = list: list ++ [ gnome3.gnome_shell gnome3.gnome-shell-extensions ];
     };
 
     environment.gnome3.packageSet = mkOption {

nixos/modules/system/boot/kernel.nix

···
       type = types.int;
       default = 4;
       description = ''
-        The kernel console log level.  Only log messages with a
-        priority numerically less than this will appear on the
-        console.
+        The kernel console log level.  Log messages with a priority
+        numerically less than this will not appear on the console.
       '';
     };
 

nixos/modules/system/boot/loader/grub/grub.nix

···
 
   realGrub = if cfg.version == 1 then pkgs.grub
     else if cfg.zfsSupport then pkgs.grub2.override { zfsSupport = true; }
-    else if cfg.enableTrustedboot then pkgs.trustedGrub
+    else if cfg.enableTrustedBoot then pkgs.trustedGrub
            else pkgs.grub2;
 
   grub =
···
         description = ''
           The devices on which the boot loader, GRUB, will be
           installed. Can be used instead of <literal>device</literal> to
-          install grub into multiple devices (e.g., if as softraid arrays holding /boot).
+          install GRUB onto multiple devices.
         '';
       };
 
···
             example = "/boot1";
             type = types.str;
             description = ''
-              The path to the boot directory where grub will be written. Generally
-              this boot parth should double as an efi path.
+              The path to the boot directory where GRUB will be written. Generally
+              this boot path should double as an EFI path.
             '';
           };
 
···
             example = [ "/dev/sda" "/dev/sdb" ];
             type = types.listOf types.str;
             description = ''
-              The path to the devices which will have the grub mbr written.
+              The path to the devices which will have the GRUB MBR written.
               Note these are typically device paths and not paths to partitions.
             '';
           };
···
         type = types.lines;
         description = ''
           Additional bash commands to be run at the script that
-          prepares the grub menu entries.
+          prepares the GRUB menu entries.
         '';
       };
 
···
         example = "1024x768";
         type = types.str;
         description = ''
-          The gfxmode to pass to grub when loading a graphical boot interface under efi.
+          The gfxmode to pass to GRUB when loading a graphical boot interface under EFI.
         '';
       };
 
···
         example = "auto";
         type = types.str;
         description = ''
-          The gfxmode to pass to grub when loading a graphical boot interface under bios.
+          The gfxmode to pass to GRUB when loading a graphical boot interface under BIOS.
         '';
       };
 
···
         type = types.addCheck types.str
           (type: type == "uuid" || type == "label" || type == "provided");
         description = ''
-          Determines how grub will identify devices when generating the
+          Determines how GRUB will identify devices when generating the
           configuration file. A value of uuid / label signifies that grub
           will always resolve the uuid or label of the device before using
-          it in the configuration. A value of provided means that grub will
+          it in the configuration. A value of provided means that GRUB will
           use the device name as show in <command>df</command> or
           <command>mount</command>. Note, zfs zpools / datasets are ignored
           and will always be mounted using their labels.
···
         default = false;
         type = types.bool;
         description = ''
-          Whether grub should be build against libzfs.
+          Whether GRUB should be build against libzfs.
           ZFS support is only available for GRUB v2.
           This option is ignored for GRUB v1.
         '';
···
         default = false;
         type = types.bool;
         description = ''
-          Whether grub should be build with EFI support.
+          Whether GRUB should be build with EFI support.
           EFI support is only available for GRUB v2.
           This option is ignored for GRUB v1.
         '';
···
         default = false;
         type = types.bool;
         description = ''
-          Enable support for encrypted partitions. Grub should automatically
+          Enable support for encrypted partitions. GRUB should automatically
           unlock the correct encrypted partition and look for filesystems.
         '';
       };
 
-      enableTrustedboot = mkOption {
+      enableTrustedBoot = mkOption {
         default = false;
         type = types.bool;
         description = ''
-          Enable trusted boot. Grub will measure all critical components during
+          Enable trusted boot. GRUB will measure all critical components during
           the boot process to offer TCG (TPM) support.
         '';
       };
···
       assertions = [
         {
           assertion = !cfg.zfsSupport || cfg.version == 2;
-          message = "Only grub version 2 provides zfs support";
+          message = "Only GRUB version 2 provides ZFS support";
         }
         {
           assertion = cfg.mirroredBoots != [ ];
···
           message = "You cannot have duplicated devices in mirroredBoots";
         }
         {
-          assertion = !cfg.enableTrustedboot || cfg.version == 2;
+          assertion = !cfg.enableTrustedBoot || cfg.version == 2;
           message = "Trusted GRUB is only available for GRUB 2";
         }
         {
-          assertion = !cfg.efiSupport || !cfg.enableTrustedboot;
+          assertion = !cfg.efiSupport || !cfg.enableTrustedBoot;
           message = "Trusted GRUB does not have EFI support";
         }
         {
-          assertion = !cfg.zfsSupport || !cfg.enableTrustedboot;
+          assertion = !cfg.zfsSupport || !cfg.enableTrustedBoot;
           message = "Trusted GRUB does not have ZFS support";
         }
         {
-          assertion = !cfg.enableTrustedboot;
+          assertion = !cfg.enableTrustedBoot;
           message = "Trusted GRUB can break your system. Remove assertion if you want to test trustedGRUB nevertheless.";
         }
       ] ++ flip concatMap cfg.mirroredBoots (args: [
···
         }
       ] ++ flip map args.devices (device: {
         assertion = device == "nodev" || hasPrefix "/" device;
-        message = "Grub devices must be absolute paths, not ${dev} in ${args.path}";
+        message = "GRUB devices must be absolute paths, not ${dev} in ${args.path}";
       }));
     })
 

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

···
 , withGTK2 ? true, gtk2
 }:
 
-assert (libXft != null) -> libpng != null;	# probably a bug
-assert stdenv.isDarwin -> libXaw != null;	# fails to link otherwise
+assert (libXft != null) -> libpng != null;      # probably a bug
+assert stdenv.isDarwin -> libXaw != null;       # fails to link otherwise
 assert withGTK2 -> withX || stdenv.isDarwin;
 assert withGTK3 -> withX || stdenv.isDarwin;
 assert withGTK2 -> !withGTK3 && gtk2 != null;

pkgs/applications/editors/emacs-modes/proofgeneral/4.3pre.nix

···
 { stdenv, fetchurl, emacs, texinfo, texLive, perl, which, automake, enableDoc ? false }:
 
 stdenv.mkDerivation (rec {
-  name = "ProofGeneral-4.3pre131011";
+  name = "ProofGeneral-4.3pre150313";
 
   src = fetchurl {
-    url = http://proofgeneral.inf.ed.ac.uk/releases/ProofGeneral-4.3pre131011.tgz;
-    sha256 = "0104iy2xik5npkdg9p2ir6zqyrmdc93azrgm3ayvg0z76vmnb816";
+    url = "http://proofgeneral.inf.ed.ac.uk/releases/${name}.tgz";
+    sha256 = "1jq5ykkk14xr5qcn4kyxmi5ls0fibr0y47gfygzm1mzrfvz9aw3f";
   };
 
   sourceRoot = name;

pkgs/applications/editors/emacs-modes/proofgeneral/pg.patch

···
  if [ -z "$PGHOME" ] || [ ! -d "$PGHOME" ]; then
 -    # default relative to this script, otherwise PGHOMEDEFAULT
 -    MYDIR="`readlink --canonicalize "$0" | sed -ne 's,/bin/proofgeneral$,,p'`"
--    if [ -d "$MYDIR" ]; then
+-    if [ -d "$MYDIR/generic" ]; then
 -	PGHOME="$MYDIR"
 -    elif [ -d "$PGHOMEDEFAULT" ]; then
 +    if [ -d "$PGHOMEDEFAULT" ]; then

pkgs/applications/gis/qgis/default.nix

···
   pyqt4, qwt, fcgi, pythonPackages, libspatialindex, libspatialite, qscintilla, postgresql, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "qgis-2.8.2";
+  name = "qgis-2.10.1";
 
   buildInputs = [ gdal qt4 flex bison proj geos x11 sqlite gsl pyqt4 qwt qscintilla
     fcgi libspatialindex libspatialite postgresql ] ++
···
 
   src = fetchurl {
     url = "http://qgis.org/downloads/${name}.tar.bz2";
-    sha256 = "fd3c01e48224f611c3bb279b0af9cc1dff3844cdc93f7b45e4f37cf8f350bc4b";
+    sha256 = "79119b54642edaffe3cda513531eb7b81913e013954a49c6d3b21c8b00143307";
   };
 
   postInstall = ''

pkgs/applications/graphics/apitrace/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, python, libX11, qt4 }:
+{ stdenv, fetchFromGitHub, cmake, libX11, procps, python, qt5 }:
 
-let version = "6.1"; in
+let version = "7.0"; in
 stdenv.mkDerivation {
   name = "apitrace-${version}";
 
   src = fetchFromGitHub {
-    sha256 = "1v38111ljd35v5sahshs3inhk6nsv7rxh4r0ck8k0njkwzlx2yqk";
+    sha256 = "0nn3z7i6cd4zkmms6jpp1v2q194gclbs06v0f5hyiwcsqaxzsg5b";
     rev = version;
     repo = "apitrace";
     owner = "apitrace";
   };
 
-  buildInputs = [ python libX11 qt4 ];
+  buildInputs = [ libX11 procps python qt5.base ];
   nativeBuildInputs = [ cmake ];
 
   buildPhase = ''
···
   '';
 
   meta = with stdenv.lib; {
+    inherit version;
     homepage = https://apitrace.github.io;
     description = "Tools to trace OpenGL, OpenGL ES, Direct3D, and DirectDraw APIs";
     license = licenses.mit;

pkgs/applications/graphics/digikam/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "digikam-4.10.0";
+  name = "digikam-4.11.0";
 
   src = fetchurl {
     url = "http://download.kde.org/stable/digikam/${name}.tar.bz2";
-    sha256 = "4207e68b6221307111b66bb69485d3e88150df95dae014a99f6f161a3da0c725";
+    sha256 = "1nak3w0717fpbpmklzd3xkkbp2mwi44yxnc789wzmi9d8z9n3jwh";
   };
 
   nativeBuildInputs = [ cmake automoc4 pkgconfig ];

pkgs/applications/misc/gxmessage/default.nix

···
+{stdenv, fetchurl, gnome3, intltool, pkgconfig, texinfo}:
+
+stdenv.mkDerivation rec {
+  name = "gxmessage-${version}";
+  version = "3.4.3";
+
+  src = fetchurl {
+    url = "http://homepages.ihug.co.nz/~trmusson/stuff/${name}.tar.gz";
+    sha256 = "db4e1655fc58f31e5770a17dfca4e6c89028ad8b2c8e043febc87a0beedeef05";
+  };
+
+  buildInputs = [ intltool gnome3.gtk pkgconfig texinfo ];
+  meta = {
+    description = "a GTK enabled dropin replacement for xmessage";
+    homepage = "http://homepages.ihug.co.nz/~trmusson/programs.html#gxmessage";
+    license = stdenv.lib.licenses.gpl3;
+    maintainers = with stdenv.lib.maintainers; [jfb];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

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

···
 , libXcursor, libXi, libXinerama }:
 
 stdenv.mkDerivation rec {
-  version = "3.0.4.1";
+  version = "3.0.5";
   name = "dillo-${version}";
 
   src = fetchurl {
     url = "http://www.dillo.org/download/${name}.tar.bz2";
-    sha256 = "0iw617nnrz3541jkw5blfdlk4x8jxb382pshi8nfc7xd560c95zd";
+    sha256 = "12ql8n1lypv3k5zqgwjxlw1md90ixz3ag6j1gghfnhjq3inf26yv";
   };
 
   buildInputs = with stdenv.lib;
-    [ fltk openssl libjpeg libpng libXcursor libXi libXinerama ];
-
-  nativeBuildInputs = [ perl ];
+  [ perl fltk openssl libjpeg libpng libXcursor libXi libXinerama ];
 
   configureFlags =  "--enable-ssl";
 

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

···
 { stdenv, fetchurl
-, gpm, openssl, pkgconfig # Misc.
-, libpng, libjpeg, libtiff # graphic formats
+, gpm, openssl, pkgconfig, libev # Misc.
+, libpng, libjpeg, libtiff, librsvg # graphic formats
 , bzip2, zlib, xz # Transfer encodings
 , enableFB ? true
 , enableDirectFB ? false, directfb
···
 }:
 
 stdenv.mkDerivation rec {
-  version = "2.8";
+  version = "2.10";
   name = "links2-${version}";
 
   src = fetchurl {
     url = "${meta.homepage}/download/links-${version}.tar.bz2";
-    sha256 = "15h07498z52jfdahzgvkphg1f7qvxnpbyfn2xmsls0d2dwwdll3r";
+    sha256 = "0lqxg55sp1kphl7ykm2km0s2vsn92a0gmlgypmkqb984r060n3l4";
   };
 
   buildInputs =
-    [ libpng libjpeg libtiff gpm openssl xz bzip2 zlib ]
+    [ libev librsvg libpng libjpeg libtiff gpm openssl xz bzip2 zlib ]
     ++ stdenv.lib.optionals enableX11 [ libX11 libXau libXt ]
     ++ stdenv.lib.optional enableDirectFB [ directfb ];
 

pkgs/applications/networking/copy-com/default.nix

···
-{ stdenv, coreutils, fetchurl, patchelf, gcc }:
+{ stdenv, fetchurl, patchelf, fontconfig, freetype
+, gcc, glib, libICE, libSM, libX11, libXext, libXrender }:
 
 let
   arch = if stdenv.system == "x86_64-linux" then "x86_64"
···
 
   appdir = "opt/copy";
   
+  libPackages = [ fontconfig freetype gcc.cc glib libICE libSM libX11 libXext
+    libXrender ];
+  libPaths = stdenv.lib.concatStringsSep ":"
+    (map (path: "${path}/lib") libPackages);
+
 in stdenv.mkDerivation {
   
-  name = "copy-com-1.47.0410";
+  name = "copy-com-3.2.01.0481";
 
   src = fetchurl {
     # Note: copy.com doesn't version this file. Annoying.
     url = "https://copy.com/install/linux/Copy.tgz";
-    sha256 = "a48c69f6798f888617cfeef5359829e619057ae0e6edf3940b4ea6c81131012a";
+    sha256 = "0bpphm71mqpaiygs57kwa23nli0qm64fvgl1qh7fkxyqqabh4g7k";
   };
 
-  buildInputs = [ coreutils patchelf ];
+  nativeBuildInputs = [ patchelf ];
 
   phases = "unpackPhase installPhase";
 
   installPhase = ''
     mkdir -p $out/opt
     cp -r ${arch} "$out/${appdir}"
-    ensureDir "$out/bin"
-    ln -s "$out/${appdir}/CopyConsole" "$out/bin/copy_console"
-    ln -s "$out/${appdir}/CopyAgent" "$out/bin/copy_agent"
-    ln -s "$out/${appdir}/CopyCmd" "$out/bin/copy_cmd"
-    patchelf --set-interpreter ${stdenv.glibc}/lib/${interpreter} \
-      "$out/${appdir}/CopyConsole"
 
-    RPATH=${gcc.cc}/lib:$out/${appdir}
-    echo "updating rpaths to: $RPATH"
-    find "$out/${appdir}" -type f -a -perm +0100 \
-      -print -exec patchelf --force-rpath --set-rpath "$RPATH" {} \;
+    mkdir -p "$out/bin"
+    for binary in Copy{Agent,Console,Cmd}; do
+      binary="$out/${appdir}/$binary"
+      ln -sv "$binary" "$out/bin"
+      patchelf --set-interpreter ${stdenv.glibc}/lib/${interpreter} "$binary"
+    done
 
-
+    # Older versions of this package happily installed broken copies of
+    # anything other than CopyConsole - which was then also mangled to
+    # copy_console for some reason. Keep backwards compatibility (only
+    # for CopyConsole) for now; the NixOS service is already fixed.
+    ln -sv "$out/bin"/{CopyConsole,copy_console}
 
+    RPATH=${libPaths}:$out/${appdir}
+    echo "Updating rpaths to $RPATH in:"
+    find "$out/${appdir}" -type f -a -perm +0100 \
+      -print -exec patchelf --force-rpath --set-rpath "$RPATH" {} \;
   '';
 
   meta = {
     homepage = http://copy.com;
-    description = "Copy.com Client";
+    description = "Copy.com graphical & command-line clients";
     # Closed Source unfortunately.
     license = stdenv.lib.licenses.unfree;
-    maintainers = with stdenv.lib.maintainers; [ nathan-gs ];
+    maintainers = with stdenv.lib.maintainers; [ nathan-gs nckx ];
     # NOTE: Copy.com itself only works on linux, so this is ok.
     platforms = stdenv.lib.platforms.linux;
   };

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

···
+{ stdenv, fetchgit, pkgconfig, pidgin } :
+
+let
+  version = "54b2992";
+in
+stdenv.mkDerivation rec {
+  name = "pidgin-mra-${version}";
+
+  src = fetchgit {
+    url = "https://github.com/dreadatour/pidgin-mra";
+    rev = "${version}";
+    sha256 = "1nhfx9gi5lhh2xjr9rw600bb53ly2nwiqq422vc0f297qkm1q9y0";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ pidgin ];
+
+  preConfigure = ''
+    sed -i 's|-I/usr/include/libpurple|$(shell pkg-config --cflags purple)|' Makefile
+    export DESTDIR=$out
+    export LIBDIR=/lib
+    export DATADIR=/share
+  '';
+
+  meta = {
+    homepage = https://github.com/dreadatour/pidgin-mra;
+    description = "Mail.ru Agent plugin for Pidgin / libpurple";
+    license = stdenv.lib.licenses.gpl2;
+  };
+}

pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-vk-plugin/default.nix

···
+{ stdenv, fetchhg, pidgin, cmake, libxml2 } :
+
+let
+  version = "40ddb6d";
+in
+stdenv.mkDerivation rec {
+  name = "purple-vk-plugin-${version}";
+
+  src = fetchhg {
+    url = "https://bitbucket.org/olegoandreev/purple-vk-plugin";
+    rev = "${version}";
+    sha256 = "02p57fgx8ml00cbrb4f280ak2802svz80836dzk9f1zwm1bcr2qc";
+  };
+
+  buildInputs = [ pidgin cmake libxml2 ];
+
+  preConfigure = ''
+    sed -i -e 's|DESTINATION.*PURPLE_PLUGIN_DIR}|DESTINATION lib/purple-2|' CMakeLists.txt
+  '';
+
+  cmakeFlags = "-DCMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT=1";
+
+  meta = {
+    homepage = https://bitbucket.org/olegoandreev/purple-vk-plugin;
+    description = "Vk (russian social network) plugin for Pidgin / libpurple";
+    license = stdenv.lib.licenses.gpl3;
+  };
+}

pkgs/applications/networking/instant-messengers/teamspeak/client.nix

···
-{ stdenv, fetchurl, makeWrapper, zlib, glib, libpng, freetype, xorg
-, fontconfig, xlibs, qt5, xkeyboard_config, alsaLib, libpulseaudio ? null
-, libredirect, quazip, less, which
+{ stdenv, fetchurl, makeWrapper, makeDesktopItem, zlib, glib, libpng, freetype
+, xorg, fontconfig, xlibs, qt5, xkeyboard_config, alsaLib, libpulseaudio ? null
+, libredirect, quazip, less, which, unzip
 }:
 
 let
···
       xlibs.libxcb fontconfig xorg.libXext xorg.libX11 alsaLib qt5.base libpulseaudio
     ];
 
+  desktopItem = makeDesktopItem {
+    name = "teamspeak";
+    exec = "ts3client";
+    icon = "teamspeak";
+    comment = "The TeamSpeak voice communication tool";
+    desktopName = "TeamSpeak";
+    genericName = "TeamSpeak";
+    categories = "Network";
+  };
+
 in
 
 stdenv.mkDerivation rec {
···
                 else "1b3nbvfpd8lx3dig8z5yk6zjkbmsy6y938dhj1f562wc8adixciz";
   };
 
-  buildInputs = [ makeWrapper less which ];
+  # grab the plugin sdk for the desktop icon
+  pluginsdk = fetchurl {
+    url = "http://dl.4players.de/ts/client/pluginsdk/pluginsdk_3.0.16.zip";
+    sha256 = "1qpqpj3r21wff3ly9ail4l6b57pcqycsh2hca926j14sdlvpv7kl";
+  };
+
+  buildInputs = [ makeWrapper less which unzip ];
 
   unpackPhase =
     ''
···
       # Install files.
       mkdir -p $out/lib/teamspeak
       mv * $out/lib/teamspeak/
+
+      # Make a desktop item
+      mkdir -p $out/share/applications/ $out/share/icons/
+      unzip ${pluginsdk}
+      cp pluginsdk/docs/client_html/images/logo.png $out/share/icons/teamspeak.png
+      cp ${desktopItem}/share/applications/* $out/share/applications/
 
       # Make a symlink to the binary from bin.
       mkdir -p $out/bin/

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

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "sic-${version}";
+  version = "1.2";
+
+  makeFlags = "PREFIX=$out";
+  src = fetchurl {
+    url = "http://dl.suckless.org/tools/sic-${version}.tar.gz";
+    sha256 = "ac07f905995e13ba2c43912d7a035fbbe78a628d7ba1c256f4ca1372fb565185";
+  };
+
+  meta = {
+    description = "Simple IRC client";
+    homepage = http://tools.suckless.org/sic/;
+    license = stdenv.lib.licenses.mit;
+  };
+}

pkgs/applications/networking/mailreaders/mutt-kz/default.nix

···
 assert gpgmeSupport -> gpgme != null;
 
 let
-  version = "1.5.23.1-rc1";
+  version = "1.5.23.1";
 in
 stdenv.mkDerivation rec {
   name = "mutt-kz-${version}";
 
   src = fetchurl {
     url = "https://github.com/karelzak/mutt-kz/archive/v${version}.tar.gz";
-    sha256 = "1m4bnn8psyrx2wy8ribannmp5qf75lv1gz116plji2z37z015zny";
+    sha256 = "01k4hrf8x2100pcqnrm61mm1x0pqi2kr3rx22k5hwvbs1wh8zyhz";
   };
 
   buildInputs = with stdenv.lib;

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

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+
+  name = "lp_solve-${version}";
+  version = "5.5.2.0";
+
+  src = fetchurl {
+    url = "http://sourceforge.net/projects/lpsolve/files/lpsolve/${version}/lp_solve_${version}_source.tar.gz";
+    sha256 = "176c7f023mb6b8bfmv4rfqnrlw88lsg422ca74zjh19i2h5s69sq";
+  };
+
+  buildCommand = ''
+    . $stdenv/setup
+    tar xvfz $src
+    (
+    cd lp_solve*/lpsolve55
+    bash ccc
+    mkdir -pv $out/lib
+    cp -v bin/*/* $out/lib
+    )
+    (
+    cd lp_solve*/lp_solve
+    bash ccc
+    mkdir -pv $out/bin
+    cp -v bin/*/* $out/bin
+    )
+    (
+    mkdir -pv $out/include
+    cp -v lp_solve*/*.h $out/include
+    )
+  '';
+
+  meta = with stdenv.lib; {
+    description = "lp_solve is a Mixed Integer Linear Programming (MILP) solver.";
+    homepage    = "http://lpsolve.sourceforge.net";
+    license     = licenses.gpl2Plus;
+    maintainers = with maintainers; [ smironov ];
+    platforms   = platforms.unix;
+  };
+
+}
+

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

···
+{stdenv, fetchgit, fetchsvn, autoconf, automake, libtool, gfortran, clang, cmake, gnumake,
+hwloc, jre, liblapack, blas, hdf5, expat, ncurses, readline, qt4, webkit, which,
+lp_solve, omniorb, sqlite, libatomic_ops, pkgconfig, file, gettext, flex, bison,
+doxygen, boost, openscenegraph, gnome, pangox_compat, xlibs, git, bash, gtk, makeWrapper }:
+
+let
+
+  fakegit = import ./fakegit.nix {inherit stdenv fetchgit fetchsvn bash;} ;
+
+in
+
+stdenv.mkDerivation {
+  name = "openmodelica";
+
+  src = fetchgit (import ./src-main.nix);
+
+  buildInputs = [autoconf cmake automake libtool gfortran clang gnumake
+    hwloc jre liblapack blas hdf5 expat ncurses readline qt4 webkit which
+    lp_solve omniorb sqlite libatomic_ops pkgconfig file gettext flex bison
+    doxygen boost openscenegraph gnome.gtkglext pangox_compat xlibs.libXmu
+    git gtk makeWrapper];
+
+  patchPhase = ''
+    cp -fv ${fakegit}/bin/checkout-git.sh libraries/checkout-git.sh
+    cp -fv ${fakegit}/bin/checkout-svn.sh libraries/checkout-svn.sh
+  '';
+
+  configurePhase = ''
+    autoconf
+    ./configure CC=${clang}/bin/clang CXX=${clang}/bin/clang++ --prefix=$out
+  '';
+
+  postFixup = ''
+    for e in $(cd $out/bin && ls); do
+      wrapProgram $out/bin/$e \
+        --prefix PATH : "${gnumake}/bin" \
+        --prefix LIBRARY_PATH : "${liblapack}/lib:${blas}/lib"
+    done
+  '';
+
+  meta = with stdenv.lib; {
+    description = "OpenModelica is an open-source Modelica-based modeling and simulation environment";
+    homepage    = "https://openmodelica.org";
+    license     = licenses.gpl3;
+    maintainers = with maintainers; [ smironov ];
+    platforms   = platforms.linux;
+  };
+}
+
+

pkgs/applications/science/misc/openmodelica/fakegit.nix

···
+{stdenv, fetchgit, fetchsvn, bash } :
+
+let
+  mkscript = path : text : ''
+    mkdir -pv `dirname ${path}`
+    cat > ${path} <<"EOF"
+    #!${bash}/bin/bash
+    ME=`basename ${path}`
+    ${text}
+    EOF
+    sed -i "s@%out@$out@g" ${path}
+    chmod +x ${path}
+  '';
+  
+  hashname = r: let
+    rpl = stdenv.lib.replaceChars [":" "/"] ["_" "_"];
+  in
+    (rpl r.url) + "-" + (rpl r.rev);
+
+in
+
+stdenv.mkDerivation {
+  name = "fakegit";
+
+  buildCommand = ''
+    mkdir -pv $out/repos
+    ${stdenv.lib.concatMapStrings
+       (r : ''
+        cp -r ${fetchgit r} $out/repos/${hashname r}
+       ''
+       ) (import ./src-libs-git.nix)
+    }
+
+    ${mkscript "$out/bin/checkout-git.sh" ''
+      if test "$#" -ne 4; then
+        echo "Usage: $0 DESTINATION URL GITBRANCH HASH"
+        exit 1
+      fi
+      DEST=$1
+      URL=`echo $2 | tr :/ __`
+      GITBRANCH=$3
+      REVISION=$4
+
+      L=`echo $REVISION | wc -c`
+      if expr $L '<' 10 >/dev/null; then
+        REVISION=refs/tags/$REVISION
+      fi
+
+      REVISION=`echo $REVISION | tr :/ __`
+
+      rm -rf $DEST
+      mkdir -pv $DEST
+      echo "FAKEGIT cp -r %out/repos/$URL-$REVISION $DEST" >&2
+      cp -r %out/repos/$URL-$REVISION/* $DEST
+      chmod u+w -R $DEST
+    ''}
+
+    ${stdenv.lib.concatMapStrings
+       (r : ''
+        cp -r ${fetchsvn r} $out/repos/${hashname r}
+       ''
+       ) (import ./src-libs-svn.nix)
+    }
+
+    ${mkscript "$out/bin/checkout-svn.sh" ''
+      if test "$#" -ne 3; then
+        echo "Usage: $0 DESTINATION URL REVISION"
+        exit 1
+      fi
+      DEST=$1
+      URL=`echo $2 | tr :/ __`
+      REVISION=`echo $4 | tr :/ __`
+
+      rm -rf $DEST
+      mkdir -pv $DEST
+      echo "FAKE COPY %out/repos/$URL-$REVISION $DEST"
+      cp -r %out/repos/$URL-$REVISION/* $DEST
+      chmod u+w -R $DEST
+    ''}
+  '';
+}

pkgs/applications/science/misc/openmodelica/src-libs-git.nix

···
+[
+{ url = "https://github.com/modelica-3rdparty/ADGenKinetics.git"; rev = "42428db6e84bcde28543a3bba9bccee581309bb1"; sha256="14l005jwj1wz35gq8xlbzfz0bpsx99rs4q3dxkfh76yhnv1jh9h3"; }
+{ url = "https://github.com/modelica-3rdparty/ADMSL.git"; rev = "ed0305603f86b46d9af03e7d37dcb8b6704915b4"; sha256="15b0nqxyh8444az56ydjn594jikdl1ina5wamabk3nzm1yx218cl"; }
+{ url = "https://github.com/iea-annex60/modelica-annex60.git"; rev = "8015a01591bb24d219f57e7b69cdfcde66e39b47"; sha256="05k4pa007a6p628fq1xac0cfv8g8dnpy2bgy8h99rqpmlaa072z7"; }
+{ url = "https://github.com/OpenModelica/BioChem.git"; rev = "b5f3cb999f3cfad2bbb6fb429b496f61ecf2f628"; sha256="1l52dg888vwx4668spn59hqvfkpl9g06g8n2cdxiap7lvsyh6w9x"; }
+{ url = "https://github.com/modelica-3rdparty/BondGraph.git"; rev = "20c23e60d12989bd4668ccac47659d82d39d29cc"; sha256="1i9cmiy1ya04h2ld0gy0x2gvdrfksl66fmcrgdm1vpsnbb6pviv9"; }
+{ url = "https://github.com/modelica-3rdparty/BondLib.git"; rev = "df7a40fe612617da22e27d39edfa4b27d65f23d0"; sha256="005djwxd568zyk3ndss9hv165dci9x0dgjmcdjhnqmsap3w83hlz"; }
+{ url = "https://github.com/modelica-3rdparty/BrineProp.git"; rev = "fed013cdeec0fb9552964376b575a8e3635539ab"; sha256="020hm2q65d5iv3h8b3lhgl6j930vi2pbh4lvxv3b3k7i9z02q43a"; }
+{ url = "https://github.com/lbl-srg/modelica-buildings.git"; rev = "ef89361cc8673b077b9221efbf78aa63b4d7babd"; sha256="04gclknhl2f5z7w9fsbhwawisd0ibmvwpplx0siqwzvjx7nsmdg4"; }
+{ url = "https://github.com/lbl-srg/modelica-buildings.git"; rev = "444aa231f423b8d04225bf8672e3212d089fbfe4"; sha256="0q754mlkwqj0jcqsmxksvcz4ak2i86f9s41fhffh5jvra27cvq01"; }
+{ url = "https://github.com/modelica-3rdparty/Chemical.git"; rev = "aa2642608e587ddb6897e8c3ffabb3aa099510bd"; sha256="0y46spcb6rw0jpj4v20nlw8xlvi5kypij46f1msvwgr7dfgy4gl4"; }
+{ url = "https://github.com/modelica-3rdparty/ComplexLib.git"; rev = "0b78942ee4fa95ae71347a0d552dd869fdf4c708"; sha256="18llf5ccrq3b0f4cjznfycskwf78pik8370xv45w9gb51gamszrn"; }
+{ url = "https://github.com/lochel/ConPNlib.git"; rev = "bbf6e9711665d55e5a8cf2f7235fa013c2315104"; sha256="0g3ll44sn2ff14qxwdyakw9h5b8b7vzabxp8cb8km16wcdqzgcxx"; }
+{ url = "https://github.com/modelica-3rdparty/DESLib.git"; rev = "7a473d8d16b118c3ea05761c6f43b17fd9838e4e"; sha256="19f2121n8rdc9svcjk8irivsd9wqcb9ai9jx72s2r85fkbvm8jc3"; }
+{ url = "https://github.com/modelica-3rdparty/ExtendedPetriNets.git"; rev = "2f4eac0651c1ab0ed56b75ec61424e0ef15181d3"; sha256="0wwj756pg33qwb90ycbfkrk5xsiwsbrqvq3i16i4pisi21vl6jk9"; }
+{ url = "https://github.com/modelica-3rdparty/ExternData.git"; rev = "396164fa708cc7c7e64da55ac0b3cba23939f790"; sha256="09052qmv91a9wawsl93b5b3q47awrxhnsbb9mrv39kpnwygfh7dq"; }
+{ url = "https://github.com/modelica/ExternalMedia.git"; rev = "1b77869b31dc3509defeccb1236db4b05d2f6f5b"; sha256="05sszn4bn8r78syydyjq8csn9xv4az56mm9lrarqykqdh78pvlqp"; }
+{ url = "https://github.com/kdavies4/FCSys.git"; rev = "cb4b17f34313b9d8f2d4223d5365684b4dc1ab65"; sha256="114p7ja6b3fwlkvkkjhbx78fxc7v4af2sbs783hkdga86m1v4ib6"; }
+{ url = "https://github.com/modelica-3rdparty/FastBuildings.git"; rev = "1f5cfebc2f42c13e272bff639ffa3449d5740bf7"; sha256="0sry1n2pliddz0pjv8dp899fx98f16n1arc8zvq36k5grvi52fby"; }
+{ url = "https://github.com/modelica-3rdparty/FaultTriggering.git"; rev = "10c226b7e5b2af901b356ac437c90d6616a6e9a4"; sha256="0a9j18qjwigq11nghl97syxa9bscs1aj6vwpkldh50csnj5h6g2s"; }
+{ url = "https://github.com/modelica-3rdparty/FuzzyControl.git"; rev = "19ff67ff129a440482cc85f216f287b05ea6ec0d"; sha256="0ijcqns7pijsavijn4wlrdsz64k5ks626sly7r28wvrk9af2m2cx"; }
+{ url = "https://github.com/modelica-3rdparty/HelmholtzMedia.git"; rev = "e54fcd0e436d65c85de6c6b935983e363cdc9f6c"; sha256="05afh0379fx4mjjn7jb8j5p4am6qi62hjxvasb38b6fcp9rnysn4"; }
+{ url = "https://github.com/modelica-3rdparty/IdealizedContact.git"; rev = "8ebac550d913f6d2b3af4d1aea5044e72c7eb6b0"; sha256="03gh2a7hf44clshwkiyz786w847hmyr3bicdqd9969fbirgcqn6m"; }
+{ url = "https://github.com/modelica-3rdparty/IndustrialControlSystems.git"; rev = "6a2414307d5998c6d081efe803c2b575a532b3ba"; sha256="09la9h07x8bkh7zhrwykgj1467qdryjvxhvnnm8qvsim0dl9inc4"; }
+{ url = "https://github.com/modelica-3rdparty/LinearMPC.git"; rev = "1e91a5dcaa662cd30c5b09a9d0267289703f933b"; sha256="12094fqmwi65h0mc65b96krbj6b8dgn6jiww3fnv6khglb21kwvd"; }
+{ url = "https://github.com/modelica/Modelica.git"; rev = "refs/tags/v1.6"; sha256="106w83ylgbxf63wr7p9z5q8vqz2qcsaw0zwaad7d3saq6rdbj30c"; }
+{ url = "https://github.com/modelica/Modelica.git"; rev = "d442bcd461b8db9873e33b6141bdbd37bcff9de8"; sha256="1icnd0fxix5khnsvdhy7kmzn6lnqkggbvfrbln98a2h5zqd6s32w"; }
+{ url = "https://github.com/modelica/Modelica.git"; rev = "af2a3e1597d648d6826665c89cf9eaf5c2a632bc"; sha256="0ryk0iwakdazhsjqvan41w6f9bvgl329zkqchcdg6nkidiigziwh"; }
+{ url = "https://github.com/modelica/Modelica.git"; rev = "48943d87db45a6c312b5a5789d384acde44a934b"; sha256="1hi2vkpmx734baa9m1lqzallcykhh3snd68r387gndiv96f6zx3n"; }
+{ url = "https://github.com/modelica/Modelica.git"; rev = "164af873cc5955c50f9592a7d2f3c155f703849c"; sha256="071svqwd72sy85sngbg5r22ab693c0gw2xx29gk1sqrk2nchmvia"; }
+{ url = "https://github.com/OpenModelica/modelica3d.git"; rev = "daf5669b03ad33fc6999671d1c0e7521134a282b"; sha256="1scs6v2cp2r4jz4diszwbqf9kvzf49pid50dmpsz0gfhx06j9y2v"; }
+{ url = "https://github.com/modelica-deprecated/ModelicaAdditions.git"; rev = "568db43766186826b880f9d4bfafeff25cc2c4ab"; sha256="1py5i3afxdvz1dmxxwb2mqj8kyzdhg4jnnqwl8h50akizg4i49pl"; }
+{ url = "https://github.com/xogeny/ModelicaBook.git"; rev = "0e670cfae4db653bd34ea777d6b56423e9be2c9f"; sha256="0lxh08w6nii4p5yk7c0xmfi5y4xkjkzz4hirr3kqdhdfybcwq824"; }
+{ url = "https://github.com/modelica-compliance/compliance.git"; rev = "ca5092c14bb7af4507a10700ee49181a3a3ee199"; sha256="12ja6dhwlbq412kxjdviypgchipxpsg8l0sf6r17g6lbsi19i2b6"; }
+{ url = "https://github.com/modelica-3rdparty/ModelicaDEVS.git"; rev = "a987aa9552fbbe71b2ee2e8c28958f9d213087ae"; sha256="0qcw7vw28xadim0h8kr2km09d8vdj05ibdpzcnpny9n43pm9s5hx"; }
+{ url = "https://github.com/modelica/Modelica_DeviceDrivers.git"; rev = "db912ba7e1317b8f6a776ccf9a19f69c77a9c477"; sha256="052h2lr7xgfag5fks19wbldqmb985kxlc5fzysl7c9w3fnijp0ml"; }
+{ url = "https://github.com/modelica/Modelica_EnergyStorages.git"; rev = "9f057365232364e31a31a8e525f96284b98c7de3"; sha256="195m5b3z8qgg9kih9zsdx1h8zgrm37q63890r59akka05a97j48h"; }
+{ url = "https://github.com/modelica/Modelica_LinearSystems2.git"; rev = "18916fdc485285baab12481701b53d4eb606a3f1"; sha256="0fhvdwcgk8q3z1a98l2bxv8a6dysrs4ll6xfyzpni7yq8gp4mg4q"; }
+{ url = "https://github.com/modelica/Modelica_Synchronous.git"; rev = "d0f5ee57bc7b639738e88026674a87343b33dbe1"; sha256="0l75v4d0fgf07ify0h3skh4y9pfw9gxh9hbj1lbsdgglmzlrcvbg"; }
+{ url = "https://github.com/modelica-3rdparty/MotorcycleDynamics.git"; rev = "2be2667f9936d88ffb9b8a8246c5af9ccb0b307f"; sha256="0jazwmpqpyhhgs9qdn9drmplgp2yjs0ky7wll5x9929dkgy80m6x"; }
+{ url = "https://github.com/modelica-3rdparty/NCLib.git"; rev = "ed3d72f176ac6b7031ce73be9d80101141e74a69"; sha256="1pbpv8w1lsa9vdwp7qbih8iim91ms22b01wz376b548d0x2r95la"; }
+{ url = "https://github.com/modelica-3rdparty/NeuralNetwork.git"; rev = "c44e4d1fe97fd4f86dafcd05ad3713692e3f1806"; sha256="0s1v8k71zq1s9gjlvi3zr23nwfknp4x17cxm64a0y3vsi3kahj2s"; }
+{ url = "https://github.com/DLR-SR/Noise.git"; rev = "9b57476845539e56769cf76ea0fe7bf3c7eb5d11"; sha256="0icrb63f6dm4gww2nyby9i7s7qxvhvialp36xzcgmi7nlq7crjr2"; }
+{ url = "https://github.com/modelica-3rdparty/ObjectStab.git"; rev = "2a723e0b223af50f4ffdd62f8ac901e0f87b9323"; sha256="1b6zi27slzzfbkmbcqxygsn5i5w0zkq0hfrfb72vf7mbgz07j19j"; }
+{ url = "https://github.com/cparedis/OpenHydraulics.git"; rev = "d3173d1f06f7d14c9d7c41769f143617ff03a3ad"; sha256="1hn5rcnmzcbiaqdnxfn02wddmrpj9bcdi9p680f31hbh3vb0i3r6"; }
+{ url = "https://github.com/lochel/PNlib.git"; rev = "44c7d277980b7a88b449b72edec0a56416b40fa9"; sha256="026wdhbxnzarmj8gw0as70vj8f1gwc51z38hjqpswxkl0xd6mfvp"; }
+{ url = "https://github.com/MarekMatejak/Physiolibrary.git"; rev = "49d59060f6e5b4cb68560c6d7467e84ea4318056"; sha256="0klqs2axjm3s780sq4plq4wmbf9mszz2jmq9fprgxy9pw7iszbhc"; }
+{ url = "https://github.com/dzimmer/PlanarMechanics.git"; rev = "d998a1b27355e83d2ff4849d71281a919a3234aa"; sha256="0vyq6mninn38wy2d60rk753xbkfqim2y6y31py7kq2mm170jfqf4"; }
+{ url = "https://github.com/modelica/PowerSystems.git"; rev = "7b551888089277a0dd979db636d47aba0279e8f0"; sha256="0y13f1nllc7riksnly25wmmp6mc30c1b48dbq2lr1nag6yg3blwm"; }
+{ url = "https://github.com/modelica/PowerSystems.git"; rev = "3abd48aa53bbcd3f3e2ddfa2371680febf8baf48"; sha256="1nr2nbpaxywk8cpwnk9rr2zr87mm2gb9b4plqipjdlrrkjlk9fka"; }
+{ url = "https://github.com/modelica-3rdparty/PraxisSimulationstechnik.git"; rev = "f7db177786f84033f3a50b7474988b190a1dfb46"; sha256="08bdm7k7w35kg9gkrvcn382zkwf5h3iwkkx60d5fj64j5d5klray"; }
+{ url = "https://github.com/modelica-3rdparty/QCalc.git"; rev = "af6c34dda691a9bdf7ca1de10650974b2d5cecf5"; sha256="0p0zhl27cnr492byrzib0dyn7zp5yb7wcr0spv10ngm6j90cij6y"; }
+{ url = "https://github.com/modelica-3rdparty/QSSFluidFlow.git"; rev = "d84a2c107132f2cd47ea3c3751238d69e4b1f64b"; sha256="02cdvv33pi0qlmg8n401s4cxf59l9b4ff4ixf7gwn4w4n1y9bw0g"; }
+{ url = "https://github.com/modelica-3rdparty/RealTimeCoordinationLibrary.git"; rev = "655ac1a22aa6deb04ea8e3869dd0aa9fb9540754"; sha256="19crf8pl9vpqq3pq1rhcbl49kkmnm4jrzpwrpqp8qc6dj8096za4"; }
+{ url = "https://github.com/modelica-3rdparty/ScalableTestSuite.git"; rev = "c6319908d45ac97ffb10e96cd42654bce36ffb97"; sha256="1g79d88bfmzcqvaghyyj86ajs38v0qnmjxbj8d53yp6nmgnaasx5"; }
+{ url = "https://github.com/modelica-3rdparty/Servomechanisms.git"; rev = "22e1874ef9ad46156617817c67a4fb1238621bf5"; sha256="0nwb7apayk7ba9iv27yv67wi4b934dy57kkvn0acxy393jhd8jqd"; }
+{ url = "https://openmodelica.org/git/SiemensPower.git"; rev = "73a3bfc6d2ddd72165bb0f3e7e9df48b643a5ed0"; sha256="0mvrkpkmr0bx2cvsb23syg7cs8k6a15vjf4n1hivdcigq4x8g2nc"; }
+{ url = "https://openmodelica.org/git/SiemensPower.git"; rev = "5ef2e38b64ff481801c0db19d52f0bef21f85f77"; sha256="1llnpl2x1g28gari1rk34hdnnwf7a4fwwxlf7i18d8bl1vsrfaja"; }
+{ url = "https://openmodelica.org/git/SiemensPower.git"; rev = "2bd9e367baaa8d44946897c3c3a32a4050ad2a2a"; sha256="1shm9blpn9m87ci6wwkinpmihr1fik9j0a0pj2nxy0cjrr2jzbn4"; }
+{ url = "https://github.com/modelica-3rdparty/Spot.git"; rev = "2f74417f1681570900a1ed373dcbe4b42634ec7b"; sha256="0k5h2k6x98zvvsafpw7y16xs9d6lxz0csa0mlm4wwggaywadn255"; }
+{ url = "https://github.com/modelica-3rdparty/SystemDynamics.git"; rev = "c58a26dc3e62a50e64fd336dc4aa499b2d5ad314"; sha256="0ra3a2vgqmry92kmm060gfa41mrpkgbs4swzl78ih3icawfzjz8q"; }
+{ url = "https://github.com/modelica-3rdparty/ThermoPower.git"; rev = "e012268625dd1645fe5570cf31d64129d83a8192"; sha256="1rlkli48kc9hnkplgb0bjkb6ajn7agiw4yh9l5sfvlv7k7k2gc8l"; }
+{ url = "https://openmodelica.org/git/ThermoSysPro.git"; rev = "d4f9c3ed35f7520f82439eb6e9f4057ae0f82b73"; sha256="0hxbn26g479qkr6rrglx9ljdxnpzd5ll1sf2v08skghrdjjb8jcx"; }
+{ url = "https://openmodelica.org/git/ThermoSysPro.git"; rev = "51e7ea2d2e121ee640e7897335c294923f8eaeb0"; sha256="0l11mzjkaxndsqrnnr0z7qvk08svv229119qkm81yb53ich9wnyw"; }
+{ url = "https://github.com/modelica/VehicleInterfaces.git"; rev = "ad956a35643d53e207ee126d67ea1f3f38337a39"; sha256="0g90cqwjpi06gn7vca5kqnz56im76s2hrdqjhsj2bl43rza8mhr0"; }
+{ url = "https://github.com/modelica-3rdparty/WasteWater.git"; rev = "90ff44ac791ba5ed98444c8597efbd2a2af01cad"; sha256="1icrn0y389rhxmf6i0mnsfgw9v9j5innpkz3q069rfm2ji268b12"; }
+{ url = "https://github.com/xogeny/XogenyTest.git"; rev = "9b98981e8ff0f440dd319d1a806e1fd2f0ab3436"; sha256="18glaxrlxfml26w7ljlf0yj3ah1fnhpbg01py28nplsgnrfwfwqj"; }
+{ url = "https://github.com/modelica-3rdparty/msgpack-modelica.git"; rev = "6ce2ca600c4902038c0f20b43ed442f1ee204310"; sha256="01x5a9y11yf62sc0j2y49yxwm24imj2lfl3z5mwvi9038gwn0lkx"; }
+{ url = "https://github.com/modelica-3rdparty/netCDF-DataReader.git"; rev = "3d2cc8272abfbc4b667d8868f851bf3e11c6f00e"; sha256="194810a4rn0flxgirrlnxsbxarnm97309dkp1w7nva9zv1q3wj7h"; }
+{ url = "https://github.com/joewa/open-bldc-modelica.git"; rev = "7817cd703b88fc1f433269d32c31e75eb50a21c6"; sha256="1plkxkx51f9yi99ysarmx2ymldizvyr0m66k996y5lj5h81jv8a8"; }
+]

pkgs/applications/science/misc/openmodelica/src-libs-svn.nix

···
+[
+{ url = "https://svn.modelica.org/projects/Modelica_ElectricalSystems/InstantaneousSymmetricalComponents"; rev = "7978"; sha256="0f100c7bz4ai3ryhpkbbszw8z6mykvg40p03ic92n2qq58wjk37z"; }
+{ url = "https://svn.modelica.org/projects/Modelica_EmbeddedSystems/trunk/Modelica_StateGraph2"; rev = "8121"; sha256="1cys57nc1yzkr5admc139qs5pa48rj3g69pb3j3s9xcmpd483hzp"; }
+{ url = "https://svn.modelica.org/projects/Modelica_ElectricalSystems/Modelica_PowerFlow/trunk"; rev = "3174"; sha256="0yviw1b8psn8vfyl4q1naylak3lcqi2q1bqplqg3gg9iw4aiymxl"; }
+]

pkgs/applications/science/misc/openmodelica/src-main.nix

···
+{
+  url = "https://openmodelica.org/git-readonly/OpenModelica.git";
+  fetchSubmodules = true;
+  rev = "8c5d48eb31a638d5220621b20377bfe6f9e9535e";
+  sha256 = "15r0qpvnsb9a7nw3bh5n9r770ngd7p5py0ld2jy5mc4llaslkpa5";
+}

pkgs/applications/science/misc/openmodelica/update-src-libs-git.sh

···
+#!/bin/sh
+
+CWD=`pwd`
+
+chko() { (
+T=`mktemp -d`
+trap "rm -rf $T" EXIT INT PIPE
+cd $T
+cat >check.nix <<EOF
+with import <nixpkgs> {};
+fetchgit `cat $CWD/src-main.nix`
+EOF
+nix-build check.nix
+cat result/libraries/Makefile.libs
+) }
+
+getsha256() { (
+T=`mktemp -d`
+trap "rm -rf $T" EXIT INT PIPE
+cd $T
+
+L=`echo $2 | wc -c`
+if expr $L '<' 10 >/dev/null; then
+T=`echo $2 | sed 's@"\(.*\)"@"refs/tags/\1"@'`
+cat >check.nix <<EOF
+with import <nixpkgs> {};
+fetchgit {
+  url = $1;
+  rev = $T;
+  sha256 = "0000000000000000000000000000000000000000000000000000";
+}
+EOF
+SHA=`nix-build check.nix 2>&1 | sed -n 's/.*instead has ‘\(.*\)’.*/\1/g p'`
+echo "{ url = $1; rev = $T; sha256=\"$SHA\"; }"
+else
+cat >check.nix <<EOF
+with import <nixpkgs> {};
+fetchgit {
+  url = $1;
+  rev = $2;
+  sha256 = "0000000000000000000000000000000000000000000000000000";
+}
+EOF
+SHA=`nix-build check.nix 2>&1 | sed -n 's/.*instead has ‘\(.*\)’.*/\1/g p'`
+echo "{ url = $1; rev = $2; sha256=\"$SHA\"; }"
+fi
+
+# nix-build check.nix
+) }
+
+OUT=src-libs-git.nix
+
+echo '[' > $OUT
+
+chko |
+grep checkout-git.sh |
+tr \' \" |
+while read NM TGT URL BR REV ; do
+  echo Trying $TGT $URL $REV >&2
+  getsha256 $URL $REV >> $OUT || exit 1
+done
+
+echo ']' >> $OUT
+

pkgs/applications/science/misc/openmodelica/update-src-libs-svn.sh

···
+#!/bin/sh
+
+CWD=`pwd`
+
+chko() { (
+T=`mktemp -d`
+trap "rm -rf $T" EXIT INT PIPE
+cd $T
+cat >check.nix <<EOF
+with import <nixpkgs> {};
+fetchgit `cat $CWD/src-main.nix`
+EOF
+nix-build check.nix
+cat result/libraries/Makefile.libs
+) }
+
+getsha256() { (
+T=`mktemp -d`
+trap "rm -rf $T" EXIT INT PIPE
+cd $T
+
+L=`echo $2 | wc -c`
+cat >check.nix <<EOF
+with import <nixpkgs> {};
+fetchsvn {
+  url = $1;
+  rev = $2;
+  sha256 = "0000000000000000000000000000000000000000000000000000";
+}
+EOF
+SHA=`nix-build check.nix 2>&1 | sed -n 's/.*instead has ‘\(.*\)’.*/\1/g p'`
+echo "{ url = $1; rev = $2; sha256=\"$SHA\"; }"
+
+# nix-build check.nix
+) }
+
+OUT=src-libs-svn.nix
+
+echo '[' > $OUT
+
+chko |
+grep checkout-svn.sh |
+tr \' \" |
+while read NM TGT URL REV ; do
+  echo Trying $TGT $URL $REV >&2
+  getsha256 $URL $REV >> $OUT || exit 1
+done
+
+echo ']' >> $OUT
+

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

···
 { stdenv, fetchurl, itstool, buildPythonPackage, python27, intltool, makeWrapper
 , libxml2, pygobject3, gobjectIntrospection, gtk3, gnome3, pycairo, cairo
-, hicolor_icon_theme
 }:
 
 
 let
-  minor = "3.12";
-  version = "${minor}.3";
+  minor = "3.14";
+  version = "${minor}.0";
 in
 
 buildPythonPackage rec {
···
 
   src = fetchurl {
     url = "mirror://gnome/sources/meld/${minor}/meld-${version}.tar.xz";
-    sha256 = "1zg6qhm53j0vxmjj3pcj2hwi8c12dxzmlh98zks0jnwhqv2p4dfv";
+    sha256 = "0g0h9wdr6nqdalqkz4r037569apw253cklwr17x0zjc7nwv2j3j3";
   };
 
   buildInputs = [
     python27 intltool makeWrapper itstool libxml2
     gnome3.gtksourceview gnome3.gsettings_desktop_schemas pycairo cairo
-    hicolor_icon_theme
+    gnome3.defaultIconTheme
   ];
   propagatedBuildInputs = [ gobjectIntrospection pygobject3 gtk3 ];
 
···
   preFixup = ''
     wrapProgram $out/bin/meld \
       --prefix GI_TYPELIB_PATH : "$GI_TYPELIB_PATH" \
-      --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH:$out/share"
+      --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH:$out/share" \
+      --prefix GIO_EXTRA_MODULES : "${gnome3.dconf}/lib/gio/modules"
   '';
 
   patchPhase = ''
-    sed -e 's,#!.*,#!${python27}/bin/python27,' -i bin/meld
+    patchShebangs bin/meld
   '';
 
   pythonPath = [ gtk3 ];
 
   meta = with stdenv.lib; {
     description = "Visual diff and merge tool";
-    homepage = http://meld.sourceforge.net;
+    homepage = http://meldmerge.org/;
     license = stdenv.lib.licenses.gpl2;
     platforms = platforms.linux ++ stdenv.lib.platforms.darwin;
   };

pkgs/applications/virtualization/remotebox/default.nix

···
-{ stdenv, fetchurl, perl, perlPackages }:
+{ stdenv, fetchurl, makeWrapper, perl, perlPackages }:
 
-stdenv.mkDerivation rec {
-  version = "1.9";
+let version = "2.0"; in
+stdenv.mkDerivation {
   name = "remotebox-${version}";
 
   src = fetchurl {
-    url = "${meta.homepage}/downloads/RemoteBox-${version}.tar.bz2";
-    sha256 = "0vsfz2qmha9nz60fyksgqqyrw4lz9z2d5isnwqc6afn8z3i1qmkp";
+    url = "http://remotebox.knobgoblin.org.uk/downloads/RemoteBox-${version}.tar.bz2";
+    sha256 = "0c73i53wdjd2m2sdgq3r3xp30irxh5z5rak2rk79yb686s6bv759";
   };
 
-  buildInputs = [ perl perlPackages.Gtk2 perlPackages.SOAPLite ];
+  buildInputs = with perlPackages; [ perl Glib Gtk2 Pango SOAPLite ];
+  nativeBuildInputs = [ makeWrapper ];
 
   installPhase = ''
-    mkdir -p $out/bin
-    cp -a docs/ share/ $out
+    mkdir -pv $out/bin
 
     substituteInPlace remotebox --replace "\$Bin/" "\$Bin/../"
-    install -t $out/bin remotebox
+    install -v -t $out/bin remotebox
+    wrapProgram $out/bin/remotebox --prefix PERL5LIB : $PERL5LIB
 
-    mkdir -p $out/share/applications
-    cp -p packagers-readme/*.desktop $out/share/applications
+    cp -av docs/ share/ $out
+
+    mkdir -pv $out/share/applications
+    cp -pv packagers-readme/*.desktop $out/share/applications
   '';
 
   meta = with stdenv.lib; {
+    inherit version;
     description = "VirtualBox client with remote management";
     homepage = http://remotebox.knobgoblin.org.uk/;
     license = licenses.gpl2Plus;
     longDescription = ''
       VirtualBox is traditionally considered to be a virtualization solution
-      aimed at the desktop.  While it is certainly possible to install
+      aimed at the desktop. While it is certainly possible to install
       VirtualBox on a server, it offers few remote management features beyond
       using the vboxmanage command line.
       RemoteBox aims to fill this gap by providing a graphical VirtualBox
       client which is able to manage a VirtualBox server installation.
     '';
     maintainers = with maintainers; [ nckx ];
-    platforms = with platforms; all;
+    platforms = platforms.all;
   };
 }

pkgs/applications/virtualization/virtualbox/default.nix

···
       src/apps/adpctl/VBoxNetAdpCtl.cpp
   '';
 
+  # first line: ugly hack, and it isn't yet clear why it's a problem
   configurePhase = ''
+    NIX_CFLAGS_COMPILE=$(echo "$NIX_CFLAGS_COMPILE" | sed 's,\-isystem ${stdenv.cc.libc}/include,,g')
+
     cat >> LocalConfig.kmk <<LOCAL_CONFIG
     VBOX_WITH_TESTCASES            :=
     VBOX_WITH_TESTSUITE            :=

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

···
       --prefix PYTHONPATH : "$out/lib/${python.libPrefix}/site-packages"
   '';
 
+  # automatic moving fails, perhaps due to having two $out/lib*/pkgconfig
+  dontMoveLib64 = true;
+
   meta = {
     description = "Compoziting window manager";
     homepage = "http://launchpad.net/compiz/";

pkgs/build-support/rust/default.nix

···
     export CARGO_HOME="$(realpath deps)"
 
     # Let's find out which $indexHash cargo uses for file:///dev/null
-    (cd $sourceRoot && cargo fetch &>/dev/null)
+    (cd $sourceRoot && cargo fetch &>/dev/null) || true
     cd deps
     indexHash="$(basename $(echo registry/index/*))"
 

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

···
 { stdenv, fetchurl }:
 
-let version = "4.00"; in
+let version = "4.01"; in
 stdenv.mkDerivation rec {
   name = "man-pages-${version}";
 
   src = fetchurl {
     url = "mirror://kernel/linux/docs/man-pages/${name}.tar.xz";
-    sha256 = "18zb1g12s15sanffh0sykmmyx0j176pp7q1xxs0gk0imgvmn8hj4";
+    sha256 = "116jp2rnsdlnb3cwnbfp0g053frcmchndwyrj714swl1lgabb56i";
   };
 
   makeFlags = "MANDIR=$(out)/share/man";

pkgs/data/fonts/dejavu-fonts/default.nix

···
     ln -s ${unicodeData} resources/UnicodeData.txt
     ln -s ${blocks} resources/Blocks.txt
   '';
-  installPhase = '' 
+  installPhase = ''
     mkdir -p $out/share/fonts/truetype
-    for i in $(find build -name '*.ttf'); do 
-        cp $i $out/share/fonts/truetype; 
+    for i in $(find build -name '*.ttf'); do
+        cp $i $out/share/fonts/truetype;
     done;
-    mkdir -p $out/share/dejavu-fonts
-    cp -r build/* $out/share/dejavu-fonts
   '';
 }
-  
+

pkgs/data/fonts/font-awesome-ttf/default.nix

···
 
   src = fetchurl {
     url = "http://fortawesome.github.io/Font-Awesome/assets/${name}.zip";
-    sha256 = "018syfvkj01jym60mpys93xv84ky9l2x90gprnm9npzwkw5169jc";
+    sha256 = "0wg9q6mq026jjw1bsyj9b5dgba7bb4h7i9xiwgsfckd412xpsbzd";
   };
 
   buildCommand = ''

pkgs/data/fonts/pecita/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "pecita-${version}";
-  version = "1.1";
+  version = "5.0";
 
   src = fetchurl {
     url = "http://pecita.eu/b/Pecita.otf";
-    sha256 = "07krzpbmc5yhfbf3aklv1f150i2g1spaan9girmg3189jsn6qw6p";
+    sha256 = "1smf1mqciwavf29lwgzjam3xb37bwxp6wf6na4c9xv6islidsrd9";
   };
 
   phases = ["installPhase"];

pkgs/data/misc/geolite-legacy/default.nix

···
 { stdenv, fetchurl }:
 
 let
-  fetchDB = name: sha256: fetchurl {
-    inherit sha256;
-    url = "https://geolite.maxmind.com/download/geoip/database/${name}";
+  fetchDB = src: name: sha256: fetchurl {
+    inherit name sha256;
+    url = "https://geolite.maxmind.com/download/geoip/database/${src}";
   };
 
   # Annoyingly, these files are updated without a change in URL. This means that
   # builds will start failing every month or so, until the hashes are updated.
-  version = "2015-07-08";
+  version = "2015-07-25";
 in
 stdenv.mkDerivation {
   name = "geolite-legacy-${version}";
 
-  srcGeoIP = fetchDB "GeoLiteCountry/GeoIP.dat.gz"
-    "0c6jcmlgkybsqiwqwa21igjazf95dj38mn516cqqqfdg7ciaj1d5";
-  srcGeoIPv6 = fetchDB "GeoIPv6.dat.gz"
-    "1vi82p41vas18yp17yk236pn1xamsi9662aav79fa0hm43i3ydx3";
-  srcGeoLiteCity = fetchDB "GeoLiteCity.dat.xz"
+  srcGeoIP = fetchDB
+    "GeoLiteCountry/GeoIP.dat.gz" "GeoIP.dat.gz"
+    "1yacbh8qcakmnpipscdh99vmsm0874g2gkq8gp8hjgkgi0zvcsnz";
+  srcGeoIPv6 = fetchDB
+    "GeoIPv6.dat.gz" "GeoIPv6.dat.gz"
+    "038ll8142svhyffxxrg0isrr16rjbz0cnkhd14mck77f1v8z01y5";
+  srcGeoLiteCity = fetchDB
+    "GeoLiteCity.dat.xz" "GeoIPCity.dat.xz"
     "0x5ihg7qikzc195nix9r0izvbdnj4hy4rznvaxk56rf8yqcigdyv";
-  srcGeoLiteCityv6 = fetchDB "GeoLiteCityv6-beta/GeoLiteCityv6.dat.gz"
-    "0xjzg76vdsayxyy1yyw64w781vad4c9nbhw61slh2qmazdr360g9";
-  srcGeoIPASNum = fetchDB "asnum/GeoIPASNum.dat.gz"
+  srcGeoLiteCityv6 = fetchDB
+    "GeoLiteCityv6-beta/GeoLiteCityv6.dat.gz" "GeoIPCityv6.dat.gz"
+    "0j5dq06pjrh6d94wczsg6qdys4v164nvp2a7qqrg8w4knh94qp6n";
+  srcGeoIPASNum = fetchDB
+    "asnum/GeoIPASNum.dat.gz" "GeoIPASNum.dat.gz"
     "18kxswr0b5klimfpj1zhxipvyvrljvcywic4jc1ggcr44lf4hj9w";
-  srcGeoIPASNumv6 = fetchDB "asnum/GeoIPASNumv6.dat.gz"
+  srcGeoIPASNumv6 = fetchDB
+    "asnum/GeoIPASNumv6.dat.gz" "GeoIPASNumv6.dat.gz"
     "0asnmmirridiy57zm0kccb7g8h7ndliswfv3yfk7zm7dk98njnxs";
 
   meta = with stdenv.lib; {

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

···
     gtk3 # for gtk-update-icon-cache
     glib_networking gvfs dconf gnome-backgrounds gnome_control_center
     gnome-menus gnome_settings_daemon gnome_shell
-    gnome_themes_standard defaultIconTheme
+    gnome_themes_standard defaultIconTheme gnome-shell-extensions
   ];
 
   optionalPackages = with gnome3; [ baobab empathy eog epiphany evince
     gucharmap nautilus totem vino yelp gnome-bluetooth
     gnome-calculator gnome-contacts gnome-font-viewer gnome-screenshot
-    gnome-shell-extensions gnome-system-log gnome-system-monitor
+    gnome-system-log gnome-system-monitor
     gnome_terminal gnome-user-docs bijiben evolution file-roller gedit
     gnome-clocks gnome-music gnome-tweak-tool gnome-photos
     nautilus-sendto dconf-editor vinagre
   ];
+
+  gamesPackages = with gnome3; [ swell-foop lightsoff iagno ];
 
   inherit (pkgs) libsoup glib gtk2 webkitgtk24x gtk3 gtkmm3 libcanberra;
   inherit (pkgs.gnome2) ORBit2;
···
   anjuta = callPackage ./devtools/anjuta { };
 
   gdl = callPackage ./devtools/gdl { };
+
+#### Games
+
+  iagno = callPackage ./games/iagno { };
+
+  lightsoff = callPackage ./games/lightsoff { };
+
+  swell-foop = callPackage ./games/swell-foop { };
 
 #### Misc -- other packages on http://ftp.gnome.org/pub/GNOME/sources/
 

pkgs/desktops/gnome-3/3.16/games/iagno/default.nix

···
+{ stdenv, fetchurl, pkgconfig, gtk3, gnome3, gdk_pixbuf, librsvg, makeWrapper
+, intltool, itstool, libcanberra_gtk3, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "iagno-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/iagno/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0pg4sx277idfab3qxxn8c7r6gpdsdw5br0x7fxhxqascvvx8my1k";
+  };
+
+  buildInputs = [ pkgconfig gtk3 gnome3.defaultIconTheme gdk_pixbuf librsvg
+                  libxml2 libcanberra_gtk3 makeWrapper itstool intltool ];
+
+  enableParallelBuilding = true;
+
+  preFixup = ''
+    wrapProgram "$out/bin/iagno" \
+      --set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE" \
+      --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH:$out/share" \
+      --prefix GIO_EXTRA_MODULES : "${gnome3.dconf}/lib/gio/modules"
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Iagno;
+    description = "Computer version of the game Reversi, more popularly called Othello";
+    maintainers = with maintainers; [ lethalman ];
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}

pkgs/desktops/gnome-3/3.16/games/lightsoff/default.nix

···
+{ stdenv, fetchurl, pkgconfig, gtk3, gnome3, gdk_pixbuf, librsvg, makeWrapper
+, intltool, itstool, clutter, clutter_gtk, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "lightsoff-${gnome3.version}.1.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/lightsoff/${gnome3.version}/${name}.tar.xz";
+    sha256 = "00a2jv7wr6fxrzk7avwa0wspz429ad7ri7v95jv31nqn5q73y4c0";
+  };
+
+  buildInputs = [ pkgconfig gtk3 gnome3.defaultIconTheme gdk_pixbuf librsvg
+                  libxml2 clutter clutter_gtk makeWrapper itstool intltool ];
+
+  enableParallelBuilding = true;
+
+  preFixup = ''
+    wrapProgram "$out/bin/lightsoff" \
+      --set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE" \
+      --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH:$out/share" \
+      --prefix GIO_EXTRA_MODULES : "${gnome3.dconf}/lib/gio/modules"
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Lightsoff;
+    description = "Puzzle game, where the objective is to turn off all of the tiles on the board";
+    maintainers = with maintainers; [ lethalman ];
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}

pkgs/desktops/gnome-3/3.16/games/swell-foop/default.nix

···
+{ stdenv, fetchurl, pkgconfig, gtk3, gnome3, gdk_pixbuf, librsvg, makeWrapper
+, clutter, clutter_gtk, intltool, itstool, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "swell-foop-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/swell-foop/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0bhjmjcjsqdb89shs0ygi6ps5hb3lk8nhrbjnsjk4clfqbw0jzwf";
+  };
+
+  buildInputs = [ pkgconfig gtk3 gnome3.defaultIconTheme gdk_pixbuf librsvg
+                  makeWrapper itstool intltool clutter clutter_gtk libxml2 ];
+
+  enableParallelBuilding = true;
+
+  preFixup = ''
+    wrapProgram "$out/bin/swell-foop" \
+      --set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE" \
+      --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH:$out/share" \
+      --prefix GIO_EXTRA_MODULES : "${gnome3.dconf}/lib/gio/modules"
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = "https://wiki.gnome.org/Apps/Swell%20Foop";
+    description = "Puzzle game, previously known as Same GNOME";
+    maintainers = with maintainers; [ lethalman ];
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}

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

···
     # Whether building a cross-compiler for GNU/Hurd.
     crossGNU = cross != null && cross.config == "i586-pc-gnu";
 
-    enableParallelBuilding = true;
+    # Builds of gfortran have failed with strange errors that we cannot reproduce
+    # (http://hydra.nixos.org/build/23951123). Our best guess is that the build
+    # system has bugs that are exposed by compiling with multiple threads.
+    enableParallelBuilding = !langFortran;
 
     patches = [ ]
       ++ optional enableParallelBuilding ../parallel-bconfig.patch

pkgs/development/compilers/haxe/default.nix

···
-{ stdenv, fetchgit, ocaml, zlib, neko }:
+{ stdenv, fetchgit, ocaml, zlib, neko, camlp4 }:
 
 stdenv.mkDerivation {
   name = "haxe-3.1.3";
 
-  buildInputs = [ocaml zlib neko];
+  buildInputs = [ocaml zlib neko camlp4];
 
   src = fetchgit {
     url = "https://github.com/HaxeFoundation/haxe.git";

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

···
-{ pkgs, newScope, stdenv, isl, fetchurl, overrideCC, wrapCC }:
+{ newScope, stdenv, isl, fetchurl, overrideCC, wrapCC }:
 let
   callPackage = newScope (self // { inherit stdenv isl version fetch; });
 

pkgs/development/compilers/mezzo/default.nix

···
-{stdenv, fetchurl, ocaml, findlib, menhir, yojson, ulex, pprint, fix, functory}:
+{ stdenv, fetchFromGitHub, ocaml, findlib, menhir, yojson, ulex, pprint, fix, functory }:
+
+let
+  check-ocaml-version = with stdenv.lib; versionAtLeast (getVersion ocaml);
+in
+
+assert check-ocaml-version "4";
 
 stdenv.mkDerivation {
 
   name = "mezzo-0.0.m8";
 
-  src = fetchurl {
-    url = https://github.com/protz/mezzo/archive/m8.tar.gz;
-    sha256 = "17mfapgqp8ssa5x9blv72zg9l561zbiwv3ikwi6nl9dd36lwkkc6";
+  src = fetchFromGitHub {
+    owner = "protz";
+    repo = "mezzo";
+    rev = "m8";
+    sha256 = "0yck5r6di0935s3iy2mm9538jkf77ssr789qb06ms7sivd7g3ip6";
   };
 
   buildInputs = [ ocaml findlib yojson menhir ulex pprint fix functory ];
+
+  # Sets warning 3 as non-fatal
+  prePatch = stdenv.lib.optionalString (check-ocaml-version "4.02") ''
+    substituteInPlace myocamlbuild.pre.ml \
+    --replace '@1..3' '@1..2+3'
+  '';
 
   createFindlibDestdir = true;
 

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

···
-{ fetchurl, stdenv, guile, guile_lib, gwrap
+{ fetchgit, stdenv, guile, guile_lib, gwrap
 , pkgconfig, gconf, glib, gnome_vfs, gtk
-, libglade, libgnome, libgnomecanvas, libgnomeui, pango, guileCairo }:
+, libglade, libgnome, libgnomecanvas, libgnomeui
+, pango, guileCairo, autoconf, automake, texinfo }:
 
 stdenv.mkDerivation rec {
-  name = "guile-gnome-platform-2.16.1";
+  name = "guile-gnome-platform-20150123";
 
-  src = fetchurl {
-    url = "mirror://gnu/guile-gnome/guile-gnome-platform/${name}.tar.gz";
-    sha256 = "0yy5f4c78jlakxi2bwgh3knc2szw26hg68xikyaza2iim39mc22c";
+  src = fetchgit {
+    url = "git://git.sv.gnu.org/guile-gnome.git";
+    rev = "0fcbe69797b9501b8f1283a78eb92bf43b08d080";
+    sha256 = "1vqlzb356ggmp8jh833gksg59c53vbmmhycbcf52qj0fdz09mpb5";
   };
 
-  buildInputs =
-    [ guile gwrap
-      pkgconfig gconf glib gnome_vfs gtk libglade libgnome libgnomecanvas
-      libgnomeui pango guileCairo
-    ]
-    ++ stdenv.lib.optional doCheck guile_lib;
+  buildInputs = [
+    autoconf
+    automake
+    texinfo
+    guile
+    gwrap
+    pkgconfig
+    gconf
+    glib
+    gnome_vfs
+    gtk
+    libglade
+    libgnome
+    libgnomecanvas
+    libgnomeui
+    pango
+    guileCairo
+  ] ++ stdenv.lib.optional doCheck guile_lib;
+
+  preConfigure = ''
+      ./autogen.sh
+  '';
 
   # The test suite tries to open an X display, which fails.
   doCheck = false;
···
 
     license = stdenv.lib.licenses.gpl2Plus;
 
-    maintainers = [ ];
+    maintainers = [ stdenv.lib.maintainers.taktoa ];
   };
 }

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

···
       });
 
   # Does not compile: "fatal error: ieee-flpt.h: No such file or directory"
-  base_4_8_0_0 = markBroken super.base_4_8_0_0;
+  base_4_8_1_0 = markBroken super.base_4_8_1_0;
 
   # Obsolete: https://github.com/massysett/prednote/issues/1.
   prednote-test = markBrokenVersion "0.26.0.4" super.prednote-test;
···
 
   # Won't compile with recent versions of QuickCheck.
   testpack = markBroken super.testpack;
+  inilist = dontCheck super.inilist;
   MissingH = dontCheck super.MissingH;
 
   # Obsolete for GHC versions after GHC 6.10.x.
···
   # This package can't be built on non-Windows systems.
   Win32 = overrideCabal super.Win32 (drv: { broken = !pkgs.stdenv.isCygwin; });
   inline-c-win32 = dontDistribute super.inline-c-win32;
+  Southpaw = dontDistribute super.Southpaw;
 
   # Doesn't work with recent versions of mtl.
   cron-compat = markBroken super.cron-compat;
···
 
   # https://ghc.haskell.org/trac/ghc/ticket/9825
   vimus = overrideCabal super.vimus (drv: { broken = pkgs.stdenv.isLinux && pkgs.stdenv.isi686; });
+
 }

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

···
          http-types httpd-shed HUnit mtl network network-uri pureMD5 split
          test-framework test-framework-hunit wai warp
        ];
+       jailbreak = true;
        homepage = "https://github.com/haskell/HTTP";
        description = "A library for client-side HTTP";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, array, base, containers, StateVar, transformers }:
      mkDerivation {
        pname = "Hipmunk";
-       version = "5.2.0.16";
-       sha256 = "0jnidzky0004xh1yzkcg41df21vbvqhk075d183jv6iwjiljsh3s";
+       version = "5.2.0.17";
+       sha256 = "1yxs1v9pzb35g3zlvycsx762dk8swrbry7ajr50zlq667j20n4a8";
        buildDepends = [ array base containers StateVar transformers ];
-       jailbreak = true;
        homepage = "https://github.com/meteficha/Hipmunk";
        description = "A Haskell binding for Chipmunk";
        license = "unknown";
···
 
   "Network-NineP" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, convertible
-     , monad-loops, mstate, mtl, network, NineP, regex-posix, stateref
-     , transformers
+     , exceptions, monad-loops, monad-peel, mstate, mtl, network, NineP
+     , regex-posix, stateref, transformers
      }:
      mkDerivation {
        pname = "Network-NineP";
-       version = "0.3.0";
-       sha256 = "02igsbmhkpkaxdpdhkl6vb7kzryhg7p5bb59irykz0dkg095wr89";
+       version = "0.4.0";
+       sha256 = "1h6p1p16wvsi6pjpz2xdvbljd394bzpqqfiah7aq9d7f7zh7hzid";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         base binary bytestring containers convertible monad-loops mstate
-         mtl network NineP regex-posix stateref transformers
+         base binary bytestring containers convertible exceptions
+         monad-loops monad-peel mstate mtl network NineP regex-posix
+         stateref transformers
        ];
        description = "High-level abstraction over 9P protocol";
        license = "unknown";
···
        license = "GPL";
      }) {};
 
+  "Southpaw" = callPackage
+    ({ mkDerivation, ALUT, base, bytestring, cairo, containers
+     , filepath, GLFW-b, gtk3, JuicyPixels, OpenAL, OpenGL, vector
+     , Win32
+     }:
+     mkDerivation {
+       pname = "Southpaw";
+       version = "0.1.0.2";
+       sha256 = "1zijb1b6ryrmq2230i1fr7iqz8iax9f2rwpy75fkggiknrd4xnpq";
+       buildDepends = [
+         ALUT base bytestring cairo containers filepath GLFW-b gtk3
+         JuicyPixels OpenAL OpenGL vector Win32
+       ];
+       jailbreak = true;
+       description = "Assorted utility modules";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "SpaceInvaders" = callPackage
     ({ mkDerivation, array, base, HGL, random, Yampa }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "active";
-       version = "0.2.0.3";
-       sha256 = "18z6gki5bjr4847r90aw89j8gkfs0w9dv1w2na4msd36i3jym3sc";
+       version = "0.2.0.4";
+       sha256 = "1xm2y8knqhd883c41194h323vchv4hx57wl32l9f64kf7gdglag0";
        buildDepends = [
          base lens linear semigroupoids semigroups vector
        ];
        testDepends = [
          base lens linear QuickCheck semigroupoids semigroups vector
        ];
-       jailbreak = true;
        description = "Abstractions for animation";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, array, base, containers, mtl, random, vector }:
      mkDerivation {
        pname = "aivika";
-       version = "4.2";
-       sha256 = "0pg1wqssqqdjd0cafimsy8ibmxfyjk16w10ibkj13a6ggzfn75j1";
+       version = "4.3";
+       sha256 = "01vcjc6i040lp92xhxma6sp3iffam9d7nxqch6i64pajvd8cq97j";
        buildDepends = [ array base containers mtl random vector ];
        homepage = "http://github.com/dsorokin/aivika";
        description = "A multi-paradigm simulation library";
···
      }:
      mkDerivation {
        pname = "aivika-experiment-cairo";
-       version = "3.1";
-       sha256 = "0b4nwzrkpxhiwph93zvyk8bi9770bsdnhxkzhbri3l0zsm9250kz";
+       version = "4.3.1";
+       sha256 = "0p54ssbl0ack51gwlj962x45954v4h22mqq6zqa5r8xrbcig2pdb";
        buildDepends = [
          aivika-experiment aivika-experiment-chart base Chart Chart-cairo
        ];
···
      }:
      mkDerivation {
        pname = "aivika-experiment-chart";
-       version = "4.2";
-       sha256 = "15aqq8mmjybi7kkrfsmablf7ymi328p9y6nsr8pc7sv144fadaf0";
+       version = "4.3.1";
+       sha256 = "18fagq4ddvqzi6r0c850yassgncicqy0plasfn262fmhgwflpa8n";
        buildDepends = [
          aivika aivika-experiment array base Chart colour containers
          data-default-class filepath lens mtl split
···
      }:
      mkDerivation {
        pname = "aivika-experiment-diagrams";
-       version = "3.1";
-       sha256 = "1vjis6184cvw7jzg8a3nvs0d0sv30d6qx598phcq9ncs3bmh9h3f";
+       version = "4.3.1";
+       sha256 = "1plb44bcjnawg3fsb9crmlyzwzyiz802ldsk559ni9sb590ywr7n";
        buildDepends = [
          aivika-experiment aivika-experiment-chart base Chart Chart-diagrams
          containers filepath
···
   "amqp" = callPackage
     ({ mkDerivation, base, binary, bytestring, clock, connection
      , containers, data-binary-ieee754, hspec, hspec-expectations
-     , monad-control, network, network-uri, split, text, vector, xml
+     , monad-control, network, network-uri, split, stm, text, vector
+     , xml
      }:
      mkDerivation {
        pname = "amqp";
-       version = "0.12.3";
-       sha256 = "17kvhn6s3grv5ygswkk0x8qclr8j4nxgv04z9q6wac9vydjsaz8m";
+       version = "0.13.0";
+       sha256 = "1qnknyk8xizq5i94s9zv7prqqcpccigc92c6jqqh82y2yqz5xnjj";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          base binary bytestring clock connection containers
-         data-binary-ieee754 monad-control network network-uri split text
-         vector xml
+         data-binary-ieee754 monad-control network network-uri split stm
+         text vector xml
        ];
        testDepends = [
          base binary bytestring clock connection containers
          data-binary-ieee754 hspec hspec-expectations network network-uri
-         split text vector
+         split stm text vector
        ];
        homepage = "https://github.com/hreinhardt/amqp";
        description = "Client library for AMQP servers (currently only RabbitMQ)";
···
      }) {};
 
   "api-builder" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
-     , Cabal, containers, either, hspec, HTTP, http-client, http-conduit
-     , http-types, text, transformers
+    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
+     , containers, hspec, HTTP, http-client, http-client-tls
+     , http-conduit, http-types, text, transformers
      }:
      mkDerivation {
        pname = "api-builder";
-       version = "0.7.4.0";
-       sha256 = "0af0ld0rlrpvbl4iw3g5n5bjij5z5jq2sbd9fqila5891qkvb30d";
+       version = "0.10.0.0";
+       sha256 = "0pzbp0grmnrc48h1cbsxsxzyjgnxzmf4d6cfi53ccq0v3yfybw9v";
        buildDepends = [
-         aeson attoparsec base bifunctors bytestring either HTTP http-client
-         http-conduit http-types text transformers
+         aeson base bifunctors bytestring HTTP http-client http-client-tls
+         http-types text transformers
        ];
        testDepends = [
          aeson base bytestring Cabal containers hspec http-conduit text
          transformers
        ];
-       jailbreak = true;
        homepage = "https://github.com/intolerable/api-builder";
        description = "Library for easily building REST API wrappers in Haskell";
        license = stdenv.lib.licenses.bsd3;
···
 
   "aur" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, filepath, lens
-     , lens-aeson, mtl, text, vector, wreq-sb
+     , lens-aeson, mtl, text, vector, wreq
      }:
      mkDerivation {
        pname = "aur";
-       version = "2.0.4";
-       sha256 = "1f6j85nz1mb9cn4l4pqv6jcx42m6rp8fj1g4xrfp8k2y9yyx7hjn";
+       version = "3.0.0";
+       sha256 = "1sf76lysp8xchym78ha4glrw11hxic5g684mm8h6w0n05x1ywxcn";
        buildDepends = [
          aeson aeson-pretty base filepath lens lens-aeson mtl text vector
-         wreq-sb
+         wreq
        ];
        homepage = "https://github.com/fosskers/haskell-aur";
        description = "Access metadata from the Arch Linux User Repository";
···
      }:
      mkDerivation {
        pname = "bake";
-       version = "0.3";
-       sha256 = "0h0byqv9m0jp5awbjcad0gggbgp66qqws6qvyfxwzk5jgwdifa0k";
+       version = "0.4";
+       sha256 = "1xxv78i2q9hiw30vkbcx09nabqv88g3a6k872ckm9wk8isrnw2zz";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "base_4_8_0_0" = callPackage
+  "base_4_8_1_0" = callPackage
     ({ mkDerivation, ghc-prim, rts }:
      mkDerivation {
        pname = "base";
-       version = "4.8.0.0";
-       sha256 = "1mf5s7niw0zmm1db7sr6kdpln8drcy77fn44h6sspima8flwcp44";
+       version = "4.8.1.0";
+       sha256 = "0rwya445hvnnzj3x5gsrmr72kr3yspd6w9mypxkrxxg19zfazjaj";
        buildDepends = [ ghc-prim rts ];
        description = "Basic libraries";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "biostockholm";
-       version = "0.3.2";
-       sha256 = "13rzlb2s3y8vp969s8z1gxmiccvpgrv4yxpim4bjbyc2yblbbnk7";
+       version = "0.3.4";
+       sha256 = "04k7cl8fjsi2mv60p2qg2nmy86z2adw9gzjnkxffqsc1q85y4lz7";
        buildDepends = [
          attoparsec attoparsec-conduit base biocore blaze-builder
          blaze-builder-conduit bytestring conduit containers deepseq
···
      mkDerivation {
        pname = "blank-canvas";
        version = "0.5";
+       revision = "1";
        sha256 = "05kfyjp9vncyzsvq018ilb8vh7fyzbc06nlx35jk3dzj6i6x5bgs";
+       editedCabalFile = "a9d9c32056144a2e5b84e96dfb3a5334aa89dc616c759e523c538a6b950d5084";
        buildDepends = [
          aeson base base64-bytestring bytestring colour containers
          data-default-class http-types kansas-comet scotty stm text
···
      }:
      mkDerivation {
        pname = "cgrep";
-       version = "6.4.16";
-       sha256 = "0mvd80gn6z8iyy8y43drjzmq479zh2zsz3swmlmgvmbvsb1kchlb";
+       version = "6.4.20";
+       sha256 = "1p0nm6gb7hvxvfkgrync1a66zl58s041pgnkly2vx91cpm6yavcm";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "chatter";
-       version = "0.5.1.0";
-       sha256 = "014palhzpphwq3q1c211xajl30afr4ac6mjcpvyzqwxdr9ia74c8";
+       version = "0.5.2.0";
+       sha256 = "01594wp13kigqvr27112fmsrgz4cny4vlprqvyygp90k8mavxw8s";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "conduit";
-       version = "1.2.4.2";
-       sha256 = "1shx58xg4lqf0dj50m2svh132xlzasgg6j175hxk8zf8k1v9b1zl";
+       version = "1.2.5";
+       sha256 = "0iia5hc3rx813aayp839ixr377ajnrhfvpbjach266bk52scs05i";
        buildDepends = [
          base exceptions lifted-base mmorph mtl resourcet transformers
          transformers-base
···
      }:
      mkDerivation {
        pname = "conduit-combinators";
-       version = "1.0.1";
-       sha256 = "014n3qhn9flwj43zjp62vagp5df9ll6nkjk1x9qpagni1vf9cbqq";
+       version = "1.0.1.1";
+       sha256 = "02x0n4yar1s3x73pbaxs6ghd5kihl3wz3svrvvm24xnmwv5j9aaz";
        buildDepends = [
          base base16-bytestring base64-bytestring bytestring chunked-data
          conduit conduit-extra filepath monad-control mono-traversable
···
      }:
      mkDerivation {
        pname = "conduit-extra";
-       version = "1.1.9";
-       sha256 = "1bs28gs0xfsqywhm8bchap9zr10wxfrlpdphflhzkm8am2bgz55i";
+       version = "1.1.9.1";
+       sha256 = "18x01yll1jfv1p9kb7529k8gdh0lav4pbqcqkam2qr9jxxdy26rz";
        buildDepends = [
          attoparsec base blaze-builder bytestring conduit directory filepath
          monad-control network primitive process resourcet stm
···
      }) {};
 
   "conf" = callPackage
-    ({ mkDerivation, base, haskell-src }:
+    ({ mkDerivation, base, haskell-src, HUnit, test-framework
+     , test-framework-hunit, test-framework-th
+     }:
      mkDerivation {
        pname = "conf";
-       version = "0.1.0.0";
-       sha256 = "15zd72l2izdiw79hldf34pymxc4d9r06db91x6p2mfv2i31wy2n2";
+       version = "0.1.1.0";
+       sha256 = "1mxrr14188ikizyxb06764qq1iwhnh19g150mz310q8yw6cypbfw";
        buildDepends = [ base haskell-src ];
+       testDepends = [
+         base HUnit test-framework test-framework-hunit test-framework-th
+       ];
        jailbreak = true;
        description = "Parser for Haskell-based configuration files";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "creatur";
-       version = "5.9.6";
-       sha256 = "0lxmsd59sa37j8bc7y6v29s8wlscqa4xz15p60jiy5ks7am61wa5";
+       version = "5.9.7";
+       sha256 = "1617whwg9f0l6ji3jmd7fcs3n650mz0jpvrw4hf97r7mqzlyfkjp";
        buildDepends = [
          array base bytestring cereal cond directory filepath gray-extended
          hdaemonize hsyslog MonadRandom mtl old-locale process random split
···
      }:
      mkDerivation {
        pname = "dash-haskell";
-       version = "1.1.0.1";
-       sha256 = "1m82zpr37jdqr06ynqz4bbnvy1s81756frcgfiyk4wvlmmcl2fyk";
+       version = "1.1.0.2";
+       sha256 = "1h22ay2cl5j2ngm2xi2hyvvprnmz48qcpzxiq9ldkzx8gg3gs36j";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "data-lens";
-       version = "2.10.6";
-       sha256 = "0pnn84m6xvqvxmqpddsi4db1w65788yrwdkpfm9z1vkkajqixaxj";
+       version = "2.10.7";
+       sha256 = "0l70jzys2qb31cyq3nci97i01ncadkhizxvc9c3psxcd2n28l69v";
        buildDepends = [
          base comonad containers semigroupoids transformers
        ];
-       jailbreak = true;
        homepage = "http://github.com/roconnor/data-lens/";
        description = "Used to be Haskell 98 Lenses";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, data-lens, template-haskell }:
      mkDerivation {
        pname = "data-lens-template";
-       version = "2.1.8";
-       sha256 = "0w8x5zn3d98z0q74bqfgkb9s0ca9hd1xc53gjl759s77wm4iwa0q";
+       version = "2.1.9";
+       sha256 = "0dpj3a1dj5l5jll2f0flj3wss9h2jbsljihrwh68zbb92pcgb56g";
        buildDepends = [ base data-lens template-haskell ];
-       jailbreak = true;
        homepage = "http://github.com/roconnor/data-lens-template/";
        description = "Utilities for Data.Lens";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "datetime" = callPackage
-    ({ mkDerivation, base, old-locale, old-time, QuickCheck, time }:
+    ({ mkDerivation, base, HUnit, old-locale, old-time, QuickCheck
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , time
+     }:
      mkDerivation {
        pname = "datetime";
-       version = "0.2.1";
-       sha256 = "1yfg3wvi13r725dhfsmcdw4ns3cgl2ayrb5jck0q8b4crk2dlrzg";
-       buildDepends = [ base old-locale old-time QuickCheck time ];
-       homepage = "http://github.com/esessoms/datetime";
-       description = "Utilities to make Data.Time.* easier to use.";
+       version = "0.3.1";
+       sha256 = "0jmxxmv5s9rch84ivfjhqxdqnvqqzvabjs152wyv47h5qmvpag1k";
+       buildDepends = [ base old-locale old-time time ];
+       testDepends = [
+         base HUnit old-locale old-time QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2 time
+       ];
+       homepage = "http://github.com/stackbuilders/datetime";
+       description = "Utilities to make Data.Time.* easier to use";
        license = "GPL";
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "debian-build";
-       version = "0.7.1.1";
-       sha256 = "0r2f14h0bpbq861jfa0rgp0y87nq142f80dyjzyzzrdwc8szj120";
+       version = "0.7.2.1";
+       sha256 = "1x3jvrz5y85m9mnp5b8b85f4magbxa4r0yhkw30vgcljph6v7mfm";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }) {};
 
   "delta" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath, sodium
-     , time
+    ({ mkDerivation, base, containers, directory, filepath
+     , optparse-applicative, process, sodium, time
      }:
      mkDerivation {
        pname = "delta";
-       version = "0.1.2.0";
-       revision = "1";
-       sha256 = "1yk4cb21n4kq0wvsw6lw8s8sc69gnmzfdn9f5zgwsknza0vayi39";
-       editedCabalFile = "5f7c4ae62f0d0758b892ac7002bc31eebfc4e4dcbe1ff141f0135daf5788e6e9";
+       version = "0.2.1.1";
+       sha256 = "06msfi733jmqqgxyx5p4mifjgxrgh0x8ls4j0fkcan5377sydjcv";
        isLibrary = true;
        isExecutable = true;
-       buildDepends = [ base containers directory filepath sodium time ];
+       buildDepends = [
+         base containers directory filepath optparse-applicative process
+         sodium time
+       ];
        homepage = "https://github.com/kryoxide/delta";
        description = "A library for detecting file changes";
        license = stdenv.lib.licenses.gpl3;
···
      }:
      mkDerivation {
        pname = "diagrams-builder";
-       version = "0.7.1";
-       sha256 = "1cfmklds0l2jyn7p2hldq0riq4m01dxfg9cran6sx65a7d82x96d";
+       version = "0.7.1.1";
+       sha256 = "1klmmh144bdwrg3zs45l6yy1li64r60jygqspxzyzlm8pfgzvgah";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          lucid-svg mtl split transformers
        ];
        configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams";
        description = "hint-based build service for the diagrams graphics EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-cairo";
-       version = "1.3.0.2";
-       sha256 = "1ja089hnq24fx5sd5r3r2z76pmwk5w6j93b7hha7m4jylcdjcnpp";
+       version = "1.3.0.3";
+       sha256 = "0962kz1b45hycjij90yxq88wa5qsdll82h16agzf0pm16j8r4v5s";
        buildDepends = [
          base bytestring cairo colour containers data-default-class
          diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl
          optparse-applicative pango split statestack transformers unix
          vector
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams";
        description = "Cairo backend for diagrams drawing EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-canvas";
-       version = "1.3.0.1";
-       sha256 = "0ik2kfgs5fi1a51hn9g5sii0n4j9lb0xd9paydz342b7zizy0w70";
+       version = "1.3.0.2";
+       sha256 = "1jklgvkmdhg5ari577jh5y7vr54wjdwyz2hql1n1icbfba5d6p0c";
        buildDepends = [
          base blank-canvas cmdargs containers data-default-class
          diagrams-core diagrams-lib lens mtl NumInstances
          optparse-applicative statestack text
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "HTML5 canvas backend for diagrams drawing EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-contrib";
-       version = "1.3.0.3";
-       sha256 = "0sl99ikghfmiwa51iyacgrma844dqn44iw7c9ahx70r4l8j8is2q";
+       version = "1.3.0.4";
+       sha256 = "0mr4m4kl028jxrjldn38kq7zsph6vqwzdjhxd0rznzbwpsnvsnkf";
        buildDepends = [
          base circle-packing colour containers data-default
          data-default-class diagrams-core diagrams-lib diagrams-solve
···
          base containers diagrams-lib HUnit QuickCheck test-framework
          test-framework-hunit test-framework-quickcheck2
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "Collection of user contributions to diagrams EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-core";
-       version = "1.3.0.1";
-       sha256 = "1whig632hx03ysiqidaxf29r67xl2skw0pkx454s036gdwl7sqj2";
+       version = "1.3.0.2";
+       sha256 = "0lrzphpia24dk1mxv33c9f5iy18r5d0lfsw92422nhbs36dslyzm";
        buildDepends = [
          adjunctions base containers distributive dual-tree lens linear
          monoid-extras mtl semigroups unordered-containers
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams";
        description = "Core libraries for diagrams EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-haddock";
-       version = "0.3.0.5";
-       sha256 = "00118bnxkgfg4s4h825bl9v1mdb8cfv27l6licmx8z0dch3all9k";
+       version = "0.3.0.6";
+       sha256 = "0pa83kd1b1fnj9plwmz8gsi2nm35ghdsxdxi4w4f7shsgc64nhrj";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          base containers haskell-src-exts lens parsec QuickCheck tasty
          tasty-quickcheck
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "Preprocessor for embedding diagrams in Haddock documentation";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-html5";
-       version = "1.3.0.1";
-       sha256 = "1b6qrhqangdd2j3hzgslkq2sgk9wgk9ll9znfcmxpzc9k04aanqc";
+       version = "1.3.0.2";
+       sha256 = "18ifqv5xkk9cd86d3mir1qka2jy35vj4hqycq44z96hhp50yl29j";
        buildDepends = [
          base cmdargs containers data-default-class diagrams-core
          diagrams-lib lens mtl NumInstances optparse-applicative split
          statestack static-canvas text
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "HTML5 canvas backend for diagrams drawing EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-lib";
-       version = "1.3.0.1";
-       sha256 = "04s21ms9w521fhm7hralq155lwisjv1pszz4cvpl3hc1jm1vwfa3";
+       version = "1.3.0.2";
+       sha256 = "1gvvyzpzzdwzvrh452l6r2709qpbdzx1fi1ysvzalywi3gib69ds";
        buildDepends = [
          active adjunctions array base colour containers data-default-class
          diagrams-core diagrams-solve directory distributive dual-tree
···
          process semigroups system-filepath tagged text transformers
          unordered-containers
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams";
        description = "Embedded domain-specific language for declarative graphics";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-postscript";
-       version = "1.3.0.1";
-       sha256 = "0w6ck71hjjx0rl930v2wapznjvrg5jq538gnyidp2yshik8xh2rp";
+       version = "1.3.0.2";
+       sha256 = "0cdhs5ia6jm89h1bxgqm1w9gkjqnw6g0nw13vjasj0fh08nayk7s";
        buildDepends = [
          base containers data-default-class diagrams-core diagrams-lib dlist
          filepath hashable lens monoid-extras mtl semigroups split
          statestack
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "Postscript backend for diagrams drawing EDSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-rasterific";
-       version = "1.3.1.2";
-       sha256 = "1shkwhi7yv8cmv8697z7qqax0z7brcmjqlc17hldfflzwniiyk81";
+       version = "1.3.1.3";
+       sha256 = "1gkapj3n2xyy13a819zbckslvv8k5jkdlz7x2dzhcganra9gkcki";
        buildDepends = [
          base bytestring containers data-default-class diagrams-core
          diagrams-lib filepath FontyFruity hashable JuicyPixels lens mtl
          optparse-applicative Rasterific split unix
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "Rasterific backend for diagrams";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "diagrams-svg";
-       version = "1.3.1.3";
-       sha256 = "0migb5vjlslbxlmbqxl0qdrpsi0ghbiq86rjna57g804r149n7ni";
+       version = "1.3.1.4";
+       sha256 = "009xn6q9qwgi3l4v0rm79309i91m1s0jbng34bbli29s6vzwgjmz";
        buildDepends = [
          base base64-bytestring bytestring colour containers diagrams-core
          diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
          monoid-extras mtl old-time optparse-applicative process semigroups
          split text time
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams/";
        description = "SVG backend for diagrams drawing EDSL";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "draw-poker" = callPackage
+    ({ mkDerivation, base, random-shuffle, safe }:
+     mkDerivation {
+       pname = "draw-poker";
+       version = "0.1.0.1";
+       revision = "1";
+       sha256 = "16b17qfj3bah468hqsksk2rhyl33m2vyqw0rrs1wyaz75yq35257";
+       editedCabalFile = "62a11039e0b634f0b372c28d87f6fe84f40a33981211c9f2bc077135abcef629";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [ base random-shuffle safe ];
+       testDepends = [ base ];
+       homepage = "http://tune.hateblo.jp/entry/2015/05/12/023112";
+       description = "playing draw poker";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "drawille" = callPackage
     ({ mkDerivation, base, containers, hspec, QuickCheck }:
      mkDerivation {
···
      }) {};
 
   "dtw" = callPackage
-    ({ mkDerivation, base, containers, MemoTrie, QuickCheck
-     , test-framework, test-framework-quickcheck2, thyme, vector
-     , vector-space
+    ({ mkDerivation, base, containers, QuickCheck, test-framework
+     , test-framework-quickcheck2, thyme, vector, vector-space
      }:
      mkDerivation {
        pname = "dtw";
-       version = "1.0.0.0";
-       sha256 = "0kcb773sly86lkvnb3ihsswrz432phi3ccizwbf1phzf72kdflzr";
-       buildDepends = [ base containers MemoTrie vector vector-space ];
+       version = "1.0.1.0";
+       sha256 = "15qk8r958pssgwqhxffw45vm5bpvv9wfarv9spaplrnb3sm5bzhk";
+       buildDepends = [ base containers vector vector-space ];
        testDepends = [
-         base containers MemoTrie QuickCheck test-framework
+         base containers QuickCheck test-framework
          test-framework-quickcheck2 thyme vector vector-space
        ];
        jailbreak = true;
···
        buildDepends = [ base monoid-extras newtype semigroups ];
        description = "Rose trees with cached and accumulating monoidal annotations";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "dump" = callPackage
+    ({ mkDerivation, base, haskell-src-meta, hspec
+     , interpolatedstring-perl6, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "dump";
+       version = "0.2.6";
+       sha256 = "0rhjx4g83pbm0zfqgz8ykfccaq8wa7wspjc6k1n4d1bgcwkc617y";
+       buildDepends = [
+         base haskell-src-meta interpolatedstring-perl6 template-haskell
+         text
+       ];
+       testDepends = [
+         base haskell-src-meta hspec interpolatedstring-perl6
+         template-haskell text
+       ];
+       homepage = "https://github.com/Wizek/dump";
+       description = "Dumps the names and values of expressions to ease debugging";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "duplo" = callPackage
···
      }:
      mkDerivation {
        pname = "dynamic-pp";
-       version = "0.1.0";
-       sha256 = "1i01k8c75yxdmxz3db4kajpqbgl8lcbfsp9rb9q2kzbk44fc2zpc";
+       version = "0.2.0";
+       sha256 = "03y9sl3xcnp1ixi4y0i1a7frd2bgfvnb0r4pqjs38bvjkz96bbdd";
        buildDepends = [
          ansi-terminal base blaze-builder bytestring Cabal hashable
          unordered-containers utf8-string
···
      }) { eibclient = null;};
 
   "eigen" = callPackage
-    ({ mkDerivation, base, bytestring, primitive, vector }:
+    ({ mkDerivation, base, binary, bytestring, mtl, primitive
+     , transformers, vector
+     }:
      mkDerivation {
        pname = "eigen";
-       version = "2.1.0";
-       sha256 = "14amg4g7gxsi529hz5ilhv8b8nzs8p2ypmxh21hq5x4sfnsl4n07";
-       buildDepends = [ base bytestring primitive vector ];
-       testDepends = [ base primitive vector ];
-       jailbreak = true;
+       version = "2.1.6";
+       sha256 = "0287j907pasjb7w7bwr6snb4qic7j14msxhps445yjfkqa2arzfz";
+       buildDepends = [
+         base binary bytestring primitive transformers vector
+       ];
+       testDepends = [
+         base binary bytestring mtl primitive transformers vector
+       ];
        homepage = "https://github.com/osidorkin/haskell-eigen";
-       description = "Eigen C++ library (linear algebra: matrices, vectors, numerical solvers)";
+       description = "Eigen C++ library (linear algebra: matrices, sparse matrices, vectors, numerical solvers)";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
 
   "elm-init" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
-     , directory, file-embed, filepath, text
+     , directory, file-embed, filepath, text, time
      }:
      mkDerivation {
        pname = "elm-init";
-       version = "0.1.2.1";
-       sha256 = "0x5p5jwxz07m515421xpcw777lgc3bx40mnl0y9fdw2gz4f3svs2";
+       version = "1.0.1.0";
+       sha256 = "0jvdln18dhsxly33ysy1vv1740ri1576x44jn10gjva432rp8rwx";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
          aeson aeson-pretty base bytestring containers directory file-embed
-         filepath text
+         filepath text time
        ];
        description = "Set up basic structure for an elm project";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "engine-io-wai" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, engine-io
+     , http-types, mtl, text, transformers, unordered-containers, wai
+     , wai-websockets, websockets
+     }:
+     mkDerivation {
+       pname = "engine-io-wai";
+       version = "1.0.1";
+       sha256 = "0cr53x8bxfmrx97v7jsb7gw3hqb94zp9xvvnl16080zmqm0gi2rh";
+       buildDepends = [
+         attoparsec base bytestring engine-io http-types mtl text
+         transformers unordered-containers wai wai-websockets websockets
+       ];
+       homepage = "http://github.com/ocharles/engine.io";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "engine-io-yesod" = callPackage
     ({ mkDerivation, base, bytestring, conduit, conduit-extra
      , engine-io, http-types, text, unordered-containers, wai
···
     ({ mkDerivation, base, exceptions, mtl }:
      mkDerivation {
        pname = "eprocess";
-       version = "1.7.0";
-       sha256 = "1h4ajq1rraiz7qw7350128n26jnqhzk9iyjzqc3lnbyx87q8j73v";
+       version = "1.7.2";
+       sha256 = "190qgsqj41dbkphjrgljif7q0zjm9ddp8wawc9wx8qklb897jrvj";
        buildDepends = [ base exceptions mtl ];
-       jailbreak = true;
-       description = "*Very* basic Erlang-like process support for Haskell";
+       description = "Basic Erlang-like process support for Haskell";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
      }) {};
 
   "exceptional" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation, base, exceptions }:
      mkDerivation {
        pname = "exceptional";
-       version = "0.1.5.1";
-       revision = "1";
-       sha256 = "1fkz90d776z8fj8p3123ssqwxy9nmz4bgh9gn4nvg0xnvwzc069c";
-       editedCabalFile = "a79514b512d8776f9ae66a80aeb3f604ac9ae1d4c5c98fdd9ea2acc8c312adda";
-       buildDepends = [ base ];
-       homepage = "https://github.com/pharpend/exceptional";
+       version = "0.3.0.0";
+       sha256 = "01lzx4ihdvyivjnkvn78hcdsk83dvm6iy9v5q1f28kd1iv96x1ns";
+       buildDepends = [ base exceptions ];
+       homepage = "https://github.com/";
        description = "Essentially the Maybe type with error messages";
        license = stdenv.lib.licenses.bsd2;
      }) {};
···
      }:
      mkDerivation {
        pname = "extra";
-       version = "1.3";
-       sha256 = "12n67ibj6zk7r8hzk0vn6ijfr926h0g6jkwn5krkp79xzdq82apr";
+       version = "1.4";
+       sha256 = "1cp9vsqgjc46v1i8w8lhakdk1qj6q2bd0y365qj0madpjj7q1qi8";
        buildDepends = [ base directory filepath process time unix ];
        testDepends = [ base directory filepath QuickCheck time unix ];
        homepage = "https://github.com/ndmitchell/extra#readme";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fast-builder" = callPackage
+    ({ mkDerivation, base, bytestring, ghc-prim, process, QuickCheck
+     , stm
+     }:
+     mkDerivation {
+       pname = "fast-builder";
+       version = "0.0.0.0";
+       sha256 = "1ga28vxsv4hk8491jv51jd8xqvafss56kkm97x2ma4naqx4v6snw";
+       buildDepends = [ base bytestring ghc-prim ];
+       testDepends = [ base bytestring process QuickCheck stm ];
+       homepage = "http://github.com/takano-akio/fast-builder";
+       description = "Fast ByteString Builder";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "fast-logger" = callPackage
     ({ mkDerivation, array, auto-update, base, bytestring
      , bytestring-builder, directory, filepath, hspec, text
···
      }:
      mkDerivation {
        pname = "fay";
-       version = "0.23.1.7";
-       sha256 = "1yjpbbxxjz8hrqb3arcn74i9s936kr44zg2v27kxmhrin4lnrw4b";
+       version = "0.23.1.8";
+       sha256 = "1772gdqka5hcgs2bq76bba9pca5xx32q3fg9vvkjqd5249rk5gv6";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }) { inherit (pkgs) fftw;};
 
   "fgl" = callPackage
-    ({ mkDerivation, array, base, containers, mtl }:
+    ({ mkDerivation, array, base, containers, deepseq, hspec
+     , QuickCheck, transformers
+     }:
      mkDerivation {
        pname = "fgl";
-       version = "5.5.1.0";
-       sha256 = "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga";
-       buildDepends = [ array base containers mtl ];
+       version = "5.5.2.0";
+       sha256 = "1r9vkv5v32nyqghr4fq3ijrdl2sr9bncfpj3zix53h5m2zyn7kg3";
+       buildDepends = [ array base containers deepseq transformers ];
+       testDepends = [ base containers hspec QuickCheck ];
        description = "Martin Erwig's Functional Graph Library";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, containers, fgl, hspec, QuickCheck }:
      mkDerivation {
        pname = "fgl-arbitrary";
-       version = "0.1.0.0";
-       sha256 = "0npgwg2lgi8rr3wm40q4a9srpnih3mzy1add2aazc4ahr32dfzm1";
-       buildDepends = [ base containers fgl QuickCheck ];
+       version = "0.2.0.0";
+       sha256 = "1116c4r1ick3xjhwwq9b6i1082njmxj2aymgkqppabj3d0hv43c4";
+       buildDepends = [ base fgl QuickCheck ];
        testDepends = [ base containers fgl hspec QuickCheck ];
        description = "QuickCheck support for fgl";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "foldl";
-       version = "1.1.0";
-       sha256 = "184arkpffi2z7dayplc47nvyabzr5sig4zs8hc4lilcklv4q9zn6";
+       version = "1.1.1";
+       sha256 = "01zqlb3hh5jsq49ax08nkwvysqq4fgkxpz4sdcman9y9fnxgwjgg";
        buildDepends = [
          base bytestring containers mwc-random primitive profunctors text
          transformers vector
···
      }:
      mkDerivation {
        pname = "force-layout";
-       version = "0.4.0.1";
-       sha256 = "1qchmhn6hp91gzds6yqjn4kssp7n3g7vqhl919wf8d3nn4ykz3av";
+       version = "0.4.0.2";
+       sha256 = "0lncciqizp55if5ivlcbv5lqj21hlp2vfi40iagjswf2apxi0w0g";
        buildDepends = [ base containers data-default-class lens linear ];
-       jailbreak = true;
        description = "Simple force-directed layout";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "fwgl";
-       version = "0.1.1.0";
-       sha256 = "07ml9f8x4rw7wg6wib63nayh8mpszrkx0zal9zz0cpjh2f85n10a";
+       version = "0.1.2.0";
+       revision = "1";
+       sha256 = "1b18xzxbbrnmmvjgmzhy5r4ww7rvbli76m7vh3li30fb95k1sznr";
+       editedCabalFile = "d97edefc7ee59578d181dfc36d85b1a82a6e0c9ed1bb602918655a3439a5eb51";
        buildDepends = [
          base hashable transformers unordered-containers vector Yampa
        ];
        jailbreak = true;
-       homepage = "https://github.com/ZioCrocifisso/FWGL";
+       homepage = "https://github.com/ziocroc/FWGL";
        description = "FRP 2D/3D game engine";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "fwgl-glfw";
-       version = "0.1.0.3";
+       version = "0.1.0.4";
        revision = "1";
-       sha256 = "1zmvw7945lkghavik72w096rqh8ivjyb9h6j98yjvlj6xf85bsq0";
-       editedCabalFile = "f2a35fcd71bbea225624cf3b6d1f78647e103a1ee1edcc0a7eb9e27b0c4642d8";
+       sha256 = "1pph1arlmi905rkcjcn3yf5ypdmk82363vgdmwg26dbrb2sb4cs8";
+       editedCabalFile = "26e4026f5ac7fe57292c5df79d35894b736728c31cad845f11641d833f789fb8";
        buildDepends = [
          base fwgl gl GLFW-b hashable JuicyPixels transformers
          unordered-containers vector Yampa
        ];
        jailbreak = true;
-       homepage = "https://github.com/ZioCrocifisso/FWGL";
+       homepage = "https://github.com/ziocroc/FWGL";
        description = "FWGL GLFW backend";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "fwgl-javascript";
-       version = "0.1.0.2";
-       sha256 = "1vgc3dqm0pqac8l17w0fi4xv2rx2bik6n405qzarjnjlyp7czqcm";
+       version = "0.1.0.4";
+       sha256 = "1bwg6dzp2kgny5s6zygdi120pcrdclql22rgp43vhwim5aqkp9d7";
        buildDepends = [
          base fwgl ghcjs-base hashable unordered-containers Yampa
        ];
        jailbreak = true;
-       homepage = "https://github.com/ZioCrocifisso/FWGL";
+       homepage = "https://github.com/ziocroc/FWGL";
        description = "FWGL GHCJS backend";
        license = stdenv.lib.licenses.bsd3;
        broken = true;
···
      }:
      mkDerivation {
        pname = "generic-accessors";
-       version = "0.4.0";
-       sha256 = "0wpv9i80lai771fws5yg5ri05iskbq2vgar66f72xqwvz3nm44i7";
+       version = "0.4.1";
+       sha256 = "1qhik496296v42pjmlxxlimnw4z9p451ndc2fjvrid4g0knfzvg0";
        buildDepends = [ base linear spatial-math ];
        testDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
···
      }) {};
 
   "ghc-exactprint" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath, free, ghc
-     , ghc-paths, ghc-syb-utils, HUnit, mtl, random, stm, syb
+    ({ mkDerivation, base, containers, directory, filemanip, filepath
+     , free, ghc, ghc-paths, HUnit, mtl, random, silently, syb
      }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "0.2";
-       sha256 = "1sqk6y6b1scn51kjbvdnazw34bkwmfii5dhb1fzwzx4cb4iqg3ik";
+       version = "0.3";
+       sha256 = "0wgqlll95fbxnni1dzlyiyb4d7lqp3hrfw9xh5hqsnqm45smi7j1";
+       isLibrary = true;
+       isExecutable = true;
        buildDepends = [
-         base containers directory filepath free ghc ghc-paths ghc-syb-utils
-         mtl syb
+         base containers directory filepath free ghc ghc-paths mtl syb
        ];
        testDepends = [
-         base containers directory filepath ghc ghc-paths ghc-syb-utils
-         HUnit mtl random stm syb
+         base containers directory filemanip filepath ghc ghc-paths HUnit
+         mtl random silently syb
        ];
        description = "ExactPrint for GHC";
        license = stdenv.lib.licenses.bsd3;
···
          gitlib gitlib-libgit2 scientific shake split tagged text
          unordered-containers vector yaml
        ];
+       jailbreak = true;
        homepage = "https://github.com/nomeata/gipeda";
        description = "Git Performance Dashboard";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, hierarchical-clustering }:
      mkDerivation {
        pname = "gsc-weighting";
-       version = "0.2";
-       sha256 = "1mdm0n96gy00wf7lv6c0qxk9bi1ahf58vzrgnh3jfiwhzjivcvlj";
+       version = "0.2.2";
+       sha256 = "0y80j5qk601c965assl8d91k9bpvzijn2z0w64n2ksij9lm6b8p5";
        buildDepends = [ base hierarchical-clustering ];
        description = "Generic implementation of Gerstein/Sonnhammer/Chothia weighting";
        license = stdenv.lib.licenses.bsd3;
···
 
   "gtk-mac-integration" = callPackage
     ({ mkDerivation, array, base, containers, glib, gtk
-     , gtk-mac-integration, gtk2hs-buildtools, mtl
+     , gtk-mac-integration-gtk2, gtk2hs-buildtools, mtl
      }:
      mkDerivation {
        pname = "gtk-mac-integration";
-       version = "0.3.0.2";
-       sha256 = "05pihi7fc413j8iwwrdb7p1ckxsjzd8cvayk76hhwnqcyykvjlr5";
+       version = "0.3.1.1";
+       sha256 = "02s5ksr8fkqlbwlq468v93w0is1xa73wswgxahyyvhh51wnqp3ax";
        buildDepends = [ array base containers glib gtk mtl ];
        buildTools = [ gtk2hs-buildtools ];
-       pkgconfigDepends = [ gtk-mac-integration ];
+       pkgconfigDepends = [ gtk-mac-integration-gtk2 ];
        homepage = "http://www.haskell.org/gtk2hs/";
        description = "Bindings for the Gtk/OS X integration library";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
-     }) { gtk-mac-integration = null;};
+     }) { gtk-mac-integration-gtk2 = null;};
 
   "gtk-serialized-event" = callPackage
     ({ mkDerivation, array, base, containers, glib, gtk, haskell98, mtl
···
      }:
      mkDerivation {
        pname = "gtk3-mac-integration";
-       version = "0.3.0.3";
-       sha256 = "1jzkx10mmmxxv1ys9ywr2sfpy0pxvy8276pbkh0xnypxsyd2sfdn";
+       version = "0.3.1.1";
+       sha256 = "0j6fpzk1gq1y15cjpkq3k1azkn7xvlqiidn3m0g9czz5iy303adv";
        buildDepends = [ array base containers glib gtk3 mtl ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ gtk-mac-integration-gtk3 ];
···
      }:
      mkDerivation {
        pname = "haddock";
-       version = "2.16.0";
-       sha256 = "1afb96w1vv3gmvha2f1h3p8zywpdk8dfk6bgnsa307ydzsmsc3qa";
+       version = "2.16.1";
+       sha256 = "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [ base haddock-api ];
···
      }:
      mkDerivation {
        pname = "haddock-api";
-       version = "2.16.0";
-       sha256 = "0hk42w6fbr6xp8xcpjv00bhi9r75iig5kp34vxbxdd7k5fqxr1hj";
+       version = "2.16.1";
+       sha256 = "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2";
        buildDepends = [
          array base bytestring Cabal containers deepseq directory filepath
          ghc ghc-paths haddock-library xhtml
···
      }:
      mkDerivation {
        pname = "haddock-library";
-       version = "1.2.0";
-       revision = "1";
-       sha256 = "0kf8qihkxv86phaznb3liq6qhjs53g3iq0zkvz5wkvliqas4ha56";
-       editedCabalFile = "39bebb4a575c547378a245ee6028135602cbb73e5adbb4f7743449e5717517da";
+       version = "1.2.1";
+       sha256 = "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g";
        buildDepends = [ base bytestring deepseq transformers ];
        testDepends = [
          base base-compat bytestring deepseq hspec QuickCheck transformers
···
      }:
      mkDerivation {
        pname = "hailgun";
-       version = "0.4.0.1";
-       sha256 = "1jwk8rip8d96ivkv2k3dzmppid8dyvkrhgkjrxawgvwjzavfwwfn";
+       version = "0.4.0.3";
+       sha256 = "1c4fd116xhkw0hknzfyxyw7v62wjixcdbdidx804rs8g8f3c5p1c";
        buildDepends = [
          aeson base bytestring email-validate exceptions filepath
          http-client http-client-tls http-types tagsoup text time
···
      }:
      mkDerivation {
        pname = "hakyll-agda";
-       version = "0.1.9";
-       sha256 = "1fh0901r140p3lvw54q8d6x17zhbvpik5bsx2hifa8q2g5bnxnxd";
+       version = "0.1.10";
+       sha256 = "1621l7pw2rcyalp17dcjp1bk650rs8w1i3swnwrzr9wwi6nrx7qb";
        buildDepends = [
          Agda base containers directory filepath hakyll mtl pandoc
          transformers xhtml
···
      }:
      mkDerivation {
        pname = "halma";
-       version = "0.2.0.0";
-       sha256 = "053r1npyq7f07d29bryrr0vwx4kpm3m1bdjkwr77znimshcvy9b3";
+       version = "0.2.0.1";
+       sha256 = "04b0djijhmgwr79hkprikqxdzfxabavrvkwmb1pv9qybsa82j6sc";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          base containers grid HUnit QuickCheck test-framework
          test-framework-hunit test-framework-quickcheck2
        ];
-       jailbreak = true;
        homepage = "https://github.com/timjb/halma";
        description = "Library implementing Halma rules";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "harp";
-       version = "0.4";
-       sha256 = "0fk3prqai1ynm5wdfsn9f700i9r499jc2z9fbsgy81k1rci2mrxh";
+       version = "0.4.1";
+       sha256 = "0q9q3rw9yqkryjf5vvm41ckycqjfaxnsrmc1p0kmdrlb4f4dgclz";
        buildDepends = [ base ];
-       homepage = "http://www.cs.chalmers.se/~d00nibro/harp/";
+       homepage = "https://github.com/seereason/harp";
        description = "HaRP allows pattern-matching with regular expressions";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, process }:
      mkDerivation {
        pname = "haskell-coffee";
-       version = "0.1.0.1";
-       sha256 = "0g95vhqga7hq6w6x993d29wpphcqidmm0vzni93blqka7yfc7ybb";
+       version = "0.1.0.2";
+       sha256 = "1iz94kyq1xn3v89aay282qglv2sh41b04p8vaygwm22v1g4b4kk7";
        buildDepends = [ base process ];
-       jailbreak = true;
        description = "Simple CoffeeScript API";
        license = stdenv.lib.licenses.gpl3;
      }) {};
···
      }:
      mkDerivation {
        pname = "haskell-neo4j-client";
-       version = "0.3.1.2";
-       sha256 = "1qb2m6bxpw24ll1r0hyicmddn9plm55ipdgbykd6yrw1cfrm9qz7";
+       version = "0.3.1.4";
+       sha256 = "171ar3vfhgijy79p0a4wqm0b8bisgqf8iqzm17yb5pwirlfm5hi6";
        buildDepends = [
          aeson base bytestring containers data-default hashable HTTP
          http-conduit http-types lifted-base mtl network-uri resourcet
···
          test-framework-quickcheck2 test-framework-th text transformers
          transformers-base transformers-compat unordered-containers vector
        ];
-       jailbreak = true;
        homepage = "https://github.com/asilvestre/haskell-neo4j-rest-client";
        description = "A Haskell neo4j client";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "haxr";
-       version = "3000.11.1";
-       sha256 = "07rz03n0v9nflzid0vx5qh5hc7fmlq9c9kkk35slljv7lwmxw0qh";
+       version = "3000.11.1.1";
+       sha256 = "0a4ad0h45a6jv1x19ss0p6krhq040164cvvaivf0zba5q4ifmffh";
        buildDepends = [
          array base base-compat base64-bytestring blaze-builder bytestring
          HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
···
      }:
      mkDerivation {
        pname = "hedis";
-       version = "0.6.8";
-       sha256 = "0n6x7dbdbfrxn3y6q9vp7x6vqgdc9nb3w85xjmim7agdf088zzh6";
+       version = "0.6.9";
+       sha256 = "0yciwxsnqc8d09356fisfb44nbzsnvi01aad86gbx4vhrdnw7n7a";
        buildDepends = [
          attoparsec base BoundedChan bytestring bytestring-lexing mtl
          network resource-pool time vector
···
      mkDerivation {
        pname = "heist";
        version = "0.14.1.1";
+       revision = "1";
        sha256 = "0hwf8d20lw4gn5mal8iqd62npr2859541h3md451hjlbwpjyqd19";
+       editedCabalFile = "51f2aa86d7582ba504e26ead511da54db5350cf4bed7f13252c678c0cf19d400";
        buildDepends = [
          aeson attoparsec base blaze-builder blaze-html bytestring
          containers directory directory-tree dlist either filepath hashable
          map-syntax MonadCatchIO-transformers mtl process random text time
          transformers unordered-containers vector xmlhtml
        ];
-       jailbreak = true;
        homepage = "http://snapframework.com/";
        description = "An Haskell template system supporting both HTML5 and XML";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, bytestring, case-insensitive, configurator
      , containers, directory, errors, exceptions, filemanip, filepath
      , HandsomeSoup, hspec, HTTP, http-types, hxt, iso8601-time
-     , MissingH, mtl, multipart, old-locale, random, silently, stm, tar
-     , temporary, text, time, transformers, unix, unordered-containers
-     , utf8-string, wai, warp
+     , MissingH, mtl, multipart, old-locale, optparse-applicative
+     , random, silently, stm, tar, temporary, text, time, transformers
+     , unix, unordered-containers, utf8-string, wai, warp
      }:
      mkDerivation {
        pname = "heyefi";
-       version = "0.1.0.2";
-       sha256 = "0zjhdhigkfh3wrhwynpcqimasifs3qxkv8x2w7bl1ly8amlz7hf4";
+       version = "0.1.1.0";
+       sha256 = "13m66ix0kmvqwgvqh56mjdwgwpjjqi67hyr6giwhs63fr3wxw3f3";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
          base bytestring case-insensitive configurator directory errors
          exceptions filemanip filepath HandsomeSoup HTTP http-types hxt
-         iso8601-time MissingH mtl multipart old-locale random stm tar
-         temporary text time transformers unix unordered-containers
-         utf8-string wai warp
+         iso8601-time MissingH mtl multipart old-locale optparse-applicative
+         random stm tar temporary text time transformers unix
+         unordered-containers utf8-string wai warp
        ];
        testDepends = [
          base bytestring case-insensitive configurator containers directory
          errors exceptions filemanip filepath HandsomeSoup hspec HTTP
          http-types hxt iso8601-time MissingH mtl multipart old-locale
-         random silently stm tar temporary text time transformers unix
-         unordered-containers utf8-string wai warp
+         optparse-applicative random silently stm tar temporary text time
+         transformers unix unordered-containers utf8-string wai warp
        ];
        homepage = "https://github.com/ryantm/heyefi";
        description = "A server for Eye-Fi SD cards";
···
      }:
      mkDerivation {
        pname = "hierarchical-clustering";
-       version = "0.4.4";
-       sha256 = "1hm47fccji8dn70477ww7s6846mxrmgr5n056c11dh9azz5jl5x2";
+       version = "0.4.6";
+       sha256 = "1cfcrnxqczqzqgpyipsw9dwfw1j75zd11vpd12i533f3p44pzwbm";
        buildDepends = [ array base containers ];
        testDepends = [ base hspec HUnit QuickCheck ];
        description = "Fast algorithms for single, average/UPGMA and complete linkage clustering";
···
      }:
      mkDerivation {
        pname = "hierarchical-clustering-diagrams";
-       version = "0.3";
-       sha256 = "0yq3sh6xn3p1jzp3w33zv1sx7yhv9v2ddcqd27cl3rm6lhph81jc";
+       version = "0.3.2";
+       sha256 = "06ncyzhql74ni746a9hzma1v0grw99vas4xglmyvgd6yhdwl08sr";
        buildDepends = [ base diagrams-lib hierarchical-clustering ];
        testDepends = [
          base diagrams-cairo diagrams-lib hierarchical-clustering hspec
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "highjson" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers, hashable
+     , hspec, hvect, scientific, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "highjson";
+       version = "0.1.0.0";
+       sha256 = "1j0gcbgawimzr8vvglikmdr8q58zvvak68k8221ljydppanc30k0";
+       buildDepends = [
+         attoparsec base bytestring containers hashable hvect scientific
+         text unordered-containers vector
+       ];
+       testDepends = [ base hspec text ];
+       homepage = "https://github.com/agrafix/highjson";
+       description = "Very fast JSON parsing";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "highlight-versions" = callPackage
     ({ mkDerivation, ansi-terminal, base, Cabal, containers, hackage-db
      }:
···
      }:
      mkDerivation {
        pname = "hint-server";
-       version = "1.4.0";
-       sha256 = "0iirk76n9j4iwll44gs4spnssv2kkxrw4ypp228gap5h4pyimvx5";
+       version = "1.4.2";
+       sha256 = "1rv6b0vlqs855m3bv047pvdkycmx2mv049cnp9iw8b97d0fsfyf5";
        buildDepends = [ base eprocess exceptions hint monad-loops mtl ];
-       jailbreak = true;
        description = "A server process that runs hint";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "hnix";
-       version = "0.2.0";
-       revision = "1";
-       sha256 = "02aygnc0hhg3gsj9z323pq6i6v9ijjj5r6i8g1zx1cnwd51dw1aj";
-       editedCabalFile = "8267f50b3b3fc9736bb1e942fbe425a1a4ef2b96a6b906dff18496ce1e0578d6";
+       version = "0.2.1";
+       sha256 = "1y10w6ylgrdgy271a372f14rqdkvzlmpkjl08d5zg3r84jxhy6ia";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
     ({ mkDerivation, base, deepseq, HUnit, mtl, parallel, random }:
      mkDerivation {
        pname = "hs-carbon";
-       version = "0.1.0.0";
-       sha256 = "0i6jzqqlayxi1aqkrsdlb9kbj6ysj2qxr0rbmdw66zr5hinm345v";
+       version = "0.1.1.0";
+       sha256 = "0frip4q5vxvdkc4f8bigpp066i53f4786cj2znyq21h65zndaq53";
        buildDepends = [ base deepseq mtl parallel random ];
        testDepends = [ base HUnit ];
        description = "A Haskell framework for parallel monte carlo simulations";
···
 
   "hsdev" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
-     , bytestring, Cabal, containers, deepseq, directory, exceptions
-     , filepath, ghc, ghc-mod, ghc-paths, haddock-api, haskell-src-exts
-     , hdocs, HTTP, lens, monad-loops, mtl, network, process
-     , regex-pcre-builtin, scientific, template-haskell, text, time
-     , transformers, uniplate, unix, unordered-containers, vector
+     , bin-package-db, bytestring, Cabal, containers, deepseq, directory
+     , exceptions, filepath, fsnotify, ghc, ghc-mod, ghc-paths
+     , haddock-api, haskell-src-exts, hdocs, hlint, HTTP, lens
+     , monad-loops, MonadCatchIO-transformers, mtl, network, process
+     , regex-pcre-builtin, scientific, simple-log, system-filepath
+     , template-haskell, text, time, transformers, uniplate, unix
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "hsdev";
-       version = "0.1.3.4";
-       sha256 = "1m21wwl93sba113qr733a9qpxc0ljrn6mpd17760gzxpa5vhfjqd";
+       version = "0.1.4.0";
+       sha256 = "1m7pfrzi23wq7b3bwp4fc885di96gkg453q8xmlwdip37mh2swgz";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         aeson aeson-pretty array attoparsec base bytestring Cabal
-         containers deepseq directory exceptions filepath ghc ghc-mod
-         ghc-paths haddock-api haskell-src-exts hdocs HTTP lens monad-loops
-         mtl network process regex-pcre-builtin scientific template-haskell
-         text time transformers uniplate unix unordered-containers vector
+         aeson aeson-pretty array attoparsec base bin-package-db bytestring
+         Cabal containers deepseq directory exceptions filepath fsnotify ghc
+         ghc-mod ghc-paths haddock-api haskell-src-exts hdocs hlint HTTP
+         lens monad-loops MonadCatchIO-transformers mtl network process
+         regex-pcre-builtin scientific simple-log system-filepath
+         template-haskell text time transformers uniplate unix
+         unordered-containers vector
        ];
        testDepends = [ base ];
+       jailbreak = true;
        homepage = "https://github.com/mvoidex/hsdev";
        description = "Haskell development library and tool with support of autocompletion, symbol info, go to declaration, find references etc";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "html-tokenizer";
-       version = "0.3.0.2";
-       sha256 = "1cd332xv2acx626hkiaakng1fwwkg9m2mg7p6jj1zzb981r6xh6y";
+       version = "0.3.0.3";
+       sha256 = "0xdjjmpp1wh17cb4lnziglwhv7frr0y5v216s5ycy9lkby9r9fyv";
        buildDepends = [
          attoparsec base-prelude case-insensitive conversion
          conversion-case-insensitive conversion-text text
···
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.4.16";
-       sha256 = "1ghz498h3c0n1wfkxgkh9zd8l6yik650505hihnayp4wcykc1p82";
+       version = "0.4.18";
+       sha256 = "0skla9kvlak482fsk21gz57jcwc568x3q62nkanxjn1pgxc1jili";
        buildDepends = [
          array base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie data-default-class deepseq
···
      }:
      mkDerivation {
        pname = "http-conduit";
-       version = "2.1.5.1";
-       sha256 = "1rpp830319hqqazf1gh28jh239a67qksmx2ki3p91h9nsa8lh6w2";
+       version = "2.1.7.1";
+       sha256 = "15caswd172i8hzwmxsd3rynnfz96v5iqg9avv1ybydikvvgbqx56";
        buildDepends = [
          base bytestring conduit http-client http-client-tls http-types
          lifted-base monad-control mtl resourcet transformers
···
     ({ mkDerivation, base, HTF }:
      mkDerivation {
        pname = "hvect";
-       version = "0.1.0.0";
-       sha256 = "12zwrzz0bk83i42q3iv5cs2dma2a80s8zkjyill0ysxyrjni25wy";
+       version = "0.2.0.0";
+       sha256 = "01iarjnwm5syhmf6552g3p9dc05nqc74r4nfmagajgv7fnlsf3ri";
        buildDepends = [ base ];
        testDepends = [ base HTF ];
        homepage = "https://github.com/agrafix/hvect";
-       description = "Simple heterogeneous lists";
+       description = "Simple strict heterogeneous lists";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      mkDerivation {
        pname = "ib-api";
        version = "0.1.0.0";
+       revision = "1";
        sha256 = "1030bj90myx5x3y297qmlmnzppfnh5d3cmwglqj1s7i6nyrh86k5";
+       editedCabalFile = "7cb1fe96767e6253ef55d4997404eb3f4048f1b9bfccfb9e6cca627a734c3bcd";
        buildDepends = [ attoparsec base bytestring network ];
        jailbreak = true;
        homepage = "https://github.com/rbermani/ib-api";
···
      }:
      mkDerivation {
        pname = "inflections";
-       version = "0.1.0.10";
-       sha256 = "0v9iz9q4f5cx2hr0afvbzy5ax71kx1klbjrla14bqdfh55hzdhrp";
+       version = "0.2.0.0";
+       sha256 = "16s2sj2417qmhdlzn7j51yf7fh50f5msgb50fsavw80845602x43";
        buildDepends = [ base containers parsec ];
        testDepends = [
          base containers HUnit parsec QuickCheck test-framework
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "inilist" = callPackage
+    ({ mkDerivation, base, bifunctors, containers, deepseq, HUnit, safe
+     , tasty, tasty-hunit, testpack, trifecta
+     }:
+     mkDerivation {
+       pname = "inilist";
+       version = "0.1.0.0";
+       sha256 = "18f93kvc5x0y1wqcicrh510r3skldf52jn0n6cxyn7fk2271cc1b";
+       buildDepends = [ base bifunctors containers safe trifecta ];
+       testDepends = [
+         base bifunctors containers deepseq HUnit safe tasty tasty-hunit
+         testpack trifecta
+       ];
+       homepage = "https://chiselapp.com/user/mwm/repository/inilist";
+       description = "Processing for .ini files with duplicate sections and options";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "inject" = callPackage
     ({ mkDerivation, attoparsec, base, hspec, hspec-expectations
      , process, text
···
      }:
      mkDerivation {
        pname = "instant-aeson";
-       version = "0.1";
-       sha256 = "1idxwd0wxy6xziwlwnjwgbv9canpvwbnigrcjn3kvl0j7nld6wvj";
+       version = "0.1.0.1";
+       sha256 = "18zxvd4sw13j4gn2f7r2xdy6p0xayjv3ks8j97j7vi6cdw9aqw2z";
        buildDepends = [ aeson base instant-generics ];
        testDepends = [
          aeson base instant-generics tasty tasty-quickcheck
        ];
-       jailbreak = true;
        description = "Generic Aeson instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "instant-bytes";
-       version = "0.1";
-       sha256 = "0gjj7ix1dxlbk1im2ww3qpfx4m40vg0hl7n9ribnlx2krw53mmm1";
+       version = "0.1.0.1";
+       sha256 = "1g99yakjychx12amls2b6cfma0fzh0n9w4m2k03wqibk1aagl940";
        buildDepends = [ base bytes instant-generics ];
        testDepends = [
          base bytes instant-generics tasty tasty-quickcheck
        ];
-       jailbreak = true;
        description = "Generic Serial instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, deepseq, instant-generics }:
      mkDerivation {
        pname = "instant-deepseq";
-       version = "0.1";
-       sha256 = "13w4ilnjm6m9idqkxzp0l91f156n097zlhmpny1lamy5brvzpls0";
+       version = "0.1.0.1";
+       sha256 = "1yv5zqv2fqj8b7qzx2004sa287mrvrswmghl13vsbj2whmdh0kjz";
        buildDepends = [ base deepseq instant-generics ];
-       jailbreak = true;
        description = "Generic NFData instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, hashable, instant-generics }:
      mkDerivation {
        pname = "instant-hashable";
-       version = "0.1";
-       sha256 = "0bqn9na0pxkkffmwwz6p4rgv11fq2mn724sk4l7nxv44k7vrirz2";
+       version = "0.1.0.1";
+       sha256 = "1yaf24r68zh5vsp73747hbv2fdk9y9vgswj6lv22s52s8h6f1agj";
        buildDepends = [ base hashable instant-generics ];
-       jailbreak = true;
        description = "Generic Hashable instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "interpolatedstring-perl6";
-       version = "0.9.0";
-       sha256 = "15hzmni3wfdgjl0vyk5mcld61ba99wdax87s7wkz2s8bsyxkbq9n";
+       version = "1.0.0";
+       sha256 = "1lx125wzadvbicsaml9wrhxxplc4gd0i4wk3f1apb0kl5nnv5q35";
        buildDepends = [
          base bytestring haskell-src-meta template-haskell text
        ];
        description = "QuasiQuoter for Perl6-style multi-line interpolated strings";
-       license = stdenv.lib.licenses.bsd3;
+       license = stdenv.lib.licenses.publicDomain;
      }) {};
 
   "interpolatedstring-qq" = callPackage
···
        license = "unknown";
      }) {};
 
+  "irc-fun-color" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "irc-fun-color";
+       version = "0.1.0.0";
+       sha256 = "1zb3d3m17049g7cfnpnl8c1ldyhhwvxh99dbfx1xzyadg841i08a";
+       buildDepends = [ base ];
+       testDepends = [ base ];
+       homepage = "http://rel4tion.org/projects/irc-fun-color/";
+       description = "Add color and style decorations to IRC messages";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "ircbot" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , irc, mtl, network, parsec, random, SafeSemaphore, stm, time, unix
···
      }) {};
 
   "jsaddle" = callPackage
-    ({ mkDerivation, base, hslogger, lens, template-haskell, text
-     , transformers
+    ({ mkDerivation, base, glib, gtk3, hslogger, lens, template-haskell
+     , text, transformers, webkitgtk3, webkitgtk3-javascriptcore
      }:
      mkDerivation {
        pname = "jsaddle";
-       version = "0.2.0.5";
-       sha256 = "0avl5gvq3sv2fk524hazfk1xgb9rlyqqqrvnxb63psjds7s6rxp1";
-       buildDepends = [ base lens template-haskell text transformers ];
+       version = "0.2.0.6";
+       sha256 = "1ggnhv9lgsd330p1k6zvg20dbqb1ysh282nalxramqvn2yhmqsx4";
+       buildDepends = [
+         base lens template-haskell text transformers webkitgtk3
+         webkitgtk3-javascriptcore
+       ];
        testDepends = [
-         base hslogger lens template-haskell text transformers
+         base glib gtk3 hslogger lens template-haskell text transformers
+         webkitgtk3 webkitgtk3-javascriptcore
        ];
-       jailbreak = true;
        description = "High level interface for webkit-javascriptcore";
        license = stdenv.lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "json-rpc-client";
-       version = "0.2.0.0";
-       sha256 = "13mc23dpyn9zsv1gfb913g8w8csjgnk5xrbbyhxgmam9kslpbxjj";
+       version = "0.2.1.0";
+       sha256 = "1ma5vahbcfarbvc0m8n88i0hn9szbvanmfd81jmvwkamkqxxgmis";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "json-rpc-server";
-       version = "0.2.0.0";
-       sha256 = "08v2bvswn0a0jhd0gd83f2lxr0n0nirl9xav7zj3y3bjdkxwlkys";
+       version = "0.2.1.0";
+       sha256 = "1rbm8anj3lg3x7gky5nazxcsdwd5c48b1axphgcqzzy5hn8hsg2r";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }) {};
 
   "lambdacms-core" = callPackage
-    ({ mkDerivation, base, blaze-html, bytestring, containers
-     , data-default, esqueleto, file-embed, friendly-time, gravatar
-     , lists, mime-mail, old-locale, persistent, shakespeare
-     , template-haskell, text, time, uuid, wai, yesod, yesod-auth
-     , yesod-core, yesod-form
+    ({ mkDerivation, base, blaze-html, bytestring, classy-prelude
+     , classy-prelude-yesod, containers, data-default, esqueleto
+     , file-embed, friendly-time, gravatar, hspec, lists, mime-mail
+     , old-locale, persistent, shakespeare, template-haskell, text, time
+     , uuid, wai, yesod, yesod-auth, yesod-core, yesod-form
      }:
      mkDerivation {
        pname = "lambdacms-core";
-       version = "0.1.0.0";
-       sha256 = "0f34158j493ga5zrl1fxqyxvxfj3gzx77vs3p9rb7syn7c1zxa53";
+       version = "0.3.0.2";
+       sha256 = "0m8piymzcciy4dqhxqxslpm1rbzasm1diasr8ab05r9lcrs1dn76";
        buildDepends = [
          base blaze-html bytestring containers data-default esqueleto
          file-embed friendly-time gravatar lists mime-mail old-locale
          persistent shakespeare template-haskell text time uuid wai yesod
          yesod-auth yesod-core yesod-form
        ];
-       jailbreak = true;
+       testDepends = [
+         base classy-prelude classy-prelude-yesod hspec yesod yesod-core
+       ];
        homepage = "http://lambdacms.org";
-       description = "LambdaCms Core subsite for Yesod apps";
+       description = "LambdaCms 'core' subsite for Yesod apps";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "lambdacms-media";
-       version = "0.2.0";
-       sha256 = "08c2qdpqv8bw0qkpjk5fcyyqdgpxgp6xivfimai6bh3lxz2yk0gz";
+       version = "0.3.0.1";
+       sha256 = "074bghfbi3m4ffla34z0yq2qgbw3ps81fq2cm8ibqry3bps511xp";
        buildDepends = [
          base directory filepath lambdacms-core persistent shakespeare text
          time yesod yesod-form
···
      }:
      mkDerivation {
        pname = "leksah";
-       version = "0.15.1.0";
-       sha256 = "0skvn5n69ir63q91jaj5qdhk8cxvic61g9ar5wck0gwpzdjcfl6w";
+       version = "0.15.1.1";
+       sha256 = "0gjgaigkd34gzfvqhlxqqxcydh12064prnn0x653kb5ks8bq4qml";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "leksah-server";
-       version = "0.15.0.4";
-       sha256 = "0zjdzsv9vwhsabkkyf47gfsca4b1yqjgd2vlvb0qm7ca9gymd0ic";
+       version = "0.15.0.6";
+       sha256 = "1pcf42hipc5q3n61pbd2sdgvhshl2ri261i94myb3fc13kbi90hb";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "lentil";
-       version = "0.1.2.6";
-       sha256 = "0pn4x75l04qs95h9ca5chvxbivnb29h4d8415n4r2b1gmx4apn0w";
+       version = "0.1.2.7";
+       sha256 = "1g3if2y41li6wyg7ffvpybqvbywiq8bf5b5fb6pz499hinzahb9d";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "libsystemd-journal";
-       version = "1.3.1";
-       sha256 = "1i66w6dhycvi3d0vnws91mc0k9v46qr0zpc35yliv1paipm1s51a";
+       version = "1.3.3";
+       sha256 = "02d1zpmimmisjngkx9l23af51v18pdbc5mh7yljyw81lm39yzvfn";
        buildDepends = [
          base bytestring hashable hsyslog pipes pipes-safe text transformers
          uniplate unix-bytestring unordered-containers uuid vector
        ];
        pkgconfigDepends = [ systemd ];
-       jailbreak = true;
        homepage = "http://github.com/ocharles/libsystemd-journal";
        description = "Haskell bindings to libsystemd-journal";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "limp";
-       version = "0.3.2.0";
-       sha256 = "0shc69jlzmn8b2pxdfav9lk9cbhxpd1cmsr36rwgyvyn5shiijy1";
+       version = "0.3.2.1";
+       sha256 = "0fx8q7ll47qc06laagiap0z4b5mbp958r3b9mc6qm1h9rhksimjk";
        buildDepends = [ base containers ];
        testDepends = [
          base containers QuickCheck tasty tasty-quickcheck tasty-th
···
     ({ mkDerivation, base, c2hs, containers, limp, vector }:
      mkDerivation {
        pname = "limp-cbc";
-       version = "0.3.2.0";
-       sha256 = "10cm2vwbjyzqpq2ras8viza0vy0r0hgrm84landlcgkbhfj71l79";
+       version = "0.3.2.1";
+       sha256 = "0q4az96nbwvm7jhrwvbjp87vzkb5nlp739jhkya6z0iq340cjxjy";
        buildDepends = [ base containers limp vector ];
        testDepends = [ base limp ];
        buildTools = [ c2hs ];
···
      }:
      mkDerivation {
        pname = "linklater";
-       version = "3.1.0.0";
-       sha256 = "0mvmlq1nl428syc013hif07rssvya7wxkr44rs58rjn2zsxhhlqq";
+       version = "3.2.0.0";
+       sha256 = "15c6p63yd1g5if2nz9pig6kc0rvqpjixjs6zr2j9m16q0h6kgrfr";
        buildDepends = [
          aeson base base-prelude bytestring containers http-types text wai
          wreq
        ];
-       jailbreak = true;
        homepage = "https://github.com/hlian/linklater";
        description = "The fast and fun way to write Slack.com bots";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "ltk";
-       version = "0.15.0.1";
-       sha256 = "0qw689ip8kibczjvar6bicns6g8a0zwlb6vdcmpicxxmpr1p7g16";
+       version = "0.15.0.2";
+       sha256 = "19wnkl9acibs6kcnm0m02jhjxrn19sanf5z2w0kqwjbqlfcrcc4a";
        buildDepends = [
          base Cabal containers filepath ghc glib gtk3 mtl parsec pretty text
          transformers
···
      }:
      mkDerivation {
        pname = "mangopay";
-       version = "1.11.3";
-       sha256 = "1w9p0na0am2hl8f32qgkdym00kjjnavv1wxp6f4vh9msa6cfw6yl";
+       version = "1.11.4";
+       sha256 = "0yb6i97ihcywbgzqkrad72q33m7fgx903rqizlhb4nz4bkl8793d";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "monoid-subclasses";
-       version = "0.4.1.1";
-       sha256 = "0r2ypb85qz88jz70pr4rgygwsdslaw781s0d3svd6s7xfibi9hww";
+       version = "0.4.1.2";
+       sha256 = "0j9an1zq3dg02jz8skqkch01kg2ha59zja2729v8lpwxsd4sbi9x";
        buildDepends = [ base bytestring containers primes text vector ];
        testDepends = [
          base bytestring containers primes QuickCheck quickcheck-instances
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "ms" = callPackage
+    ({ mkDerivation, base, contravariant, doctest, edit-distance, lens
+     , profunctors, semigroupoids, semigroups, tasty, tasty-quickcheck
+     , vector
+     }:
+     mkDerivation {
+       pname = "ms";
+       version = "0.2.1";
+       sha256 = "0h70dkgzybbjm48ay9xqbvydf13a6q1zy99ln8kx4qlfdi4gsrnp";
+       buildDepends = [
+         base contravariant edit-distance lens profunctors semigroupoids
+         semigroups vector
+       ];
+       testDepends = [
+         base doctest profunctors tasty tasty-quickcheck vector
+       ];
+       homepage = "https://github.com/relrod/ms";
+       description = "metric spaces";
+       license = stdenv.lib.licenses.bsd2;
+     }) {};
+
   "msgpack" = callPackage
     ({ mkDerivation, base, binary, blaze-builder, bytestring
      , containers, data-binary-ieee754, deepseq, hashable, mtl
···
     ({ mkDerivation, base, netwire }:
      mkDerivation {
        pname = "netwire-input";
-       version = "0.0.3";
-       sha256 = "0c6wi1gfr0pxm8hav6ziic444a83cns3yf07kdylxbymgzgq7n7z";
+       version = "0.0.4";
+       sha256 = "1f0dczgnc1fibq5ypdzi1hgsahmbfmv783bliwh5x4j4vm81k0h6";
        buildDepends = [ base netwire ];
-       jailbreak = true;
        homepage = "https://www.github.com/Mokosha/netwire-input";
        description = "Input handling abstractions for netwire";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "netwire-input-glfw";
-       version = "0.0.3";
-       sha256 = "04flihwgs4wibhppyjw7x23s2629rbywafbv9dmdcda6bv6d8qm3";
+       version = "0.0.4";
+       sha256 = "163jd8bb0msy9r51s8qb6ypk25lax46kkbzq9wh2s4kvzribmdlg";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [ base containers GLFW-b mtl netwire-input stm ];
-       jailbreak = true;
        homepage = "https://www.github.com/Mokosha/netwire-input-glfw";
        description = "GLFW instance of netwire-input";
        license = stdenv.lib.licenses.mit;
···
          amqp base network-transport network-transport-tests tasty
          tasty-hunit
        ];
+       jailbreak = true;
        description = "AMQP-based transport layer for distributed-process (aka Cloud Haskell)";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
     ({ mkDerivation, base, primitive, vector }:
      mkDerivation {
        pname = "nonlinear-optimization";
-       version = "0.3.7";
-       sha256 = "147dbq19n18ixfz6bhx9yi9ppr9j3wnc5dfz8kx5gwihy64b8l1b";
+       version = "0.3.10";
+       sha256 = "11dq7fvysdb0szkg58f2wmx2vg6sa9qfj9kfv7wv6fl3386dnp7f";
        buildDepends = [ base primitive vector ];
-       jailbreak = true;
        description = "Various iterative algorithms for optimization of nonlinear functions";
        license = "GPL";
      }) {};
 
   "nonlinear-optimization-ad" = callPackage
-    ({ mkDerivation, ad, base, nonlinear-optimization, primitive
+    ({ mkDerivation, ad, base, csv, nonlinear-optimization, primitive
      , reflection, vector
      }:
      mkDerivation {
        pname = "nonlinear-optimization-ad";
-       version = "0.2.0";
-       sha256 = "1aglqfmvjb7wmxlnlkakkp27lbyq62pjy48k18sqppj6q0qp062m";
+       version = "0.2.1";
+       sha256 = "0k3iynppdvmm9asy1wddp8n3gmskh40dmcngqv8pgy5qx0bnx8jd";
+       isLibrary = true;
+       isExecutable = true;
        buildDepends = [
-         ad base nonlinear-optimization primitive reflection vector
+         ad base csv nonlinear-optimization primitive reflection vector
        ];
        homepage = "https://github.com/msakai/nonlinear-optimization-ad";
        description = "Wrapper of nonlinear-optimization package for using with AD package";
···
      }:
      mkDerivation {
        pname = "not-gloss";
-       version = "0.7.4.0";
-       sha256 = "11ikk8yia52qbaajcnwc7gq1jwwid12j8vzgn2v18j5d272lzwyc";
+       version = "0.7.5.0";
+       sha256 = "1r0mycb3ilz2k89vab08c1diz18mp03b5sds4ixmxfb0zqaz68lb";
        buildDepends = [
          base binary bmp bytestring cereal GLUT OpenGL OpenGLRaw
          spatial-math time vector vector-binary-instances
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "nvim-hs" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
+     , conduit-extra, containers, data-default, directory, dyre
+     , filepath, hslogger, hspec, hspec-discover, HUnit, lifted-base
+     , messagepack, monad-control, mtl, network, optparse-applicative
+     , parsec, process, QuickCheck, resourcet, stm, streaming-commons
+     , template-haskell, text, time, transformers, transformers-base
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "nvim-hs";
+       version = "0.0.1";
+       sha256 = "1zma19lb4kzzfiabkx55ffgvdqrycijpm2yz3jszm1m6m58khif5";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         base bytestring cereal cereal-conduit conduit conduit-extra
+         containers data-default directory dyre filepath hslogger
+         lifted-base messagepack monad-control mtl network
+         optparse-applicative parsec process resourcet stm streaming-commons
+         template-haskell text time transformers transformers-base
+         utf8-string
+       ];
+       testDepends = [
+         base bytestring cereal cereal-conduit conduit conduit-extra
+         containers data-default directory dyre filepath hslogger hspec
+         hspec-discover HUnit lifted-base messagepack mtl network
+         optparse-applicative parsec process QuickCheck resourcet stm
+         streaming-commons template-haskell text time transformers
+         utf8-string
+       ];
+       homepage = "https://github.com/saep/nvim-hs";
+       description = "Haskell plugin backend for neovim";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "nyan" = callPackage
     ({ mkDerivation, base, bytestring, mtl, ncurses, text }:
      mkDerivation {
···
 
   "opaleye" = callPackage
     ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
-     , case-insensitive, contravariant, postgresql-simple, pretty
-     , product-profunctors, profunctors, semigroups, text, time
-     , time-locale-compat, transformers, uuid
+     , case-insensitive, containers, contravariant, postgresql-simple
+     , pretty, product-profunctors, profunctors, QuickCheck, semigroups
+     , text, time, time-locale-compat, transformers, uuid, void
      }:
      mkDerivation {
        pname = "opaleye";
-       version = "0.3.1.2";
-       revision = "3";
-       sha256 = "01ldghza5l1qgcpvsphajfkq7g09fw0dm4vnya9wbs0hla307av9";
-       editedCabalFile = "9ee83219b8bc26fe01cca7484513bc3373d2868855ba8757fd210482f0605852";
+       version = "0.4.0.0";
+       sha256 = "1dzfxy5r2phqcnijvq74ardjg9p2mlkpidg95dd3v9qiz1ls71rk";
        buildDepends = [
          attoparsec base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
          profunctors semigroups text time time-locale-compat transformers
-         uuid
+         uuid void
        ];
        testDepends = [
-         base postgresql-simple product-profunctors profunctors time
+         base containers contravariant postgresql-simple product-profunctors
+         profunctors QuickCheck semigroups time
        ];
        homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
        description = "An SQL-generating DSL targeting PostgreSQL";
···
      }:
      mkDerivation {
        pname = "pandoc-crossref";
-       version = "0.1.2.2";
-       sha256 = "1ynxg9d3ssq9bby073j40913z11xap6gpf8hkjl0h0ll3mx89vb9";
+       version = "0.1.2.4";
+       sha256 = "1ay54zkxxa22nz5sr40d6k4bam81hxh19583kffwqdcp0af23d7l";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "persist2er" = callPackage
+    ({ mkDerivation, base, optparse-applicative, persistent, text }:
+     mkDerivation {
+       pname = "persist2er";
+       version = "0.1.0.1";
+       sha256 = "096gjkmw06crywwwydyr67447xmp8x967dwh1gavlr0061skb72p";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [ base optparse-applicative persistent text ];
+       jailbreak = true;
+       description = "Transforms persist's quasi-quoted syntax into ER format";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "persistable-record" = callPackage
     ({ mkDerivation, array, base, containers, dlist, names-th
      , template-haskell, transformers
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "persistent-instances-iproute" = callPackage
+    ({ mkDerivation, base, bytestring, iproute, persistent }:
+     mkDerivation {
+       pname = "persistent-instances-iproute";
+       version = "0.1.0.1";
+       sha256 = "0nmk138kv020aa0pw29l177rb6rji4rnmw4ndnkn1xvp8gh3w0yn";
+       buildDepends = [ base bytestring iproute persistent ];
+       description = "Persistent instances for types in iproute";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "persistent-map" = callPackage
     ({ mkDerivation, base, binary, containers, directory, EdisonAPI
      , EdisonCore, filepath, LRU, mtl, stm-io-hooks
···
        buildDepends = [ base bytestring data-cell pipes pipes-cellular ];
        homepage = "https://github.com/zadarnowski/pipes-cellular-csv";
        description = "Efficient pipes-based cellular CSV codec";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "pipes-cereal" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, mtl, pipes
+     , pipes-bytestring, pipes-parse
+     }:
+     mkDerivation {
+       pname = "pipes-cereal";
+       version = "0.1.0.0";
+       sha256 = "04f538gyzvwxhqscsj9sywi6hz5k1fabjaga0vf861hlmv9agaa8";
+       buildDepends = [
+         base bytestring cereal mtl pipes pipes-bytestring pipes-parse
+       ];
+       description = "Encode and decode binary streams using the pipes and cereal libraries";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "pusher-haskell" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, hspec, HTTP, MissingH
+     , mtl, SHA, time
+     }:
+     mkDerivation {
+       pname = "pusher-haskell";
+       version = "0.1.0.0";
+       sha256 = "0ymj27a3kmaddydd5zshj108fmzhlxasn9i4igzjaj308f1ygki6";
+       buildDepends = [
+         aeson base bytestring HTTP MissingH mtl SHA time
+       ];
+       testDepends = [ base hspec ];
+       jailbreak = true;
+       homepage = "http://www.github.com/sidraval/pusher-haskell";
+       description = "A Pusher.com client written in Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "pushme" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, deepseq
      , hslogger, io-storage, lens, old-locale, optparse-applicative
···
      }) {};
 
   "range" = callPackage
-    ({ mkDerivation, base, Cabal, parsec, QuickCheck, random
+    ({ mkDerivation, base, Cabal, free, parsec, QuickCheck, random
      , test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "range";
-       version = "0.1.1.1";
-       sha256 = "05xcy4r97yyqr72cqpr5rq514zygbwa2hfnhilvgzrh3cmk61n0p";
-       buildDepends = [ base parsec ];
+       version = "0.1.2.0";
+       sha256 = "028bigaq4vk5ykzf04f5hi3g37gxzzp6q24bjcb3gjfzcgy7z6ab";
+       buildDepends = [ base free parsec ];
        testDepends = [
-         base Cabal QuickCheck random test-framework
+         base Cabal free QuickCheck random test-framework
          test-framework-quickcheck2
        ];
        homepage = "https://bitbucket.org/robertmassaioli/range";
···
      }:
      mkDerivation {
        pname = "rdf4h";
-       version = "1.3.1";
-       sha256 = "0mcswyjlvhnv4rvapanfmxf2brsp5b9r1ps22n3rlhpa3mfw72rc";
+       version = "1.3.2";
+       sha256 = "09ya3d1svg6fj7jdm408gisv0cnn0c2i2c3pn07xggnn882s93bw";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          unordered-containers
        ];
        testDepends = [
-         base bytestring containers deepseq fgl hashable HTTP HUnit hxt knob
-         network network-uri parsec QuickCheck test-framework
-         test-framework-hunit test-framework-quickcheck2 text
+         base binary bytestring containers deepseq fgl hashable HTTP HUnit
+         hxt knob network network-uri parsec QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2 text text-binary
          unordered-containers
        ];
        homepage = "https://github.com/robstewart57/rdf4h";
···
      }) {};
 
   "react-haskell" = callPackage
-    ({ mkDerivation, base, deepseq, haste-compiler, lens-family
-     , monads-tf, transformers, void
+    ({ mkDerivation, aeson, base, deepseq, lens-family, monads-tf, text
+     , transformers, unordered-containers, void
      }:
      mkDerivation {
        pname = "react-haskell";
-       version = "1.3.0.0";
-       sha256 = "1jq96fiq133ng6ayknzxwcz59f2gxa5f5hhj9n46pixwdp6bf2aa";
+       version = "2.0.0";
+       sha256 = "016bpbci89b6grkwnq1yqjm5y50di1hmjlf2mkxjc0wyi82c7say";
        buildDepends = [
-         base deepseq haste-compiler lens-family monads-tf transformers void
+         aeson base deepseq lens-family monads-tf text transformers
+         unordered-containers void
        ];
        homepage = "https://github.com/joelburget/react-haskell";
        description = "Haskell React bindings";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "reddit" = callPackage
+    ({ mkDerivation, aeson, api-builder, base, bytestring, Cabal
+     , data-default, hspec, http-conduit, http-types, network, stm, text
+     , time, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "reddit";
+       version = "0.1.0.0";
+       revision = "1";
+       sha256 = "1g18lfl9hvz13f3i5h819pfh724i5lhgqfvyy2r06ni7hjfylzj4";
+       editedCabalFile = "84c6e65809dcd5c4fed83d64c71c6465a6ee1fe6e913c637dc2db608c6cc5870";
+       buildDepends = [
+         aeson api-builder base bytestring data-default http-conduit
+         http-types network stm text time transformers unordered-containers
+         vector
+       ];
+       testDepends = [
+         api-builder base bytestring Cabal hspec http-conduit text time
+         transformers
+       ];
+       homepage = "https://github.com/intolerable/reddit";
+       description = "Library for interfacing with Reddit's API";
+       license = stdenv.lib.licenses.bsd2;
+     }) {};
+
   "redis" = callPackage
     ({ mkDerivation, base, bytestring, concurrent-extra, containers
      , exceptions, mtl, network, old-time, utf8-string
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "refact" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "refact";
+       version = "0.2.0.0";
+       sha256 = "1ixbji328bxdz4rblb0s7hp6vbckj4yj03a8a8sa756igj988v8f";
+       buildDepends = [ base ];
+       description = "Specify refactorings to perform with apply-refact";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "refcount" = callPackage
     ({ mkDerivation, base, Cabal, hashable, HUnit, QuickCheck
      , test-framework, test-framework-hunit, test-framework-quickcheck2
···
        license = stdenv.lib.licenses.bsd3;
        broken = true;
      }) { ghcjs-base = null;};
+
+  "reflex-gloss" = callPackage
+    ({ mkDerivation, base, dependent-sum, gloss, reflex, transformers
+     }:
+     mkDerivation {
+       pname = "reflex-gloss";
+       version = "0.1.0.2";
+       sha256 = "18sbqryf6kxadgbvr6nh0f07897fq9fjj0h2w07xcdpp1ygg1nfg";
+       buildDepends = [ base dependent-sum gloss reflex transformers ];
+       homepage = "https://github.com/reflex-frp/reflex-gloss";
+       description = "An reflex interface for gloss";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
 
   "reform" = callPackage
     ({ mkDerivation, base, containers, mtl, text }:
···
        homepage = "https://github.com/jwiegley/rehoo";
        description = "Rebuild default.hoo from many .hoo files in the current directory";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "rei" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers
+     , directory, regex-posix, split
+     }:
+     mkDerivation {
+       pname = "rei";
+       version = "0.1.0.1";
+       sha256 = "15xq2aj77y7l4frxkariw1z0c3y324iz697im8ynlzm88z2iixs6";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         attoparsec base bytestring containers directory regex-posix split
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/kerkomen/rei";
+       description = "Process lists easily";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "reified-records" = callPackage
···
 
   "satchmo" = callPackage
     ({ mkDerivation, array, async, base, bytestring, containers
-     , directory, minisat, mtl, process
+     , deepseq, directory, hashable, lens, memoize, minisat, mtl
+     , process, transformers
      }:
      mkDerivation {
        pname = "satchmo";
-       version = "2.9.7.3";
-       sha256 = "1gkb3whi0sv51jxb3x4dpam532fv3wbn1dyp9sc2c7mdjnv24kn8";
+       version = "2.9.9";
+       sha256 = "134i2xd7fvdhx43a51486mb3szi6c604pqc6w3cxsic1ngm30jbw";
        buildDepends = [
-         array async base bytestring containers directory minisat mtl
-         process
+         array async base bytestring containers deepseq directory hashable
+         lens memoize minisat mtl process transformers
        ];
        testDepends = [ array base ];
        homepage = "https://github.com/jwaldmann/satchmo";
···
      mkDerivation {
        pname = "scotty";
        version = "0.10.2";
+       revision = "1";
        sha256 = "0jlw82brnvc4cbpws0dq3qxn4rnb3z6rx6cfiarqwas14x4k3kl6";
+       editedCabalFile = "e0ab23342583c37af1a5422fad9a64926e54cad208dbcac75c70b3db40bf9e99";
        buildDepends = [
          aeson base blaze-builder bytestring case-insensitive
          data-default-class http-types monad-control mtl nats network
···
     ({ mkDerivation, base, scotty, transformers, wai, warp, warp-tls }:
      mkDerivation {
        pname = "scotty-tls";
-       version = "0.3.0.0";
-       sha256 = "11zpbqrfmjyl8kck1za0pvf1b1gn0ih3an8vq85si22414bs5j23";
+       version = "0.4.0";
+       sha256 = "1axr54s8zi9jw5y6yl2izjx4xvd25y18nh4fw7asq9fz0nwjb45a";
        buildDepends = [ base scotty transformers wai warp warp-tls ];
        homepage = "https://github.com/dmjio/scotty-tls.git";
        description = "TLS for Scotty";
···
 
   "second-transfer" = callPackage
     ({ mkDerivation, attoparsec, base, base16-bytestring, binary
-     , bytestring, conduit, containers, cpphs, exceptions, hashable
-     , hashtables, hslogger, http2, HUnit, lens, network, network-uri
-     , openssl, text, time, transformers
+     , bytestring, clock, conduit, containers, cpphs, deepseq
+     , exceptions, hashable, hashtables, hslogger, http2, HUnit, lens
+     , network, network-uri, openssl, pqueue, SafeSemaphore, stm, text
+     , time, transformers, unordered-containers
      }:
      mkDerivation {
        pname = "second-transfer";
-       version = "0.5.5.1";
-       sha256 = "06ldrfzp96w7q99nhhhjhay6g0gsvg16x64hwjih1nswcj9rpl6x";
+       version = "0.6.0.0";
+       sha256 = "1w726qfbz86sicpg5apx5n767av61l3kn8fra7ban8f67amg3z7w";
        buildDepends = [
-         attoparsec base base16-bytestring binary bytestring conduit
-         containers exceptions hashable hashtables hslogger http2 lens
-         network network-uri text time transformers
+         attoparsec base base16-bytestring binary bytestring clock conduit
+         containers deepseq exceptions hashable hashtables hslogger http2
+         lens network network-uri pqueue SafeSemaphore stm text time
+         transformers
        ];
        testDepends = [
-         attoparsec base base16-bytestring binary bytestring conduit
-         containers cpphs exceptions hashable hashtables hslogger http2
-         HUnit lens network network-uri text time transformers
+         attoparsec base base16-bytestring binary bytestring clock conduit
+         containers cpphs deepseq exceptions hashable hashtables hslogger
+         http2 HUnit lens network network-uri pqueue SafeSemaphore stm text
+         time transformers unordered-containers
        ];
        buildTools = [ cpphs ];
        extraLibraries = [ openssl ];
-       jailbreak = true;
        homepage = "https://www.httptwo.com/second-transfer/";
        description = "Second Transfer HTTP/2 web server";
        license = stdenv.lib.licenses.bsd3;
···
          network parsec QuickCheck servant string-conversions temporary text
          transformers wai wai-extra warp
        ];
+       jailbreak = true;
        homepage = "http://haskell-servant.github.io/";
        description = "A family of combinators for defining webservices APIs and serving them";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "shared-fields";
-       version = "0.1.0.0";
-       sha256 = "178jpksnxmyc07nc49wdalyh63bxwshddif9fb48p1fzcy2z5aph";
+       version = "0.2.0.0";
+       sha256 = "107n6w4dn0n4iv7qmfm1d9y04rgj3ab3qc8kyqqddnbnfa44y157";
        buildDepends = [ base template-haskell ];
        testDepends = [ base Cabal hspec lens text ];
        homepage = "http://github.com/intolerable/shared-fields";
···
      }:
      mkDerivation {
        pname = "shelly";
-       version = "1.6.2.5";
-       sha256 = "1dvaf1w1b5y717n24b9c3ri1qnpqppk5syh834h4iqcwfwlkjcvy";
+       version = "1.6.3.1";
+       sha256 = "1yd54i4ac1h23b4l4mz9ixpkhj0zxnb8gamk5jdhzgsd809cqy9q";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }) {};
 
   "shelly-extra" = callPackage
-    ({ mkDerivation, async, base, HUnit, mtl, SafeSemaphore, shelly
-     , text
+    ({ mkDerivation, async, base, hspec, HUnit, mtl, SafeSemaphore
+     , shelly, text
      }:
      mkDerivation {
        pname = "shelly-extra";
-       version = "0.3";
-       sha256 = "0rin1rqpzrjh4gs9235wy9w8rj4ac9yh83ap78a6nj0zi9w9vlwd";
+       version = "0.3.0.1";
+       sha256 = "1mc55m10s89mp2fz267sqhayaj0igj27kwyx7hnk5h23w0nhc0h5";
        buildDepends = [ async base mtl SafeSemaphore shelly ];
-       testDepends = [ base HUnit SafeSemaphore shelly text ];
+       testDepends = [
+         async base hspec HUnit mtl SafeSemaphore shelly text
+       ];
        homepage = "https://github.com/yesodweb/Shelly.hs";
        description = "shelly features that require extra dependencies";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "silently" = callPackage
-    ({ mkDerivation, base, deepseq, directory, nanospec }:
+    ({ mkDerivation, base, deepseq, directory, nanospec, temporary }:
      mkDerivation {
        pname = "silently";
-       version = "1.2.4.1";
-       sha256 = "035dw3zg680ykyz5rqkkrjn51wkznbc4jb45a8l2gh3vgqzgbf52";
+       version = "1.2.5";
+       sha256 = "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf";
        buildDepends = [ base deepseq directory ];
-       testDepends = [ base deepseq directory nanospec ];
-       homepage = "https://github.com/trystan/silently";
+       testDepends = [ base deepseq directory nanospec temporary ];
+       homepage = "https://github.com/hspec/silently";
        description = "Prevent or capture writing to stdout and other handles";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, aeson, base, linear, text, vector }:
      mkDerivation {
        pname = "smoothie";
-       version = "0.4";
-       sha256 = "0j8nwc44q9l7wf4m3z7r32b7if7is21k3xgmi2206r4i1yxc869j";
+       version = "0.4.0.1";
+       sha256 = "1h501mcgfwak586gakqsjhmrdkq2mmfi8gwalb7wbsp57bchfg67";
        buildDepends = [ aeson base linear text vector ];
        homepage = "https://github.com/phaazon/smoothie";
        description = "Smooth curves via several interpolation modes";
···
   "snap" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
      , clientsession, comonad, configurator, containers, directory
-     , directory-tree, dlist, errors, filepath, hashable, heist, lens
+     , directory-tree, dlist, either, filepath, hashable, heist, lens
      , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
      , pwstore-fast, regex-posix, snap-core, snap-server, stm
      , template-haskell, text, time, transformers, unordered-containers
···
      }:
      mkDerivation {
        pname = "snap";
-       version = "0.14.0.5";
-       sha256 = "0wifww6mry2lxj572j9gwjxpjz4z7z9hd9jzhfyfwv2c67b39iyr";
+       version = "0.14.0.6";
+       sha256 = "05xnil6kfxwrnbvg7sigzh7hl8jsfr8cvbjd41z9ywn6ymxzr7zs";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          aeson attoparsec base bytestring cereal clientsession comonad
-         configurator containers directory directory-tree dlist errors
+         configurator containers directory directory-tree dlist either
          filepath hashable heist lens logict MonadCatchIO-transformers mtl
          mwc-random old-time pwstore-fast regex-posix snap-core snap-server
          stm template-haskell text time transformers unordered-containers
          vector vector-algorithms xmlhtml
        ];
-       jailbreak = true;
        homepage = "http://snapframework.com/";
        description = "Top-level package for the Snap Web Framework";
        license = stdenv.lib.licenses.bsd3;
···
      mkDerivation {
        pname = "snap-core";
        version = "0.9.7.2";
+       revision = "1";
        sha256 = "0lgnflwcjyiinrm75dy1flr37bvjn3yljx53cvlsb3ccfnxqwsjj";
+       editedCabalFile = "d39520edcc970d9d1f683af9631ccbcad39536b9f88040b93efb66cbe7aefc55";
        buildDepends = [
          attoparsec attoparsec-enumerator base blaze-builder
          blaze-builder-enumerator bytestring bytestring-mmap
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "spanout" = callPackage
+    ({ mkDerivation, base, containers, gloss, lens, linear, MonadRandom
+     , mtl, netwire
+     }:
+     mkDerivation {
+       pname = "spanout";
+       version = "0.1";
+       sha256 = "0qi1pm46fyrn4vv1b5kcwhd8im59nz5qil6z33r8wq16vv151qb4";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         base containers gloss lens linear MonadRandom mtl netwire
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/vtan/spanout";
+       description = "A breakout clone written in netwire and gloss";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "sparse" = callPackage
     ({ mkDerivation, base, bytestring, containers, contravariant
      , deepseq, directory, doctest, filepath, hlint, hybrid-vectors
···
      }) {};
 
   "spatial-math" = callPackage
-    ({ mkDerivation, base, binary, cereal, doctest, ghc-prim, linear }:
+    ({ mkDerivation, base, binary, cereal, doctest, ghc-prim, lens
+     , linear
+     }:
      mkDerivation {
        pname = "spatial-math";
-       version = "0.2.3.0";
-       sha256 = "0170v4wjdpwf5s1bil9jj6magaa3fv05zz8b6zd4s6ca8cgw4lc4";
-       buildDepends = [ base binary cereal ghc-prim linear ];
+       version = "0.2.4.0";
+       sha256 = "0aysc8r9ry7ii76d6522ja4pjwrfl3m212mbrimbdrh20ykirjvv";
+       buildDepends = [ base binary cereal ghc-prim lens linear ];
        testDepends = [ base doctest ];
        description = "3d math including quaternions/euler angles/dcms and utility functions";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        description = "metric spaces";
-       version = "0.9.0";
-       description = "metric spaces";
+       version = "0.10.0";
+       sha256 = "0dlsgm9bbib45591m7kj9vai48r4n0zvkwm4vd4c78rj54qhnq9n";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        description = "metric spaces";
-       version = "1.0.1.1";
-       description = "metric spaces";
+       version = "1.1.0";
+       sha256 = "0ynfnkpzvgd54x294w4ga8nyg8lrmcwg3bhlwdlxs2fcffaazi81";
        buildDepends = [
        description = "metric spaces";
          text time unordered-containers vector
···
      }:
      mkDerivation {
        description = "metric spaces";
-       version = "0.6.1";
-       description = "metric spaces";
+       version = "0.6.3";
+       sha256 = "1sx7hxv5gvzr270h4lb76dihcqcqwgdm6mq2394s407iipb2clbw";
        buildDepends = [
        description = "metric spaces";
        ];
-       jailbreak = true;
        description = "metric spaces";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        description = "metric spaces";
-       version = "0.3.0.0";
-       description = "metric spaces";
+       version = "0.3.2.0";
+       sha256 = "1h8n7ry8wmzvz4bjfg6vsd7ssy17y54h2pzgjdlfam8yfcly2bb7";
        buildDepends = [ base containers text transformers ];
        description = "metric spaces";
        description = "metric spaces";
···
      }:
      mkDerivation {
        description = "metric spaces";
-       version = "0.2.0";
-       description = "metric spaces";
+       version = "0.2.2";
+       sha256 = "1kymwwj7yjdsyykqdqcnvgphbb1ypx7hi5a2wvx1wzv53lrspa9c";
        buildDepends = [
        description = "metric spaces";
        description = "metric spaces";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "telegram" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, data-default
+     , http-conduit, url, utf8-string
+     }:
+     mkDerivation {
+       pname = "telegram";
+       version = "0.1.0.0";
+       sha256 = "1ci6606fx5cisb9yrjh0mkd549w2j3h1vzj3zm2zsl9gr7agvh4n";
+       buildDepends = [
+         aeson base bytestring data-default http-conduit url utf8-string
+       ];
+       description = "Telegram API client";
+       license = stdenv.lib.licenses.gpl2;
+     }) {};
+
        description = "metric spaces";
        description = "metric spaces";
        description = "metric spaces";
···
     ({ mkDerivation, base, text }:
      mkDerivation {
        pname = "text-zipper";
-       version = "0.1.1";
-       sha256 = "0g8w7kyvqmjx4psj0cicv4bxn1ngx0giqyz8fyfhdr6v8wd9r410";
+       version = "0.2.1";
+       sha256 = "1a4kzn2s0ah1sizbdj6fks8zb4wmsx8cqjml4id9xj94zp4akq2r";
        buildDepends = [ base text ];
        description = "A text editor zipper library";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "themoviedb";
-       version = "1.1.0.0";
-       sha256 = "0yvpijr2dk01g1ks65nalyz547l9aq97a9v1bx3lp47allihrp8k";
+       version = "1.1.1.0";
+       sha256 = "1859hbhznmp7x8kbqzrpyhndfy69jg01qrp1vh67557mznari6d8";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          transformers
        ];
        testDepends = [ base bytestring tasty tasty-hunit text time ];
-       jailbreak = true;
        homepage = "http://github.com/pjones/themoviedb";
        description = "Haskell API bindings for http://themoviedb.org";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "0.4.33";
-       sha256 = "0xx02wbclq6hh50gz6vj3wmq7d5y7l4d6h48yxg3nwv4kwf44gf6";
+       version = "0.5.2";
+       sha256 = "0ll65q5fi8qfi50q9lqxdq9nsr7gizbh2xrsxgvj09nacdnwfwv0";
        buildDepends = [
          base binary bytestring colour containers hashable hmt hosc
          mersenne-random-pure64 mtl parsec process text time transformers
···
      }) {};
 
   "total" = callPackage
-    ({ mkDerivation, base, ghc-prim, void }:
+    ({ mkDerivation, base, void }:
      mkDerivation {
        pname = "total";
-       version = "1.0.3";
-       sha256 = "1aqpjpxg4incb03zryp6j66fn9wq1jd7nr5kjvrad8awk7349ggn";
-       buildDepends = [ base ghc-prim void ];
-       jailbreak = true;
+       version = "1.0.4";
+       sha256 = "0zl02pznpgg719d2639491cy4df2amj7rmwfdy9dz9cksm029pga";
+       buildDepends = [ base void ];
        description = "Exhaustive pattern matching using lenses, traversals, and prisms";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "tttool";
-       version = "1.4.0.2";
-       sha256 = "0avn7011868nqibmdz07s27d8g46v9hwps5h04dg57vk9305j70g";
+       version = "1.4.0.3";
+       sha256 = "0mypgqgqaf2c74vka1pmqzrvz1kwl8pjm1llh4bflizfzrxq3s9d";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "turkish-deasciifier" = callPackage
+    ({ mkDerivation, base, containers, HUnit, vector }:
+     mkDerivation {
+       pname = "turkish-deasciifier";
+       version = "0.1.0.0";
+       sha256 = "0dk63dknwxi7v67jn9b747mkyiz2af4b76a9q1ynn16xva2qsh93";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [ base containers vector ];
+       testDepends = [ base HUnit ];
+       homepage = "http://github.com/joom/turkish-deasciifier.hs";
+       description = "Haskell port of Deniz Yuret's Turkish deasciifier";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "turni" = callPackage
     ({ mkDerivation, base, containers, MonadRandom, random }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "twitter-conduit";
-       version = "0.1.0";
-       revision = "2";
-       sha256 = "1cymgp3wlswxn5qfdr442cqq2ak48b5w1zcsr67n2g5p1izadwji";
-       editedCabalFile = "e70397da5f43d657c6c3bef7419810f61675e78aa0b0da688b1f5939d1e11bf8";
+       version = "0.1.1";
+       sha256 = "0rair336wjgg5pd0vh3g3nlc64f5sw2sg60jj2sjaxv296jvr3xx";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          template-haskell text time transformers transformers-base
          twitter-types twitter-types-lens
        ];
-       jailbreak = true;
        homepage = "https://github.com/himura/twitter-conduit";
        description = "Twitter API package with conduit interface and Streaming API support";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "twitter-feed";
-       version = "0.1.1.5";
-       sha256 = "1205s5a7x8vnv09717x6a2dv7y8rvzcxmmh6hm4cyph6b5p485vz";
+       version = "0.2.0.1";
+       sha256 = "19j10mbvmmdni136b0sdyr0isdhslxcvgabvdqrd3if6cizpmndn";
        buildDepends = [
          aeson authenticate-oauth base bytestring http-conduit
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "vimeta" = callPackage
+    ({ mkDerivation, aeson, base, byline, bytestring, containers
+     , directory, either, filepath, http-client, http-client-tls
+     , http-types, mtl, old-locale, optparse-applicative, parsec
+     , process, temporary, text, themoviedb, time, time-locale-compat
+     , transformers, xdg-basedir, yaml
+     }:
+     mkDerivation {
+       pname = "vimeta";
+       version = "0.2.0.0";
+       sha256 = "14xzqhykw963ja6wsnrbq8dh9wbk63aramzj4n210srwxy6yqc05";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         aeson base byline bytestring containers directory either filepath
+         http-client http-client-tls http-types mtl old-locale
+         optparse-applicative parsec process temporary text themoviedb time
+         time-locale-compat transformers xdg-basedir yaml
+       ];
+       homepage = "http://github.com/pjones/vimeta";
+       description = "Frontend for video metadata tagging tools";
+       license = stdenv.lib.licenses.bsd2;
+     }) {};
+
   "vimus" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, containers, data-default
      , deepseq, directory, filepath, hspec, hspec-expectations, libmpd
···
      }:
      mkDerivation {
        pname = "wai-app-static";
-       version = "3.1.0.1";
-       sha256 = "1z542ivy5x4qj9kizkbbvhz5pn54rcxrs6cc52199khxkfc07gdm";
+       version = "3.1.1";
+       sha256 = "0aiywk7a25fpk9fwm6fmibi4zvg5kynnjs6syfxyzfw4hl1dazjv";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "wai-extra";
-       version = "3.0.8.2";
-       sha256 = "0j6yvwzw1mpamx0phplgang4gcjv25dhqvngfmzmh5fk76npmxr9";
+       version = "3.0.9";
+       sha256 = "19rnkqg4x6n2w2313naxbkcp2hyj4bj6d6kx3rwakk8wmdy70r04";
        buildDepends = [
          ansi-terminal base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie data-default-class deepseq
···
        sha256 = "1fm985jq1sa8v3vj850cpcjl6kcyq2kgq6xwpb1rmzi8zmb80kpc";
        buildDepends = [ base wai warp ];
        pkgconfigDepends = [ QtWebKit ];
+       jailbreak = true;
        homepage = "https://github.com/yesodweb/wai/tree/master/wai-handler-webkit";
        description = "Turn WAI applications into standalone GUIs using QtWebkit";
        license = stdenv.lib.licenses.mit;
···
 
   "warp" = callPackage
     ({ mkDerivation, array, async, auto-update, base, blaze-builder
-     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
-     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
-     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
-     , time, transformers, unix, unix-compat, vault, wai
+     , bytestring, case-insensitive, containers, directory, doctest
+     , ghc-prim, hashable, hspec, HTTP, http-date, http-types, http2
+     , HUnit, iproute, lifted-base, network, old-locale, process
+     , QuickCheck, simple-sendfile, stm, streaming-commons, text, time
+     , transformers, unix, unix-compat, vault, wai, word8
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.0.13.1";
-       sha256 = "17vik5xf2amyi4pwq7wfia2a6f1pksa4ll155hbhkndhbwszvrkc";
+       version = "3.1.0";
+       sha256 = "1lx1fbcf8bkr5g6j0flk6mplnvs289lkyds5hv31naa450wbca62";
        buildDepends = [
          array auto-update base blaze-builder bytestring case-insensitive
-         ghc-prim hashable http-date http-types iproute network
-         simple-sendfile streaming-commons text unix unix-compat vault wai
+         containers ghc-prim hashable http-date http-types http2 iproute
+         network simple-sendfile stm streaming-commons text unix unix-compat
+         vault wai word8
        ];
        testDepends = [
          array async auto-update base blaze-builder bytestring
-         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
-         http-types HUnit iproute lifted-base network old-locale QuickCheck
-         simple-sendfile streaming-commons text time transformers unix
-         unix-compat vault wai
+         case-insensitive containers directory doctest ghc-prim hashable
+         hspec HTTP http-date http-types http2 HUnit iproute lifted-base
+         network old-locale process QuickCheck simple-sendfile stm
+         streaming-commons text time transformers unix unix-compat vault wai
+         word8
        ];
        homepage = "http://github.com/yesodweb/wai";
        description = "A fast, light-weight web server for WAI applications";
···
      }:
      mkDerivation {
        pname = "warp-tls";
-       version = "3.0.4.2";
-       sha256 = "070bq28mg29yw5w7n92j73b74amqxn0yb5cx9z28p8ilmx3y03v1";
+       version = "3.1.0";
+       sha256 = "1790hl3a327fv01w2shdslylmhp5zv0bh7ljhymipr5vpjwjknrz";
        buildDepends = [
          base bytestring cprng-aes data-default-class network
          streaming-commons tls wai warp
        ];
        homepage = "http://github.com/yesodweb/wai";
-       description = "HTTP over SSL/TLS support for Warp via the TLS package";
+       description = "HTTP over TLS support for Warp via the TLS package";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "wordpass";
-       version = "1.0.0.3";
-       sha256 = "1nbgzrc3g3kcc8462sqskdywk0n1m54810r0jsw8ip2xllvkxx9b";
+       version = "1.0.0.4";
+       sha256 = "0plyggai2mq38bmmgc92gd0n3q4dlsywh44yflradg50aslqw0vv";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "xcffib";
-       version = "0.3.2";
-       sha256 = "0njsflaxz2l01vbwndsmqmq37i6nl4cfczy776jdpnv7043b1ynv";
+       version = "0.3.4";
+       sha256 = "03z31c5gnybpfvh3idqimnz90pzbijhrqa8hlikryab148gp1gzn";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }) {};
 
   "yaml" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring
-     , conduit, containers, directory, enclosed-exceptions, filepath
-     , hspec, hspec-expectations, HUnit, resourcet, scientific, text
+    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
+     , bytestring, conduit, containers, directory, enclosed-exceptions
+     , filepath, hspec, HUnit, mockery, resourcet, scientific, text
      , transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "yaml";
-       version = "0.8.11";
-       sha256 = "18ara96wca3gnk436i8rarb5smv80aa3ww4lnlrd5w01rp0p171v";
+       version = "0.8.12";
+       sha256 = "0nmpc1n80sv2bjqhzq5jdhd0zxzz9vka31y7k54fmdwr2jbg879i";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          unordered-containers vector
        ];
        testDepends = [
-         aeson aeson-qq base bytestring conduit directory hspec
-         hspec-expectations HUnit resourcet text transformers
-         unordered-containers vector
+         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
+         mockery resourcet text transformers unordered-containers vector
        ];
        homepage = "http://github.com/snoyberg/yaml/";
        description = "Support for parsing and rendering YAML documents";
···
        description = "Generate OWL schema from YAML syntax, and an RDFa template";
        license = "LGPL";
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "yamlkeysdiff" = callPackage
+    ({ mkDerivation, base, containers, parsec, text
+     , unordered-containers, yaml
+     }:
+     mkDerivation {
+       pname = "yamlkeysdiff";
+       version = "0.5.1";
+       sha256 = "13s5qiydxcwpp0j8xap556yrlmqs7bsi62ql2c9clr4hpbw8may7";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         base containers parsec text unordered-containers yaml
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/acatton/yamlkeysdiff";
+       description = "Compares the keys from two yaml files";
+       license = "unknown";
      }) {};
 
   "yampa-canvas" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-auth-fb";
-       version = "1.6.6";
-       sha256 = "00pk5vridic77laydkfhrixfv50ps7f15dxvcd44cn0z8s2d3y74";
+       version = "1.7";
+       sha256 = "1kp4vka9sjij8zyp15vj1jkaqwgy483q2gjb5wmhlqwcyp843h02";
        buildDepends = [
          aeson base bytestring conduit fb http-conduit lifted-base
          shakespeare text time transformers wai yesod-auth yesod-core
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "yesod-auth-ldap-mediocre" = callPackage
+    ({ mkDerivation, aeson, base, LDAP, text, yesod-auth, yesod-core
+     , yesod-form
+     }:
+     mkDerivation {
+       pname = "yesod-auth-ldap-mediocre";
+       version = "0.1.0.0";
+       sha256 = "03pij218i9lk79n02c2pfrxsxyqi6lzjn5bzg7zgk5a87b6b57jh";
+       buildDepends = [
+         aeson base LDAP text yesod-auth yesod-core yesod-form
+       ];
+       jailbreak = true;
+       description = "Very simlple LDAP auth for yesod";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "yesod-auth-oauth" = callPackage
     ({ mkDerivation, authenticate-oauth, base, bytestring, lifted-base
      , text, transformers, yesod-auth, yesod-core, yesod-form
···
      }:
      mkDerivation {
        pname = "yesod-bin";
-       version = "1.4.11";
-       sha256 = "0n9ssbg7iggrgmxn3hb8niqic2rf453a4fqp0g9xx1rz6p323dv2";
+       version = "1.4.13";
+       sha256 = "0rqwmvl2pl05fp7xyfcpmpjkki8ww47rhifcclasaxvj109hvj1k";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "yesod-mangopay";
-       version = "1.11.2";
-       sha256 = "1jyn38q0q4s4lrnw93yzvnn49js4jf6zhq8wb7whyxks1jbkjxbv";
+       version = "1.11.4";
+       sha256 = "0syg5a0xihrdbclsrbgqgf6llhji7zdn1g50fbvlklfpw4dkb1f7";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "yesod-media-simple" = callPackage
+    ({ mkDerivation, base, bytestring, diagrams-cairo, diagrams-core
+     , diagrams-lib, directory, JuicyPixels, vector, yesod
+     }:
+     mkDerivation {
+       pname = "yesod-media-simple";
+       version = "0.1.0.1";
+       sha256 = "1ajlrqsq7x83vc67xqb4r3328akwjp0a0vwf7nvqj3bsjqg5af76";
+       buildDepends = [
+         base bytestring diagrams-cairo diagrams-core diagrams-lib directory
+         JuicyPixels vector yesod
+       ];
+       homepage = "https://github.com/mgsloan/yesod-media-simple";
+       description = "Simple display of media types, served by yesod";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "yesod-newsfeed" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
      , containers, shakespeare, text, time, xml-conduit, yesod-core
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-routes-flow" = callPackage
+    ({ mkDerivation, attoparsec, base, classy-prelude, system-fileio
+     , text, yesod-core
+     }:
+     mkDerivation {
+       pname = "yesod-routes-flow";
+       version = "1.0";
+       sha256 = "1bb0w1910mnzci4mi6r2zxhjy4wsridi5h2g97nqhd65qncq4km0";
+       buildDepends = [
+         attoparsec base classy-prelude system-fileio text yesod-core
+       ];
+       homepage = "https://github.com/frontrowed/yesod-routes-flow";
+       description = "Generate Flow routes for Yesod";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "yesod-routes-typescript" = callPackage
     ({ mkDerivation, attoparsec, base, classy-prelude, system-fileio
      , text, yesod-core, yesod-routes
···
      }:
      mkDerivation {
        pname = "yesod-static";
-       version = "1.5.0";
-       revision = "1";
-       sha256 = "1i95c43hlks1wclhwal9yr1pasmz78ddi7wzjhg9k5w21hrkcp92";
-       editedCabalFile = "d01c0a6fcb4ae005dea0c4898fd1ad452cde5e1989c90e62309c481cd0ff36c3";
+       version = "1.5.0.1";
+       sha256 = "1yda1m7dafcmq9s2gv0cdq3kphl5gg1279crqjgf3x57dyrypjpl";
        buildDepends = [
          async attoparsec base base64-bytestring blaze-builder byteable
          bytestring conduit conduit-extra containers cryptohash
···
      }:
      mkDerivation {
        pname = "yesod-table";
-       version = "1.0.1";
-       sha256 = "0ixypahxrm23pahjq972r8kc4h2a14fidf1cx3wiip8wxfhc9jsi";
+       version = "1.0.2";
+       sha256 = "0rrc9cfjl1g8if0ncs2xzpb1hnaa4hi3w62q16gwir0l79vfj7b9";
        buildDepends = [ base containers contravariant text yesod-core ];
        homepage = "https://github.com/andrewthad/yesod-table";
        description = "HTML tables for Yesod";
···
      }) {};
 
   "yesod-transloadit" = callPackage
-    ({ mkDerivation, aeson, base, byteable, bytestring, cryptohash
-     , hspec, lens, lens-aeson, old-locale, shakespeare, text, time
-     , transformers, yesod, yesod-core, yesod-form, yesod-test
+    ({ mkDerivation, aeson, base, byteable, bytestring, containers
+     , cryptohash, hspec, lens, lens-aeson, old-locale, shakespeare
+     , text, time, transformers, unordered-containers, yesod, yesod-core
+     , yesod-form, yesod-test
      }:
      mkDerivation {
        pname = "yesod-transloadit";
-       version = "0.2.1.0";
-       sha256 = "1x4sbjzlx5kxwcsywb90milk5s7shgggsqjsq7zrys28w079y00k";
+       version = "0.3.0.0";
+       sha256 = "0p2npza0clflh1vswyjr4gxx5fxggzv1x61x7c7d79jadq88bi4m";
        buildDepends = [
          aeson base byteable bytestring cryptohash lens lens-aeson
-         old-locale shakespeare text time transformers yesod yesod-core
-         yesod-form
+         old-locale shakespeare text time transformers unordered-containers
+         yesod yesod-core yesod-form
        ];
        testDepends = [
-         base hspec old-locale text time yesod yesod-form yesod-test
+         aeson base containers hspec lens old-locale text time yesod
+         yesod-form yesod-test
        ];
        description = "Transloadit support for Yesod";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "yesod-websockets" = callPackage
-    ({ mkDerivation, async, base, conduit, monad-control, transformers
-     , wai, wai-websockets, websockets, yesod-core
+    ({ mkDerivation, async, base, conduit, enclosed-exceptions
+     , monad-control, transformers, wai, wai-websockets, websockets
+     , yesod-core
      }:
      mkDerivation {
        pname = "yesod-websockets";
-       version = "0.2.1.1";
-       sha256 = "0ksmyag5h5i78jb7bdvsvq0wkyb82k8i4y5d2m6czvhf3i1zw6da";
+       version = "0.2.3";
+       sha256 = "15kklk4wkxclrmsvwzjcy8ggal14c6nrckfn0kqcrfp0hbxzj09m";
        buildDepends = [
-         async base conduit monad-control transformers wai wai-websockets
-         websockets yesod-core
+         async base conduit enclosed-exceptions monad-control transformers
+         wai wai-websockets websockets yesod-core
        ];
        homepage = "https://github.com/yesodweb/yesod";
        description = "WebSockets support for Yesod";
···
      }:
      mkDerivation {
        pname = "z3";
-       version = "4.0.0";
-       sha256 = "1axn3kzy6hsrnq5mcgf2n1sv63q3pqkhznvvhlj13k6jc3h2jzhl";
+       version = "4.1.0";
+       sha256 = "1vpmwizxcab1mlz7vp3hp72ddla7805jn0lq60fmkjgmj95ryvq9";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [ base containers mtl ];

pkgs/development/libraries/libbluray/default.nix

···
 { stdenv, fetchurl, pkgconfig, fontconfig, autoreconfHook
-, withJava ? true, jdk ? null, ant ? null
+, withJava ? false, jdk ? null, ant ? null
 , withAACS ? false, libaacs ? null
 , withBDplus ? false, libbdplus ? null
 , withMetadata ? true, libxml2 ? null

pkgs/development/libraries/libdmtx/default.nix

···
-{ stdenv, fetchurl, pkgconfig, imagemagick }:
+{ stdenv, fetchurl, pkgconfig }:
 
 stdenv.mkDerivation rec {
   name = "libdmtx-0.7.4";
···
   };
 
   nativeBuildInputs = [ pkgconfig ];
-
-  propagatedBuildInputs = [ imagemagick ];
 
   meta = {
     description = "An open source software for reading and writing Data Matrix barcodes";

pkgs/development/libraries/libraw/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "libraw-${version}";
-  version = "0.16.1";
+  version = "0.16.0";
 
   src = fetchurl {
     url = "http://www.libraw.org/data/LibRaw-${version}.tar.gz";
···
 
   nativeBuildInputs = [ pkgconfig ];
 
-  meta = { 
+  meta = {
     description = "Library for reading RAW files obtained from digital photo cameras (CRW/CR2, NEF, RAF, DNG, and others)";
     homepage = http://www.libraw.org/;
     license = stdenv.lib.licenses.gpl2Plus;

pkgs/development/libraries/librsvg/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, gdk_pixbuf, pango, cairo, libxml2, libgsf
+{ lib, stdenv, fetchurl, pkgconfig, glib, gdk_pixbuf, pango, cairo, libxml2, libgsf
 , bzip2, libcroco, libintlOrEmpty
-, gtk3 ? null
+, withGTK ? false, gtk3 ? null
 , gobjectIntrospection ? null, enableIntrospection ? false }:
 
 # no introspection by default, it's too big
···
   buildInputs = [ libxml2 libgsf bzip2 libcroco pango libintlOrEmpty ]
     ++ stdenv.lib.optional enableIntrospection [ gobjectIntrospection ];
 
-  propagatedBuildInputs = [ glib gdk_pixbuf cairo gtk3 ];
+  propagatedBuildInputs = [ glib gdk_pixbuf cairo ] ++ lib.optional withGTK gtk3;
 
   nativeBuildInputs = [ pkgconfig ];
 

pkgs/development/libraries/libva/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "libva-1.5.1";
+  name = "libva-1.6.0";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/vaapi/releases/libva/${name}.tar.bz2";
-    sha256 = "01d01mm9fgpwzqycmjjcj3in3vvzcibi3f64icsw2sksmmgb4495";
+    sha256 = "0n1l2mlhsvmsbs3qcphl4p6w13jnbv6s3hil8b6fj43a3afdrn9s";
   };
 
   buildInputs = [ libX11 libXext pkgconfig libdrm libXfixes wayland libffi mesa ];

pkgs/development/libraries/ppl/default.nix

···
 { fetchurl, stdenv, gmpxx, perl, gnum4 }:
 
-let version = "1.0"; in
+let version = "1.1"; in
 
 stdenv.mkDerivation rec {
   name = "ppl-${version}";
 
   src = fetchurl {
     url = "http://bugseng.com/products/ppl/download/ftp/releases/${version}/ppl-${version}.tar.bz2";
-    sha256 = "0m0b6dzablci8mlavpsmn5w1v3r46li0wpjwvsybgxx0p1ifjsf1";
+    sha256 = "1vrqhbpyca6sf984cfcwlp8wdnfzj1g7ph9958qdky9978i1nlny";
   };
 
   nativeBuildInputs = [ perl gnum4 ];
···
       "--disable-ppl_lcdd" "--disable-ppl_lpsol" "--disable-ppl_pips"
     ];
 
-  patches = [ ./upstream-based.patch ];
+  patches = [ ./ppl-cstddef.patch /* from Fedora */ ];
 
   # Beware!  It took ~6 hours to compile PPL and run its tests on a 1.2 GHz
   # x86_64 box.  Nevertheless, being a dependency of GCC, it probably ought

pkgs/development/libraries/ppl/ppl-cstddef.patch

···
+diff -up ppl-1.1/src/Dense_Row_defs.hh.orig ppl-1.1/src/Dense_Row_defs.hh
+--- ppl-1.1/src/Dense_Row_defs.hh.orig	2014-04-29 13:08:10.516682937 -0300
++++ ppl-1.1/src/Dense_Row_defs.hh	2014-04-29 13:08:50.447684466 -0300
+@@ -33,6 +33,7 @@ site: http://bugseng.com/products/ppl/ .
+ #include <memory>
+ #include <vector>
+ #include <limits>
++#include <cstddef>
+ 
+ #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
+ //! A finite sequence of coefficients.
+@@ -433,7 +434,7 @@ public:
+ 
+   typedef std::bidirectional_iterator_tag iterator_category;
+   typedef Coefficient value_type;
+-  typedef ptrdiff_t difference_type;
++  typedef std::ptrdiff_t difference_type;
+   typedef value_type* pointer;
+   typedef value_type& reference;
+ 
+@@ -474,7 +475,7 @@ class Parma_Polyhedra_Library::Dense_Row
+ public:
+ 
+   typedef const Coefficient value_type;
+-  typedef ptrdiff_t difference_type;
++  typedef std::ptrdiff_t difference_type;
+   typedef value_type* pointer;
+   typedef Coefficient_traits::const_reference reference;
+ 
+diff -up ppl-1.1/src/Linear_Expression_Interface_defs.hh.orig ppl-1.1/src/Linear_Expression_Interface_defs.hh
+--- ppl-1.1/src/Linear_Expression_Interface_defs.hh.orig	2014-04-29 13:08:17.337683198 -0300
++++ ppl-1.1/src/Linear_Expression_Interface_defs.hh	2014-04-29 13:08:40.999684104 -0300
+@@ -32,6 +32,7 @@ site: http://bugseng.com/products/ppl/ .
+ #include "Sparse_Row_types.hh"
+ #include <vector>
+ #include <set>
++#include <cstddef>
+ 
+ #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
+ //! A linear expression.
+@@ -65,7 +66,7 @@ public:
+   public:
+     typedef std::bidirectional_iterator_tag iterator_category;
+     typedef const Coefficient value_type;
+-    typedef ptrdiff_t difference_type;
++    typedef std::ptrdiff_t difference_type;
+     typedef value_type* pointer;
+     typedef Coefficient_traits::const_reference reference;
+ 
+diff -up ppl-1.1/src/CO_Tree_defs.hh.orig ppl-1.1/src/CO_Tree_defs.hh
+--- ppl-1.1/src/CO_Tree_defs.hh.orig	2014-04-29 13:11:33.725690719 -0300
++++ ppl-1.1/src/CO_Tree_defs.hh	2014-04-29 13:11:55.943691569 -0300
+@@ -28,6 +28,7 @@ site: http://bugseng.com/products/ppl/ .
+ 
+ #include "Coefficient_defs.hh"
+ #include <memory>
++#include <cstddef>
+ 
+ #ifndef PPL_CO_TREE_EXTRA_DEBUG
+ #ifdef PPL_ABI_BREAKING_EXTRA_DEBUG
+@@ -159,7 +160,7 @@ public:
+ 
+     typedef std::bidirectional_iterator_tag iterator_category;
+     typedef const data_type value_type;
+-    typedef ptrdiff_t difference_type;
++    typedef std::ptrdiff_t difference_type;
+     typedef value_type* pointer;
+     typedef data_type_const_reference reference;
+ 
+@@ -314,7 +315,7 @@ public:
+ 
+     typedef std::bidirectional_iterator_tag iterator_category;
+     typedef data_type value_type;
+-    typedef ptrdiff_t difference_type;
++    typedef std::ptrdiff_t difference_type;
+     typedef value_type* pointer;
+     typedef value_type& reference;
+ 
+diff -up ppl-1.1/src/CO_Tree_inlines.hh.orig ppl-1.1/src/CO_Tree_inlines.hh
+--- ppl-1.1/src/CO_Tree_inlines.hh.orig	2014-04-29 13:14:12.738696808 -0300
++++ ppl-1.1/src/CO_Tree_inlines.hh	2014-04-29 13:14:48.887698192 -0300
+@@ -24,6 +24,8 @@ site: http://bugseng.com/products/ppl/ .
+ #ifndef PPL_CO_Tree_inlines_hh
+ #define PPL_CO_Tree_inlines_hh 1
+ 
++#include <cstddef>
++
+ namespace Parma_Polyhedra_Library {
+ 
+ inline dimension_type
+@@ -31,7 +33,7 @@ CO_Tree::dfs_index(const_iterator itr) c
+   PPL_ASSERT(itr.current_index != 0);
+   PPL_ASSERT(itr.current_index >= indexes + 1);
+   PPL_ASSERT(itr.current_index <= indexes + reserved_size);
+-  const ptrdiff_t index = itr.current_index - indexes;
++  const std::ptrdiff_t index = itr.current_index - indexes;
+   return static_cast<dimension_type>(index);
+ }
+ 
+@@ -40,7 +42,7 @@ CO_Tree::dfs_index(iterator itr) const {
+   PPL_ASSERT(itr.current_index != 0);
+   PPL_ASSERT(itr.current_index >= indexes + 1);
+   PPL_ASSERT(itr.current_index <= indexes + reserved_size);
+-  const ptrdiff_t index = itr.current_index - indexes;
++  const std::ptrdiff_t index = itr.current_index - indexes;
+   return static_cast<dimension_type>(index);
+ }
+ 
+@@ -772,7 +774,7 @@ CO_Tree::tree_iterator::follow_left_chil
+   p -= (offset - 1);
+   while (*p == unused_index)
+     ++p;
+-  const ptrdiff_t distance = p - tree.indexes;
++  const std::ptrdiff_t distance = p - tree.indexes;
+   PPL_ASSERT(distance >= 0);
+   i = static_cast<dimension_type>(distance);
+   offset = least_significant_one_mask(i);
+@@ -787,7 +789,7 @@ CO_Tree::tree_iterator::follow_right_chi
+   p += (offset - 1);
+   while (*p == unused_index)
+     --p;
+-  const ptrdiff_t distance = p - tree.indexes;
++  const std::ptrdiff_t distance = p - tree.indexes;
+   PPL_ASSERT(distance >= 0);
+   i = static_cast<dimension_type>(distance);
+   offset = least_significant_one_mask(i);
+diff -up ppl-1.1/src/Linear_Expression_defs.hh.orig ppl-1.1/src/Linear_Expression_defs.hh
+--- ppl-1.1/src/Linear_Expression_defs.hh.orig	2014-04-29 13:15:39.793700141 -0300
++++ ppl-1.1/src/Linear_Expression_defs.hh	2014-04-29 13:16:07.464701201 -0300
+@@ -51,6 +51,7 @@ site: http://bugseng.com/products/ppl/ .
+ 
+ #include "Linear_Expression_Interface_defs.hh"
+ #include "Variable_defs.hh"
++#include <cstddef>
+ 
+ namespace Parma_Polyhedra_Library {
+ 
+@@ -381,7 +382,7 @@ public:
+   public:
+     typedef std::bidirectional_iterator_tag iterator_category;
+     typedef const Coefficient value_type;
+-    typedef ptrdiff_t difference_type;
++    typedef std::ptrdiff_t difference_type;
+     typedef value_type* pointer;
+     typedef Coefficient_traits::const_reference reference;
+ 
+diff -up ppl-1.1/src/CO_Tree.cc.orig ppl-1.1/src/CO_Tree.cc
+--- ppl-1.1/src/CO_Tree.cc.orig	2014-04-29 13:19:37.192709232 -0300
++++ ppl-1.1/src/CO_Tree.cc	2014-04-29 13:19:58.000710029 -0300
+@@ -954,7 +954,7 @@ PPL::CO_Tree
+     --subtree_size;
+   }
+ 
+-  const ptrdiff_t distance = first_unused_index - indexes;
++  const std::ptrdiff_t distance = first_unused_index - indexes;
+   PPL_ASSERT(distance >= 0);
+   return static_cast<dimension_type>(distance);
+ }
+diff -up ppl-1.1/src/Constraint_System_defs.hh.orig ppl-1.1/src/Constraint_System_defs.hh
+--- ppl-1.1/src/Constraint_System_defs.hh.orig	2014-04-29 13:30:05.530733294 -0300
++++ ppl-1.1/src/Constraint_System_defs.hh	2014-04-29 13:30:27.167734122 -0300
+@@ -37,6 +37,7 @@ site: http://bugseng.com/products/ppl/ .
+ #include "termination_types.hh"
+ #include <iterator>
+ #include <iosfwd>
++#include <cstddef>
+ 
+ namespace Parma_Polyhedra_Library {
+ 
+@@ -609,7 +610,7 @@ for (Constraint_System::const_iterator i
+ class Parma_Polyhedra_Library::Constraint_System_const_iterator
+   : public std::iterator<std::forward_iterator_tag,
+                          Constraint,
+-                         ptrdiff_t,
++                         std::ptrdiff_t,
+                          const Constraint*,
+                          const Constraint&> {
+ public:
+diff -up ppl-1.1/src/Congruence_System_defs.hh.orig ppl-1.1/src/Congruence_System_defs.hh
+--- ppl-1.1/src/Congruence_System_defs.hh.orig	2014-04-29 13:33:56.927742155 -0300
++++ ppl-1.1/src/Congruence_System_defs.hh	2014-04-29 13:34:15.535742867 -0300
+@@ -33,6 +33,7 @@ site: http://bugseng.com/products/ppl/ .
+ #include "Congruence_defs.hh"
+ #include "Constraint_System_types.hh"
+ #include <iosfwd>
++#include <cstddef>
+ 
+ namespace Parma_Polyhedra_Library {
+ 
+@@ -249,7 +250,7 @@ public:
+   class const_iterator
+     : public std::iterator<std::forward_iterator_tag,
+                            Congruence,
+-                           ptrdiff_t,
++                           std::ptrdiff_t,
+                            const Congruence*,
+                            const Congruence&> {
+   public:
+diff -up ppl-1.1/src/Generator_System_defs.hh.orig ppl-1.1/src/Generator_System_defs.hh
+--- ppl-1.1/src/Generator_System_defs.hh.orig	2014-04-29 13:44:30.122766402 -0300
++++ ppl-1.1/src/Generator_System_defs.hh	2014-04-29 13:44:48.167767093 -0300
+@@ -33,6 +33,7 @@ site: http://bugseng.com/products/ppl/ .
+ #include "Poly_Con_Relation_defs.hh"
+ #include "Polyhedron_types.hh"
+ #include <iosfwd>
++#include <cstddef>
+ 
+ namespace Parma_Polyhedra_Library {
+ 
+@@ -679,7 +680,7 @@ copy(gs.begin(), gs.end(), ostream_itera
+ class Parma_Polyhedra_Library::Generator_System_const_iterator
+   : public std::iterator<std::forward_iterator_tag,
+         Generator,
+-        ptrdiff_t,
++        std::ptrdiff_t,
+         const Generator*,
+         const Generator&> {
+ public:
+diff -up ppl-1.1/src/Grid_Generator_System_defs.hh.orig ppl-1.1/src/Grid_Generator_System_defs.hh
+--- ppl-1.1/src/Grid_Generator_System_defs.hh.orig	2014-04-29 13:45:26.073768544 -0300
++++ ppl-1.1/src/Grid_Generator_System_defs.hh	2014-04-29 13:45:42.535769175 -0300
+@@ -31,6 +31,7 @@ site: http://bugseng.com/products/ppl/ .
+ #include "Variables_Set_types.hh"
+ #include "Polyhedron_types.hh"
+ #include <iosfwd>
++#include <cstddef>
+ 
+ namespace Parma_Polyhedra_Library {
+ 
+@@ -277,7 +278,7 @@ public:
+   class const_iterator
+     : public std::iterator<std::forward_iterator_tag,
+                            Grid_Generator,
+-                           ptrdiff_t,
++                           std::ptrdiff_t,
+                            const Grid_Generator*,
+                            const Grid_Generator&> {
+   public:

pkgs/development/libraries/ppl/upstream-based.patch

···
-https://bugs.gentoo.org/show_bug.cgi?id=447928
---- ppl-1.0/src/p_std_bits.cc.org	2012-12-30 00:37:03.033948083 +0100
-+++ ppl-1.0/src/mp_std_bits.cc	2012-12-30 00:44:12.893019313 +0100
-@@ -25,6 +25,9 @@
- #include "ppl-config.h"
- #include "mp_std_bits.defs.hh"
- 
-+#if __GNU_MP_VERSION < 5 \
-+  || (__GNU_MP_VERSION == 5 && __GNU_MP_VERSION_MINOR < 1)
-+
- const bool std::numeric_limits<mpz_class>::is_specialized;
- const int std::numeric_limits<mpz_class>::digits;
- const int std::numeric_limits<mpz_class>::digits10;
-@@ -70,3 +73,6 @@
- const bool std::numeric_limits<mpq_class>::traps;
- const bool std::numeric_limits<mpq_class>::tininess_before;
- const std::float_round_style std::numeric_limits<mpq_class>::round_style;
-+
-+#endif // __GNU_MP_VERSION < 5
-+       // || (__GNU_MP_VERSION == 5 && __GNU_MP_VERSION_MINOR < 1)
---- ppl-1.0/src/mp_std_bits.defs.hh.org	2012-12-30 00:37:03.037948187 +0100
-+++ ppl-1.0/src/mp_std_bits.defs.hh	2012-12-30 00:42:32.002424189 +0100
-@@ -38,6 +38,9 @@
- #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
- void swap(mpq_class& x, mpq_class& y);
- 
-+#if __GNU_MP_VERSION < 5 \
-+  || (__GNU_MP_VERSION == 5 && __GNU_MP_VERSION_MINOR < 1)
-+
- namespace std {
- 
- #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
-@@ -164,6 +167,9 @@
- 
- } // namespace std
- 
-+#endif // __GNU_MP_VERSION < 5
-+       // || (__GNU_MP_VERSION == 5 && __GNU_MP_VERSION_MINOR < 1)
-+
- #include "mp_std_bits.inlines.hh"
- 
- #endif // !defined(PPL_mp_std_bits_defs_hh)

pkgs/development/libraries/vaapi-intel/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "libva-intel-driver-1.5.1";
+  name = "libva-intel-driver-1.6.0";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/vaapi/releases/libva-intel-driver/${name}.tar.bz2";
-    sha256 = "1p7aw0wmb6z3rbbm3bqlp6rxw41kii23csbjmcvbbk037lq6rnqb";
+    sha256 = "1m08z9md113rv455i78k6784vkjza5k84d59bgpah08cc7jayxlq";
   };
 
   patchPhase = ''

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

···
 
 stdenv.mkDerivation {
 
-  name = "ocaml-csv-1.4";
+  name = "ocaml-csv-1.4.1";
 
   src = fetchzip {
-    url = https://github.com/Chris00/ocaml-csv/releases/download/1.4/csv-1.4.tar.gz;
-    sha256 = "0si0v79rxzyzmgyhd6lidpzxdlcpprlhg0pgrsf688g83xsclkwa";
+    url = https://github.com/Chris00/ocaml-csv/releases/download/1.4.1/csv-1.4.1.tar.gz;
+    sha256 = "1z38qy92lq8qh91bs70vsv868szainif53a2y6rf47ijdila25j4";
   };
 
   buildInputs = [ ocaml findlib ];

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

···
-{ stdenv, fetchurl, ocaml, findlib }:
+{ stdenv, fetchurl, ocaml, findlib, ounit }:
 
 stdenv.mkDerivation {
-  name = "ocaml-fileutils-0.4.5";
+  name = "ocaml-fileutils-0.5.0";
 
   src = fetchurl {
-    url = https://forge.ocamlcore.org/frs/download.php/1194/ocaml-fileutils-0.4.5.tar.gz;
-    sha256 = "0rlqmcgjrfjihjgw5cfmack169cag8054gh5yrqph15av3lx5cra";
+    url = https://forge.ocamlcore.org/frs/download.php/1531/ocaml-fileutils-0.5.0.tar.gz;
+    sha256 = "0xs96nlrrm335mcsgsxnqzspiqyfn26b0jjxm72br7c7ax534n47";
   };
 
-  buildInputs = [ ocaml findlib ];
+  buildInputs = [ ocaml findlib ounit ];
+
+  configureFlags = "--enable-tests";
+  doCheck = true;
+  checkTarget = "test";
 
   createFindlibDestdir = true;
 

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

···
-{stdenv, fetchurl, ocaml, findlib, pgocaml, camlp4}:
+{ stdenv, fetchzip, ocaml, findlib, pgocaml, camlp4 }:
 
 stdenv.mkDerivation {
-  name = "ocaml-macaque-0.7.1";
-  src = fetchurl {
-    url = https://github.com/ocsigen/macaque/archive/0.7.1.tar.gz;
-    sha256 = "0wnq3pgpcrfpivr8j7p827rhag6hdx0yr0bdvma0hw1g30vwf9qa";
+  name = "ocaml-macaque-0.7.2";
+  src = fetchzip {
+    url = https://github.com/ocsigen/macaque/archive/0.7.2.tar.gz;
+    sha256 = "14i0a8cndzndjmlkyhf31r451q99cnkndgxcj0id4qjqhdl4bmjv";
   };
 
   buildInputs = [ ocaml findlib camlp4 ];

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

···
 
   createFindlibDestdir = true;
 
-  propagatedbuildInputs = [ mysql.lib ];
+  propagatedBuildInputs = [ mysql.lib ];
 
   preConfigure = ''
     export LDFLAGS="-L${mysql.lib}/lib/mysql"

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

···
 { fetchurl, stdenv, buildPythonPackage }:
 
 buildPythonPackage {
-  name = "zc.buildout-nix-2.2.1";
+  name = "zc.buildout-nix-2.4.0";
 
   src = fetchurl {
-    url = "https://pypi.python.org/packages/source/z/zc.buildout/zc.buildout-2.2.1.tar.gz";
-    md5 = "476a06eed08506925c700109119b6e41";
+    url = "https://pypi.python.org/packages/source/z/zc.buildout/zc.buildout-2.4.0.tar.gz";
+    md5 = "b8323b1ad285544de0c3dc14ee76ddd3";
   };
 
   patches = [ ./nix.patch ];

pkgs/development/python-modules/buildout-nix/nix.patch

···
 --- a/src/zc/buildout/easy_install.py	2013-08-27 22:28:40.233718116 +0200
 +++ b/src/zc/buildout/easy_install.py   2013-10-07 00:29:31.077413935 +0200
-@@ -508,16 +508,31 @@
-                         self._dest, os.path.basename(dist.location))
+@@ -227,6 +227,12 @@
  
-                     if os.path.isdir(dist.location):
--                        # we got a directory. It must have been
--                        # obtained locally.  Just copy it.
--                        shutil.copytree(dist.location, newloc)
-+                        # Replace links to garbage collected eggs in
-+                        # /nix/store
-+                        if os.path.islink(newloc):
-+                            # It seems necessary to jump through these
-+                            # hoops, otherwise we end up in an
-+                            # infinite loop because
-+                            # self._env.best_match fails to find the dist
-+                            os.remove(newloc)
-+                            dist = self._fetch(avail, tmp, self._download_cache)
-+                            os.symlink(dist.location, newloc)
-+                            newdist = pkg_resources.Distribution.from_filename(
-+                                newloc)
-+                            self._env.add(newdist)
-+                            logger.info("Updated link to %s" %dist.location)
-+                        # Symlink to the egg in /nix/store
-+                        elif not os.path.exists(newloc):
-+                            os.symlink(dist.location, newloc)
-+                            logger.info("Created link to %s" %dist.location)
-                     else:
- 
- 
-                         setuptools.archive_util.unpack_archive(
-                             dist.location, newloc)
- 
--                    redo_pyc(newloc)
-+                        redo_pyc(newloc)
- 
-                     # Getting the dist from the environment causes the
-                     # distribution meta data to be read.  Cloning isn't
+     def _satisfied(self, req, source=None):
+         dists = [dist for dist in self._env[req.project_name] if dist in req]
++        try:
++            dists = ([dist for dist in dists
++                     if dist.precedence == pkg_resources.DEVELOP_DIST]
++                     + [pkg_resources.get_distribution(req.project_name)])
++        except pkg_resources.DistributionNotFound:
++            pass
+         if not dists:
+             logger.debug('We have no distributions for %s that satisfies %r.',
+                          req.project_name, str(req))

pkgs/development/tools/guile/g-wrap/default.nix

···
-{ fetchurl, stdenv, guile, libffi, pkgconfig, glib
-, guile_lib }:
+{ fetchurl, stdenv, guile, libffi, pkgconfig, glib, guile_lib }:
 
 stdenv.mkDerivation rec {
-  name = "g-wrap-1.9.13";
+  name = "g-wrap-1.9.15";
   src = fetchurl {
     url = "mirror://savannah/g-wrap/${name}.tar.gz";
-    sha256 = "0fc874zlwzjahyliqnva1zfsv0chlx4cvfhwchij9n2d3kmsss9v";
+    sha256 = "140fcvp24pqmfmiibhjxl3s75hj26ln7pkl2wxas84lnchbj9m4d";
   };
 
   # Note: Glib support is optional, but it's quite useful (e.g., it's
···
     '';
     homepage = http://www.nongnu.org/g-wrap/;
     license = stdenv.lib.licenses.lgpl2Plus;
-    maintainers = [ ];
+    maintainers = [ stdenv.lib.maintainers.taktoa ];
   };
 }

pkgs/development/tools/misc/dfu-util/default.nix

···
+{ stdenv, fetchurl, pkgconfig, libusb1 }:
+
+stdenv.mkDerivation rec {
+  name="dfu-util-${version}";
+  version = "0.8";
+
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ libusb1 ];
+
+  src = fetchurl {
+    url = "mirror://debian/pool/main/d/dfu-util/dfu-util_0.8.orig.tar.gz";
+    sha256 = "0n7h08avlzin04j93m6hkq9id6hxjiiix7ff9gc2n89aw6dxxjsm";
+  };
+
+  meta = with stdenv.lib; {
+    description = "Device firmware update (DFU) USB programmer";
+    longDescription = ''
+      dfu-util is a program that implements the host (PC) side of the USB
+      DFU 1.0 and 1.1 (Universal Serial Bus Device Firmware Upgrade) protocol.
+
+      DFU is intended to download and upload firmware to devices connected over
+      USB. It ranges from small devices like micro-controller boards up to mobile
+      phones. With dfu-util you are able to download firmware to your device or
+      upload firmware from it.
+    '';
+    homepage = http://dfu-util.gnumonks.org/;
+    license = licenses.gpl2Plus;
+    platforms = platforms.unix;
+    maintainers = [ maintainers.fpletz ];
+  };
+}

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

···
 
 let
 
-  basename = "gdb-7.9";
+  basename = "gdb-7.9.1";
 
   # Whether (cross-)building for GNU/Hurd.  This is an approximation since
   # having `stdenv ? cross' doesn't tell us if we're building `crossDrv' and
···
 
   src = fetchurl {
     url = "mirror://gnu/gdb/${basename}.tar.xz";
-    sha256 = "14l3hhsy7fmpn2dk7ivc67gnbjdhkxlq90kxijpzfa35l58mcccv";
+    sha256 = "0h5sfg4ndhb8q4fxbq0hdxfjp35n6ih96f6x8yvb418s84x5976d";
   };
-
-  # patches = [ ./edit-signals.patch ];
 
   # I think python is not a native input, but I leave it
   # here while I will not need it cross building

pkgs/development/tools/omniorb/default.nix

···
+{ stdenv, fetchurl, python }:
+stdenv.mkDerivation rec {
+
+  name = "omniorb-${version}";
+
+  version = "4.2.0";
+
+  src = fetchurl rec {
+    url = "http://sourceforge.net/projects/omniorb/files/omniORB/omniORB-${version}/omniORB-${version}.tar.bz2";
+    sha256 = "1g58xcw4641wyisp9wscrkzaqrz0vf123dgy52qq2a3wk7y77hkl";
+  };
+
+  buildInputs = [ python ];
+
+  meta = with stdenv.lib; {
+    description = "omniORB is a robust high performance CORBA ORB for C++ and Python. It is freely available under the terms of the GNU Lesser General Public License (for the libraries), and GNU General Public License (for the tools). omniORB is largely CORBA 2.6 compliant.";
+    homepage    = "http://omniorb.sourceforge.net/";
+    license     = licenses.gpl2Plus;
+    maintainers = with maintainers; [ smironov ];
+    platforms   = platforms.unix;
+  };
+}

pkgs/development/web/iojs/default.nix

···
 { stdenv, fetchurl, python, utillinux, openssl_1_0_2, http-parser, zlib, libuv }:
 
 let
-  version = "2.3.4";
+  version = "2.4.0";
   inherit (stdenv.lib) optional maintainers licenses platforms;
 in stdenv.mkDerivation {
   name = "iojs-${version}";
 
   src = fetchurl {
     url = "https://iojs.org/dist/v${version}/iojs-v${version}.tar.gz";
-    sha256 = "1h9cjrs93c8rdycc0ahhc27wv826211aljvfmxfg8jdmg6nvibhq";
+    sha256 = "0g81bn8q4zgm8skkbxbzwa22dnpbing4b5wjqacvpxq3ygz4c98y";
   };
 
   prePatch = ''

pkgs/games/minecraft/default.nix

···
 { stdenv, fetchurl, jre, libX11, libXext, libXcursor, libXrandr, libXxf86vm
-, mesa, openal, alsaOss, pulseaudioSupport ? false, libpulseaudio }:
+, mesa, openal
+, useAlsa ? false, alsaOss ? null }:
 
-assert jre ? architecture;
+assert useAlsa -> alsaOss != null;
 
 stdenv.mkDerivation {
-  name = "minecraft-2013.07.01";
+  name = "minecraft-2015.07.24";
 
   src = fetchurl {
     url = "https://s3.amazonaws.com/Minecraft.Download/launcher/Minecraft.jar";
···
     #!${stdenv.shell}
 
     # wrapper for minecraft
-    export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:${jre}/lib/${jre.architecture}/:${libX11}/lib/:${libXext}/lib/:${libXcursor}/lib/:${libXrandr}/lib/:${libXxf86vm}/lib/:${mesa}/lib/:${openal}/lib/
-    ${if pulseaudioSupport then "${libpulseaudio}/bin/padsp" else "${alsaOss}/bin/aoss" } \
+    export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:${libX11}/lib/:${libXext}/lib/:${libXcursor}/lib/:${libXrandr}/lib/:${libXxf86vm}/lib/:${mesa}/lib/:${openal}/lib/
+    ${if useAlsa then "${alsaOss}/bin/aoss" else "" } \
       ${jre}/bin/java -jar $out/minecraft.jar
     EOF
 

pkgs/games/steam/chrootenv.nix

···
       pkgs.openal
       pkgs.libpulseaudio
 
-      pkgs.flashplayer
-
       pkgs.gst_all_1.gst-plugins-ugly # "Audiosurf 2" needs this
     ];
 

pkgs/misc/drivers/hplip/default.nix

···
 { stdenv, fetchurl, automake, pkgconfig
-, cups, zlib, libjpeg, libusb1, pythonPackages, saneBackends, dbus
+, cups, zlib, libjpeg, libusb1, pythonPackages, saneBackends, dbus, usbutils
 , polkit, qtSupport ? true, qt4, pyqt4, net_snmp
 , withPlugin ? false, substituteAll, makeWrapper
 }:
 
 let
 
-  name = "hplip-3.15.6";
+  version = "3.15.7";
+
+  name = "hplip-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/hplip/${name}.tar.gz";
-    sha256 = "1jbnjw7vrn1qawrjfdv8j58w69q8ki1qkzvlh0nk8nxacpp17i9h";
+    sha256 = "17flpl89lgwlbsy9mka910g530nnvlwqqnif8a9hyq7k90q9046k";
+  };
+
+  plugin = fetchurl {
+    url = "http://www.openprinting.org/download/printdriver/auxfiles/HP/plugins/${name}-plugin.run";
+    sha256 = "0fblh5m43jnws4vkwks0b4m9k3jg9kspaj1l8bic0r5swy97s41m";
   };
 
   hplip_state =
     substituteAll
       {
+        inherit version;
         src = ./hplip.state;
-        # evaluated this way, version is always up-to-date
-        version = (builtins.parseDrvName name).version;
       };
 
   hplip_arch =
···
       "arm7l-linux" = "arm32";
     }."${stdenv.system}" or (abort "Unsupported platform ${stdenv.system}");
 
-  plugin = fetchurl {
-    url = "http://www.openprinting.org/download/printdriver/auxfiles/HP/plugins/${name}-plugin.run";
-    sha256 = "1rymxahz12s1s37rri5qyvka6q0yi0yai08kgspg24176ry3a3fx";
-  };
-
 in
 
 stdenv.mkDerivation {
   inherit name src;
 
+  buildInputs = [
+    libjpeg
+    cups
+    libusb1
+    pythonPackages.python
+    pythonPackages.wrapPython
+    saneBackends
+    dbus
+    net_snmp
+  ] ++ stdenv.lib.optional qtSupport qt4;
+  nativeBuildInputs = [
+    pkgconfig
+  ];
+
+  pythonPath = with pythonPackages; [
+    dbus
+    pillow
+    pygobject
+    recursivePthLoader
+    reportlab
+    usbutils
+  ] ++ stdenv.lib.optional qtSupport pyqt4;
+
   prePatch = ''
     # HPLIP hardcodes absolute paths everywhere. Nuke from orbit.
     find . -type f -exec sed -i \
···
       {} +
   '';
 
-  preConfigure = ''
-    export configureFlags="$configureFlags
-      --with-cupsfilterdir=$out/lib/cups/filter
-      --with-cupsbackenddir=$out/lib/cups/backend
-      --with-icondir=$out/share/applications
-      --with-systraydir=$out/xdg/autostart
-      --with-mimedir=$out/etc/cups
-      --enable-policykit
-    "
+  configureFlags = ''
+    --with-cupsfilterdir=$(out)/lib/cups/filter
+    --with-cupsbackenddir=$(out)/lib/cups/backend
+    --with-icondir=$(out)/share/applications
+    --with-systraydir=$(out)/xdg/autostart
+    --with-mimedir=$(out)/etc/cups
+    --enable-policykit
+  '';
 
-    export makeFlags="
-      halpredir=$out/share/hal/fdi/preprobe/10osvendor
-      rulesdir=$out/etc/udev/rules.d
-      policykit_dir=$out/share/polkit-1/actions
-      policykit_dbus_etcdir=$out/etc/dbus-1/system.d
-      policykit_dbus_sharedir=$out/share/dbus-1/system-services
-      hplip_confdir=$out/etc/hp
-      hplip_statedir=$out/var/lib/hp
-    ";
+  makeFlags = ''
+    halpredir=$(out)/share/hal/fdi/preprobe/10osvendor
+    rulesdir=$(out)/etc/udev/rules.d
+    policykit_dir=$(out)/share/polkit-1/actions
+    policykit_dbus_etcdir=$(out)/etc/dbus-1/system.d
+    policykit_dbus_sharedir=$(out)/share/dbus-1/system-services
+    hplip_confdir=$(out)/etc/hp
+    hplip_statedir=$(out)/var/lib/hp
   '';
+
+  enableParallelBuilding = true;
 
   postInstall =
-    ''
-      # Wrap the user-facing Python scripts in /bin without turning the ones
-      # in /share into shell scripts (they need to be importable).
-      # Complicated by the fact that /bin contains just symlinks to /share.
-      for bin in $out/bin/*; do
-        py=`readlink -m $bin`
-        rm $bin
-        cp $py $bin
-        wrapPythonProgramsIn $bin "$out $pythonPath"
-        sed -i "s@$(dirname $bin)/[^ ]*@$py@g" $bin
-      done
-
-      # Remove originals. Knows a little too much about wrapPythonProgramsIn.
-      rm -f $out/bin/.*-wrapped
-
-      wrapPythonPrograms $out/lib "$out $pythonPath"
-    ''
-    + (stdenv.lib.optionalString withPlugin
+    (stdenv.lib.optionalString withPlugin
     (let hplip_arch =
           if stdenv.system == "i686-linux" then "x86_32"
           else if stdenv.system == "x86_64-linux" then "x86_64"
-          else abort "Platform must be i686-linux or x86_64-linux!";
+          else abort "Plugin platform must be i686-linux or x86_64-linux!";
     in
     ''
     sh ${plugin} --noexec --keep
···
     mv $out/etc/sane.d/dll.conf $out/etc/sane.d/dll.d/hpaio.conf
 
     rm $out/etc/udev/rules.d/56-hpmud.rules
-    ''));
+  ''));
+
+  fixupPhase = ''
+    # Wrap the user-facing Python scripts in $out/bin without turning the
+    # ones in $out /share into shell scripts (they need to be importable).
+    # Note that $out/bin contains only symlinks to $out/share.
+    for bin in $out/bin/*; do
+      py=`readlink -m $bin`
+      rm $bin
+      cp $py $bin
+      wrapPythonProgramsIn $bin "$out $pythonPath"
+      sed -i "s@$(dirname $bin)/[^ ]*@$py@g" $bin
+    done
+
+    # Remove originals. Knows a little too much about wrapPythonProgramsIn.
+    rm -f $out/bin/.*-wrapped
+
+    # Merely patching shebangs in $out/share does not cause trouble.
+    for i in $out/share/hplip{,/*}/*.py; do
+      substituteInPlace $i \
+        --replace /usr/bin/python \
+        ${pythonPackages.python}/bin/${pythonPackages.python.executable} \
+        --replace "/usr/bin/env python" \
+        ${pythonPackages.python}/bin/${pythonPackages.python.executable}
+    done
 
-  buildInputs = [
-      libjpeg
-      cups
-      libusb1
-      pythonPackages.python
-      pythonPackages.wrapPython
-      saneBackends
-      dbus
-      net_snmp
-    ] ++ stdenv.lib.optional qtSupport qt4;
-  nativeBuildInputs = [
-    pkgconfig
-  ];
+    wrapPythonProgramsIn $out/lib "$out $pythonPath"
 
-  pythonPath = with pythonPackages; [
-      dbus
-      pillow
-      pygobject
-      recursivePthLoader
-      reportlab
-    ] ++ stdenv.lib.optional qtSupport pyqt4;
+    substituteInPlace $out/etc/hp/hplip.conf --replace /usr $out
+  '';
 
   meta = with stdenv.lib; {
+    inherit version;
     description = "Print, scan and fax HP drivers for Linux";
     homepage = http://hplipopensource.com/;
     license = if withPlugin

pkgs/os-specific/linux/firmware/firmware-linux-nonfree/default.nix

···
-{ stdenv, fetchgit }:
+{ stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   name = "firmware-linux-nonfree-${version}";
-  version = "2015-07-12";
+  version = "2015-07-23";
 
-  src = fetchgit {
-    url = "http://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/linux-firmware.git";
-    rev = "5e6d7a9d70b562c60471e234f78137020d65ccbf";
-    sha256 = "06gvjdqpbayfv696hxn9xjkbzddj1hy6z9aahi156lvj96qb9z49";
+  # This repo is built by merging the latest versions of
+  # http://git.kernel.org/cgit/linux/kernel/git/firmware/linux-firmware.git/
+  # and
+  # http://git.kernel.org/cgit/linux/kernel/git/iwlwifi/linux-firmware.git/
+  # for any given date. This gives us up to date iwlwifi firmware as well as
+  # the usual set of firmware. firmware/linux-firmware usually lags kernel releases
+  # so iwlwifi cards will fail to load on newly released kernels.
+  src = fetchFromGitHub {
+    owner = "wkennington";
+    repo = "linux-firmware";
+    rev = "854b7f33e839ceea41034b45d6f755ea70c85486";
+    sha256 = "1hhqvb96adk64ljf6hp5qss8fhpic28y985gbggh5p2w9bsgs5zq";
   };
 
   preInstall = ''

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

···
 { fetchurl, stdenv, flex, bison, db, iptables, pkgconfig }:
 
 stdenv.mkDerivation rec {
-  name = "iproute2-4.0.0";
+  name = "iproute2-4.1.1";
 
   src = fetchurl {
     url = "mirror://kernel/linux/utils/net/iproute2/${name}.tar.xz";
-    sha256 = "0616cg6liyysfddf6d8i4vyndd9b0hjmfw35icq8p18b0nqnxl2w";
+    sha256 = "0vz6m2k6hdrjlg4x0r3cd75lg9ysmndbsp35pm8494zvksc7l1vk";
   };
 
   patch = [ ./vpnc.patch ];

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.18.18";
+  version = "3.18.19";
   extraMeta.branch = "3.18";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1fcd4xfnywwb3grdvcnf39njwzb40v10rnzagxqmancsaqy253jv";
+    sha256 = "1jdp4mixggzjy1v806v5q7qqimkm6pbjav3gwbcl2cccv6wd701x";
   };
 
   features.iwlwifi = true;

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

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.1.2";
+  version = "4.1.3";
   extraMeta.branch = "4.1";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1mdyjhnzhh254cblahqmpsk226z006z6sm9dmwvg6jlhpsw4cjhy";
+    sha256 = "02z3palvki31qimmycz4y4wl4lb46n662qql46iah224k0q2rpcn";
   };
 
   features.iwlwifi = true;

pkgs/os-specific/linux/perf-tools/default.nix

···
 { lib, stdenv, fetchFromGitHub, perl }:
 
 stdenv.mkDerivation {
-  name = "perf-tools-20150704";
+  name = "perf-tools-20150723";
 
   src = fetchFromGitHub {
     owner = "brendangregg";
     repo = "perf-tools";
-    rev = "30ff4758915a98fd43020c1b45a63341208fd8b9";
-    sha256 = "0x59xm96jmpfgik6f9d6q6v85dip3kvi4ncijpghhg59ayyd5i6a";
+    rev = "80e25785e16acfbc0f048cae86a69006fa45148d";
+    sha256 = "13g98vqwy50yf2h0w6iav80kzwfz29mvnjw8akbjv4v36r9hcb69";
   };
 
   buildInputs = [ perl ];

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

···
-{ callPackage, fetchgit, ... } @ args:
+{ callPackage, fetchFromGitHub, ... } @ args:
 
 callPackage ./generic.nix (args // rec {
-  version = "2015-06-29";
+  version = "2015-07-21";
 
-  src = fetchgit {
-    url = git://github.com/zfsonlinux/spl.git;
-    rev = "77ab5dd33a99bdf7fb062f0ea327582236a225b3";
-    sha256 = "1hbn8hi305cn15nlcm9x99nczjqjkhdc38hzww11xn78py8d90w9";
+  src = fetchFromGitHub {
+    owner = "zfsonlinux";
+    repo = "spl";
+    rev = "9eb361aaa537724c9a90ab6a9f33521bfd80bad9";
+    sha256 = "18sv4mw85fbm8i1s8k4y5dc43l6ll2f6hgfrawvzgvwni5i4h7n8";
   };
 
   patches = [ ./const.patch ./install_prefix.patch ];

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

···
 
 stdenv.mkDerivation rec {
   name = "v4l2loopback-${version}-${kernel.version}";
-  version = "0.8.0";
+  version = "0.9.1";
 
   src = fetchurl {
     url = "https://github.com/umlaeute/v4l2loopback/archive/v${version}.tar.gz";
-    sha256 = "1rhsgc4prrj8s6njixic7fs5m3gs94v9hhf3am6lnfh5yv6yab9h";
+    sha256 = "1crkhxlnskqrfj3f7jmiiyi5m75zmj7n0s26xz07wcwdzdf2p568";
   };
   
   preBuild = ''
···
     export PATH=${kmod}/sbin:$PATH
   '';
 
-  patches = [ ./kernel-3.18-fix.patch ];
-  
   buildInputs = [ kmod ];
   
   makeFlags = [

pkgs/os-specific/linux/v4l2loopback/kernel-3.18-fix.patch

···
-From 21195cd6d1ff767a271359dfa7d201078f766611 Mon Sep 17 00:00:00 2001
-From: tatokis <[e-mail]>
-Date: Mon, 24 Nov 2014 16:28:33 +0200
-Subject: [PATCH] Updated v4l2loopback.c to compile on >= 3.18 kernel
-
----
- v4l2loopback.c | 9 +++++++--
- 1 file changed, 7 insertions(+), 2 deletions(-)
-
-diff --git a/v4l2loopback.c b/v4l2loopback.c
-index bb228bb..67f6ed4 100644
---- a/v4l2loopback.c
-+++ b/v4l2loopback.c
-@@ -498,10 +498,15 @@ static ssize_t attr_store_maxopeners(struct device *cd,
- {
- 	struct v4l2_loopback_device *dev = NULL;
- 	unsigned long curr = 0;
--
-+	
-+	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,0)
-+	if (kstrtoul(buf, 0, &curr))
-+		return -EINVAL;
-+	#else
- 	if (strict_strtoul(buf, 0, &curr))
- 		return -EINVAL;
--
-+	#endif
-+	
- 	dev = v4l2loopback_cd2dev(cd);
- 
- 	if (dev->max_openers == curr)

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

···
     "--with-udevdir=$(out)/lib/udev"
     "--with-systemdunitdir=$(out)/etc/systemd/system"
     "--with-systemdpresetdir=$(out)/etc/systemd/system-preset"
+    "--with-mounthelperdir=$(out)/bin"
     "--sysconfdir=/etc"
     "--localstatedir=/var"
     "--enable-systemd"
···
   ];
 
   enableParallelBuilding = true;
+
+  installFlags = [
+    "sysconfdir=\${out}/etc"
+    "DEFAULT_INITCONF_DIR=\${out}/default"
+  ];
 
   postInstall = ''
     # Prevent kernel modules from depending on the Linux -dev output.

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

···
-{ callPackage, stdenv, fetchgit, spl_git, ... } @ args:
+{ callPackage, stdenv, fetchFromGitHub, spl_git, ... } @ args:
 
 callPackage ./generic.nix (args // rec {
-  version = "2015-05-13";
+  version = "2015-07-21";
 
-  src = fetchgit {
-    url = git://github.com/zfsonlinux/zfs.git;
-    rev = "7fec46b9d8967109ad289d208e8cf36a0c16e40c";
-    sha256 = "0gvzw6vn7wyq2g9psv0fdars7ssidqc5l85x4yym5niccy1xl437";
+  src = fetchFromGitHub {
+    owner = "zfsonlinux";
+    repo = "zfs";
+    rev = "3b79cef21294f3ec46c4f71cc5a68a75a4d0ebc7";
+    sha256 = "01l4cg62wgn3wzasskx2nh3a4c74vq8qcwz090x8x1r4c2r4v943";
   };
 
   patches = [ ./nix-build.patch ];

pkgs/servers/x11/xorg/default.nix

···
   }) // {inherit fontsproto libpciaccess randrproto renderproto videoproto xextproto xorgserver xproto ;};
 
   xf86videointel = (mkDerivation "xf86videointel" {
-    name = "xf86-video-intel-2.99.917";
+    name = "xf86-video-intel-2015-07-22";
     builder = ./builder.sh;
     src = fetchurl {
-      url = mirror://xorg/individual/driver/xf86-video-intel-2.99.917.tar.bz2;
-      sha256 = "1jb7jspmzidfixbc0gghyjmnmpqv85i7pi13l4h2hn2ml3p83dq0";
+      url = http://cgit.freedesktop.org/xorg/driver/xf86-video-intel/snapshot/a29e765ec0c1d73ee7ef2dad3aa148214ec04335.tar.gz;
+      sha256 = "094qa8x0f7vgyirjbj9qdyak71nwxnmmsxml4zk49z59blq4l874";
     };
     buildInputs = [pkgconfig dri2proto dri3proto fontsproto libdrm libpng udev libpciaccess presentproto randrproto renderproto libX11 xcbutil libxcb libXcursor libXdamage libXext xextproto xf86driproto libXfixes xorgserver xproto libXrandr libXrender libxshmfence libXtst libXvMC ];
   }) // {inherit dri2proto dri3proto fontsproto libdrm libpng udev libpciaccess presentproto randrproto renderproto libX11 xcbutil libxcb libXcursor libXdamage libXext xextproto xf86driproto libXfixes xorgserver xproto libXrandr libXrender libxshmfence libXtst libXvMC ;};

pkgs/servers/x11/xorg/overrides.nix

···
 
   xf86videointel = attrs: attrs // {
     buildInputs = attrs.buildInputs ++ [xorg.libXfixes];
-    patches = [ ./xf86-video-intel-2.99.917-libdrm-kernel-4_0-crash.patch ];
+    nativeBuildInputs = [args.autoreconfHook xorg.utilmacros];
   };
 
   xwd = attrs: attrs // {

pkgs/servers/x11/xorg/xf86-video-intel-2.99.917-libdrm-kernel-4_0-crash.patch

···
-From 7fe2b2948652443ff43d907855bd7a051d54d309 Mon Sep 17 00:00:00 2001
-From: Chris Wilson <[e-mail]>
-Date: Thu, 19 Mar 2015 23:14:17 +0000
-Subject: sna: Protect against ABI breakage in recent versions of libdrm
-
-Signed-off-by: Chris Wilson <[e-mail]>
-
-diff --git a/src/sna/kgem.c b/src/sna/kgem.c
-index 11f0828..6f16cba 100644
---- a/src/sna/kgem.c
-+++ b/src/sna/kgem.c
-@@ -182,6 +182,15 @@ struct local_i915_gem_caching {
- #define LOCAL_IOCTL_I915_GEM_SET_CACHING DRM_IOW(DRM_COMMAND_BASE + LOCAL_I915_GEM_SET_CACHING, struct local_i915_gem_caching)
- #define LOCAL_IOCTL_I915_GEM_GET_CACHING DRM_IOW(DRM_COMMAND_BASE + LOCAL_I915_GEM_GET_CACHING, struct local_i915_gem_caching)
- 
-+struct local_i915_gem_mmap {
-+	uint32_t handle;
-+	uint32_t pad;
-+	uint64_t offset;
-+	uint64_t size;
-+	uint64_t addr_ptr;
-+};
-+#define LOCAL_IOCTL_I915_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP, struct local_i915_gem_mmap)
-+
- struct local_i915_gem_mmap2 {
- 	uint32_t handle;
- 	uint32_t pad;
-@@ -514,15 +523,15 @@ retry_wc:
- 
- static void *__kgem_bo_map__cpu(struct kgem *kgem, struct kgem_bo *bo)
- {
--	struct drm_i915_gem_mmap mmap_arg;
-+	struct local_i915_gem_mmap arg;
- 	int err;
- 
- retry:
--	VG_CLEAR(mmap_arg);
--	mmap_arg.handle = bo->handle;
--	mmap_arg.offset = 0;
--	mmap_arg.size = bytes(bo);
--	if ((err = do_ioctl(kgem->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg))) {
-+	VG_CLEAR(arg);
-+	arg.handle = bo->handle;
-+	arg.offset = 0;
-+	arg.size = bytes(bo);
-+	if ((err = do_ioctl(kgem->fd, LOCAL_IOCTL_I915_GEM_MMAP, &arg))) {
- 		assert(err != EINVAL);
- 
- 		if (__kgem_throttle_retire(kgem, 0))
-@@ -536,10 +545,10 @@ retry:
- 		return NULL;
- 	}
- 
--	VG(VALGRIND_MAKE_MEM_DEFINED(mmap_arg.addr_ptr, bytes(bo)));
-+	VG(VALGRIND_MAKE_MEM_DEFINED(arg.addr_ptr, bytes(bo)));
- 
- 	DBG(("%s: caching CPU vma for %d\n", __FUNCTION__, bo->handle));
--	return bo->map__cpu = (void *)(uintptr_t)mmap_arg.addr_ptr;
-+	return bo->map__cpu = (void *)(uintptr_t)arg.addr_ptr;
- }
- 
- static int gem_write(int fd, uint32_t handle,
--- 
-cgit v0.10.2
-

pkgs/tools/backup/borg/default.nix

···
+{ stdenv, fetchzip, python3Packages, openssl, acl }:
+
+python3Packages.buildPythonPackage rec {
+  name = "borg-${version}";
+  version = "0.23.0";
+  namePrefix = "";
+
+  src = fetchzip {
+    name = "${name}-src";
+    url = "https://github.com/borgbackup/borg/archive/${version}.tar.gz";
+    sha256 = "1ns00bhrh4zm1s70mm32gnahj7yh4jdpkb8ziarhvcnknz7aga67";
+  };
+
+  propagatedBuildInputs = with python3Packages;
+    [ cython msgpack openssl acl llfuse tox detox ];
+
+  preConfigure = ''
+    export BORG_OPENSSL_PREFIX="${openssl}"
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A deduplicating backup program (attic fork)";
+    homepage = https://borgbackup.github.io/;
+    license = licenses.bsd3;
+    platforms = platforms.unix; # Darwin and FreeBSD mentioned on homepage
+  };
+}

pkgs/tools/filesystems/ceph/0.80.nix

···
   src = fetchgit {
     url = "git://github.com/ceph/ceph.git";
     rev = "refs/tags/v${version}";
-    sha256 = "1arajccczjdqp7igs17569xlq5cj4azcm5wwixg6ryypjr2grcbl";
+    leaveDotGit = true;
+    sha256 = "0s81j6yj8y27hlx1hid9maz0l7bhjjskjxzxlhsikzmdc1j27m4r";
   };
 
   patches = [

pkgs/tools/filesystems/ceph/0.94.nix

···
   src = fetchgit {
     url = "https://github.com/ceph/ceph.git";
     rev = "refs/tags/v${version}";
-    sha256 = "1nhqzmxv7bz93b8rbd88wgmw9icm2lhmc94dfscgh23kfpipyd6l";
+    leaveDotGit = true;
+    sha256 = "094f9knxgx8vb9fb1yzld9ib4m0wpqwqgqjl3xqf0dzm48nxqd73";
   };
 
   patches = [

pkgs/tools/filesystems/ceph/dev.nix

···
   src = fetchgit {
     url = "https://github.com/ceph/ceph.git";
     rev = "refs/tags/v${version}";
-    sha256 = "0kydjyvb1566mh33p6dlljfx1r4cfdj8ic4i19h5r9vavkc46nf0";
+    leaveDotGit = true;
+    sha256 = "13iyv53kq2ka5py759cdiw0wmzpsycskvhmyr74qkpxmw9g6177y";
   };
 
   patches = [ ./fix-pythonpath.patch ];

pkgs/tools/filesystems/ceph/generic.nix

···
-{ stdenv, autoconf, automake, makeWrapper, pkgconfig, libtool, which
-, boost, python, pythonPackages, libxml2, git, zlib
+{ stdenv, autoconf, automake, makeWrapper, pkgconfig, libtool, which, git
+, boost, python, pythonPackages, libxml2, zlib
 
 # Optional Dependencies
 , snappy ? null, leveldb ? null, yasm ? null, fcgi ? null, expat ? null
···
     ./0001-Makefile-env-Don-t-force-sbin.patch
   ];
 
-  nativeBuildInputs = [ autoconf automake makeWrapper pkgconfig libtool which ]
+  nativeBuildInputs = [ autoconf automake makeWrapper pkgconfig libtool which git ]
     ++ optionals (versionAtLeast version "9.0.2") [
       pythonPackages.setuptools pythonPackages.argparse
     ];
   buildInputs = buildInputs ++ cryptoLibsMap.${cryptoStr} ++ [
     boost python libxml2 optYasm optLibatomic_ops optLibs3 malloc pythonPackages.flask zlib
   ] ++ optional (versionAtLeast version "9.0.0") [
-    git                   # Used for the gitversion string
     pythonPackages.sphinx # Used for docs
   ] ++ optional stdenv.isLinux [
     linuxHeaders libuuid udev keyutils optLibaio optLibxfs optZfs

pkgs/tools/filesystems/ceph/git.nix

···
-{ callPackage, fetchgit, git, ... } @ args:
+{ callPackage, fetchgit, ... } @ args:
 
 callPackage ./generic.nix (args // rec {
-  version = "2015-07-20";
+  version = "2015-07-23";
 
   src = fetchgit {
     url = "git://github.com/ceph/ceph.git";
-    rev = "ce534e1e0addfe93194a553cec98799ea97affe4";
-    sha256 = "19i9fp06fdyhx5x6ryw5q81id0354601yxnywvir3i9hy51p9xaz";
+    rev = "f7bda9567d2a1acf015ab891eb5bb9ca0cdc8396";
+    leaveDotGit = true;
+    sha256 = "0z3i4aadyyklafm3lia8dg8l0wr3cvy53v3h7b533nm61lq07maf";
   };
 
   patches = [ ./fix-pythonpath.patch ];

pkgs/tools/misc/fzf/default.nix

···
+{ stdenv, fetchFromGitHub, goPackages, syncthing, ncurses }:
+
+with goPackages;
+
+buildGoPackage rec {
+  name = "fzf-${version}";
+  version = "0.10.0";
+  goPackagePath = "github.com/junegunn/fzf";
+  src = fetchFromGitHub {
+    owner = "junegunn";
+    repo = "fzf";
+    rev = "${version}";
+    sha256 = "0dx9qwmcrnh31m2n75qmpj1dxm6rr6xsbazy4nwa3bzrb8y6svh2";
+  };
+
+  buildInputs = with goPackages; [
+    crypto
+    ginkgo
+    gomega
+    junegunn.go-runewidth
+    go-shellwords
+    ncurses
+    syncthing
+    text
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/junegunn/fzf;
+    description = "A command-line fuzzy finder written in Go";
+    license = licenses.mit;
+    maintainers = [ maintainers.magnetophon ];
+  };
+}

pkgs/tools/misc/wyrd/default.nix

···
-{ stdenv, fetchurl, ocaml, ncurses, remind }:
+{ stdenv, fetchurl, ocaml, ncurses, remind, camlp4 }:
 
 stdenv.mkDerivation rec {
   version = "1.4.6";
···
     sha256 = "0zlrg602q781q8dij62lwdprpfliyy9j1rqfqcz8p2wgndpivddj";
   };
 
-  buildInputs = [ ocaml ncurses remind ];
+  buildInputs = [ ocaml ncurses remind camlp4 ];
 
   preferLocalBuild = true;
 

pkgs/tools/networking/dhcpcd/default.nix

···
 { stdenv, fetchurl, pkgconfig, udev }:
 
 stdenv.mkDerivation rec {
-  name = "dhcpcd-6.9.0";
+  name = "dhcpcd-6.9.1";
 
   src = fetchurl {
-    url = "mirror://roy/dhcpcd/${name}.tar.bz2";
-    sha256 = "0s0a29ml9x108lxv5yz55f3l5kvlx4hcbxigfq3hr245yy7aarhm";
+    url = "mirror://roy/dhcpcd/${name}.tar.xz";
+    sha256 = "0vq6gjgn2sjq2rwvd23gvf55k2v9l6970z8fmii0p2g23w77afy0";
   };
 
   buildInputs = [ pkgconfig udev ];

pkgs/tools/networking/horst/default.nix

···
+{stdenv, fetchFromGitHub, pkgconfig, ncurses, libnl }:
+
+stdenv.mkDerivation rec {
+  name = "horst-${version}";
+  version = "git-2015-07-22";
+
+  src = fetchFromGitHub {
+    owner = "br101";
+    repo = "horst";
+    rev = "b62fc20b98690061522a431cb278d989e21141d8";
+    sha256 = "176yma8v2bsab2ypgmgzvjg0bsbnk9sga3xpwkx33mwm6q79kd6g";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ ncurses libnl ];
+
+  installPhase = ''
+    mkdir -p $out/bin
+    mv horst $out/bin
+
+    mkdir -p $out/man/man1
+    cp horst.1 $out/man/man1
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Small and lightweight IEEE802.11 wireless LAN analyzer with a text interface";
+    homepage = http://br1.einfach.org/tech/horst/;
+    maintainers = [ maintainers.fpletz ];
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/networking/i2p/default.nix

···
 { stdenv, procps, coreutils, fetchurl, jdk, jre, ant, gettext, which }:
 
 stdenv.mkDerivation rec {
-  name = "i2p-0.9.19";
+  name = "i2p-0.9.20";
   src = fetchurl {
     url = "https://github.com/i2p/i2p.i2p/archive/${name}.tar.gz";
-    sha256 = "1q9sda1a708laxf452qnzbfv7bwfwyam5n1giw2n3z3ar602i936";
+    sha256 = "10rynkl9dbnfl67ck3d7wdwz52h7354r7nbwcypsjnng4f1dmj5s";
   };
   buildInputs = [ jdk ant gettext which ];
+  patches = [ ./i2p.patch ];
   buildPhase = ''
     export JAVA_TOOL_OPTIONS="-Dfile.encoding=UTF8"
     ant preppkg-linux-only
···
     cp -r pkg-temp/* $out
     cp installer/lib/wrapper/linux64/* $out
     sed -i $out/i2prouter -i $out/runplain.sh \
-      -e "s#%INSTALL_PATH#$out#" \
+      -e "s#uname#${coreutils}/bin/uname#" \
+      -e "s#which#${which}/bin/which#" \
+      -e "s#%gettext%#${gettext}/bin/gettext#" \
       -e "s#/usr/ucb/ps#${procps}/bin/ps#" \
       -e "s#/usr/bin/tr#${coreutils}/bin/tr#" \
+      -e "s#%INSTALL_PATH#$out#" \
       -e 's#%USER_HOME#$HOME#' \
       -e "s#%SYSTEM_java_io_tmpdir#/tmp#" \
-      -e 's#JAVA=java#JAVA=${jre}/bin/java#'
-    sed -i $out/runplain.sh \
-      -e "s#nohup \(.*Launch\) .*#\1#" \
-      -e "s#echo \$\! .*##"
+      -e "s#%JAVA%#${jre}/bin/java#"
     mv $out/runplain.sh $out/bin/i2prouter-plain
     mv $out/man $out/share/
     chmod +x $out/bin/* $out/i2psvc

pkgs/tools/networking/i2p/i2p.patch

···
+--- a/installer/resources/runplain.sh
++++ b/installer/resources/runplain.sh
+@@ -21,7 +21,7 @@
+ 
+ # Try using the Java binary that I2P was installed with.
+ # If it's not found, try looking in the system PATH.
+-JAVA=$(which %JAVA_HOME/bin/java || which java)
++JAVA=%JAVA%
+ 
+ if [ -z $JAVA ] || [ ! -x $JAVA ]; then
+     echo "Error: Cannot find java." >&2
+@@ -40,15 +40,4 @@
+     export JAVA_TOOL_OPTIONS="-Djava.awt.headless=true"
+ fi
+ JAVAOPTS="-Djava.net.preferIPv4Stack=${PREFERv4} -Djava.library.path=${I2P}:${I2P}/lib -Di2p.dir.base=${I2P} -DloggerFilenameOverride=logs/log-router-@.txt"
+-(
+-    nohup ${JAVA} -cp \"${CP}\" ${JAVAOPTS} net.i2p.router.RouterLaunch > /dev/null 2>&1
+-) &
+-PID=$!
+-
+-if [ ! -z $PID ] && kill -0 $PID > /dev/null 2>&1 ; then
+-    echo "I2P started [$PID]" >&2
+-    echo $PID > "${I2PTEMP}/router.pid"
+-else
+-    echo "I2P failed to start." >&2
+-    exit 1
+-fi
++${JAVA} -cp \"${CP}\" ${JAVAOPTS} net.i2p.router.RouterLaunch
+--- a/installer/resources/i2prouter
++++ b/installer/resources/i2prouter
+@@ -49,7 +49,7 @@
+ 
+ # gettext - we look for it in the path
+ # fallback to echo is below, we can't set it to echo here.
+-GETTEXT=$(which gettext > /dev/null 2>&1)
++GETTEXT=%gettext%
+ 
+ # Where to install the systemd service
+ SYSTEMD_SERVICE="/etc/systemd/system/${APP_NAME}.service"

pkgs/tools/networking/ipv6calc/default.nix

···
 { stdenv, fetchurl, geoip, geolite-legacy, getopt, openssl, perl }:
 
+let version = "0.99.0"; in
 stdenv.mkDerivation rec {
-  version = "0.98.0";
   name = "ipv6calc-${version}";
 
   src = fetchurl {
     url = "ftp://ftp.deepspace6.net/pub/ds6/sources/ipv6calc/${name}.tar.gz";
-    sha256 = "02r0r4lgz10ivbmgdzivj7dvry1aad75ik9vyy6irjvngjkzg5r3";
+    sha256 = "1dgx6gji9dyz77jssk2ax5r0ycq4jcsks71bhvcpb79k02wkaxgw";
   };
 
   buildInputs = [ geoip geolite-legacy getopt openssl ];
···
     done
   '';
 
-  configureFlags = ''
-    --disable-bundled-getopt
-    --disable-bundled-md5
-    --disable-dynamic-load
-    --enable-shared
-    --enable-geoip
-    --with-geoip-db=${geolite-legacy}/share/GeoIP
-  '';
+  configureFlags = [
+    "--disable-bundled-getopt"
+    "--disable-bundled-md5"
+    "--disable-dynamic-load"
+    "--enable-shared"
+  ] ++ stdenv.lib.optional (geoip != null ) [
+    "--enable-geoip"
+  ] ++ stdenv.lib.optional (geolite-legacy != null) [
+    "--with-geoip-db=${geolite-legacy}/share/GeoIP"
+  ];
 
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
+    inherit version;
     description = "Calculate/manipulate (not only) IPv6 addresses";
     longDescription = ''
       ipv6calc is a small utility to manipulate (not only) IPv6 addresses and
···
     '';
     homepage = http://www.deepspace6.net/projects/ipv6calc.html;
     license = licenses.gpl2;
-    platforms = with platforms; linux;
+    platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
 }

pkgs/tools/networking/netsniff-ng/default.nix

···
   postInstall = ''
     ln -sv ${geolite-legacy}/share/GeoIP/GeoIP.dat		$out/etc/netsniff-ng/country4.dat
     ln -sv ${geolite-legacy}/share/GeoIP/GeoIPv6.dat		$out/etc/netsniff-ng/country6.dat
-    ln -sv ${geolite-legacy}/share/GeoIP/GeoLiteCity.dat	$out/etc/netsniff-ng/city4.dat
-    ln -sv ${geolite-legacy}/share/GeoIP/GeoLiteCityv6.dat	$out/etc/netsniff-ng/city6.dat
+    ln -sv ${geolite-legacy}/share/GeoIP/GeoIPCity.dat		$out/etc/netsniff-ng/city4.dat
+    ln -sv ${geolite-legacy}/share/GeoIP/GeoIPCityv6.dat	$out/etc/netsniff-ng/city6.dat
     ln -sv ${geolite-legacy}/share/GeoIP/GeoIPASNum.dat		$out/etc/netsniff-ng/asname4.dat
     ln -sv ${geolite-legacy}/share/GeoIP/GeoIPASNumv6.dat	$out/etc/netsniff-ng/asname6.dat
     rm -v $out/etc/netsniff-ng/geoip.conf # updating databases after installation is impossible

pkgs/tools/networking/zerotierone/default.nix

···
     homepage = https://www.zerotier.com;
     license = stdenv.lib.licenses.gpl3;
     maintainers = [ stdenv.lib.maintainers.sjmackenzie ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = with stdenv.lib; platforms.allBut [ "i686-linux" ];
   };
 }

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

···
         docdir=$out/share/doc/nixops mandir=$out/share/man
 
       mkdir -p $out/share/nix/nixops
-      cp -av nix/* $out/share/nix/nixops
+      cp -av "nix/"* $out/share/nix/nixops
 
       # Add openssh to nixops' PATH. On some platforms, e.g. CentOS and RHEL
       # the version of openssh is causing errors when have big networks (40+)

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

···
     sha256 = "01n2ykszrnqr3kqqdg1n2l8wm38yhri7r3d7b0abklsslz9dlvmy";
   };
 
-  buildInputs = [ pythonPackages.nose pythonPackages.coverage ];
+  buildInputs = [ /* libxslt */ pythonPackages.nose pythonPackages.coverage ];
 
   propagatedBuildInputs =
     [ pythonPackages.prettytable
···
       # Backward compatibility symlink.
       ln -s nixops $out/bin/charon
 
-      make -C doc/manual install \
+      # Documentation build is currently broken. Re-try with newer version.
+      : make -C doc/manual install nixops.1 docbookxsl=${docbook5_xsl}/xml/xsl/docbook \
         docdir=$out/share/doc/nixops mandir=$out/share/man
 
       mkdir -p $out/share/nix/nixops
-      cp -av nix/* $out/share/nix/nixops
+      cp -av "nix/"* $out/share/nix/nixops
 
       # Add openssh to nixops' PATH. On some platforms, e.g. CentOS and RHEL
       # the version of openssh is causing errors when have big networks (40+)
       wrapProgram $out/bin/nixops --prefix PATH : "${openssh}/bin"
-    ''; # */
+    '';
 
   meta = {
     homepage = https://github.com/NixOS/nixops;

pkgs/tools/security/sudo/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "sudo-1.8.14p1";
+  name = "sudo-1.8.14p3";
 
   src = fetchurl {
     urls =
       [ "ftp://ftp.sudo.ws/pub/sudo/${name}.tar.gz"
         "ftp://ftp.sudo.ws/pub/sudo/OLD/${name}.tar.gz"
       ];
-    sha256 = "1806kxnkjibky8y04s4f9mpj0403v4b6sqdnmyaa98mnq3qwsb5i";
+    sha256 = "0dqj1bq2jr4jxqfrd5yg0i42a6268scd0l28jic9118kn75rg9m8";
   };
 
   configureFlags = [

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

···
 { stdenv, fetchurl, attr }:
 
-let version = "0.04.10"; in
+let version = "0.04.12"; in
 stdenv.mkDerivation rec {
   name = "stress-ng-${version}";
 
   src = fetchurl {
-    sha256 = "1y0jmcgwn8np22r3ajg7giai8dvfg0r5ddpgbiqs48cx2gz7iyhf";
+    sha256 = "0gc5mai1dzhb7n8wsy2kzx0q85zbsa2ilvc2fpa30ilcwmg28kgm";
     url = "http://kernel.ubuntu.com/~cking/tarballs/stress-ng/${name}.tar.gz";
   };
 

pkgs/top-level/all-packages.nix

···
 
   bochs = callPackage ../applications/virtualization/bochs { };
 
+  borg = callPackage ../tools/backup/borg { };
+
   boomerang = callPackage ../development/tools/boomerang { };
 
   boost-build = callPackage ../development/tools/boost-build { };
···
   fop = callPackage ../tools/typesetting/fop { };
 
   filter_audio = callPackage ../development/libraries/filter_audio { };
+
+  fzf = callPackage ../tools/misc/fzf { };
 
   gist = callPackage ../tools/text/gist { };
 
···
 
   libbladeRF = callPackage ../development/libraries/libbladeRF { };
 
+  lp_solve = callPackage ../applications/science/math/lp_solve { };
+
   lprof = callPackage ../tools/graphics/lprof { };
 
   fdk_aac = callPackage ../development/libraries/fdk-aac { };
···
   };
 
   honcho = callPackage ../tools/system/honcho { };
+
+  horst = callPackage ../tools/networking/horst { };
 
   host = callPackage ../tools/networking/host { };
 
···
   mfoc = callPackage ../tools/security/mfoc { };
 
   minecraft = callPackage ../games/minecraft {
-    pulseaudioSupport = config.pulseaudio or true;
+    useAlsa = config.minecraft.alsa or false;
   };
 
   minecraft-server = callPackage ../games/minecraft-server { };
···
 
   openmpi = callPackage ../development/libraries/openmpi { };
 
+  openmodelica = callPackage ../applications/science/misc/openmodelica { };
+
   qarte = callPackage ../applications/video/qarte {
     sip = pythonPackages.sip_4_16;
   };
···
 
   shellinabox = callPackage ../servers/shellinabox { };
 
+  sic = callPackage ../applications/networking/irc/sic { };
+
   siege = callPackage ../tools/networking/siege {};
 
   sigil = callPackage ../applications/editors/sigil { };
···
 
   wv2 = callPackage ../tools/misc/wv2 { };
 
-  wyrd = callPackage ../tools/misc/wyrd { };
+  wyrd = callPackage ../tools/misc/wyrd {
+    inherit (ocamlPackages) camlp4;
+  };
 
   x86info = callPackage ../os-specific/linux/x86info { };
 
···
     isl = isl_0_14;
   }));
 
-  gfortran = if !stdenv.isDarwin then gfortran48
+  gfortran = if !stdenv.isDarwin then gfortran49
              else callPackage ../development/compilers/gcc/gfortran-darwin.nix {};
 
   gfortran48 = wrapCC (gcc48.cc.override {
+    name = "gfortran";
+    langFortran = true;
+    langCC = false;
+    langC = false;
+    profiledCompiler = false;
+  });
+
+  gfortran49 = wrapCC (gcc49.cc.override {
     name = "gfortran";
     langFortran = true;
     langCC = false;
···
     overrides = config.haskellPackageOverrides or (self: super: {});
   };
 
-  haxe = callPackage ../development/compilers/haxe { };
+  haxe = callPackage ../development/compilers/haxe {
+    inherit (ocamlPackages) camlp4;
+  };
   hxcpp = callPackage ../development/compilers/haxe/hxcpp.nix { };
 
   hhvm = callPackage ../development/compilers/hhvm { };
···
   llvm_36 = llvmPackages_36.llvm;
   llvm_35 = llvmPackages_35.llvm;
   llvm_34 = llvmPackages_34.llvm;
-  llvm_33 = llvm_v ../development/compilers/llvm/3.3/llvm.nix;
+  llvm_33 = callPackage ../development/compilers/llvm/3.3/llvm.nix { };
 
-  llvm_v = path: callPackage path { };
+  llvmPackages = recurseIntoAttrs llvmPackages_36;
 
-  llvmPackages = llvmPackages_36;
+  llvmPackagesSelf = llvmPackages_34.override {
+    stdenv = libcxxStdenv;
+  };
 
-  llvmPackages_34 = recurseIntoAttrs (import ../development/compilers/llvm/3.4 {
-    inherit stdenv newScope fetchurl;
+  llvmPackages_34 = callPackage ../development/compilers/llvm/3.4 {
     isl = isl_0_12;
-  });
-  llvmPackagesSelf = import ../development/compilers/llvm/3.4 { inherit newScope fetchurl; isl = isl_0_12; stdenv = libcxxStdenv; };
-
-  llvmPackages_35 = import ../development/compilers/llvm/3.5 {
-    inherit pkgs stdenv newScope fetchurl isl;
   };
 
-  llvmPackages_36 = import ../development/compilers/llvm/3.6 {
-    inherit pkgs stdenv newScope fetchurl isl wrapCC;
+  llvmPackages_35 = callPackage ../development/compilers/llvm/3.5 { };
+
+  llvmPackages_36 = callPackage ../development/compilers/llvm/3.6 {
     inherit (stdenvAdapters) overrideCC;
   };
 
···
 
   dfu-programmer = callPackage ../development/tools/misc/dfu-programmer { };
 
+  dfu-util = callPackage ../development/tools/misc/dfu-util { };
+
   ddd = callPackage ../development/tools/misc/ddd { };
 
   distcc = callPackage ../development/tools/misc/distcc { };
···
 
   omake = callPackage ../development/tools/ocaml/omake { };
   omake_rc1 = callPackage ../development/tools/ocaml/omake/0.9.8.6-rc1.nix { };
+
+  omniorb = callPackage ../development/tools/omniorb { };
 
   opengrok = callPackage ../development/tools/misc/opengrok { };
 
···
   hawknl = callPackage ../development/libraries/hawknl { };
 
   herqq = callPackage ../development/libraries/herqq { };
+
+  heyefi = haskellPackages.heyefi;
 
   hidapi = callPackage ../development/libraries/hidapi {
     libusb = libusb1;
···
   xorg = recurseIntoAttrs (import ../servers/x11/xorg/default.nix {
     inherit clangStdenv fetchurl fetchgit fetchpatch stdenv pkgconfig intltool freetype fontconfig
       libxslt expat libpng zlib perl mesa_drivers spice_protocol
-      dbus libuuid openssl gperf m4 libevdev tradcpp libinput makeWrapper
+      dbus libuuid openssl gperf m4 libevdev tradcpp libinput makeWrapper autoreconfHook
       autoconf automake libtool xmlto asciidoc flex bison python mtdev pixman;
     bootstrap_cmds = if stdenv.isDarwin then darwin.bootstrap_cmds else null;
     mesa = mesa_noglu;
···
 
   guvcview = callPackage ../os-specific/linux/guvcview { };
 
+  gxmessage = callPackage ../applications/misc/gxmessage { };
+
   hackrf = callPackage ../applications/misc/hackrf { };
 
   hello = callPackage ../applications/misc/hello/ex-2 { };
···
 
   pidginmsnpecan = callPackage ../applications/networking/instant-messengers/pidgin-plugins/msn-pecan { };
 
+  pidgin-mra = callPackage ../applications/networking/instant-messengers/pidgin-plugins/pidgin-mra { };
+
   pidginotr = callPackage ../applications/networking/instant-messengers/pidgin-plugins/otr { };
 
   pidginsipe = callPackage ../applications/networking/instant-messengers/pidgin-plugins/sipe { };
···
   pidginwindowmerge = callPackage ../applications/networking/instant-messengers/pidgin-plugins/window-merge { };
 
   purple-plugin-pack = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-plugin-pack { };
+
+  purple-vk-plugin = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-vk-plugin { };
 
   toxprpl = callPackage ../applications/networking/instant-messengers/pidgin-plugins/tox-prpl { };
 

pkgs/top-level/go-packages.nix

···
     };
   };
 
+  junegunn.go-runewidth = buildGoPackage rec {
+    rev = "travisish";
+    name = "go-runewidth-${rev}";
+    goPackagePath = "github.com/junegunn/go-runewidth";
+    src = fetchFromGitHub {
+      inherit rev;
+      owner = "junegunn";
+      repo = "go-runewidth";
+      sha256 = "07d612val59sibqly5d6znfkp4h4gjd77783jxvmiq6h2fwb964k";
+    };
+  };
+
+  go-shellwords = buildGoPackage rec {
+    rev = "35d512af75e283aae4ca1fc3d44b159ed66189a4";
+    name = "go-shellwords-${rev}";
+    goPackagePath = "github.com/junegunn/go-shellwords";
+    src = fetchFromGitHub {
+      inherit rev;
+      owner = "junegunn";
+      repo = "go-shellwords";
+      sha256 = "c792abe5fda48d0dfbdc32a84edb86d884a0ccbd9ed49ad48a30cda5ba028a22";
+    };
+  };
+
   go-runit = buildGoPackage rec {
     rev = "a9148323a615e2e1c93b7a9893914a360b4945c8";
     name = "go-runit-${stdenv.lib.strings.substring 0 7 rev}";

pkgs/top-level/perl-packages.nix

···
   };
 
   Glib = buildPerlPackage rec {
-    name = "Glib-1.310";
+    name = "Glib-1.312";
     src = fetchurl {
       url = "mirror://cpan/authors/id/X/XA/XAOC/${name}.tar.gz";
-      sha256 = "1iv8q7d0817m3byh2yn7bxxk5qp8bgapaflbglhkw467i31slign";
+      sha256 = "1aqww3ncaxiclfiqvl81hx7k3w4pri3k52rrar0hpzcasics5zr3";
     };
     buildInputs = [ ExtUtilsDepends ExtUtilsPkgConfig pkgs.glib ];
     meta = {

pkgs/top-level/python-packages.nix

···
     };
   };
 
+  netcdf4 = buildPythonPackage rec {
+    name = "netCDF4-${version}";
+    version = "1.1.8";
+
+    disabled = isPyPy;
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/n/netCDF4/${name}.tar.gz";
+      sha256 = "0y6s8g82rbij0brh9hz3aapyyq6apj8fpmhhlyibz1354as7rjq1";
+    };
+
+    propagatedBuildInputs = with self ; [
+      numpy
+      pkgs.zlib
+      pkgs.netcdf
+      pkgs.hdf5
+      pkgs.curl
+      pkgs.libjpeg
+    ];
+
+    patchPhase = ''
+      export USE_NCCONFIG=0
+      export HDF5_DIR="${pkgs.hdf5}"
+      export NETCDF4_DIR="${pkgs.netcdf}"
+      export CURL_DIR="${pkgs.curl}"
+      export JPEG_DIR="${pkgs.libjpeg}"
+    '';
+
+    meta = {
+      description = "interface to netCDF library (versions 3 and 4)";
+      homepage = https://pypi.python.org/pypi/netCDF4;
+      license = licenses.free;  # Mix of license (all MIT* like)
+    };
+  };
+
   odfpy = buildPythonPackage rec {
     version = "0.9.6";
     name = "odfpy-${version}";
···
       click configobj prompt_toolkit psycopg2 pygments sqlparse
     ];
 
+    postPatch = ''
+      substituteInPlace setup.py --replace "==" ">="
+    '';
+
     meta = {
       inherit version;
       description = "Command-line interface for PostgreSQL";
···
 
   prompt_toolkit = buildPythonPackage rec {
     name = "prompt_toolkit-${version}";
-    version = "0.42";
+    version = "0.43";
 
     src = pkgs.fetchurl {
-      sha256 = "04nywwyxzkl3qgah29i959irsbqi8viiadxfkxycqh7hq2yq8h86";
+      sha256 = "1z5fap8c7q27p0s82jn11i6fwg0g9zm2zy5na8is53kgbhl10fdr";
       url = "https://pypi.python.org/packages/source/p/prompt_toolkit/${name}.tar.gz";
     };
 
···
   };
 
 
-  scikitlearn = buildPythonPackage {
+  scikitlearn = buildPythonPackage rec {
     name = "scikit-learn-0.16.1";
 
     src = pkgs.fetchurl {
-      url = "https://pypi.python.org/packages/source/s/scikit-learn/scikit-learn-0.15.2.tar.gz";
-      sha256 = "19jzmbi3j4ix8418i80ayl595dwyi4gy474kb2nc1v8kdwgqi2hs";
+      url = "https://pypi.python.org/packages/source/s/scikit-learn/${name}.tar.gz";
+      sha256 = "1r761qmsq2mnl8sapplbx0ipj6i7ppr2cmz009q5rjana0liwwn0";
     };
 
     buildInputs = with self; [ nose pillow pkgs.gfortran pkgs.glibcLocales ];