Merge remote-tracking branch 'origin/master' into stdenv-updates

pkgs/applications/editors/vbindiff/default.nix

···
+{ stdenv, fetchurl, ncurses }:
+
+stdenv.mkDerivation rec {
+  name = "vbindiff-${version}";
+  version = "3.0_beta4";
+
+  buildInputs = [ ncurses ];
+
+  src = fetchurl {
+    url = "http://www.cjmweb.net/vbindiff/${name}.tar.gz";
+    sha256 = "0gcqy4ggp60qc6blq1q1gc90xmhip1m6yvvli4hdqlz9zn3mlpbx";
+  };
+
+  meta = {
+    description = "A terminal visual binary diff viewer";
+    homepage = "http://www.cjmweb.net/vbindiff/";
+    license = stdenv.lib.licenses.gpl2Plus;
+  };
+}

pkgs/applications/misc/librecad/2.0.nix

···
+{ stdenv, fetchurl, qt4, muparser, which, boost}:
+
+stdenv.mkDerivation {
+  name = "librecad-2.0.0beta1";
+
+  src = fetchurl {
+    url = https://github.com/LibreCAD/LibreCAD/tarball/2.0.0beta1;
+    name = "librecad-2.0.0beta1.tar.gz";
+    sha256 = "8bf969b79be115f3b3ff72cc030a4c21fe93164dd0cb19ddfb78a7d66b8bc770";
+  };
+
+  patchPhase = ''
+    sed -i -e s,/bin/bash,`type -P bash`, scripts/postprocess-unix.sh
+    sed -i -e s,/usr/share,$out/share, librecad/src/lib/engine/rs_system.cpp
+  '';
+
+  configurePhase = ''
+    qmake librecad.pro PREFIX=$out MUPARSER_DIR=${muparser} BOOST_DIR=${boost}
+  '';
+
+  installPhase = ''
+    ensureDir $out/bin $out/share
+    cp -R unix/librecad $out/bin
+    cp -R unix/resources $out/share/librecad
+  '';
+
+  buildInputs = [ qt4 muparser which boost ];
+
+  enableParallelBuilding = true;
+
+  meta = {
+    description = "A 2D CAD package based upon Qt";
+    homepage = http://librecad.org;
+    license = "GPLv2";
+    maintainers = with stdenv.lib.maintainers; [viric];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

pkgs/applications/misc/rxvt_unicode/default.nix

···
 
   preConfigure =
     ''
-      configureFlags="${if perlSupport then "--enable-perl" else "--disable-perl"}";
+      configureFlags="--with-terminfo=$out/share/terminfo ${if perlSupport then "--enable-perl" else "--disable-perl"}";
       export TERMINFO=$out/share/terminfo # without this the terminfo won't be compiled by tic, see man tic
       NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -I${freetype}/include/freetype2"
       NIX_LDFLAGS="$NIX_LDFLAGS -lfontconfig -lXrender "
···
 
   meta = {
     description = "A clone of the well-known terminal emulator rxvt";
-    longDescription = "
-      You should put this into your ~/.bashrc:
-      export TERMINFO=~/.nix-profile/share/terminfo
-    ";
     homepage = "http://software.schmorp.de/pkg/rxvt-unicode.html";
   };
 })

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

···
-{ stdenv, config, fetchurl, makeWrapper, which
+{ stdenv, fetchurl, makeWrapper, which
 
 # default dependencies
 , bzip2, flac, speex
···
 , libXScrnSaver, libXcursor, mesa
 
 # optional dependencies
-, libgnome_keyring # config.gnomeKeyring
-, gconf # config.gnome
-, libgcrypt # config.gnome || config.cups
-, nss, openssl # config.openssl
-, pulseaudio # config.pulseaudio
-, libselinux # config.selinux
+, libgcrypt ? null # gnomeSupport || cupsSupport
+
+# package customization
+, channel ? "stable"
+, enableSELinux ? false, libselinux ? null
+, enableNaCl ? false
+, useOpenSSL ? false, nss ? null, openssl ? null
+, gnomeSupport ? false, gconf ? null
+, gnomeKeyringSupport ? false, libgnome_keyring ? null
+, proprietaryCodecs ? true
+, cupsSupport ? false
+, pulseSupport ? false, pulseaudio ? null
 }:
 
 with stdenv.lib;
 
 let
-  mkConfigurable = mapAttrs (flag: default: attrByPath ["chromium" flag] default config);
-
-  cfg = mkConfigurable {
-    channel = "stable";
-    selinux = false;
-    nacl = false;
-    openssl = false;
-    gnome = false;
-    gnomeKeyring = false;
-    proprietaryCodecs = true;
-    cups = false;
-    pulseaudio = config.pulseaudio or true;
-  };
-
-  sourceInfo = builtins.getAttr cfg.channel (import ./sources.nix);
+  sourceInfo = builtins.getAttr channel (import ./sources.nix);
 
   mkGypFlags =
     let
···
     use_system_libusb = true;
     use_system_libxml = true;
     use_system_speex = true;
-    use_system_ssl = cfg.openssl;
+    use_system_ssl = useOpenSSL;
     use_system_stlport = true;
     use_system_xdg_utils = true;
     use_system_yasm = true;
···
   post23 = !versionOlder sourceInfo.version "24.0.0.0";
   post24 = !versionOlder sourceInfo.version "25.0.0.0";
 
-  maybeFixPulseAudioBuild = optional (post23 && cfg.pulseaudio) (fetchurl {
+  maybeFixPulseAudioBuild = optional (post23 && pulseSupport) (fetchurl {
     url = http://archrepo.jeago.com/sources/chromium-dev/pulse_audio_fix.patch;
     sha256 = "1w91mirrkqigdhsj892mqxlc0nlv1dsp5shc46w9xf8nl96jxgfb";
   });
···
     which makeWrapper
     python perl pkgconfig
     nspr udev
-    (if cfg.openssl then openssl else nss)
+    (if useOpenSSL then openssl else nss)
     utillinux alsaLib
     gcc bison gperf
     krb5
     glib gtk dbus_glib
     libXScrnSaver libXcursor mesa
-  ] ++ optional cfg.gnomeKeyring libgnome_keyring
-    ++ optionals cfg.gnome [ gconf libgcrypt ]
-    ++ optional cfg.selinux libselinux
-    ++ optional cfg.cups libgcrypt
-    ++ optional cfg.pulseaudio pulseaudio
+  ] ++ optional gnomeKeyringSupport libgnome_keyring
+    ++ optionals gnomeSupport [ gconf libgcrypt ]
+    ++ optional enableSELinux libselinux
+    ++ optional cupsSupport libgcrypt
+    ++ optional pulseSupport pulseaudio
     ++ optional post24 pciutils;
 
-  opensslPatches = optional cfg.openssl openssl.patches;
+  opensslPatches = optional useOpenSSL openssl.patches;
 
   prePatch = "patchShebangs .";
 
-  patches = optional cfg.cups ./cups_allow_deprecated.patch
-         ++ optional cfg.pulseaudio ./pulseaudio_array_bounds.patch
+  patches = optional cupsSupport ./cups_allow_deprecated.patch
+         ++ optional pulseSupport ./pulseaudio_array_bounds.patch
          ++ maybeFixPulseAudioBuild;
 
-  postPatch = optionalString cfg.openssl ''
+  postPatch = optionalString useOpenSSL ''
     cat $opensslPatches | patch -p1 -d third_party/openssl/openssl
   '';
 
···
     linux_use_gold_binary = false;
     linux_use_gold_flags = false;
     proprietary_codecs = false;
-    use_gnome_keyring = cfg.gnomeKeyring;
-    use_gconf = cfg.gnome;
-    use_gio = cfg.gnome;
-    use_pulseaudio = cfg.pulseaudio;
-    disable_nacl = !cfg.nacl;
-    use_openssl = cfg.openssl;
-    selinux = cfg.selinux;
-    use_cups = cfg.cups;
-  } // optionalAttrs cfg.proprietaryCodecs {
+    use_gnome_keyring = gnomeKeyringSupport;
+    use_gconf = gnomeSupport;
+    use_gio = gnomeSupport;
+    use_pulseaudio = pulseSupport;
+    disable_nacl = !enableNaCl;
+    use_openssl = useOpenSSL;
+    selinux = enableSELinux;
+    use_cups = cupsSupport;
+  } // optionalAttrs proprietaryCodecs {
     # enable support for the H.264 codec
     proprietary_codecs = true;
     ffmpeg_branding = "Chrome";

pkgs/applications/networking/browsers/chromium/sources.nix

···
     sha256 = "1i7ga1qhnjvnw2gynmpmsvvl5pxcb5z9sgldp87d9yalim5sra6s";
   };
   beta = {
-    version = "24.0.1312.25";
-    url = "http://commondatastorage.googleapis.com/chromium-browser-official/chromium-24.0.1312.25.tar.bz2";
-    sha256 = "1d2wnv0pmvja1vwqmccngajwgf9kwz55bhid43k1db7yczi591fr";
+    version = "24.0.1312.35";
+    url = "http://commondatastorage.googleapis.com/chromium-browser-official/chromium-24.0.1312.35.tar.bz2";
+    sha256 = "0mb6xz5lrnzjk1zqr83jyprsxv20svy3a7lyxv9iwdb2bh1i13ci";
   };
   stable = {
-    version = "23.0.1271.91";
-    url = "http://commondatastorage.googleapis.com/chromium-browser-official/chromium-23.0.1271.91.tar.bz2";
-    sha256 = "00avyc8bszkb99jq399jr3h1ia7lw68msszvrdhl5rh052z1lp9q";
+    version = "23.0.1271.97";
+    url = "http://commondatastorage.googleapis.com/chromium-browser-official/chromium-23.0.1271.97.tar.bz2";
+    sha256 = "1qf21n6msj1jmxhnlw8fapsz7q6dd851rxdqv4334v06ny4i5fip";
   };
 }

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

···
 assert stdenv.system == "i686-linux";
 
 stdenv.mkDerivation rec {
-  name = "skype-4.0.0.8";
+  name = "skype-4.1.0.20";
 
   src = fetchurl {
     url = "http://download.skype.com/linux/${name}.tar.bz2";
-    sha256 = "0gq24rbmjd05ihraarn45rwr79gidnwgllvprzrh5zqx02xll17p";
+    sha256 = "1qhcxkfmlpblpy9rqimzdl79rm781swbldkzi6nyw56bbp6lf7n3";
   };
 
   buildInputs =

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

···
     sha1 = "ccc5f2e155364948945abf6fd27bebeb4d797aa8";
   };
 
-  enableParallelBuilding = true;
+  enableParallelBuilding = false;
 
   buildInputs =
     [ pkgconfig perl python zip unzip bzip2 gtk dbus_glib alsaLib libIDL nspr

pkgs/applications/office/abiword/default.nix

···
 
 stdenv.mkDerivation {
   name = "abiword-2.8.6";
-  
+
   src = fetchurl {
     url = http://www.abisource.org/downloads/abiword/2.8.6/source/abiword-2.8.6.tar.gz;
     sha256 = "059sd2apxdmcacc4pll880i7vm18h0kyjsq299m1mz3c7ak8k46r";
   };
+
+  prePatch = ''
+    sed -i -e '/#include <glib\/gerror.h>/d' src/af/util/xp/ut_go_file.h
+    sed -i -e 's|#include <glib/gmacros.h>|#include <glib.h>|' \
+      goffice-bits/goffice/app/goffice-app.h
+    sed -i -e 's/ptr->jmpbuf/jmpbuf(png_ptr)/' src/af/util/xp/ut_png.cpp
+    sed -i -e 's/\(m_pPNG\)->\(jmpbuf\)/png_\2(\1)/' \
+      src/wp/impexp/gtk/ie_impGraphic_GdkPixbuf.cpp
+    sed -i -e 's/--no-undefined //' src/Makefile*
+  '';
+
+  enableParallelBuilding = true;
 
   buildInputs =
     [ pkgconfig gtk libglade librsvg bzip2 libgnomecanvas fribidi libpng popt

pkgs/applications/science/logic/eProver/default.nix pkgs/applications/science/logic/eprover/default.nix

···
 { stdenv, fetchurl, which, texLive }:
-
+let
+  s = # Generated upstream information
+  rec {
+    baseName="eprover";
+    version="1.6";
+    name="${baseName}-${version}";
+    hash="140cnw4qck1hancrqdh0f77yfba5ljhdnfxdxsl0a86a6y7ydbwi";
+    url="http://www4.in.tum.de/~schulz/WORK/E_DOWNLOAD/V_1.6/E.tgz";
+    sha256="140cnw4qck1hancrqdh0f77yfba5ljhdnfxdxsl0a86a6y7ydbwi";
+  };
+in
 stdenv.mkDerivation {
-  name = "EProver-1.4";
+  inherit (s) name;
 
   src = fetchurl {
-    name = "E-1.4.tar.gz";
-    url = "http://www4.informatik.tu-muenchen.de/~schulz/WORK/E_DOWNLOAD/V_1.4/E.tgz";
-    sha256 = "1hxkr21xqkkh4bzqip6qf70w9xvvb8p20zzkvyin631ffgvyvr93";
+    name = "E-${s.version}.tar.gz";
+    inherit (s) url sha256;
   };
 
   buildInputs = [which texLive];
···
   '';
 
   meta = {
+    inherit (s) version;
     description = "E automated theorem prover";
     maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.all;

pkgs/applications/science/logic/eprover/default.upstream

···
+url http://www4.informatik.tu-muenchen.de/~schulz/E/Download.html
+version_link '[.]tgz$'
+version '.*[/]V_([0-9.]+)[/].*' '\1'

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

···
     inherit stdenv fetchurl ncurses asciidoc xmlto docbook_xsl;
   };
 
+  hub = import ./hub {
+    inherit (rubyLibs) rake;
+    inherit stdenv fetchgit groff makeWrapper;
+  };
+
   gitFastExport = import ./fast-export {
     inherit fetchgit stdenv mercurial coreutils git makeWrapper subversion;
   };

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

···
+{ stdenv, fetchgit, groff, rake, makeWrapper }:
+
+stdenv.mkDerivation rec {
+  name = "hub-${version}";
+  version = "1.10.3";
+
+  src = fetchgit {
+    url = "git://github.com/defunkt/hub.git";
+    rev = "refs/tags/v${version}";
+    sha256 = "0j0krmf0sf09hhw3nsn0w1y97d67762g4qrc8080bwcx38lbyvbg";
+  };
+
+  buildInputs = [ rake makeWrapper ];
+
+  installPhase = ''
+    rake install "prefix=$out"
+  '';
+
+  fixupPhase = ''
+    wrapProgram $out/bin/hub --prefix PATH : ${groff}/bin
+  '';
+
+  meta = {
+    description = "A GitHub specific wrapper for git";
+    homepage = "http://defunkt.io/hub/";
+    license = stdenv.lib.licenses.mit;
+  };
+}

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

···
 
   buildInputs = [ python makeWrapper docutils unzip ];
 
-  PYTHONPATH = "${python}/lib/python2.6/site-packages:${python}/lib/python2.7/site-packages:${docutils}/lib/python2.5/site-packages:${docutils}/lib/python2.6/site-packages:${docutils}/lib/python2.7/site-packages";
-
   makeFlags = "PREFIX=$(out)";
 
   postInstall = (stdenv.lib.optionalString guiSupport
···
       cp -v hgweb.cgi contrib/hgweb.wsgi $out/share/cgi-bin
       chmod u+x $out/share/cgi-bin/hgweb.cgi
     '';
-
-  doCheck = false;  # The test suite fails, unfortunately. Not sure why.
 
   meta = {
     description = "A fast, lightweight SCM system for very large distributed projects";

pkgs/applications/virtualization/virtualbox/default.nix

···
 , xorriso, makeself, perl, pkgconfig
 , javaBindings ? false, jdk ? null
 , pythonBindings ? false, python ? null
+, enableExtensionPack ? false, requireFile ? null, patchelf ? null
 }:
 
 with stdenv.lib;
···
 let
 
   version = "4.2.4";
+  extpackRevision = "81684";
 
   forEachModule = action: ''
     for mod in \
···
       make -C "$MODULES_BUILD_DIR" "M=$mod" DEPMOD=/do_not_use_depmod ${action}
     done
   '';
+
+  extensionPack = requireFile {
+    name = "Oracle_VM_VirtualBox_Extension_Pack-${version}-${extpackRevision}"
+         + ".vbox-extpack";
+    # Has to be base16 because it's used as an input to VBoxExtPackHelperApp!
+    sha256 = "62078e057a4ab56aec5ac086746522b3d94787333d0444169471fa5152c609ed";
+    url = "https://www.virtualbox.org/wiki/Downloads";
+  };
 
 in stdenv.mkDerivation {
   name = "virtualbox-${version}-${kernel.version}";
···
     for file in VirtualBox VBoxManage VBoxSDL VBoxBalloonCtrl VBoxBFE VBoxHeadless; do
         ln -s "$libexec/$file" $out/bin/$file
     done
+
+    ${optionalString enableExtensionPack ''
+      "$libexec/VBoxExtPackHelperApp" install \
+        --base-dir "$libexec/ExtensionPacks" \
+        --cert-dir "$libexec/ExtPackCertificates" \
+        --name "Oracle VM VirtualBox Extension Pack" \
+        --tarball "${extensionPack}"
+        --sha-256 "${extensionPack.outputHash}"
+    ''}
 
     # Create and fix desktop item
     mkdir -p $out/share/applications

pkgs/build-support/fetchurl/mirrors.nix

···
   ];
 
   postgresql = [
-    http://ftp2.nl.postgresql.org/
-    ftp://ftp.nl.postgresql.org/pub/mirror/postgresql/
     ftp://ftp.postgresql.org/pub/
     ftp://ftp-archives.postgresql.org/pub/
   ];

pkgs/build-support/upstream-updater/update-walker.sh

···
   echo "Resulting name: $CURRENT_NAME"
 }
 
+ensure_attribute_name () {
+  echo "Ensuring attribute name. CURRENT_ATTRIBUTE_NAME: $CURRENT_ATTRIBUTE_NAME" >&2
+  [ -z "$CURRENT_ATTRIBUTE_NAME" ] && attribute_name "$CURRENT_NAME"
+  echo "Resulting attribute name: $CURRENT_ATTRIBUTE_NAME"
+}
+
 ensure_choice () {
   echo "Ensuring that choice is made." >&2
   echo "NEED_TO_CHOOSE_URL: [$NEED_TO_CHOOSE_URL]." >&2
···
   echo "CURRENT_NAME: $CURRENT_NAME" >&2
 }
 
+attribute_name () {
+  CURRENT_ATTRIBUTE_NAME="$1"
+  echo "CURRENT_ATTRIBUTE_NAME: $CURRENT_ATTRIBUTE_NAME" >&2
+}
+
 retrieve_version () {
-  PACKAGED_VERSION="$(nix-instantiate --eval-only '<nixpkgs>' -A "$CURRENT_NAME".meta.version | xargs)"
+  PACKAGED_VERSION="$(nix-instantiate --eval-only '<nixpkgs>' -A "$CURRENT_ATTRIBUTE_NAME".meta.version | xargs)"
 }
 
 directory_of () {
···
   echo "${1}rec {"
   echo "${1}  baseName=\"$CURRENT_NAME\";"
   echo "${1}  version=\"$CURRENT_VERSION\";"
-  echo "${1}  name=\"$CURRENT_NAME-$CURRENT_VERSION\";"
+  echo "${1}  name=\"\${baseName}-\${version}\";"
   echo "${1}  hash=\"$CURRENT_HASH\";"
   echo "${1}  url=\"$CURRENT_URL\";"
   echo "${1}  sha256=\"$CURRENT_HASH\";"
···
   BEGIN_EXPRESSION='# Generated upstream information';
   source "$CONFIG_DIR/$(basename "$1")"
   ensure_name
+  ensure_attribute_name
   retrieve_version
   ensure_choice
   ensure_version

pkgs/build-support/upstream-updater/urls-from-page.sh

···
 
 curl -L -k "$url" | sed -re 's/^/-/;s/[hH][rR][eE][fF]="([^"]*)"/\n+\1\n-/g' | \
   sed -e '/^-/d; s/^[+]//; /^#/d;'"s/^\\//$protocol:\\/\\/$server\\//g" | \
-  sed -re 's~^[^:]*$~'"$protocol://$basepath/&~"
+  sed -re 's`^[^:]*$`'"$protocol://$basepath/&\`"

pkgs/build-support/vm/deb/deb-closure.pl

···
 use strict;
-use Dpkg::Cdata;
+use Dpkg::Control;
 use Dpkg::Deps;
 use File::Basename;
 
 my $packagesFile = shift @ARGV;
 my $urlPrefix = shift @ARGV;
 my @toplevelPkgs = @ARGV;
+
 
 my %packages;
 
···
 open PACKAGES, "<$packagesFile" or die;
 
 while (1) {
-    my $cdata = parsecdata(\*PACKAGES, $packagesFile);
-    last unless defined $cdata;
-    #print $cdata->{Package}, "\n";
+    my $cdata = Dpkg::Control->new(type => CTRL_INFO_PKG);
+    last if not $cdata->parse(\*PACKAGES, $packagesFile);
     die unless defined $cdata->{Package};
+    #print STDERR $cdata->{Package}, "\n";
     $packages{$cdata->{Package}} = $cdata;
 }
 
···
 
 foreach my $cdata (values %packages) {
     next unless defined $cdata->{Provides};
-    my @provides = getDeps(Dpkg::Deps::parse($cdata->{Provides}));
+    my @provides = getDeps(Dpkg::Deps::deps_parse($cdata->{Provides}));
     foreach my $name (@provides) {
         #die "conflicting provide: $name\n" if defined $provides{$name};
         #warn "provide by $cdata->{Package} conflicts with package with the same name: $name\n";
···
     $donePkgs{$pkgName} = 1;
 
     if (defined $cdata->{Provides}) {
-        foreach my $name (getDeps(Dpkg::Deps::parse($cdata->{Provides}))) {
+        foreach my $name (getDeps(Dpkg::Deps::deps_parse($cdata->{Provides}))) {
             $provides{$name} = $cdata->{Package};
         }
     }
···
 
     if (defined $cdata->{Depends}) {
         print STDERR "    $pkgName: $cdata->{Depends}\n";
-        my $deps = Dpkg::Deps::parse($cdata->{Depends});
+        my $deps = Dpkg::Deps::deps_parse($cdata->{Depends});
         die unless defined $deps;
         push @depNames, getDeps($deps);
     }
 
     if (defined $cdata->{'Pre-Depends'}) {
         print STDERR "    $pkgName: $cdata->{'Pre-Depends'}\n";
-        my $deps = Dpkg::Deps::parse($cdata->{'Pre-Depends'});
+        my $deps = Dpkg::Deps::deps_parse($cdata->{'Pre-Depends'});
         die unless defined $deps;
         push @depNames, getDeps($deps);
     }

pkgs/build-support/vm/default.nix

···
   debClosureGenerator =
     {name, packagesLists, urlPrefix, packages}:
 
-    runCommand "${name}.nix" {} ''
+    runCommand "${name}.nix" { buildInputs = [ perl dpkg ]; } ''
       for i in ${toString packagesLists}; do
         echo "adding $i..."
         bunzip2 < $i >> ./Packages
···
       # Work around this bug: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=452279
       sed -i ./Packages -e s/x86_64-linux-gnu/x86-64-linux-gnu/g
 
-      ${perl}/bin/perl -I${dpkg} -w ${deb/deb-closure.pl} \
+      perl -w ${deb/deb-closure.pl} \
         ./Packages ${urlPrefix} ${toString packages} > $out
     '';
 
···
       packages = commonDebPackages ++ [ "diffutils" ];
     };
 
+    ubuntu1210i386 = {
+      name = "ubuntu-12.10-quantal-i386";
+      fullName = "Ubuntu 12.10 Quantal (i386)";
+      packagesLists =
+        [ (fetchurl {
+            url = mirror://ubuntu/dists/quantal/main/binary-i386/Packages.bz2;
+            sha256 = "bee3200ac8f037700ccd2311fb8b0de665bd02d46bdb2ae946cf50c5885001c3";
+          })
+          (fetchurl {
+            url = mirror://ubuntu/dists/quantal/universe/binary-i386/Packages.bz2;
+            sha256 = "323036e81c8bf409f71d3bc5cf37cfba72fe1d0fc82e9b5418d4d0cb516646e1";
+          })
+        ];
+      urlPrefix = mirror://ubuntu;
+      packages = commonDebPackages ++ [ "diffutils" ];
+    };
+
+    ubuntu1210x86_64 = {
+      name = "ubuntu-12.10-quantal-amd64";
+      fullName = "Ubuntu 12.10 Quantal (amd64)";
+      packagesList =
+        [ (fetchurl {
+            url = mirror://ubuntu/dists/quantal/main/binary-amd64/Packages.bz2;
+            sha256 = "ef14073f335ef118ebe1c7d45f5a0c17ef28f72abb57c10b9082ab5e04b5d003";
+          })
+          (fetchurl {
+            url = mirror://ubuntu/dists/quantal/universe/binary-amd64/Packages.bz2;
+            sha256 = "c762bd4ed063326577a62ff783cf9720e772b03d4a2aa38048918ee6287b96ce";
+          })
+        ];
+      urlPrefix = mirror://ubuntu;
+      packages = commonDebPackages ++ [ "diffutils" ];
+    };
+
     debian40i386 = {
       name = "debian-4.0r9-etch-i386";
       fullName = "Debian 4.0r9 Etch (i386)";
···
     };
 
     debian60i386 = {
-      name = "debian-6.0.4-squeeze-i386";
-      fullName = "Debian 6.0.4 Squeeze (i386)";
+      name = "debian-6.0.6-squeeze-i386";
+      fullName = "Debian 6.0.6 Squeeze (i386)";
       packagesList = fetchurl {
         url = mirror://debian/dists/squeeze/main/binary-i386/Packages.bz2;
-        sha256 = "1aih4n1iz4gzzm5cy1j14mpx8i25jj1237994j33k7dm0gnqgr2w";
+        sha256 = "18c0473jacd877nkky1x21dkmp4992d8qra6wj07sq0yz5gdc9c4";
       };
       urlPrefix = mirror://debian;
       packages = commonDebianPackages;
     };
 
     debian60x86_64 = {
-      name = "debian-6.0.4-squeeze-amd64";
-      fullName = "Debian 6.0.4 Squeeze (amd64)";
+      name = "debian-6.0.6-squeeze-amd64";
+      fullName = "Debian 6.0.6 Squeeze (amd64)";
       packagesList = fetchurl {
         url = mirror://debian/dists/squeeze/main/binary-amd64/Packages.bz2;
-        sha256 = "1gb3im7kl8dwd7z82xj4wb5g58r86fjj8cirvq0ssrvcm9bqaiz7";
+        sha256 = "1n1h3pz6axcaraxq8gfzq0jywlpdrqand1dnd4q79dy6cl788bi2";
       };
       urlPrefix = mirror://debian;
       packages = commonDebianPackages;

pkgs/development/compilers/julia/default.nix

···
 { stdenv, fetchgit, gfortran, perl, m4, llvm, gmp, pcre, zlib
  , readline, fftwSinglePrec, fftw, libunwind, suitesparse, glpk, fetchurl
  , ncurses, libunistring, lighttpd, patchelf, openblas, liblapack
- , tcl, tk
+ , tcl, tk, xproto, libX11
  } :
 let
   realGcc = stdenv.gcc.gcc;
 in
 stdenv.mkDerivation rec {
   pname = "julia";
-  date = "20121122";
+  date = "20121209";
   name = "${pname}-git-${date}";
 
   grisu_ver = "1.1.1";
···
 
   src = fetchgit {
     url = "git://github.com/JuliaLang/julia.git";
-    rev = "53598b026b6fd9f79eba02cbc4e2d6c38ca32bd7";
-    sha256 = "159yasgfbbj6px16kgwf7bg478giv8zbm5hg90ipncp1ls2lv3jy";
+    rev = "27b950f62aeb3664ab76e5d827b30b4885a9efb9";
+    sha256 = "0khx8ln2zq3vpj0g66hnsdhw04hxl79fq43rc06ggsmc1j4xrifb";
   };
 
   buildInputs = [ gfortran perl m4 gmp pcre llvm readline zlib
     fftw fftwSinglePrec libunwind suitesparse glpk ncurses libunistring patchelf
-    openblas liblapack
+    openblas liblapack tcl tk xproto libX11 
     ];
 
   configurePhase = ''
     for i in GMP LLVM PCRE LAPACK OPENBLAS BLAS READLINE FFTW LIBUNWIND SUITESPARSE GLPK LIGHTTPD ZLIB; 
     do 
-      sed -e "s@USE_SYSTEM_$i=0@USE_SYSTEM_$i=1@" -i Make.inc; 
+      makeFlags="$makeFlags USE_SYSTEM_$i=1 "
     done
-    sed -e 's@-lcurses@@g' -i Make.inc
 
     copy_kill_hash(){
       cp "$1" "$2/$(basename "$1" | sed -e 's/^[a-z0-9]*-//')"
···
     ${if realGcc ==null then "" else 
     ''export NIX_LDFLAGS="$NIX_LDFLAGS -L${realGcc}/lib -L${realGcc}/lib64 -lpcre -llapack -lm -lfftw3f -lfftw3 -lglpk -lunistring -lz "''}
     export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -fPIC "
-
-    sed -e 's@ cpp @ gcc -E @g' -i base/Makefile
 
     export LDFLAGS="-L${suitesparse}/lib -L$out/lib/julia -Wl,-rpath,$out/lib/julia"
 
···
   '';
 
   preBuild = ''
-    make -C test/unicode all SHELL="${stdenv.shell}"
-    make -C extras glpk_h.jl GLPK_PREFIX="$GLPK_PREFIX" SHELL="${stdenv.shell}"
-
     mkdir -p usr/lib
     ln -s libuv.a usr/lib/uv.a
   '';
 
+  preInstall = ''
+    make -C deps install-tk-wrapper
+  '';
+
   postInstall = ''
-   ld -E --whole-archive --shared ${suitesparse}/lib/lib*[a-z].a -o "$out"/lib/libsuitesparse-shared.so
-   for i in umfpack cholmod amd camd colamd btf cxsparse ldl rbio spqr suitesparseconfig; do
-     ln -s "libsuitesparse-shared.so" "$out/lib/lib$i.so"
-   done
-   ln -s "${lighttpd}/sbin/lighttpd" "$out/sbin/"
-   ln -s "${lighttpd}/lib/"* "$out/lib/"
+   (
+   cd $out/share/julia/test/ 
+   $out/bin/julia runtests.jl all
+   ) || true
   '';
 
   meta = {

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

···
     postInstall =
       ''
         rm -rf "$out/lib/python${majorVersion}/test"
+        ln -s $out/lib/python${majorVersion}/pdb.py $out/bin/pdb
+        ln -s $out/lib/python${majorVersion}/pdb.py $out/bin/pdb${majorVersion}
       '';
 
     passthru = {

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

···
     postInstall =
       ''
         rm -rf "$out/lib/python${majorVersion}/test"
+        ln -s $out/lib/python${majorVersion}/pdb.py $out/bin/pdb
+        ln -s $out/lib/python${majorVersion}/pdb.py $out/bin/pdb${majorVersion}
       '';
 
     passthru = {

pkgs/development/interpreters/python/wrapper.nix

···
   unpackPhase = "true";
   installPhase = ''
     mkdir -p "$out/bin"
-    for prg in 2to3 idle pydoc python python-config python${python.majorVersion} python${python.majorVersion}-config smtpd.py; do
+    for prg in 2to3 idle pdb pdb${python.majorVersion} pydoc python python-config python${python.majorVersion} python${python.majorVersion}-config smtpd.py; do
       makeWrapper "$python/bin/$prg" "$out/bin/$prg" --suffix PYTHONPATH : "$PYTHONPATH"
     done
     ensureDir "$out/share"

pkgs/development/libraries/SDL_image/default.nix

···
-{ stdenv, fetchhg, SDL, libpng, libjpeg, libtiff, libungif, libXpm, automake,
-  autoconf, pkgconfig }:
+{ stdenv, fetchurl, SDL, libpng, libjpeg, libtiff, libungif, libXpm }:
 
 stdenv.mkDerivation rec {
-  pname = "SDL_image";
-  version = "1.2.10-20110925";
+  name = "SDL_image-1.2.12";
 
-  name = "${pname}-${version}";
-
-  src = fetchhg {
-    url = http://hg.libsdl.org/SDL_image;
-    tag = "bb611e7cb1e5";
-    sha256 = "0003inlvvmlc2fyrzy01lwhhfb90ppsar2skaa7x6rhmpc71dakz";
+  src = fetchurl {
+    url = "http://www.libsdl.org/projects/SDL_image/release/${name}.tar.gz";
+    sha256 = "16an9slbb8ci7d89wakkmyfvp7c0cval8xw4hkg0842nhhlp540b";
   };
 
   buildInputs = [SDL libpng libjpeg libtiff libungif libXpm];
 
-  buildNativeInputs = [ automake autoconf pkgconfig ];
-
-  patches = [ ./jpeg-linux.diff ];
-
-  preConfigure = ''
-    ./autogen.sh
-    '';
-
   postInstall = ''
     sed -i -e 's,"SDL.h",<SDL/SDL.h>,' \
-    -e 's,"SDL_version.h",<SDL/SDL_version.h>,' \
-    -e 's,"begin_code.h",<SDL/begin_code.h>,' \
-    -e 's,"close_code.h",<SDL/close_code.h>,' \
+      -e 's,"SDL_version.h",<SDL/SDL_version.h>,' \
+      -e 's,"begin_code.h",<SDL/begin_code.h>,' \
+      -e 's,"close_code.h",<SDL/close_code.h>,' \
       $out/include/SDL/SDL_image.h
-
-    ln -sv $out/include/SDL/SDL_image.h $out/include/
+    ln -sv SDL/SDL_image.h $out/include/SDL_image.h
   '';
 
   meta = {
     description = "SDL image library";
-    homepage = http://www.libsdl.org/projects/SDL_image/;
+    homepage = "http://www.libsdl.org/projects/SDL_image/";
     platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/development/libraries/SDL_image/jpeg-linux.diff

···
-# HG changeset patch
-# User Yury G. Kudryashov <[e-mail]>
-# Date 1316994786 -14400
-# Node ID 4c3cd9a4b0602c45c11ec62bcc1f5562ea071d70
-# Parent  bb611e7cb1e58cc37a6773a22a15c74b55e3d267
-Fix compilation on Linux
-
-Submitted upstream, see http://bugzilla.libsdl.org/show_bug.cgi?id=1179
-
-diff -r bb611e7cb1e5 -r 4c3cd9a4b060 IMG_jpg.c
---- a/IMG_jpg.c	Thu Aug 25 02:24:35 2011 -0400
-+++ b/IMG_jpg.c	Mon Sep 26 03:53:06 2011 +0400
-@@ -34,7 +34,7 @@
- 
- #include <jpeglib.h>
- 
--#if JPEG_LIB_VERSION >= 80
-+#ifdef JPEG_TRUE /* MinGW version of jpeg-8.x renamed TRUE to JPEG_TRUE etc. */
- 	typedef JPEG_boolean boolean;
- 	#define TRUE JPEG_TRUE
- 	#define FALSE JPEG_FALSE

pkgs/development/libraries/boost/1.52.nix

···
 
   buildPhase = "./b2 -j$NIX_BUILD_CORES -sEXPAT_INCLUDE=${expat}/include -sEXPAT_LIBPATH=${expat}/lib --layout=${layout} variant=${variant} threading=${threading} link=${link} ${cflags} install";
 
-  installPhase = ":";
+  # normal install does not install bjam, this is a separate step
+  installPhase = ''
+    cd tools/build/v2
+    sh bootstrap.sh
+    ./b2 -j$NIX_BUILD_CORES -sEXPAT_INCLUDE=${expat}/include -sEXPAT_LIBPATH=${expat}/lib --layout=${layout} variant=${variant} threading=${threading} link=${link} ${cflags} install
+  '';
 
   crossAttrs = rec {
     buildInputs = [ expat.hostDrv zlib.hostDrv bzip2.hostDrv ];

pkgs/development/libraries/ftgl/2.1.2.nix

···
 
   buildInputs = [freetype mesa];
 
+  NIX_LDFLAGS = "-lGLU -lGL";
+
   patches = [ ./gcc.patch ];
 
   configureFlags = "--enable-shared";

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

···
 
 cabal.mkDerivation (self: {
   pname = "ansi-terminal";
-  version = "0.5.5";
-  sha256 = "09r4nlpmkis6cp30jkymfas13hz6ph4zqxhvigrxn6s76v7nb5a8";
+  version = "0.5.5.1";
+  sha256 = "146kqp49dvsskws7pn54yynpac1sb1s51pbm4nkqj86wwp04f0lc";
   isLibrary = true;
   isExecutable = true;
   meta = {

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

···
+{ cabal, base64Bytestring, conduit }:
+
+cabal.mkDerivation (self: {
+  pname = "base64-conduit";
+  version = "0.5.1";
+  sha256 = "1zmp6iv55rac7x7w59az7zaarq79fr7zvgg2wcb5b627axlw909l";
+  buildDepends = [ base64Bytestring conduit ];
+  meta = {
+    homepage = "http://github.com/snoyberg/conduit";
+    description = "Base64-encode and decode streams of bytes";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "blaze-html";
-  version = "0.5.1.1";
-  sha256 = "1z1lnfph4spy9vx2nfhbykkfcdnw14fars5aydrgi70spaq5ial2";
+  version = "0.5.1.3";
+  sha256 = "0ia7pk346lc7664w859q09p163cxgxjjpkk7cbmbl1wj2shshh1w";
   buildDepends = [ blazeBuilder blazeMarkup text ];
   meta = {
     homepage = "http://jaspervdj.be/blaze";

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

···
 
 cabal.mkDerivation (self: {
   pname = "blaze-markup";
-  version = "0.5.1.2";
-  sha256 = "1iqwcmb35793drkvnxx8z3zkyyzd6b84x9b8cp2aza2n0qw7sihm";
+  version = "0.5.1.4";
+  sha256 = "0g316qhk7yv6y680w93613apfhm458a01g3jmq42yv4ndydkv4rr";
   buildDepends = [ blazeBuilder text ];
   meta = {
     homepage = "http://jaspervdj.be/blaze";

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

···
+{ cabal, blazeMarkup, mtl }:
+
+cabal.mkDerivation (self: {
+  pname = "blaze-svg";
+  version = "0.3.3.0";
+  sha256 = "1wi4nc73ic3qmbx6v9fniacwcz2nlvmp5snn144fdiwb22klfn5f";
+  buildDepends = [ blazeMarkup mtl ];
+  meta = {
+    homepage = "https://github.com/deepakjois/blaze-svg";
+    description = "SVG combinator library";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "cipher-aes";
-  version = "0.1.4";
-  sha256 = "0yidq4swwhn1ldm16faraa00gpy946r9ndjkwhfps4pb3h96z0hz";
+  version = "0.1.5";
+  sha256 = "0n0qbq2hwyksdbr6fn7yj5vwicmdrn58mfz0dprl8fj456r4j3kn";
   meta = {
     homepage = "http://github.com/vincenthz/hs-cipher-aes";
     description = "Fast AES cipher implementation with advanced mode of operations";

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

···
-{ cabal, classyPrelude, conduit, xmlConduit }:
+{ cabal, classyPrelude, conduit, monadControl, resourcet
+, transformers, void, xmlConduit
+}:
 
 cabal.mkDerivation (self: {
   pname = "classy-prelude-conduit";
-  version = "0.4.1";
-  sha256 = "0llir0xnnyhgxifay019x64jw7mnn9p1sqs1xwm14gjcqr2nqqg8";
-  buildDepends = [ classyPrelude conduit xmlConduit ];
+  version = "0.4.2";
+  sha256 = "1p5j519s95cgiy5ig0agbfs4vyay8srzwsimnblij68zz5jjfrzp";
+  buildDepends = [
+    classyPrelude conduit monadControl resourcet transformers void
+    xmlConduit
+  ];
   meta = {
     homepage = "https://github.com/snoyberg/classy-prelude";
     description = "conduit instances for classy-prelude";

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

···
 
 cabal.mkDerivation (self: {
   pname = "classy-prelude";
-  version = "0.4.1";
-  sha256 = "14s1qirss8qbicdw4bc7smdnk1xrpp1xsii8kgmrb1z4ji0h9bf1";
+  version = "0.4.2";
+  sha256 = "082zqhyswzlnl250g8pf88nmh7pkwxwjwnkp0pm9960qsl6kbn7s";
   buildDepends = [
     basicPrelude hashable systemFilepath text transformers
     unorderedContainers vector

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

···
 
 cabal.mkDerivation (self: {
   pname = "cprng-aes";
-  version = "0.3.0";
-  sha256 = "1a8imapda8k0rf0bvag1iin66f2r97pfgip7dkvpvmdkp3j1212h";
+  version = "0.3.1";
+  sha256 = "0z1kpgy9d4yp1vmcparsv3r5g1khv2yqqkr99ac3mgvr6pyh24dk";
   buildDepends = [
     cipherAes cryptoApi cryptoRandomApi entropy random
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "crypto-conduit";
-  version = "0.4.1";
-  sha256 = "1gdznwcq3fb9ls68lgpwna6k1k612j241c8441z7r2kx3a64dqwv";
+  version = "0.4.2";
+  sha256 = "0kg99kvpm5h8v28sylrp9z868ksz5737377akqy09y90xzb8pak3";
   buildDepends = [ cereal conduit cryptoApi transformers ];
   meta = {
     homepage = "https://github.com/meteficha/crypto-conduit";

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

···
 
 cabal.mkDerivation (self: {
   pname = "cryptocipher";
-  version = "0.3.6";
-  sha256 = "0r2alw0in0ndaz7y9bzqigla74wbn8h1z43s2zx5rc3sq5p3rp6s";
+  version = "0.3.7";
+  sha256 = "14qhi3969q1h9n85flb7wwsr50gdn63q7pmcpm2npy5vkp34lkp5";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "cryptohash";
-  version = "0.7.9";
-  sha256 = "1prbc65klr93mvqj4hass5yyxv353fral70mj379jrf4m93429hz";
-  isLibrary = true;
-  isExecutable = true;
+  version = "0.8.1";
+  sha256 = "1xxnmxfpd77ahyjhy2fq3fxhiivhj6k12v1z72ndyhrd3369zqky";
   buildDepends = [ cereal cryptoApi tagged ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-cryptohash";

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

···
-{ cabal, cairo, cmdargs, diagramsCore, diagramsLib, filepath, gtk
-, mtl, split
+{ cabal, cairo, cmdargs, colour, diagramsCore, diagramsLib
+, filepath, mtl, split, time
 }:
 
 cabal.mkDerivation (self: {
   pname = "diagrams-cairo";
-  version = "0.5.0.2";
-  sha256 = "1wwk65c2cx7rkhmai5spms791fjhl3snwhj0w9399q8pgj6g4lj8";
+  version = "0.6";
+  sha256 = "0fxqwkv2cpgpkr80q828rm91ybn7j0dwj1p5ysc3648w28jvhkil";
   buildDepends = [
-    cairo cmdargs diagramsCore diagramsLib filepath gtk mtl split
+    cairo cmdargs colour diagramsCore diagramsLib filepath mtl split
+    time
   ];
-  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams";
     description = "Cairo backend for diagrams drawing EDSL";

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

···
+{ cabal, colour, dataDefault, diagramsLib, forceLayout, lens, mtl
+, vectorSpace
+}:
+
+cabal.mkDerivation (self: {
+  pname = "diagrams-contrib";
+  version = "0.6";
+  sha256 = "059ljwsbrkzj2wvx9q4viinz46nw5lf4yjmx2c1dmwaqfz3i7j7i";
+  buildDepends = [
+    colour dataDefault diagramsLib forceLayout lens mtl vectorSpace
+  ];
+  meta = {
+    homepage = "http://projects.haskell.org/diagrams/";
+    description = "Collection of user contributions to diagrams EDSL";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
-{ cabal, MemoTrie, newtype, semigroups, vectorSpace
-, vectorSpacePoints
+{ cabal, dualTree, MemoTrie, monoidExtras, newtype, semigroups
+, vectorSpace, vectorSpacePoints
 }:
 
 cabal.mkDerivation (self: {
   pname = "diagrams-core";
-  version = "0.5.0.1";
-  sha256 = "073fk9cxm1kh92alr51dgwps9wxc5w3470axc6q7w91sk5cskpxy";
+  version = "0.6";
+  sha256 = "15frd5jdzkgpdcvyyhd0mbi5d4a69ajcnxawa1gafl4c3byz1778";
   buildDepends = [
-    MemoTrie newtype semigroups vectorSpace vectorSpacePoints
+    dualTree MemoTrie monoidExtras newtype semigroups vectorSpace
+    vectorSpacePoints
   ];
-  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams";
     description = "Core libraries for diagrams EDSL";

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

···
-{ cabal, diagramsCairo, diagramsCore, diagramsLib }:
+{ cabal, diagramsContrib, diagramsCore, diagramsLib, diagramsSvg }:
 
 cabal.mkDerivation (self: {
   pname = "diagrams";
-  version = "0.5";
-  sha256 = "163h2fg3gpmsfm57gjyja2rxh9pl6s3xnzlidfdy201zbk1mzdg5";
-  buildDepends = [ diagramsCairo diagramsCore diagramsLib ];
+  version = "0.6";
+  sha256 = "1i62jbixjzw82y622ymp6lrp4kzgn7iv55arivvh0y46bbmybqvh";
+  buildDepends = [
+    diagramsContrib diagramsCore diagramsLib diagramsSvg
+  ];
   noHaddock = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams";

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

···
-{ cabal, active, colour, dataDefault, diagramsCore, newtype
-, NumInstances, semigroups, vectorSpace
+{ cabal, active, colour, dataDefault, diagramsCore, monoidExtras
+, newtype, NumInstances, semigroups, vectorSpace
 }:
 
 cabal.mkDerivation (self: {
   pname = "diagrams-lib";
-  version = "0.5.0.1";
-  sha256 = "0spfsllr2z064cxkdqcij02f0ikxxmll2dqj7rfikp4738wj21dy";
+  version = "0.6";
+  sha256 = "05nfp5ggjk4fviwvwiblmzzw5dbzbi1w8dx5dimvah7wxb0km3lf";
   buildDepends = [
-    active colour dataDefault diagramsCore newtype NumInstances
-    semigroups vectorSpace
+    active colour dataDefault diagramsCore monoidExtras newtype
+    NumInstances semigroups vectorSpace
   ];
   meta = {
     homepage = "http://projects.haskell.org/diagrams";

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

···
+{ cabal, blazeSvg, cmdargs, colour, diagramsCore, diagramsLib
+, filepath, monoidExtras, mtl, split, time, vectorSpace
+}:
+
+cabal.mkDerivation (self: {
+  pname = "diagrams-svg";
+  version = "0.6";
+  sha256 = "0yiqilpksgsy87dxx4664pgbbgqcr98j1da4krb751x0yxkglyh5";
+  buildDepends = [
+    blazeSvg cmdargs colour diagramsCore diagramsLib filepath
+    monoidExtras mtl split time vectorSpace
+  ];
+  meta = {
+    homepage = "http://projects.haskell.org/diagrams/";
+    description = "SVG backend for diagrams drawing EDSL";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "digestive-functors-heist";
-  version = "0.5.0.0";
-  sha256 = "1cqzpnr53mailnmjgkbqk4f4hrjd84h6682mr8x7qg5v27zvcdbn";
+  version = "0.5.1.0";
+  sha256 = "1rycf6y1c0car2m71iia929si5iqpc2rdyyxzp326q0rgj94whpk";
   buildDepends = [ digestiveFunctors heist text xmlhtml ];
   meta = {
     homepage = "http://github.com/jaspervdj/digestive-functors";

pkgs/development/libraries/haskell/dual-tree/default.nix

···
+{ cabal, monoidExtras, newtype, semigroups }:
+
+cabal.mkDerivation (self: {
+  pname = "dual-tree";
+  version = "0.1.0.0";
+  sha256 = "0av525gjxzd2hhrg5da647chwbv4j30gccaff2b3n5qijzy8l167";
+  buildDepends = [ monoidExtras newtype semigroups ];
+  meta = {
+    description = "Rose trees with cached and accumulating monoidal annotations";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, semigroupoids, semigroups, transformers }:
+
+cabal.mkDerivation (self: {
+  pname = "either";
+  version = "3.0.2";
+  sha256 = "1s3rpxxqc9052hrmiznwqwxhl4826qzbgpivpv5acxfhm0w06lhg";
+  buildDepends = [ semigroupoids semigroups transformers ];
+  meta = {
+    homepage = "http://github.com/ekmett/either/";
+    description = "Haskell 98 either monad transformer";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, either, safe, transformers }:
+
+cabal.mkDerivation (self: {
+  pname = "errors";
+  version = "1.3.1";
+  sha256 = "0vfpnpkiz362bvjyaf35spfk3h6vw7xi1x3f8agzs7kmxrdvrfik";
+  buildDepends = [ either safe transformers ];
+  meta = {
+    description = "Simplified error-handling";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/force-layout/default.nix

···
+{ cabal, lens, newtype, vectorSpace, vectorSpacePoints }:
+
+cabal.mkDerivation (self: {
+  pname = "force-layout";
+  version = "0.2";
+  sha256 = "0aif7a28qs8ya7q9sklp02gb5228jyj8k4jabbp2sia7j4khrkpv";
+  buildDepends = [ lens newtype vectorSpace vectorSpacePoints ];
+  meta = {
+    description = "Simple force-directed layout";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/generic-deriving/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "generic-deriving";
-  version = "1.3.1";
-  sha256 = "1z02j86lgn57ws0rfq2m0zb0m866k9afh9346k8bbwb5c4914wm3";
+  version = "1.4.0";
+  sha256 = "15av3l4m4qn5by41rkpdvp1kyp3fi9ixvy76wmyj20c46kjbmra7";
   meta = {
     description = "Generic programming library for generalised deriving";
     license = self.stdenv.lib.licenses.bsd3;

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

···
 
 cabal.mkDerivation (self: {
   pname = "ghc-mod";
-  version = "1.11.2";
-  sha256 = "0df1g57mwgd9avd2smnc7j97n14553p3zdmnbjanhnzin2fqj0dc";
+  version = "1.11.3";
+  sha256 = "13r3cz25lf0ndsyfc5adqx5mdv7hcl3qp7n2syg2msrn133xpwb2";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "gloss";
-  version = "1.7.7.1";
-  sha256 = "0g5ik7zv2iywvqingnjvmb9ihk31fwpnjkbfiglzslmga5cjix2a";
+  version = "1.7.8.1";
+  sha256 = "0bi60zprgq1dd6prshvgqyyp13l6n5f171aryxg254kjagvrm3lf";
   buildDepends = [ bmp GLUT OpenGL ];
   jailbreak = true;
   meta = {

pkgs/development/libraries/haskell/glpk-hs/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "glpk-hs";
-  version = "0.3.3";
-  sha256 = "1pnq0v5va7f40ky9xb8c4z9wcmmnny2vk4afasz5pwivbxh42mfl";
+  version = "0.3.4";
+  sha256 = "0wyasd0dqi5nnh52lx980vnyhm0rwib0sd7qnpj4s9hq8rn994cm";
   buildDepends = [ deepseq mtl ];
   extraLibraries = [ glpk ];
   meta = {

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

···
     lrucache mtl pandoc parsec regexBase regexTdfa snapCore snapServer
     tagsoup text time
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://jaspervdj.be/hakyll";
     description = "A static website compiler library";

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

···
 
 cabal.mkDerivation (self: {
   pname = "hamlet";
-  version = "1.1.1.1";
-  sha256 = "0vxnvh9npsf1jxh471fnr2d13bdi7p8sxn5b2w86bla3q273jxp8";
+  version = "1.1.2";
+  sha256 = "0k6wnjqmap4wv0p1hvzpd8br4wr4vda9aw87agzf7pix6hwmiybq";
   buildDepends = [
     blazeBuilder blazeHtml blazeMarkup failure parsec shakespeare text
   ];

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

···
 { cabal, aeson, attoparsec, blazeBuilder, blazeHtml, directoryTree
-, filepath, MonadCatchIOTransformers, mtl, random, text, time
-, unorderedContainers, vector, xmlhtml
+, dlist, errors, filepath, hashable, MonadCatchIOTransformers, mtl
+, random, text, time, unorderedContainers, vector, xmlhtml
 }:
 
 cabal.mkDerivation (self: {
   pname = "heist";
-  version = "0.8.2";
-  sha256 = "0zamggvfq9054vxznbnfq1fihk110ih8q0dza1rmsjb1h2s88rkj";
+  version = "0.10.0";
+  sha256 = "0cabn1yw57qa7psmypqa20k4viis140al5zm31jlpmz599rkbi9z";
   buildDepends = [
-    aeson attoparsec blazeBuilder blazeHtml directoryTree filepath
-    MonadCatchIOTransformers mtl random text time unorderedContainers
-    vector xmlhtml
+    aeson attoparsec blazeBuilder blazeHtml directoryTree dlist errors
+    filepath hashable MonadCatchIOTransformers mtl random text time
+    unorderedContainers vector xmlhtml
   ];
   meta = {
     homepage = "http://snapframework.com/";
-    description = "An (x)html templating system";
+    description = "An Haskell template system supporting both HTML5 and XML";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
   };

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

···
     shakespeareJs shakespeareText text time transformers wai waiExtra
     warp yaml yesod yesodCore yesodDefault yesodForm yesodStatic
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://hledger.org";
     description = "A web interface for the hledger accounting tool";

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

···
 
 cabal.mkDerivation (self: {
   pname = "hspec";
-  version = "1.4.2.2";
-  sha256 = "0dsavcawa54pjicibb48648iy6bzggkvhiklksq85xq4ywg7r3g5";
+  version = "1.4.3";
+  sha256 = "0i963fxamyyi3afac67rkw4340i3xqs1q3lvcy69mq0czbdvgjmc";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "http-conduit";
-  version = "1.8.4.5";
-  sha256 = "1yr9g8pa6wggc4ycm0r3j7xccglvyf2rsd8a1y94p7h3f2hjbsgg";
+  version = "1.8.5.1";
+  sha256 = "1v70rslnga063mlpfs1w03y1s4x7kfisjqwbcbczynhz15s9hymx";
   buildDepends = [
     asn1Data attoparsec attoparsecConduit base64Bytestring blazeBuilder
     blazeBuilderConduit caseInsensitive certificate conduit cookie

pkgs/development/libraries/haskell/http-reverse-proxy/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "http-reverse-proxy";
-  version = "0.1.0.6";
-  sha256 = "0ybhzyim8b2k1kv5bz0qbignj5lwf8pbpqmrp1vrvyz8a2iy71c8";
+  version = "0.1.0.7";
+  sha256 = "1fshng7bcpzjq5iqnvl2qsyia9yi80b8sbif18a3w86gsw5xcakk";
   buildDepends = [
     blazeBuilder caseInsensitive classyPreludeConduit conduit
     httpConduit httpTypes liftedBase monadControl network

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

···
 
 cabal.mkDerivation (self: {
   pname = "iproute";
-  version = "1.2.7";
-  sha256 = "07ixxq45w5wzvfrvsv2b206kygiqn1v3bcclkd98afjpc6mv3ld3";
+  version = "1.2.9";
+  sha256 = "0r0g8dd0f5n462kil3m2lhycl84ygd0ayh900h9x8phgwzfxzv8i";
   buildDepends = [ appar byteorder network ];
   meta = {
     homepage = "http://www.mew.org/~kazu/proj/iproute/";

pkgs/development/libraries/haskell/kansas-lava/default.nix

···
+{ cabal, cmdargs, dataDefault, dataReify, dotgen, filepath, netlist
+, netlistToVhdl, random, sizedTypes, strict
+}:
+
+cabal.mkDerivation (self: {
+  pname = "kansas-lava";
+  version = "0.2.4";
+  sha256 = "0rsjlj558k57r1sfm12n9r9wn8r615bbrwgjhal07qhvy4qip4pg";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    cmdargs dataDefault dataReify dotgen filepath netlist netlistToVhdl
+    random sizedTypes strict
+  ];
+  jailbreak = true;
+  meta = {
+    homepage = "http://ittc.ku.edu/csdl/fpg/Tools/KansasLava";
+    description = "Kansas Lava is a hardware simulator and VHDL generator";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/language-c-quote/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "language-c-quote";
-  version = "0.4.3";
-  sha256 = "13xpmj3jrqkcgilkh4p8ycxhlk5yvfsisx4c1ax7n7aafg1n7phf";
+  version = "0.4.4";
+  sha256 = "1g233ja3qy64xcimy9irfb3n8zys00vg1d0s4g3hr48ilc95dl8l";
   buildDepends = [
     exceptionMtl exceptionTransformers filepath haskellSrcMeta
     mainlandPretty mtl srcloc syb symbol

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

···
 
 cabal.mkDerivation (self: {
   pname = "largeword";
-  version = "1.0.3";
-  sha256 = "18b6nhq1cww4wdbrfq0cb828kncxzcsibgs5dbgxa66y6iw93vkg";
+  version = "1.0.4";
+  sha256 = "19nrzbbbmsvxdhfhh6wc53lbk0xyjvbcwvjw0snym666j1w2b2l5";
   meta = {
-    homepage = "http://trac.haskell.org/largeword/wiki";
+    homepage = "https://github.com/idontgetoutmuch/largeword";
     description = "Provides Word128, Word192 and Word256 and a way of producing other large words if required";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;

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

···
 
 cabal.mkDerivation (self: {
   pname = "lens";
-  version = "3.6";
-  sha256 = "1zl52hj0ccx21qwlqrscfjmc7i0g2prikmd3lgbfbgjqlh7wnqdq";
+  version = "3.7.0.2";
+  sha256 = "19p71faxr78pis73r2ani0al0lmbq81cws1v2hlgqb4mv2fgw5kn";
   buildDepends = [
     comonad comonadsFd comonadTransformers filepath hashable mtl
     parallel semigroups split text transformers unorderedContainers

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

···
 
 cabal.mkDerivation (self: {
   pname = "lifted-base";
-  version = "0.2";
-  sha256 = "12ai34wb1sd6fza50arlpvsdc6l2nwrrcik0xakf2q0ddzjmhjfb";
+  version = "0.2.0.2";
+  sha256 = "19xzparj0k5h4wx71gvbd7l653fak1p57za236sncmar8cps5pdx";
   buildDepends = [
     baseUnicodeSymbols monadControl transformersBase
   ];

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

···
+{ cabal, text }:
+
+cabal.mkDerivation (self: {
+  pname = "minimorph";
+  version = "0.1.4.0";
+  sha256 = "16ri9hfriszrgqcm111b1pp5x65s034hrc35kjz5qax32mnc9rn6";
+  buildDepends = [ text ];
+  meta = {
+    homepage = "http://darcsden.com/kowey/minimorph";
+    description = "English spelling functions with an emphasis on simplicity";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, minimorph, text }:
+
+cabal.mkDerivation (self: {
+  pname = "miniutter";
+  version = "0.4.0";
+  sha256 = "1l275aad8svrqp22jv9s0mmlam7wbdlf6m4m97658rm8ks4j2mbx";
+  buildDepends = [ minimorph text ];
+  meta = {
+    homepage = "https://github.com/Mikolaj/miniutter";
+    description = "Simple English clause creation from arbitrary words";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/monoid-extras/default.nix

···
+{ cabal, semigroups }:
+
+cabal.mkDerivation (self: {
+  pname = "monoid-extras";
+  version = "0.2.2.1";
+  sha256 = "0n2zwkwwq8kg9m6qr79mrhlxsfsrjzbyg96gfhcgk21zgc09zary";
+  buildDepends = [ semigroups ];
+  meta = {
+    description = "Various extra monoid-related definitions and utilities";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "mpppc";
-  version = "0.1.2";
-  sha256 = "1zms71wx5a6rd60xy1pv6g1kxlx0hzh36pbr5a5lkfflc583z1k5";
+  version = "0.1.3";
+  sha256 = "1zcilskpslpqyrbwpabwbry4p3kpcfca94wchh9dkq9g8pg8laxi";
   buildDepends = [ ansiTerminal split text ];
   meta = {
     description = "Multi-dimensional parametric pretty-printer with color";

pkgs/development/libraries/haskell/netlist-to-vhdl/default.nix

···
+{ cabal, netlist }:
+
+cabal.mkDerivation (self: {
+  pname = "netlist-to-vhdl";
+  version = "0.3.1";
+  sha256 = "15daik7l0pjqilya01l5rl84g2fyjwkap1md0nx82gxcp8m1v76k";
+  buildDepends = [ netlist ];
+  meta = {
+    description = "Convert a Netlist AST to VHDL";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
+{ cabal, binary, syb }:
+
+cabal.mkDerivation (self: {
+  pname = "netlist";
+  version = "0.3.1";
+  sha256 = "0f3fwgpg0p3ajgxfzbqr4z04ly5cdbhjxms5xbd0k2ixdwgyxm67";
+  buildDepends = [ binary syb ];
+  meta = {
+    description = "Netlist AST";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

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

···
 
 cabal.mkDerivation (self: {
   pname = "network-conduit";
-  version = "0.6.1.1";
-  sha256 = "00x5ks1qcq5smmd2g4bm23lb3ngdxmdlz822qkkj9l9c27lkn67n";
+  version = "0.6.2";
+  sha256 = "1v9f2x4ryqiwird60n4rkj0jlyn3lqkfs40956xi11r7p656l6q6";
   buildDepends = [
     conduit liftedBase monadControl network transformers
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "optparse-applicative";
-  version = "0.4.2";
-  sha256 = "0hxl4hhh24hz1fc23mbsx83ccnv2fkxbar37d9c5cmiaalsrfb19";
+  version = "0.4.3";
+  sha256 = "1zsydxgq3lcgzrf9iwas3gkjy0vxn4z2cj6h3m63h0qqa26sfcwz";
   buildDepends = [ transformers ];
   meta = {
     homepage = "https://github.com/pcapriotti/optparse-applicative";

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

···
     description = "Conversion between markup formats";
     license = "GPL";
     platforms = self.ghc.meta.platforms;
-    maintainers = [ self.stdenv.lib.maintainers.andres ];
+    maintainers = [
+      self.stdenv.lib.maintainers.andres
+      self.stdenv.lib.maintainers.simons
+    ];
   };
 })

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

···
 
 cabal.mkDerivation (self: {
   pname = "parallel-io";
-  version = "0.3.2.1";
-  sha256 = "0wrmz0i5s8p87840pacdnpf2fi12nips4yc72vymifrc1wvlc42q";
+  version = "0.3.2.2";
+  sha256 = "04swl1mp704ijrpmvw800x0fpzmrbd382p45kvqzynmkgqzx33a3";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ extensibleExceptions random ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "parseargs";
-  version = "0.1.3.2";
-  sha256 = "1ncdbjzfkhb1f3aznsci26kss9nrv3iilc65q5xdl9nly8p837mv";
+  version = "0.1.3.4";
+  sha256 = "1n55ay42qiwm72fa63xbz5m5fi0ld5dr3vypmyz5mc0zzhqwxz2j";
   isLibrary = true;
   isExecutable = true;
   meta = {

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

···
 
 cabal.mkDerivation (self: {
   pname = "pem";
-  version = "0.1.1";
-  sha256 = "0klb39w6mihx35xgdw5wvi1q6r61xgrsqvcqi4c5r6psv5z94cil";
+  version = "0.1.2";
+  sha256 = "1p2sw36b9w6lf53jzj86ibyy9a48fjd786mx3x8mvc5lczx8v78m";
   buildDepends = [ attoparsec base64Bytestring cereal mtl ];
   meta = {
     homepage = "http://github.com/vincenthz/hs-pem";

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

···
 
 cabal.mkDerivation (self: {
   pname = "persistent-postgresql";
-  version = "1.1.0";
-  sha256 = "0vfmlmhfp20w2chiiq0jq6mz084j3bpbviswkcyzdymdkky87kni";
+  version = "1.1.1";
+  sha256 = "19ywyf0d7n6z8ws7s7jc958g30aiy6il43qwvqh92q1cz8bd1mj9";
   buildDepends = [
     aeson conduit monadControl persistent postgresqlLibpq
     postgresqlSimple text time transformers

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

···
 
 cabal.mkDerivation (self: {
   pname = "persistent-template";
-  version = "1.1.0";
-  sha256 = "18c2mawq8v094szbjncnm113fmbgzyidcfvs430xy6klag1gh629";
+  version = "1.1.1";
+  sha256 = "18rxjqgmjzx0j0sbg9ms779pkq264vf8w0qz679xsyn98wc95i36";
   buildDepends = [ aeson monadControl persistent text transformers ];
   meta = {
     homepage = "http://www.yesodweb.com/book/persistent";

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

···
 { cabal, aeson, attoparsec, base64Bytestring, blazeHtml
 , blazeMarkup, conduit, liftedBase, monadControl, monadLogger
-, pathPieces, poolConduit, resourcet, sqlite, text, time
+, pathPieces, poolConduit, resourcet, silently, sqlite, text, time
 , transformers, transformersBase, unorderedContainers, vector
 }:
 
 cabal.mkDerivation (self: {
   pname = "persistent";
-  version = "1.1.0";
-  sha256 = "15wsw3mnpic8x7qrb8w7ww47p9sazfljp6kcdx13yv2sxa8dv153";
+  version = "1.1.0.1";
+  sha256 = "07b9d9fcah3k03r2pm6mfl3qsdp4s9gbb376by3122nvc26w6sjc";
   buildDepends = [
     aeson attoparsec base64Bytestring blazeHtml blazeMarkup conduit
     liftedBase monadControl monadLogger pathPieces poolConduit
-    resourcet text time transformers transformersBase
+    resourcet silently text time transformers transformersBase
     unorderedContainers vector
   ];
   extraLibraries = [ sqlite ];

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

···
-{ cabal, base64Bytestring, classyPreludeConduit, conduit, mtl
-, systemFileio, systemFilepath, text, transformers
+{ cabal, base64Bytestring, base64Conduit, classyPreludeConduit
+, conduit, mtl, resourcet, systemFileio, systemFilepath, text
+, transformers
 }:
 
 cabal.mkDerivation (self: {
   pname = "project-template";
-  version = "0.1.0.1";
-  sha256 = "0ahmdlfn48yz8fj7199w0qsa1dbbxr21bs9hq1lnm3s2p4qiki23";
+  version = "0.1.1";
+  sha256 = "186hqfhhl77yq9gqiw59jbnkk7xmpljqfwwilzjkjknf3ifhs5na";
   buildDepends = [
-    base64Bytestring classyPreludeConduit conduit mtl systemFileio
-    systemFilepath text transformers
+    base64Bytestring base64Conduit classyPreludeConduit conduit mtl
+    resourcet systemFileio systemFilepath text transformers
   ];
   meta = {
     homepage = "https://github.com/fpco/haskell-ide";

pkgs/development/libraries/haskell/repa-examples/default.nix

···
   sha256 = "1lflgpnig2ks2mwp7bywyjqr2v426gbk1675mkkvjncgr5ahf11g";
   isLibrary = false;
   isExecutable = true;
-  jailbreak = true;
   buildDepends = [
     QuickCheck random repa repaAlgorithms repaIo vector
   ];
   extraLibraries = [ llvm ];
+  jailbreak = true;
   meta = {
     homepage = "http://repa.ouroborus.net";
     description = "Examples using the Repa array library";

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

···
 
 cabal.mkDerivation (self: {
   pname = "shelly";
-  version = "0.14.3";
-  sha256 = "0nlspgk5svc9zr2gry96sykhd8i7vdmqxpsvfsz22khw8climqzj";
+  version = "0.15.0";
+  sha256 = "138x2c76ynv0kl0kg86pawnnlk6973dqkaapycb30rf44p1m53j2";
   buildDepends = [
     mtl systemFileio systemFilepath text time unixCompat
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "silently";
-  version = "1.2.4";
-  sha256 = "0ac75b4n9566vpvv6jfcqafnyplv8dd7bgak89b16wy032z1xl5j";
+  version = "1.2.4.1";
+  sha256 = "035dw3zg680ykyz5rqkkrjn51wkznbc4jb45a8l2gh3vgqzgbf52";
   buildDepends = [ deepseq ];
   meta = {
     homepage = "https://github.com/trystan/silently";

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

···
 
 cabal.mkDerivation (self: {
   pname = "simple-sendfile";
-  version = "0.2.8";
-  sha256 = "11lw8m21cy40hd9nzp80d9jawgv9hd3sfvizjcfbvdc2lpq6m17j";
+  version = "0.2.10";
+  sha256 = "07js189yyya2vs3wsc49b7c2zbh63f48kywmz88g7s394bp3n9am";
   buildDepends = [ network ];
   meta = {
     description = "Cross platform library for the sendfile system call";

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

···
+{ cabal }:
+
+cabal.mkDerivation (self: {
+  pname = "sized-types";
+  version = "0.3.4.0";
+  sha256 = "0fpk7xpqzzylxbnxhz56lxzfnrhfibn0x7ahxl91x6biysnh714c";
+  isLibrary = true;
+  isExecutable = true;
+  meta = {
+    homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools";
+    description = "Sized types in Haskell";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/snap/loader-dynamic.nix

···
 
 cabal.mkDerivation (self: {
   pname = "snap-loader-dynamic";
-  version = "0.9.0.1";
-  sha256 = "1pzn8lfqngn8cqm1dpxn5wsx70xcd7r90rd2948n4p5309qgh9mq";
+  version = "0.10";
+  sha256 = "0wnrsbnf3crfxhhraz4my08m6yhmqj632rv6cdy9ili3wxjkqd57";
   buildDepends = [ directoryTree hint mtl snapCore time ];
   meta = {
     homepage = "http://snapframework.com/";

pkgs/development/libraries/haskell/snap/loader-static.nix

···
 
 cabal.mkDerivation (self: {
   pname = "snap-loader-static";
-  version = "0.9.0";
-  sha256 = "1blchmg0qfng7bw235z1gqkwyi764j78bc29vd5p6xxhmq111ys7";
+  version = "0.9.0.1";
+  sha256 = "0xlb8611r9l9ld97rs27nji7k1qvjg5i62b4al38xj6i0f2skyyi";
   meta = {
     homepage = "http://snapframework.com/";
     description = "Snap: A Haskell Web Framework: static loader";

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

···
-{ cabal, aeson, attoparsec, cereal, clientsession, configurator
-, dataLens, dataLensTemplate, directoryTree, filepath, hashable
-, heist, logict, MonadCatchIOTransformers, mtl, mwcRandom
-, pwstoreFast, snapCore, snapServer, stm, syb, text, time
-, transformers, unorderedContainers, vector, vectorAlgorithms
+{ cabal, aeson, attoparsec, cereal, clientsession, comonad
+, configurator, directoryTree, dlist, errors, filepath, hashable
+, heist, lens, logict, MonadCatchIOTransformers, mtl, mwcRandom
+, pwstoreFast, regexPosix, snapCore, snapServer, stm, syb, text
+, time, transformers, unorderedContainers, vector, vectorAlgorithms
 , xmlhtml
 }:
 
 cabal.mkDerivation (self: {
   pname = "snap";
-  version = "0.9.2.2";
-  sha256 = "1ql9c8b9arcd8zwlwsiipl4diah87sp339ljc5bc7yls1g4d9zsw";
+  version = "0.10.0.1";
+  sha256 = "14j9lgcdyxh7n4yidfvn1r94nziljiqz6nsqgq114v34bnn6l2yn";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
-    aeson attoparsec cereal clientsession configurator dataLens
-    dataLensTemplate directoryTree filepath hashable heist logict
-    MonadCatchIOTransformers mtl mwcRandom pwstoreFast snapCore
-    snapServer stm syb text time transformers unorderedContainers
-    vector vectorAlgorithms xmlhtml
+    aeson attoparsec cereal clientsession comonad configurator
+    directoryTree dlist errors filepath hashable heist lens logict
+    MonadCatchIOTransformers mtl mwcRandom pwstoreFast regexPosix
+    snapCore snapServer stm syb text time transformers
+    unorderedContainers vector vectorAlgorithms xmlhtml
   ];
   meta = {
     homepage = "http://snapframework.com/";

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

···
 
 cabal.mkDerivation (self: {
   pname = "stylish-haskell";
-  version = "0.5.4.0";
-  sha256 = "1bnsjs5s760xnk3s1l7kjqr2svxp4a881p9z2slaywi5kn0v5mwf";
+  version = "0.5.5.2";
+  sha256 = "1whl8qdqyw2saic70kav8srg4f6bcn77mc86m0vk8i8n5mb3q4ny";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
   version = "0.2.2.3";
   sha256 = "cf6d9f1928ec6981edcbb06c4dcbaea7a96deef5272192ad4290caa18711ea76";
   buildDepends = [ csv html mtl ];
+  jailbreak = true;
   meta = {
     homepage = "http://patch-tag.com/r/kowey/tabular";
     description = "Two-dimensional data tables with rendering functions";

pkgs/development/libraries/haskell/test-framework-hunit/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "test-framework-hunit";
-  version = "0.2.7";
-  sha256 = "1c7424i5vnggzncwiwqqwq7ir7kaijif2waqmss5pn6db3gj33fc";
+  version = "0.3.0";
+  sha256 = "1jwbpbf9q3g936gk71632h830l2wsiic8h6ms1jlmw209mpm7c84";
   buildDepends = [ extensibleExceptions HUnit testFramework ];
   meta = {
     homepage = "http://batterseapower.github.com/test-framework/";

pkgs/development/libraries/haskell/test-framework-quickcheck/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "test-framework-quickcheck";
-  version = "0.2.8.1";
-  sha256 = "042vdq18mqw4rhsj3x51mz1iv9zbxvlz7jg6r9cni2xpw5m7v6dk";
+  version = "0.3.0";
+  sha256 = "0g8sh3x3mhns03svccgbdbw8crzpzmahp1hr1fs6ag66fqr8p9mv";
   buildDepends = [
     deepseq extensibleExceptions QuickCheck random testFramework
   ];

pkgs/development/libraries/haskell/test-framework-quickcheck2/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "test-framework-quickcheck2";
-  version = "0.2.12.3";
-  sha256 = "17pj6b1cclihy203zpb75rkx2djldc9kcj10wqkf5fjmf9vvi0ks";
+  version = "0.3.0.1";
+  sha256 = "1177cvlb4qsa5x2k12dd60y7b14dyd3jr1ygb49aackhjx52c41s";
   buildDepends = [
     extensibleExceptions QuickCheck random testFramework
   ];

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

···
 
 cabal.mkDerivation (self: {
   pname = "test-framework";
-  version = "0.6.1";
-  sha256 = "1rx2c3yckw50vrydswb61ngvp27yxcimm5q6jcyqpn16fpkvxijw";
+  version = "0.8";
+  sha256 = "1w895nq357zpc4v6vr5nbszyrw7cpsjq5bj38vdd10bfpjjmijcl";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/time-compat/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "time-compat";
-  version = "0.1.0.1";
-  sha256 = "1fh5ylxv9cmgirakimizfdili3xf3ggqhhz5hz3v9i13mh4bgzvd";
+  version = "0.1.0.2";
+  sha256 = "0687bxkvqs22p7skqb8n289k9nv7cafg8jyx32sswn2h11m7dihb";
   buildDepends = [ time ];
   meta = {
     homepage = "http://hub.darcs.net/dag/time-compat";

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

···
 
 cabal.mkDerivation (self: {
   pname = "tls-extra";
-  version = "0.5.0";
-  sha256 = "1r645qljn3ql7jcphsqf4cm259cl8fsva64q4p2x37mafi01bkr8";
+  version = "0.5.1";
+  sha256 = "0a977qy6ig4bhgsl6y5iw0xv52yswmcc2x37ypm1601wikjv38x3";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "tls";
-  version = "1.0.2";
-  sha256 = "0fkbh89j4gpwq45hv88axcdy7hxhvj1wj14nf7ma8wzaga2p4m75";
+  version = "1.0.3";
+  sha256 = "14wgwz032skkgkxg2lyh8kwg1fkapmlg2jh74czbacvnssc2iidb";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

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

···
 
 cabal.mkDerivation (self: {
   pname = "uniplate";
-  version = "1.6.7";
-  sha256 = "1f71dinmp3vmx9j0a1sxm0f8gzxknsvhnyb8sxfjrvpvixzyg0dx";
+  version = "1.6.9";
+  sha256 = "1s1863w4867lz0xn70xga5nss8vvm11rr1kia4icbws6r52sqjlh";
   buildDepends = [ hashable syb unorderedContainers ];
   meta = {
     homepage = "http://community.haskell.org/~ndm/uniplate/";

pkgs/development/libraries/haskell/vector-space/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "vector-space";
-  version = "0.8.4";
-  sha256 = "1hrilbv44lrqm9p3z97xw8nlgxam98abll4iqik8a4d6ky225bwq";
+  version = "0.8.6";
+  sha256 = "03kz2qhnynbgs4vk7348zjkkakzzwvxhbasl0lcazj1cx1ay7c4l";
   buildDepends = [ Boolean MemoTrie NumInstances ];
   meta = {
     description = "Vector & affine spaces, linear maps, and derivatives";

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

···
 
 cabal.mkDerivation (self: {
   pname = "wai-app-static";
-  version = "1.3.0.4";
-  sha256 = "1dcgw6b10j5y2xa1jpqfsgcq8w6c7cdbp4pfc8nb6n54bys4linn";
+  version = "1.3.0.5";
+  sha256 = "1fz2a30f3imn0m5q6hjkm2xan0ddalhfbzx78pklz4g7k79s1ncn";
   buildDepends = [
     base64Bytestring blazeBuilder blazeHtml blazeMarkup cereal
     cryptoConduit cryptohash fileEmbed httpDate httpTypes mimeTypes

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

···
 
 cabal.mkDerivation (self: {
   pname = "warp";
-  version = "1.3.5";
-  sha256 = "0hxipvdp0nwziijzmcnf0kdb3cz1m2w6xwszq2zqpjb7fvcy2acl";
+  version = "1.3.6";
+  sha256 = "0aw5m7apj7l6fjb0w59bmgiy4j0rmdwjil4ppgp5qz2q2njqbbnj";
   buildDepends = [
     blazeBuilder blazeBuilderConduit caseInsensitive conduit hashable
     httpTypes liftedBase network networkConduit simpleSendfile

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

···
 
 cabal.mkDerivation (self: {
   pname = "word8";
-  version = "0.0.2";
-  sha256 = "0ij8l5h9kj93srsizwxiss4jcgj0hy2gsskw88l58lgd2v4c9dnb";
+  version = "0.0.3";
+  sha256 = "1k5sq91pidgw7w8fc62k9gl8iynb65pcza6mjx8pa3n2lslp7125";
   meta = {
     description = "Word8 library";
     license = self.stdenv.lib.licenses.bsd3;

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

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-auth";
-  version = "1.1.2.1";
-  sha256 = "1bz3h5w5wbls5s1pf65yzdgjgl6ndsxrrfgfkjxkj55lc50ybdcp";
+  version = "1.1.2.2";
+  sha256 = "16g2lnnwp5219i77fb4pv2y8ljz4msflj38mvh0zw3x93747baf7";
   buildDepends = [
     aeson authenticate blazeHtml blazeMarkup hamlet httpConduit
     liftedBase mimeMail network persistent persistentTemplate pureMD5

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

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-default";
-  version = "1.1.2";
-  sha256 = "0asz9daf7by0d8sx8zqjsbxbzbyy59bvrdkq4f533fbn0nm1bn38";
+  version = "1.1.3";
+  sha256 = "1g0hb6jl0bp2q50pw2cy3hkbww1l230al08s7vfpqir68n9infiy";
   buildDepends = [
     dataDefault hamlet networkConduit safe shakespeareCss shakespeareJs
     text transformers unorderedContainers wai waiExtra warp yaml

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

···
 { cabal, aeson, attoparsec, base64Bytestring, blazeBuilder
 , blazeHtml, blazeMarkup, Cabal, conduit, fileEmbed, filepath
 , fsnotify, ghcPaths, hamlet, httpConduit, httpReverseProxy
-, httpTypes, liftedBase, monadControl, network, optparseApplicative
-, parsec, projectTemplate, resourcet, shakespeare, shakespeareCss
-, shakespeareJs, shakespeareText, split, systemFileio
-, systemFilepath, tar, text, time, transformers, unixCompat
-, unorderedContainers, wai, waiExtra, warp, yaml, yesodAuth
-, yesodCore, yesodDefault, yesodForm, yesodJson, yesodPersistent
-, zlib
+, httpTypes, liftedBase, monadControl, network, networkConduit
+, optparseApplicative, parsec, projectTemplate, resourcet
+, shakespeare, shakespeareCss, shakespeareJs, shakespeareText
+, split, systemFileio, systemFilepath, tar, text, time
+, transformers, unixCompat, unorderedContainers, wai, waiExtra
+, warp, yaml, yesodAuth, yesodCore, yesodDefault, yesodForm
+, yesodJson, yesodPersistent, zlib
 }:
 
 cabal.mkDerivation (self: {
   pname = "yesod";
-  version = "1.1.5";
-  sha256 = "1w34cwnqd92hjrjhqikpgzkjd4fnv3n844zziprk5kg0mlrylpvq";
+  version = "1.1.7";
+  sha256 = "1qcvmy8ichri9ivfkanj4gp687lwymgi170sbdzwf5phy34bhkc5";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
     aeson attoparsec base64Bytestring blazeBuilder blazeHtml
     blazeMarkup Cabal conduit fileEmbed filepath fsnotify ghcPaths
     hamlet httpConduit httpReverseProxy httpTypes liftedBase
-    monadControl network optparseApplicative parsec projectTemplate
-    resourcet shakespeare shakespeareCss shakespeareJs shakespeareText
-    split systemFileio systemFilepath tar text time transformers
-    unixCompat unorderedContainers wai waiExtra warp yaml yesodAuth
-    yesodCore yesodDefault yesodForm yesodJson yesodPersistent zlib
+    monadControl network networkConduit optparseApplicative parsec
+    projectTemplate resourcet shakespeare shakespeareCss shakespeareJs
+    shakespeareText split systemFileio systemFilepath tar text time
+    transformers unixCompat unorderedContainers wai waiExtra warp yaml
+    yesodAuth yesodCore yesodDefault yesodForm yesodJson
+    yesodPersistent zlib
   ];
   meta = {
     homepage = "http://www.yesodweb.com/";

pkgs/development/libraries/opencascade/default.nix

···
 ftgl, freetype}:
 
 stdenv.mkDerivation rec {
-  name = "opencascade-6.5.2";
+  name = "opencascade-6.5.4";
   src = fetchurl {
-    url = http://files.opencascade.com/OCCT/OCC_6.5.2_release/OpenCASCADE652.tar.gz;
-    sha256 = "0nsfjhd6rv1fmq8jbyzcs0f13h4xfld487vqs9bwd4lbwcfqxwcy";
+    url = http://files.opencascade.com/OCCT/OCC_6.5.4_release/OpenCASCADE654.tar.gz;
+    sha256 = "1di08mc0wly4cdi3rh9kj52bk0bfpyk6dy03c9yfnv04i7z03kmy";
   };
 
   buildInputs = [ mesa tcl tk file libXmu automake autoconf libtool qt4 ftgl freetype ];
···
 
   # -fpermissive helps building opencascade, although gcc detects a flaw in the code
   # and reports an error otherwise. Further versions may fix that.
-  NIX_CFLAGS_COMPILE = "-I${ftgl}/include/FTGL -I${freetype}/include/freetype2 -fpermissive";
+  NIX_CFLAGS_COMPILE = "-fpermissive";
 
-  configureFlags = [ "--with-tcl=${tcl}/lib" "--with-tk=${tk}/lib" ];
+  configureFlags = [ "--with-tcl=${tcl}/lib" "--with-tk=${tk}/lib" "--with-qt=${qt4}" "--with-ftgl=${ftgl}" "--with-freetype=${freetype}" ];
 
   postInstall = ''
     mv $out/inc $out/include

pkgs/development/libraries/opencv/default.nix

···
 { stdenv, fetchurl, cmake, gtk, libjpeg, libpng, libtiff, jasper, ffmpeg
 , pkgconfig, gstreamer, xineLib, glib }:
 
-let v = "2.4.2"; in
+let v = "2.4.3"; in
 
 stdenv.mkDerivation rec {
   name = "opencv-${v}";
 
   src = fetchurl {
     url = "mirror://sourceforge/opencvlibrary/OpenCV-${v}.tar.bz2";
-    sha256 = "0a1c4ys78k670dsk1fapylpf8hwfyzy944r9jvwivqh33s0j6039";
+    sha256 = "16zmyr383x9ka81mp6h2s9hlfzd383njddf3x1rswkldjy2ykyzq";
   };
 
   buildInputs = [ gtk glib libjpeg libpng libtiff jasper ffmpeg xineLib gstreamer ];

pkgs/development/libraries/spice-protocol/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "spice-protocol-0.10.1";
+  name = "spice-protocol-0.12.2";
 
   src = fetchurl {
     url = "http://www.spice-space.org/download/releases/${name}.tar.bz2";
-    sha256 = "0drmy2ws7qwmvjxfynhssbvh1y954rfik99hnl789g7yg6vcpxp5";
+    sha256 = "0v6msf6gbl8g69qamp97dggz148zpc3ncbfgbq3b472wszjdkclb";
   };
 
   meta = {

pkgs/development/libraries/spice/default.nix

···
 { stdenv, fetchurl, pkgconfig, pixman, celt, alsaLib, openssl
 , libXrandr, libXfixes, libXext, libXrender, libXinerama, libjpeg, zlib
-, spice_protocol }:
+, spice_protocol, python, pyparsing }:
 
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  name = "spice-0.10.1";
+  name = "spice-0.12.0";
 
   src = fetchurl {
     url = "http://www.spice-space.org/download/releases/${name}.tar.bz2";
-    sha256 = "105p5fh6hhhzvz0fh1x52lzi41rpvajf390xbbw3da4417lf5pqk";
+    sha256 = "15mp6nz467h4l5jg3vk51si6r5w7g329jvsy61f2gl3yabwcxmva";
   };
 
   buildInputs = [ pixman celt alsaLib openssl libjpeg zlib
                   libXrandr libXfixes libXrender libXext libXinerama
-                ];
+                  python pyparsing ];
 
   buildNativeInputs = [ pkgconfig spice_protocol ];
 
-  # NIX_CFLAGS_COMPILE = "-fno-stack-protector";
+  NIX_CFLAGS_COMPILE = "-fno-stack-protector";
 
   configureFlags = [
     "--with-sasl=no"
+    "--disable-smartcard"
   ];
 
   postInstall = ''

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

···
    (http://pypi.python.org/pypi/setuptools/), which represents a large
    number of Python packages nowadays.  */
 
-{ python, setuptools, wrapPython, lib }:
+{ python, setuptools, wrapPython, lib, offlineDistutils, setuptoolsSite }:
 
 { name, namePrefix ? "python-"
 
 , buildInputs ? []
+
+, propagatedBuildInputs ? []
 
 , # List of packages that should be added to the PYTHONPATH
   # environment variable in programs built by this function.  Packages
···
 
 , installCommand ?
     ''
-      easy_install --prefix="$out" .
+      easy_install --always-unzip --prefix="$out" .
     ''
     
+, preConfigure ? "true"
+
 , buildPhase ? "true"
 
 , doCheck ? true
···
 
   name = namePrefix + name;
 
+  phases = "unpackPhase patchPhase configurePhase buildPhase installPhase checkPhase fixupPhase distPhase";
+
   buildInputs = [ python wrapPython setuptools ] ++ buildInputs ++ pythonPath;
 
+  # setuptoolsSite is responsible for loading pth files
+  propagatedBuildInputs = propagatedBuildInputs ++ [ setuptoolsSite ];
+
+  buildInputStrings = map toString buildInputs;
+
   pythonPath = [ setuptools] ++ pythonPath;
 
-  # XXX: Should we run `easy_install --always-unzip'?  It doesn't seem
-  # to have a noticeable impact on small scripts.
+  preConfigure = ''
+    PYTHONPATH="${offlineDistutils}/lib/${python.libPrefix}/site-packages:$PYTHONPATH"
+    ${preConfigure}
+  '';
+
   installPhase = ''
     mkdir -p "$out/lib/${python.libPrefix}/site-packages"
 
···
     export PYTHONPATH="$out/lib/${python.libPrefix}/site-packages:$PYTHONPATH"
     ${installCommand}
 
+    # A pth file might have been generated to load the package from
+    # within its own site-packages, rename this package not to
+    # collide with others.
+    eapth="$out/lib/${python.libPrefix}"/site-packages/easy-install.pth
+    if [ -e "$eapth" ]; then
+        # move colliding easy_install.pth to specifically named one
+        mv "$eapth" $(dirname "$eapth")/${name}.pth
+    fi
+
+    # Remove any site.py files generated by easy_install as these
+    # cause collisions. If pth files are to be processed a
+    # corresponding site.py needs to be included in the PYTHONPATH.
+    #
+    # leave them until we have a better solution: see #209
+    #rm -f "$out/lib/${python.libPrefix}"/site-packages/site.py*
+
     ${postInstall}
   '';
 
   postFixup =
     ''
       wrapPythonPrograms
-    
+
       # If a user installs a Python package, she probably also wants its
       # dependencies in the user environment (since Python modules don't
       # have something like an RPATH, so the only way to find the
···
       if test -e $out/nix-support/propagated-build-inputs; then
           ln -s $out/nix-support/propagated-build-inputs $out/nix-support/propagated-user-env-packages
       fi
+
+      createBuildInputsPth build-inputs "$buildInputStrings"
+      for inputsfile in propagated-build-inputs propagated-build-native-inputs; do
+        if test -e $out/nix-support/$inputsfile; then
+            createBuildInputsPth $inputsfile "$(cat $out/nix-support/$inputsfile)"
+        fi
+      done
     '';
 })

pkgs/development/python-modules/generic/wrap.sh

···
         done
     fi
 }
+
+createBuildInputsPth() {
+    local category="$1"
+    local inputs="$2"
+    if [ foo"$inputs" != foo ]; then
+        for x in $inputs; do
+            if test -d "$x"/lib/@libPrefix@/site-packages; then
+                echo $x/lib/@libPrefix@/site-packages \
+                    >> "$out"/lib/@libPrefix@/site-packages/${name}-nix-python-$category.pth
+            fi
+        done
+    fi
+}

pkgs/development/python-modules/offline-distutils/default.nix

···
+# Used during module installation to prevent easy_install and python
+# setup.py install/test from downloading
+
+{ stdenv, python }:
+
+stdenv.mkDerivation {
+  name = "python-offline-distutils-${python.version}";
+
+  buildInputs = [ python ];
+
+  unpackPhase = "true";
+  installPhase = ''
+    dst="$out/lib/${python.libPrefix}"
+    ensureDir $dst/distutils
+    ln -s ${python}/lib/${python.libPrefix}/distutils/* $dst/distutils/
+    cat <<EOF > $dst/distutils/distutils.cfg
+[easy_install]
+allow-hosts = None
+EOF
+  '';
+}

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

···
-{ fetchurl, stdenv, python, libjpeg, zlib, freetype }:
+{ fetchurl, stdenv, python, buildPythonPackage, libjpeg, zlib, freetype }:
 
 let version = "1.1.7"; in
 
-stdenv.mkDerivation {
-  name = "python-imaging-${version}";
+buildPythonPackage {
+  name = "imaging-${version}";
   
   src = fetchurl {
     url = "http://effbot.org/downloads/Imaging-${version}.tar.gz";
···
 
   buildPhase   = "python setup.py build_ext -i";
   checkPhase   = "python selftest.py";
-  installPhase = "python setup.py install --prefix=$out";
+  #installPhase = "python setup.py install --prefix=$out";
 
   meta = {
     homepage = http://www.pythonware.com/products/pil/;

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

···
-{ stdenv, fetchurl, python, gmp }:
+{ stdenv, fetchurl, python, buildPythonPackage, gmp }:
 
-stdenv.mkDerivation rec {
+buildPythonPackage rec {
   name = "pycrypto-2.6";
+  namePrefix = "";
 
   src = fetchurl {
     url = "http://pypi.python.org/packages/source/p/pycrypto/${name}.tar.gz";
···
 
   buildInputs = [ python gmp ];
 
-  buildPhase = "true";
-
-  installPhase =
+  buildPhase =
     ''
       python ./setup.py build_ext --library-dirs=${gmp}/lib
-      python ./setup.py install --prefix=$out
     '';
+
+#  installPhase =
+#    ''
+#      python ./setup.py install --prefix=$out
+#    '';
 
   meta = {
     homepage = "http://www.pycrypto.org/";

pkgs/development/python-modules/recursive-pth-loader/default.nix

···
+{ stdenv, python }:
+
+stdenv.mkDerivation rec {
+  name = "resursive-pth-loader-1.0";
+
+  unpackPhase = "true";
+
+  buildInputs = [ python ];
+
+  installPhase =
+    ''
+      dst=$out/lib/${python.libPrefix}/site-packages
+      mkdir -p $dst
+      cat ${./sitecustomize.py} >> $dst/sitecustomize.py
+    '';
+
+  meta = {
+      description = "Enable recursive processing of pth files anywhere in sys.path";
+  };
+}

pkgs/development/python-modules/recursive-pth-loader/sitecustomize.py

···
+"""Recursively load pth files in site-packages of sys.path
+
+- iterate over sys.path
+- check for pth in dirs that end in site-packages
+- ignore import statements in pth files
+- add dirs listed in pth files right after current sys.path element,
+  they will be processed in next iteration
+"""
+
+import os
+import site
+import sys
+
+
+for path_idx, sitedir in enumerate(sys.path):
+    # ignore non-site-packages
+    if not sitedir.endswith('site-packages'):
+        continue
+
+    # find pth files
+    try:
+        names = os.listdir(sitedir)
+    except os.error:
+        continue
+    dotpth = os.extsep + "pth"
+    pths = [name for name in names if name.endswith(dotpth)]
+
+    for pth in pths:
+        fullname = os.path.join(sitedir, pth)
+        try:
+            f = open(fullname, "rU")
+        except IOError:
+            continue
+
+        with f:
+            for n, line in enumerate(f):
+                if line.startswith("#"):
+                    continue
+
+                if line.startswith(("import ", "import\t")):
+                    continue
+
+                line = line.rstrip()
+                dir, dircase = site.makepath(sitedir, line)
+                if not dircase in sys.path:
+                    sys.path.insert(path_idx+1, dir)

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

···
 { stdenv, fetchurl, python, wrapPython }:
 
 stdenv.mkDerivation rec {
-  name = "setuptools-0.6c11";
+  name = "setuptools-" + version;
+
+  version = "0.6c11";
 
   src = fetchurl {
     url = "http://pypi.python.org/packages/source/s/setuptools/${name}.tar.gz";

pkgs/development/python-modules/setuptools/site.nix

···
+# Propagated by buildPythonPackge to process pth files
+
+{ stdenv, python, setuptools }:
+
+stdenv.mkDerivation {
+  name = "python-setuptools-site-${setuptools.version}";
+
+  buildInputs = [ python setuptools ];
+
+  unpackPhase = "true";
+  installPhase = ''
+    dst="$out/lib/${python.libPrefix}/site-packages"
+    ensureDir $dst
+    ln -s ${setuptools}/lib/${python.libPrefix}/site-packages/site.* $dst/
+  '';
+}

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

···
 
 cabal.mkDerivation (self: {
   pname = "hlint";
-  version = "1.8.37";
-  sha256 = "00d971r6775rf8lb0psz0n1zxjzgf7114zf1hj7ll2ylxxdn5wwl";
+  version = "1.8.39";
+  sha256 = "009qf441nri8pxzz22xvpz44dhspr9bkh5diaz29abimj10fm375";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/tools/haskell/uuagc/cabal.nix

···
 
 cabal.mkDerivation (self: {
   pname = "uuagc-cabal";
-  version = "1.0.3.0";
-  sha256 = "0kr0k8pgz52n4g7x998djwncfr9byyxg5slqq80qijh06v01bm79";
+  version = "1.0.4.0";
+  sha256 = "0m6q8lfbrzcdxd923s175x0z1rnniv7gk08ninzpq16fisscr4lf";
   buildDepends = [ Cabal filepath mtl uulib ];
   meta = {
     homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";

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

···
 
 cabal.mkDerivation (self: {
   pname = "uuagc";
-  version = "0.9.42.1";
-  sha256 = "1xyzvv9rqzqdc7kd2rncafnglfg699sn3f4987kbsxzhilvmhw78";
+  version = "0.9.42.2";
+  sha256 = "1l7w3gimcx079giw5ri4qfr1xfi1wfj93v29r8hvs8q8a6ffjifn";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ filepath haskellSrcExts mtl uuagcCabal uulib ];

pkgs/development/tools/misc/intltool/default.upstream

···
+attribute_name intltool_standalone
 url https://launchpad.net/intltool/+download

pkgs/games/LambdaHack/default.nix

···
-{ cabal, binary, ConfigFile, filepath, gtk, mtl, random, zlib }:
+{ cabal, binary, ConfigFile, filepath, gtk, miniutter, mtl, random
+, text, zlib
+}:
 
 cabal.mkDerivation (self: {
   pname = "LambdaHack";
-  version = "0.2.6";
-  sha256 = "03adjwzbql1k1ky05vivry7waa8p41ha3lsnv9j9mdgpwqldypwd";
+  version = "0.2.6.5";
+  sha256 = "114s3adqs5mh566dbn0bb20v088wgg8arsm6m8hs9vx8j3jc8nx5";
   isLibrary = true;
   isExecutable = true;
-  buildDepends = [ binary ConfigFile filepath gtk mtl random zlib ];
+  buildDepends = [
+    binary ConfigFile filepath gtk miniutter mtl random text zlib
+  ];
   meta = {
     homepage = "http://github.com/kosmikus/LambdaHack";
     description = "A roguelike game engine in early and active development";

pkgs/games/gnuchess/default.nix

···
-{builderDefsPackage, flex} @ x:
-builderDefsPackage 
-(a :  
-let 
-  fetchurl = a.fetchurl;
-
-  version = a.lib.attrByPath ["version"] "5.07" a; 
-  buildInputs = with a; [
+{stdenv, fetchurl, flex}:
+let
+  s = # Generated upstream information
+  rec {
+    baseName="gnuchess";
+    version="6.0.2";
+    name="${baseName}-${version}";
+    hash="1xd3g28glz2xyjnca0zfw3k0jl5vhgd7wvy4n9km5wnn9z7287l2";
+    url="http://ftp.gnu.org/gnu/chess/gnuchess-6.0.2.tar.gz";
+    sha256="1xd3g28glz2xyjnca0zfw3k0jl5vhgd7wvy4n9km5wnn9z7287l2";
+  };
+  buildInputs = [
     flex
   ];
 in
-rec {
+stdenv.mkDerivation rec {
+  inherit (s) name version;
   src = fetchurl {
-    url = "mirror://gnu/chess/gnuchess-${version}.tar.gz";
-    sha256 = "0zh15m35fzbsrk1aann9pwlkv54dwb00snx99pk3xbg5bwkf125k";
+    inherit (s) url sha256;
   };
-
   inherit buildInputs;
-  configureFlags = [];
-
-  /* doConfigure should be removed if not needed */
-  phaseNames = ["doConfigure" "preBuild" "doMakeInstall"];
-
-  preBuild = a.fullDepEntry (''
-    sed -i src/input.c -e 's/static pthread_t/pthread_t/'
-    sed -i "s@gnuchess@$out/bin/gnuchess@" -i src/gnuchessx
-
-
-    sed -e s/getline/gnuchess_local_getline/g -i $(grep getline -rl .)
-  '') ["minInit" "doUnpack"];
-      
-  name = "gnuchess-" + version;
   meta = {
-    description = "GNU Chess playing program";
+    inherit (s) version;
+    description = "GNU Chess engine";
+    maintainers = [stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.linux;
+    license = stdenv.lib.licenses.gpl3Plus;
   };
-}) x
+}

pkgs/games/gnuchess/default.upstream

···
+url http://ftp.gnu.org/gnu/chess/

pkgs/games/lincity/ng.upstream

···
 target ng.nix
+attribute_name lincity_ng
 url https://fedorahosted.org/LinCity-NG/wiki/Downloads
 version_link tar.bz2
 version_link tar.bz2

pkgs/games/scid/default.nix

···
+{ stdenv, fetchurl, tcl, tk, libX11, zlib, makeWrapper }:
+
+stdenv.mkDerivation rec {
+  name = "scid-${version}";
+  version = "4.3";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/scid/scid-4.3.tar.bz2";
+    sha256 = "0zb5qp04x8w4gn2kvfdfq2p44kmzfcqn7v167dixz6nlyxg41hrw";
+  };
+
+  buildInputs = [ tcl tk libX11 zlib makeWrapper ];
+
+  prePatch = ''
+    sed -i -e '/^ *set headerPath *{/a ${tcl}/include ${tk}/include' \
+           -e '/^ *set libraryPath *{/a ${tcl}/lib ${tk}/lib' \
+           -e '/^ *set x11Path *{/a ${libX11}/lib/' \
+           configure
+
+    sed -i -e '/^ *set scidShareDir/s|\[file.*|"'"$out/share"'"|' \
+      tcl/config.tcl
+  '';
+
+  configureFlags = [
+    "BINDIR=$(out)/bin"
+    "SHAREDIR=$(out)/share"
+  ];
+
+  dontPatchShebangs = true;
+
+  postFixup = ''
+    for cmd in sc_addmove sc_eco sc_epgn scidpgn \
+               sc_import sc_spell sc_tree spliteco
+    do
+      sed -i -e '1c#!'"$out"'/bin/tcscid' "$out/bin/$cmd"
+    done
+
+    sed -i -e '1c#!${tcl}/bin/tcslsh' "$out/bin/spf2spi"
+    sed -i -e '1c#!${tk}/bin/wish' "$out/bin/sc_remote"
+    sed -i -e '1c#!'"$out"'/bin/tkscid' "$out/bin/scid"
+
+    for cmd in $out/bin/*
+    do
+      wrapProgram "$cmd" \
+        --set TCLLIBPATH "${tcl}/${tcl.libdir}" \
+        --set TK_LIBRARY "${tk}/lib/${tk.libPrefix}"
+    done
+  '';
+
+  meta = {
+    description = "Chess database with play and training functionality";
+    homepage = "http://scid.sourceforge.net/";
+    license = stdenv.lib.licenses.gpl2;
+  };
+}

pkgs/games/xboard/default.nix

···
-a:  
-let 
-  fetchurl = a.fetchurl;
-
-  buildInputs = with a; [
+{stdenv, fetchurl, libX11, xproto, libXt, libXaw, libSM, libICE, libXmu
+, libXext, gnuchess, texinfo, libXpm
+}:
+let
+  s = # Generated upstream information
+  rec {
+    baseName="xboard";
+    version="4.6.2";
+    name="${baseName}-${version}";
+    hash="1pw90fh1crf0nkqyql54z728vn2093hwdh2v5i5703z9qv9g4mrf";
+    url="http://ftp.gnu.org/gnu/xboard/xboard-4.6.2.tar.gz";
+    sha256="1pw90fh1crf0nkqyql54z728vn2093hwdh2v5i5703z9qv9g4mrf";
+  };
+  buildInputs = [
     libX11 xproto libXt libXaw libSM libICE libXmu 
     libXext gnuchess texinfo libXpm
   ];
-
-  s = import ./src-for-default.nix;
 in
-rec {
+stdenv.mkDerivation {
+  inherit (s) name version;
+  inherit buildInputs;
   src = fetchurl {
-    inherit(s) url;
-    sha256 = s.hash;
+    inherit (s) url sha256;
   };
-
-  inherit buildInputs;
-  configureFlags = [];
-
-  /* doConfigure should be removed if not needed */
-  phaseNames = ["doConfigure" "preBuild" "doMakeInstall"];
-
-  preBuild = a.fullDepEntry(''
-    sed -e '/FIRST_CHESS_PROGRAM/s@gnuchessx@${a.gnuchess}/bin/gnuchessx@' -i xboard.h
-    sed -e '/SECOND_CHESS_PROGRAM/s@gnuchessx@${a.gnuchess}/bin/gnuchessx@' -i xboard.h
-  '') ["doUnpack" "minInit"];
-      
-  inherit(s) name;
   meta = {
-    description = "XBoard - a chess board compatible with GNU Chess";
+    inherit (s) version;
+    description = ''GUI for chess engines'';
+    maintainers = [stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.linux;
+    license = stdenv.lib.licenses.gpl3Plus;
   };
 }

pkgs/games/xboard/default.upstream

···
+url http://ftp.gnu.org/gnu/xboard/

pkgs/games/xboard/src-for-default.nix

···
-rec {
-   version="4.4.2";
-   name="xboard-4.4.2";
-   hash="1ihg39nnwp90w410rzwxj9layadavz08gc9m2b1jg5z5c6ky28zp";
-   url="http://ftp.gnu.org/gnu/xboard/xboard-${version}.tar.gz";
-   advertisedUrl="http://ftp.gnu.org/gnu/xboard/xboard-4.4.2.tar.gz";
-  
-  
-}

pkgs/games/xboard/src-info-for-default.nix

···
-{
-  downloadPage = "http://ftp.gnu.org/gnu/xboard/?C=T,M;O=D";
-  baseName = "xboard";
-}

pkgs/lib/platforms.nix

···
   all = linux ++ darwin ++ cygwin ++ freebsd ++ openbsd;
   none = [];
   allBut = platform: lists.filter (x: platform != x) all;
-  mesaPlatforms = linux;
+  mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin"];
 }

pkgs/misc/cups/drivers/samsung/builder.sh

···
+source $stdenv/setup
+
+arch=$(uname -m)
+# replace i[3456]86 with i386
+echo arch | egrep -q '^i[3456]86$' && arch=i386
+arch=i386
+unpackPhase
+patchPhase
+
+set -v
+
+echo $arch
+cd cdroot/Linux
+mkdir -p $out/opt
+cp -r $arch/at_root/* $out
+cp -r $arch/at_opt/* $out/opt
+#cp -r noarch/at_root/* $out
+cp -r noarch/at_opt/* $out/opt
+
+cd $out
+#test -d usr/lib64 && ln -s usr/lib64 lib || 
+ln -s usr/lib lib
+mkdir -p share/cups
+cd share/cups
+ln -s ../../opt/share/* .
+ln -s ppd model
+
+cd $out/lib/cups/filter
+for i in $(ls); do
+    echo patching $i...
+    patchelf --set-interpreter $(cat $NIX_GCC/nix-support/dynamic-linker) $i || echo "(couldn't set interpreter)"
+    patchelf --set-rpath $cups/lib:$gcc/lib:$glibc/lib $i  # This might not be necessary.
+done
+
+ln -s $ghostscript/bin/gs $out/lib/cups/filter

pkgs/misc/cups/drivers/samsung/default.nix

···
+# Tested on linux-x86_64.  Might work on linux-i386.  Probably won't work on anything else.
+
+# To use this driver in NixOS, add it to printing.drivers in configuration.nix.
+# configuration.nix might look like this when you're done:
+# { pkgs, ... }: {
+#   printing = {
+#     enable = true;
+#     drivers = [ pkgs.samsungUnifiedLinuxDriver ];
+#   };
+#   (more stuff)
+# }
+# (This advice was tested on 2010 August 2.)
+
+{stdenv, fetchurl, cups, gcc, ghostscript, glibc, patchelf}:
+
+stdenv.mkDerivation rec {
+  name = "samsung-UnifiedLinuxDriver-0.92";
+
+  src = fetchurl {
+    url = "http://downloadcenter.samsung.com/content/DR/200911/20091103171827750/UnifiedLinuxDriver_0.92.tar.gz";
+    sha256 = "0p2am0p8xvm339mad07c4j77gz31m63z76sy6d9hgwmxy2prbqfq";
+  };
+
+  buildInputs = [ cups gcc ghostscript glibc patchelf ];
+
+  inherit cups gcc ghostscript glibc;
+
+  builder = ./builder.sh;
+
+  meta = {
+    description = "Samsung's Linux drivers; includes binaries without source code";
+    homepage = "http://www.samsung.com/";
+    license = "samsung";  # Binary-only
+  };
+}

pkgs/misc/emulators/dlx/default.nix

···
 
   buildInputs = [ unzip ];
 
+  makeFlags = "LINK=gcc CFLAGS=-O2";
+
   installPhase = ''
     mkdir -p $out/include/dlx $out/share/dlx/{examples,doc} $out/bin
     mv -v masm mon dasm $out/bin/
     mv -v *.i auto.a $out/include/dlx/
-    mv -v *.a hp.m $out/share/dlx/examples/
+    mv -v *.a *.m $out/share/dlx/examples/
     mv -v README.txt MANUAL.TXT $out/share/dlx/doc/
   '';
 

pkgs/misc/emulators/wine/default.nix

···
 
   src = fetchurl {
     url = "mirror://sourceforge/wine/${name}.tar.bz2";
-    sha256 = "05ac8qlpbiacn3gmwlafpppyl7r2grsym20gz163szsbmfzlqnxi";
+    sha256 = "08qhjqia2g6pm5rnawcvfz64pm2pmjaxafmwdyn950rdwrd7kbai";
   };
 
   gecko = fetchurl {
···
   enableParallelBuilding = true;
 
   meta = {
-    version = "1.5.17";
+    version = "1.5.19";
     homepage = "http://www.winehq.org/";
     license = "LGPL";
     description = "An Open Source implementation of the Windows API on top of X, OpenGL, and Unix";

pkgs/misc/emulators/wine/default.upstream

···
+url http://sourceforge.net/projects/wine/files/Source/
+version_link '[.]tar[.][^./]+/download$'
+SF_redirect
+do_overwrite () {
+  ensure_hash
+  set_var_value version "$CURRENT_VERSION"
+  set_var_value sha256 "$CURRENT_HASH"
+}

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

···
     homepage = http://www.kernel.org/;
     maintainers = [
       lib.maintainers.eelco
+      lib.maintainers.shlevy
       lib.maintainers.chaoflow
     ];
     platforms = lib.platforms.linux;

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

···
 import ./generic.nix (
 
   rec {
-    version = "3.0.54";
+    version = "3.0.56";
 
     preConfigure = ''
       substituteInPlace scripts/depmod.sh --replace '-b "$INSTALL_MOD_PATH"' ""
···
 
     src = fetchurl {
       url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-      sha256 = "0jqdqp5rx05ph2wkj431rdcm9s8jpbzlbl53pbb6vp7yr3nichvg";
+      sha256 = "0dfj8nlrlwyq9jp85y8acmhpm7f5bdd9668ikafyd7rljqmkq61f";
     };
 
     config = configWithPlatform stdenv.platform;

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

···
 import ./generic.nix (
 
   rec {
-    version = "3.2.34";
+    version = "3.2.35";
     testing = false;
 
     modDirVersion = version;
···
 
     src = fetchurl {
       url = "mirror://kernel/linux/kernel/v3.0/${if testing then "testing/" else ""}linux-${version}.tar.xz";
-      sha256 = "0j99pg1kdrj200wda7w2v4d272y4x0hyrp3w540a6rj00gkxsmn4";
+      sha256 = "0p665msvhmjmcvgravi10yyfbnvn6bm9xfhsflj61qj0frj0lzn9";
     };
 
     config = configWithPlatform stdenv.platform;

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

···
 import ./generic.nix (
 
   rec {
-    version = "3.4.21";
+    version = "3.4.23";
     testing = false;
 
     preConfigure = ''
···
 
     src = fetchurl {
       url = "mirror://kernel/linux/kernel/v3.x/${if testing then "testing/" else ""}linux-${version}.tar.xz";
-      sha256 = "0g5w2whs1bhkga8niizsx0x7hskk2inb04mx8qzbacaya107sg9x";
+      sha256 = "1xznslbhby6ks10sb7h6zh5647ffavpmfsxxb1c5hj4cyj4d9k2z";
     };
 
     config = configWithPlatform stdenv.platform;

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

···
 import ./generic.nix (
 
   rec {
-    version = "3.6.9";
+    version = "3.6.10";
     testing = false;
 
     preConfigure = ''
···
 
     src = fetchurl {
       url = "mirror://kernel/linux/kernel/v3.x/${if testing then "testing/" else ""}linux-${version}.tar.xz";
-      sha256 = "0d4z6rycn2qdfpv2i52li0z5c6pd8d8v46sw2k0liw0apw4zfvzl";
+      sha256 = "0cqslk460yvgh3iv1m9lkdlnfy9v9ghcn4kjpf8019dsfia7pr7x";
     };
 
     config = configWithPlatform stdenv.platform;

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

···
+args @ { stdenv, fetchurl, extraConfig ? ""
+, perl, mktemp, module_init_tools
+, ... }:
+
+let
+  configWithPlatform = kernelPlatform :
+    ''
+      # Power management and debugging for powertop.
+      DEBUG_KERNEL y
+      PM_ADVANCED_DEBUG y
+      PM_RUNTIME y
+      TIMER_STATS y
+      USB_SUSPEND y
+      BACKTRACE_SELF_TEST n
+      CPU_NOTIFIER_ERROR_INJECT? n
+      DEBUG_DEVRES n
+      DEBUG_NX_TEST n
+      DEBUG_STACK_USAGE n
+      DEBUG_STACKOVERFLOW n
+      RCU_TORTURE_TEST n
+      SCHEDSTATS n
+
+      # Support drivers that need external firmware.
+      STANDALONE n
+
+      # Make /proc/config.gz available.
+      IKCONFIG_PROC y
+
+      # Optimize with -O2, not -Os.
+      CC_OPTIMIZE_FOR_SIZE n
+
+      # Enable the kernel's built-in memory tester.
+      MEMTEST y
+
+      # Include the CFQ I/O scheduler in the kernel, rather than as a
+      # module, so that the initrd gets a good I/O scheduler.
+      IOSCHED_CFQ y
+      BLK_CGROUP y # required by CFQ
+
+      # Enable NUMA.
+      NUMA? y
+
+      # Disable some expensive (?) features.
+      FTRACE n
+      KPROBES n
+      PM_TRACE_RTC n
+
+      # Enable various subsystems.
+      ACCESSIBILITY y # Accessibility support
+      AUXDISPLAY y # Auxiliary Display support
+      DONGLE y # Serial dongle support
+      HIPPI? y
+      MTD_COMPLEX_MAPPINGS y # needed for many devices
+      SCSI_LOWLEVEL y # enable lots of SCSI devices
+      SCSI_LOWLEVEL_PCMCIA y
+      SPI y # needed for many devices
+      SPI_MASTER y
+      WAN y
+
+      # Networking options.
+      IP_PNP n
+      IPV6_PRIVACY y
+      NETFILTER_ADVANCED y
+      IP_VS_PROTO_TCP y
+      IP_VS_PROTO_UDP y
+      IP_VS_PROTO_ESP y
+      IP_VS_PROTO_AH y
+      IP_DCCP_CCID3 n # experimental
+      CLS_U32_PERF y
+      CLS_U32_MARK y
+
+      # Wireless networking.
+      IPW2100_MONITOR y # support promiscuous mode
+      IPW2200_MONITOR? y # support promiscuous mode
+      HOSTAP_FIRMWARE y # Support downloading firmware images with Host AP driver
+      HOSTAP_FIRMWARE_NVRAM y
+      ATH9K_PCI y # Detect Atheros AR9xxx cards on PCI(e) bus
+      ATH9K_AHB y # Ditto, AHB bus
+      B43_PHY_HT y
+      BCMA_HOST_PCI y
+
+      # Some settings to make sure that fbcondecor works - in particular,
+      # disable tileblitting and the drivers that need it.
+
+      # Enable various FB devices.
+      FB y
+      FB_EFI y
+      FB_NVIDIA_I2C y # Enable DDC Support
+      FB_RIVA_I2C y
+      FB_ATY_CT y # Mach64 CT/VT/GT/LT (incl. 3D RAGE) support
+      FB_ATY_GX y # Mach64 GX support
+      FB_SAVAGE_I2C y
+      FB_SAVAGE_ACCEL y
+      FB_SIS_300 y
+      FB_SIS_315 y
+      FB_3DFX_ACCEL y
+      FB_GEODE y
+
+      # Video configuration
+      # Enable KMS for devices whose X.org driver supports it.
+      DRM_I915_KMS y
+      DRM_RADEON_KMS y
+      # Hybrid graphics support
+      VGA_SWITCHEROO y
+
+      # Sound.
+      SND_AC97_POWER_SAVE y # AC97 Power-Saving Mode
+      SND_HDA_INPUT_BEEP y # Support digital beep via input layer
+      SND_USB_CAIAQ_INPUT y
+      PSS_MIXER y # Enable PSS mixer (Beethoven ADSP-16 and other compatible)
+
+      # USB serial devices.
+      USB_SERIAL_GENERIC y # USB Generic Serial Driver
+      USB_SERIAL_KEYSPAN_MPR y # include firmware for various USB serial devices
+      USB_SERIAL_KEYSPAN_USA28 y
+      USB_SERIAL_KEYSPAN_USA28X y
+      USB_SERIAL_KEYSPAN_USA28XA y
+      USB_SERIAL_KEYSPAN_USA28XB y
+      USB_SERIAL_KEYSPAN_USA19 y
+      USB_SERIAL_KEYSPAN_USA18X y
+      USB_SERIAL_KEYSPAN_USA19W y
+      USB_SERIAL_KEYSPAN_USA19QW y
+      USB_SERIAL_KEYSPAN_USA19QI y
+      USB_SERIAL_KEYSPAN_USA49W y
+      USB_SERIAL_KEYSPAN_USA49WLC y
+
+      # Filesystem options - in particular, enable extended attributes and
+      # ACLs for all filesystems that support them.
+      EXT2_FS_XATTR y # Ext2 extended attributes
+      EXT2_FS_POSIX_ACL y # Ext2 POSIX Access Control Lists
+      EXT2_FS_SECURITY y # Ext2 Security Labels
+      EXT2_FS_XIP y # Ext2 execute in place support
+      EXT4_FS_POSIX_ACL y
+      EXT4_FS_SECURITY y
+      REISERFS_FS_XATTR y
+      REISERFS_FS_POSIX_ACL y
+      REISERFS_FS_SECURITY y
+      JFS_POSIX_ACL y
+      JFS_SECURITY y
+      XFS_QUOTA y
+      XFS_POSIX_ACL y
+      XFS_RT y # XFS Realtime subvolume support
+      OCFS2_DEBUG_MASKLOG n
+      BTRFS_FS_POSIX_ACL y
+      UBIFS_FS_XATTR? y
+      UBIFS_FS_ADVANCED_COMPR y
+      NFSD_V2_ACL y
+      NFSD_V3 y
+      NFSD_V3_ACL y
+      NFSD_V4 y
+      CIFS_XATTR y
+      CIFS_POSIX y
+
+      # Security related features.
+      STRICT_DEVMEM y # Filter access to /dev/mem
+      SECURITY_SELINUX_BOOTPARAM_VALUE 0 # disable SELinux by default
+
+      # Misc. options.
+      8139TOO_8129 y
+      8139TOO_PIO n # PIO is slower
+      AIC79XX_DEBUG_ENABLE n
+      AIC7XXX_DEBUG_ENABLE n
+      AIC94XX_DEBUG n
+      B43_PCMCIA y
+      BLK_DEV_CMD640_ENHANCED y # CMD640 enhanced support
+      BLK_DEV_IDEACPI y # IDE ACPI support
+      BLK_DEV_INTEGRITY y
+      BSD_PROCESS_ACCT_V3 y
+      BT_HCIUART_BCSP y
+      BT_HCIUART_H4 y # UART (H4) protocol support
+      BT_HCIUART_LL y
+      BT_RFCOMM m
+      BT_RFCOMM_TTY y # RFCOMM TTY support
+      CRASH_DUMP n
+      DMAR? n # experimental
+      DVB_DYNAMIC_MINORS? y # we use udev
+      EFI_STUB y # EFI bootloader in the bzImage itself
+      FUSION y # Fusion MPT device support
+      IDE_GD_ATAPI y # ATAPI floppy support
+      IRDA_ULTRA y # Ultra (connectionless) protocol
+      JOYSTICK_IFORCE_232 y # I-Force Serial joysticks and wheels
+      JOYSTICK_IFORCE_USB y # I-Force USB joysticks and wheels
+      JOYSTICK_XPAD_FF y # X-Box gamepad rumble support
+      JOYSTICK_XPAD_LEDS y # LED Support for Xbox360 controller 'BigX' LED
+      LDM_PARTITION y # Windows Logical Disk Manager (Dynamic Disk) support
+      LEDS_TRIGGER_IDE_DISK y # LED IDE Disk Trigger
+      LOGIRUMBLEPAD2_FF y # Logitech Rumblepad 2 force feedback
+      LOGO n # not needed
+      MEDIA_ATTACH? y
+      MEGARAID_NEWGEN y
+      MICROCODE_AMD y
+      MODVERSIONS y
+      MOUSE_PS2_ELANTECH y # Elantech PS/2 protocol extension
+      MTRR_SANITIZER y
+      NET_FC y # Fibre Channel driver support
+      PPP_MULTILINK y # PPP multilink support
+      REGULATOR y # Voltage and Current Regulator Support
+      SCSI_LOGGING y # SCSI logging facility
+      SERIAL_8250 y # 8250/16550 and compatible serial support
+      SLIP_COMPRESSED y # CSLIP compressed headers
+      SLIP_SMART y
+      THERMAL_HWMON y # Hardware monitoring support
+      USB_DEBUG n
+      USB_EHCI_ROOT_HUB_TT y # Root Hub Transaction Translators
+      USB_EHCI_TT_NEWSCHED y # Improved transaction translator scheduling
+      X86_CHECK_BIOS_CORRUPTION y
+      X86_MCE y
+      XEN_DOM0 y
+
+      # Linux Containers
+      RT_GROUP_SCHED? y
+      CGROUP_DEVICE? y
+      CGROUP_MEM_RES_CTLR? y
+      CGROUP_MEM_RES_CTLR_SWAP? y
+      DEVPTS_MULTIPLE_INSTANCES? y
+
+      # Enable staging drivers.  These are somewhat experimental, but
+      # they generally don't hurt.
+      STAGING y
+
+      # PROC_EVENTS requires that the netlink connector is not built
+      # as a module.  This is required by libcgroup's cgrulesengd.
+      CONNECTOR y
+      PROC_EVENTS y
+
+      # Tracing
+      FTRACE y
+      FUNCTION_TRACER y
+      FTRACE_SYSCALLS y
+      SCHED_TRACER y
+
+      # Devtmpfs support.
+      DEVTMPFS y
+
+      # Media support
+      MEDIA_CAMERA_SUPPORT? y
+      MEDIA_RC_SUPPORT? y
+
+      ${if kernelPlatform ? kernelExtraConfig then kernelPlatform.kernelExtraConfig else ""}
+      ${extraConfig}
+    '';
+in
+
+import ./generic.nix (
+
+  rec {
+    version = "3.7";
+    testing = false;
+
+    modDirVersion = "3.7.0";
+
+    preConfigure = ''
+      substituteInPlace scripts/depmod.sh --replace '-b "$INSTALL_MOD_PATH"' ""
+    '';
+
+    src = fetchurl {
+      url = "mirror://kernel/linux/kernel/v3.x/${if testing then "testing/" else ""}linux-${version}.tar.xz";
+      sha256 = "0n4lddghf0mvp3jrq4lckii88yvm6mwmfp0ibwsw7vkfyw5lv9k0";
+    };
+
+    config = configWithPlatform stdenv.platform;
+    configCross = configWithPlatform stdenv.cross.platform;
+
+    features.iwlwifi = true;
+    features.efiBootStub = true;
+    features.needsCifsUtils = true;
+    features.canDisableNetfilterConntrackHelpers = true;
+    features.netfilterRPFilter = true;
+  }
+
+  // removeAttrs args ["extraConfig"]
+)

pkgs/os-specific/linux/nvidia-x11/legacy304.nix

···
+{ stdenv, fetchurl, kernel ? null, xlibs, zlib, perl
+, gtk, atk, pango, glib, gdk_pixbuf
+, # Whether to build the libraries only (i.e. not the kernel module or
+  # nvidia-settings).  Used to support 32-bit binaries on 64-bit
+  # Linux.
+  libsOnly ? false
+}:
+
+with stdenv.lib;
+
+let versionNumber = "304.64"; in
+
+stdenv.mkDerivation {
+  name = "nvidia-x11-${versionNumber}${optionalString (!libsOnly) "-${kernel.version}"}";
+
+  builder = ./builder.sh;
+
+  src =
+    if stdenv.system == "i686-linux" then
+      fetchurl {
+        url = "http://us.download.nvidia.com/XFree86/Linux-x86/${versionNumber}/NVIDIA-Linux-x86-${versionNumber}.run";
+        sha256 = "0li27nlhx9bbln9424xpxw46sarjdch2fxpn4kvh0npaywll2ii3";
+      }
+    else if stdenv.system == "x86_64-linux" then
+      fetchurl {
+        url = "http://us.download.nvidia.com/XFree86/Linux-x86_64/${versionNumber}/NVIDIA-Linux-x86_64-${versionNumber}-no-compat32.run";
+        sha256 = "1x33f6b9zcsnpjcxlv38l1w0blimsv1y3bbrrzg48wwwb5wvynxl";
+      }
+    else throw "nvidia-x11 does not support platform ${stdenv.system}";
+
+  inherit versionNumber libsOnly;
+
+  kernel = if libsOnly then null else kernel;
+
+  dontStrip = true;
+
+  glPath = stdenv.lib.makeLibraryPath [xlibs.libXext xlibs.libX11 xlibs.libXrandr];
+
+  cudaPath = stdenv.lib.makeLibraryPath [zlib stdenv.gcc.gcc];
+
+  programPath = optionalString (!libsOnly) (stdenv.lib.makeLibraryPath
+    [ gtk atk pango glib gdk_pixbuf xlibs.libXv ] );
+
+  buildInputs = [ perl ];
+
+  meta = {
+    homepage = http://www.nvidia.com/object/unix.html;
+    description = "X.org driver and kernel module for NVIDIA graphics cards";
+    license = "unfree";
+  };
+}

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

···
   preConfigure = ''
     ./autogen.sh
 
-    substituteInPlace ./module/zfs/zfs_ctldir.c  --replace "umount -t zfs"   "${utillinux}/bin/umount -t zfs"
-    substituteInPlace ./module/zfs/zfs_ctldir.c  --replace "mount -t zfs"    "${utillinux}/bin/mount -t zfs"
-    substituteInPlace ./lib/libzfs/libzfs_mount.c  --replace "/bin/umount"   "${utillinux}/bin/umount"
-    substituteInPlace ./lib/libzfs/libzfs_mount.c  --replace "/bin/mount"    "${utillinux}/bin/mount"
-    substituteInPlace ./udev/rules.d/*           --replace "/lib/udev/vdev_id" "$out/lib/udev/vdev_id"
+    substituteInPlace ./module/zfs/zfs_ctldir.c    --replace "umount -t zfs"     "${utillinux}/bin/umount -t zfs"
+    substituteInPlace ./module/zfs/zfs_ctldir.c    --replace "mount -t zfs"      "${utillinux}/bin/mount -t zfs"
+    substituteInPlace ./lib/libzfs/libzfs_mount.c  --replace "/bin/umount"       "${utillinux}/bin/umount"
+    substituteInPlace ./lib/libzfs/libzfs_mount.c  --replace "/bin/mount"        "${utillinux}/bin/mount"
+    substituteInPlace ./udev/rules.d/*             --replace "/lib/udev/vdev_id" "$out/lib/udev/vdev_id"
+    substituteInPlace ./cmd/ztest/ztest.c          --replace "/usr/sbin/ztest"   "$out/sbin/ztest"
+    substituteInPlace ./cmd/ztest/ztest.c          --replace "/usr/sbin/zdb"     "$out/sbin/zdb"
   '';
 
   configureFlags = ''

pkgs/servers/nosql/redis/default.nix

···
 
   makeFlags = "PREFIX=$(out)";
 
+  # commented out until the patch is found
+  # patches = if stdenv.isDarwin then [ ./darwin.patch ] else [];
   meta = {
     homepage = http://redis.io;
     description = "An open source, advanced key-value store";

pkgs/servers/sql/mysql55/default.nix

···
     sha256 = "13y7bhjmx4daidvyqjz88yffbswb6rc1khkmiqm896fx3lglkcpr";
   };
 
-  buildInputs = [ cmake bison ncurses openssl readline zlib ];
+  buildInputs = [ cmake bison ncurses openssl readline zlib ]
+     ++ stdenv.lib.optional stdenv.isDarwin perl;
+
 
   enableParallelBuilding = true;
 
···
   
   NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isLinux "-lgcc_s";
 
+  prePatch = ''
+    sed -i -e "s|/usr/bin/libtool|libtool|" cmake/libutils.cmake
+  '';
   postInstall = ''
     sed -i -e "s|basedir=\"\"|basedir=\"$out\"|" $out/bin/mysql_install_db
     rm -rf $out/mysql-test $out/sql-bench

pkgs/servers/sql/postgresql/8.3.x.nix

···
 { stdenv, fetchurl, zlib, ncurses, readline }:
 
-let version = "8.3.21"; in
+let version = "8.3.22"; in
 
 stdenv.mkDerivation rec {
   name = "postgresql-${version}";
 
   src = fetchurl {
     url = "mirror://postgresql/source/v${version}/${name}.tar.bz2";
-    sha256 = "1y1lw83jr3v91920xdhd4ypaa5iazmdh4snl5qzq0yq6z3lnsjx6";
+    sha256 = "1iphzr8mpfz050f95vhcji4k22mih3wl65z4559y4hh4kiqg7f0p";
   };
 
   buildInputs = [ zlib ncurses readline ];

pkgs/servers/sql/postgresql/8.4.x.nix

···
 { stdenv, fetchurl, zlib, ncurses, readline }:
 
-let version = "8.4.14"; in
+let version = "8.4.15"; in
 
 stdenv.mkDerivation rec {
   name = "postgresql-${version}";
 
   src = fetchurl {
     url = "mirror://postgresql/source/v${version}/${name}.tar.bz2";
-    sha256 = "0fhk3mmk95p5gwmg2skqv1rfi7ylk8gw195hx8rska7fbdryfwhi";
+    sha256 = "0kdwg598c7ws2bvi5q5qgn2pbvznzpxs63chvp0xj6nzpcdpg0va";
   };
 
   buildInputs = [ zlib ncurses readline ];

pkgs/servers/sql/postgresql/9.0.x.nix

···
 { stdenv, fetchurl, zlib, readline }:
 
-let version = "9.0.10"; in
+let version = "9.0.11"; in
 
 stdenv.mkDerivation rec {
   name = "postgresql-${version}";
 
   src = fetchurl {
     url = "mirror://postgresql/source/v${version}/${name}.tar.bz2";
-    sha256 = "0af7in1fp4qxkvzbipz74gxm06x31a9n4z9g91mcis4r015ii523";
+    sha256 = "0b3vw1a1x658famvgsfi1dladrbkc5j3h1ibaasgx9ffqn6xrp56";
   };
 
   buildInputs = [ zlib readline ];

pkgs/servers/sql/postgresql/9.1.x.nix

···
 { stdenv, fetchurl, zlib, readline }:
 
-let version = "9.1.6"; in
+let version = "9.1.7"; in
 
 stdenv.mkDerivation rec {
   name = "postgresql-${version}";
 
   src = fetchurl {
     url = "mirror://postgresql/source/v${version}/${name}.tar.bz2";
-    sha256 = "1rridkybr55xw4a1h0ppqwv2x2ffwvmpjai9yzsvk58scb56lfbf";
+    sha256 = "10iw6c6v1s7a00s0dr8agvb2fg2dmdvg84mk05206rb0islyl6fz";
   };
 
   buildInputs = [ zlib readline ];

pkgs/servers/x11/xorg/overrides.nix

···
     buildInputs = attrs.buildInputs ++ [xorg.libXrender];
   };
 
+  xinit = attrs: attrs // {
+    configureFlags = "--with-xserver=${xorg.xorgserver}/bin/X";
+    propagatedBuildInputs = [ xorg.xauth ];
+    prePatch = ''
+      sed -i 's|^defaultserverargs="|&-logfile \"$HOME/.xorg.log\"|p' startx.cpp
+    '';
+  };
+
   xwd = attrs: attrs // {
     buildInputs = attrs.buildInputs ++ [xorg.libXt];
   };

pkgs/tools/X11/xcalib/default.nix

···
+{ stdenv, fetchurl, libX11, libXxf86vm, libXext }:
+
+stdenv.mkDerivation rec {
+  name = "xcalib-0.8";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/xcalib/xcalib-source-0.8.tar.gz";
+    sha256 = "8a112ee710e5446f6c36e62345b2066f10639d500259db8c48bf1716caea06e6";
+  };
+
+  buildInputs = [ libX11 libXxf86vm libXext ];
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp xcalib $out/bin/
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = http://xcalib.sourceforge.net/;
+    description = "A tiny monitor calibration loader for X and MS-Windows";
+    license = licenses.gpl2;
+    maintainers = [ maintainers.rickynils ];
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/backup/duplicity/default.nix

···
 { stdenv, fetchurl, python, librsync, gnupg, boto, makeWrapper }:
 
 stdenv.mkDerivation {
-  name = "duplicity-0.6.17";
+  name = "duplicity-0.6.20";
 
   src = fetchurl {
-    url = "http://code.launchpad.net/duplicity/0.6-series/0.6.17/+download/duplicity-0.6.17.tar.gz";
-    sha256 = "0n54fw55v4h0cjspgh9nhss5w18bfrib9fckgkk2fldi3835c7l9";
+    url = "http://code.launchpad.net/duplicity/0.6-series/0.6.20/+download/duplicity-0.6.20.tar.gz";
+    sha256 = "0r0nf7arc3n5ipvvbh7h6ksqzbl236iv5pjpmd5s7lff3xswdl2i";
   };
 
   installPhase = ''

pkgs/tools/filesystems/glusterfs/default.nix

···
-a :  
+{stdenv, fetchurl, fuse, bison, flex, openssl, python, ncurses, readline}:
 let 
-  s = import ./src-for-default.nix;
-  buildInputs = with a; [
-    fuse bison flex
+  s = # Generated upstream information 
+  rec {
+    baseName="glusterfs";
+    version="3.3.1";
+    name="glusterfs-3.3.1";
+    hash="06bmnyl3vh8s21kk98idm2fl7kq38na94k5l67l9l1grl3iyzahr";
+    url="http://download.gluster.org/pub/gluster/glusterfs/3.3/3.3.1/glusterfs-3.3.1.tar.gz";
+    sha256="06bmnyl3vh8s21kk98idm2fl7kq38na94k5l67l9l1grl3iyzahr";
+  };
+  buildInputs = [
+    fuse bison flex openssl python ncurses readline
   ];
 in
+stdenv.mkDerivation
 rec {
-  src = a.fetchUrlFromSrcInfo s;
-
-  inherit (s) name;
+  inherit (s) name version;
   inherit buildInputs;
   configureFlags = [
     ''--with-mountutildir="$out/sbin"''
     ];
+  src = fetchurl {
+    inherit (s) url sha256;
+  };
 
-  /* doConfigure should be removed if not needed */
-  phaseNames = ["doConfigure" "doMakeInstall"];
-      
   meta = {
+    inherit (s) version;
     description = "Distributed storage system";
     maintainers = [
-      a.lib.maintainers.raskin
+      stdenv.lib.maintainers.raskin
     ];
-    platforms = with a.lib.platforms; 
+    platforms = with stdenv.lib.platforms; 
       linux ++ freebsd;
   };
 }

pkgs/tools/filesystems/glusterfs/default.upstream

···
+url http://download.gluster.org/pub/gluster/glusterfs/
+version_link '[0-9.]+/$'
+version_link '[0-9.]+/$'
+version_link '[.]tar[.]'

pkgs/tools/filesystems/glusterfs/src-for-default.nix

···
-rec {
-  advertisedUrl="http://ftp.gluster.com/pub/gluster/glusterfs/2.0/2.0.6/glusterfs-2.0.6.tar.gz";
-  version = "2.0.6";
-  url="http://ftp.gluster.com/pub/gluster/glusterfs/2.0/2.0.6/glusterfs-2.0.6.tar.gz";
-  hash = "0qr8smwncrr63vzbaf2v4fwpdck3jpgywn2rq8sdhifff67ydc9h";
-  name = "glusterfs-2.0.6";
-  
-}

pkgs/tools/filesystems/glusterfs/src-info-for-default.nix

···
-{
-  downloadPage = "http://ftp.gluster.com/pub/gluster/glusterfs/2.0/";
-  sourceRegexp = "^2[.]0[.]";
-  choiceCommand = ''tail -1 | sed -re 's@(.*)/@&glusterfs-\1.tar.gz@' '';
-  baseName = "glusterfs";
-}

pkgs/tools/graphics/asymptote/default.nix

···
   '' ["minInit" "addInputs" "doUnpack"];
 
   meta = {
+    inherit (s) version;
     description = "A tool for programming graphics intended to replace Metapost";
     maintainers = [
       a.lib.maintainers.raskin

pkgs/tools/networking/hping/default.nix

···
+{ stdenv, fetchurl, libpcap, tcl }:
+
+stdenv.mkDerivation rec {
+  name = "hping-${version}";
+  version = "20051105";
+
+  src = fetchurl {
+    url = "http://www.hping.org/hping3-${version}.tar.gz";
+    sha256 = "1s5f9xd1msx05ibhwaw37jmc7l9fahcxxslqz8a83p0i5ak739pm";
+  };
+
+  buildInputs = [ libpcap tcl ];
+
+  configurePhase = ''
+    MANPATH="$out/share/man" ./configure
+    sed -i -r -e 's|/usr(/s?bin)|'"$out"'\1|g' Makefile
+  '';
+
+  TCLSH = "${tcl}/bin/tclsh";
+
+  prePatch = ''
+    sed -i -e '/#if.*defined(__i386__)/a \
+      || defined(__x86_64__) \\
+    ' bytesex.h
+
+    sed -i -e 's|#include.*net/bpf.h|#include <pcap/bpf.h>|' \
+      libpcap_stuff.c script.c
+
+    sed -i -r -e 's|"(/usr/(local/)?)?bin/"|"${tcl}/bin"|g' \
+              -e 's!/usr/(local/)?(lib|include)!${tcl}/\2!g' \
+              configure
+  '';
+
+  preInstall = ''
+    mkdir -vp "$out/sbin" "$out/share/man/man8"
+  '';
+
+  postInstall = ''
+    ln -vs hping3.8.gz "$out/share/man/man8/hping.8.gz"
+    ln -vs hping3.8.gz "$out/share/man/man8/hping2.8.gz"
+  '';
+
+  meta = {
+    description = "A command-line oriented TCP/IP packet assembler/analyzer";
+    homepage = "http://www.hping.org/";
+    license = stdenv.lib.licenses.gpl2;
+  };
+}

pkgs/tools/networking/samplicator/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "samplicator-${version}";
+  version = "1.3.7-beta6";
+
+  src = fetchurl {
+    url = "http://samplicator.googlecode.com/files/${name}.tar.gz";
+    sha1 = "2091af1898d6508ad9fd338a07e352e2387522d4";
+  };
+
+  meta = {
+    description = "Send copies of (UDP) datagrams to multiple receivers";
+    homepage = "http://code.google.com/p/samplicator/";
+    license = stdenv.lib.licenses.gpl2Plus;
+  };
+}

pkgs/tools/networking/wbox/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "wbox-${version}";
+  version = "5";
+
+  installPhase = ''
+    install -vD wbox "$out/bin/wbox"
+  '';
+
+  src = fetchurl {
+    url = "http://www.hping.org/wbox/${name}.tar.gz";
+    sha256 = "06daxwbysppvbh1mwprw8fgsp6mbd3kqj7a978w7ivn8hdgdi28m";
+  };
+
+  meta = {
+    description = "A simple HTTP benchmarking tool";
+    homepage = "http://www.hping.org/wbox/";
+    license = stdenv.lib.licenses.bsd3;
+  };
+}

pkgs/tools/package-management/dpkg/cache-arch.patch

···
+Don't invoke "dpkg --print-architecture" for every call to
+Dpkg::Arch::get_raw_build_arch().
+
+diff -ru -x '*~' dpkg-1.16.9/scripts/Dpkg/Arch.pm dpkg-1.16.9-new/scripts/Dpkg/Arch.pm
+--- dpkg-1.16.9/scripts/Dpkg/Arch.pm	2012-10-20 06:34:17.000000000 +0200
++++ dpkg-1.16.9-new/scripts/Dpkg/Arch.pm	2012-12-04 19:42:20.451002537 +0100
+@@ -59,7 +59,7 @@
+ 	# dpkg-architecture itself, by avoiding computing the DEB_BUILD_
+ 	# variables when they are not requested.
+ 
+-	my $build_arch = `dpkg --print-architecture`;
++	$build_arch = `dpkg --print-architecture`;
+ 	syserr("dpkg --print-architecture failed") if $? >> 8;
+ 
+ 	chomp $build_arch;

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

···
     sha256 = "0ykby9x4x2zb7rfj30lfjcsrq2q32z2lnsrl8pbdvb2l9sx7zkbk";
   };
 
+  patches = [ ./cache-arch.patch ];
+
   configureFlags = "--disable-dselect --with-admindir=/var/lib/dpkg PERL_LIBDIR=$(out)/${perl.libPrefix}";
 
   preConfigure = ''

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

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "nix-1.1";
+  name = "nix-1.2";
 
   src = fetchurl {
-    url = "http://hydra.nixos.org/build/2860022/download/4/${name}.tar.bz2";
-    sha256 = "edb2fc444eda49be144ca2901f1fc9472cd24896775ba02556ded5705863d324";
+    url = "http://nixos.org/releases/nix/${name}/${name}.tar.xz";
+    sha256 = "2f7c2d27e240b6a43ebfba330127072e3fb1473c17dbfc5e9662ea589dfd16e5";
   };
 
   buildNativeInputs = [ perl pkgconfig ];
···
   configureFlags =
     ''
       --with-store-dir=${storeDir} --localstatedir=${stateDir}
-      --with-dbi=${perlPackages.DBI}/lib/perl5/site_perl
-      --with-dbd-sqlite=${perlPackages.DBDSQLite}/lib/perl5/site_perl
+      --with-dbi=${perlPackages.DBI}/${perl.libPrefix}
+      --with-dbd-sqlite=${perlPackages.DBDSQLite}/${perl.libPrefix}
+      --with-www-curl=${perlPackages.WWWCurl}/${perl.libPrefix}
       --disable-init-state
       --enable-gc
       CFLAGS=-O3 CXXFLAGS=-O3
···
     configureFlags =
       ''
         --with-store-dir=${storeDir} --localstatedir=${stateDir}
-        --with-dbi=${perlPackages.DBI}/lib/perl5/site_perl
-        --with-dbd-sqlite=${perlPackages.DBDSQLite}/lib/perl5/site_perl
+        --with-dbi=${perlPackages.DBI}/${perl.libPrefix}
+        --with-dbd-sqlite=${perlPackages.DBDSQLite}/${perl.libPrefix}
+        --with-www-curl=${perlPackages.WWWCurl}/${perl.libPrefix}
         --disable-init-state
         --enable-gc
         CFLAGS=-O3 CXXFLAGS=-O3
       '' + stdenv.lib.optionalString (
           stdenv.cross ? nix && stdenv.cross.nix ? system
       ) ''--with-system=${stdenv.cross.nix.system}'';
-      
+
     doInstallCheck = false;
   };
 

pkgs/tools/security/tor/default.nix

···
 { stdenv, fetchurl, libevent, openssl, zlib }:
 
 stdenv.mkDerivation rec {
-  name = "tor-0.2.2.35";
+  name = "tor-0.2.3.25";
 
   src = fetchurl {
     url = "http://www.torproject.org/dist/${name}.tar.gz";
-    sha256 = "f141a41fffd31494a0f96ebbb6b999eab33ce62d5c31f81222a0acd034adbf3a";
+    sha256 = "bb2d6f1136f33e11d37e6e34184143bf191e59501613daf33ae3d6f78f3176a0";
   };
 
 #  patchPhase =

pkgs/tools/text/ascii/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "ascii-${version}";
+  version = "3.12";
+
+  src = fetchurl {
+    url = "http://www.catb.org/~esr/ascii/${name}.tar.gz";
+    sha256 = "17jhmmdbhzzaai0lr5aslg0nmqchq1ygdxwd8pgl7qn2jnxhc6ci";
+  };
+
+  prePatch = ''
+    sed -i -e 's|$(DESTDIR)/usr|$(out)|g' Makefile
+  '';
+
+  preInstall = ''
+    mkdir -vp "$out/bin" "$out/share/man/man1"
+  '';
+
+  meta = {
+    description = "Interactive ASCII name and synonym chart";
+    homepage = "http://www.catb.org/~esr/ascii/";
+    license = stdenv.lib.licenses.bsd3;
+  };
+}

pkgs/top-level/all-packages.nix

···
 
   archivemount = callPackage ../tools/filesystems/archivemount { };
 
+  ascii = callPackage ../tools/text/ascii { };
+
   asymptote = builderDefsPackage ../tools/graphics/asymptote {
     inherit freeglut ghostscriptX imagemagick fftw boehmgc
       mesa ncurses readline gsl libsigsegv python zlib perl
···
 
   gifsicle = callPackage ../tools/graphics/gifsicle { };
 
-  glusterfs = builderDefsPackage ../tools/filesystems/glusterfs {
-    inherit fuse flex bison;
-  };
+  glusterfs = callPackage ../tools/filesystems/glusterfs { };
 
   glxinfo = callPackage ../tools/graphics/glxinfo { };
 
···
   };
 
   host = callPackage ../tools/networking/host { };
+
+  hping = callPackage ../tools/networking/hping { };
 
   httpfs2 = callPackage ../tools/filesystems/httpfs { };
 
···
 
   salut_a_toi = callPackage ../applications/networking/instant-messengers/salut-a-toi {};
 
+  samplicator = callPackage ../tools/networking/samplicator { };
+
   screen = callPackage ../tools/misc/screen { };
 
   scrot = callPackage ../tools/graphics/scrot { };
···
 
   sourceHighlight = callPackage ../tools/text/source-highlight { };
 
-  socat2pre = builderDefsPackage ../tools/networking/socat/2.0.0-b3.nix {
+  socat2pre = lowPrio (builderDefsPackage ../tools/networking/socat/2.0.0-b3.nix {
     inherit fetchurl stdenv openssl;
-  };
+  });
 
   squashfsTools = callPackage ../tools/filesystems/squashfs { };
 
···
   vpnc = callPackage ../tools/networking/vpnc { };
 
   vtun = callPackage ../tools/networking/vtun { };
+
+  wbox = callPackage ../tools/networking/wbox {};
 
   welkin = callPackage ../tools/graphics/welkin {};
 
···
   # failed to build
   mediastreamer = callPackage ../development/libraries/mediastreamer { };
 
-  mesaSupported =
-    system == "i686-linux" ||
-    system == "x86_64-linux" ||
-    system == "x86_64-darwin";
+  mesaSupported = lib.elem system lib.platforms.mesaPlatforms;
 
   mesa = callPackage ../development/libraries/mesa { };
 
···
   spice = callPackage ../development/libraries/spice {
     celt = celt_0_5_1;
     inherit (xlibs) libXrandr libXfixes libXext libXrender libXinerama;
+    inherit (pythonPackages) pyparsing;
   };
 
   spice_protocol = callPackage ../development/libraries/spice-protocol { };
···
 
   numeric = callPackage ../development/python-modules/numeric { };
 
-  pil = callPackage ../development/python-modules/pil { };
+  pil = python27Packages.pil;
 
   psyco = callPackage ../development/python-modules/psyco { };
 
   pycairo = callPackage ../development/python-modules/pycairo { };
 
-  pycrypto = callPackage ../development/python-modules/pycrypto { };
+  pycrypto = python27Packages.pycrypto;
 
   pycups = callPackage ../development/python-modules/pycups { };
 
···
 
   radius = callPackage ../servers/radius { };
 
-  redis = callPackage ../servers/nosql/redis { };
+  redis = callPackage ../servers/nosql/redis {
+    stdenv =
+      if stdenv.isDarwin
+      then overrideGCC stdenv gccApple
+      else stdenv;
+  };
 
   redstore = callPackage ../servers/http/redstore { };
 
···
       ];
   };
 
+  linux_3_7 = makeOverridable (import ../os-specific/linux/kernel/linux-3.7.nix) {
+    inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
+    kernelPatches =
+      [
+        kernelPatches.sec_perm_2_6_24
+        #kernelPatches.aufs3_6
+      ] ++ lib.optionals (platform.kernelArch == "mips")
+      [ kernelPatches.mips_fpureg_emu
+        kernelPatches.mips_fpu_sigill
+        kernelPatches.mips_ext3_n32
+      ];
+  };
+
   /* Linux kernel modules are inherently tied to a specific kernel.  So
      rather than provide specific instances of those packages for a
      specific kernel, we have a function that builds those packages
···
 
     nvidia_x11_legacy96 = callPackage ../os-specific/linux/nvidia-x11/legacy96.nix { };
     nvidia_x11_legacy173 = callPackage ../os-specific/linux/nvidia-x11/legacy173.nix { };
+    nvidia_x11_legacy304 = callPackage ../os-specific/linux/nvidia-x11/legacy304.nix { };
 
     openafsClient = callPackage ../servers/openafs-client { };
 
···
   linuxPackages_3_4 = recurseIntoAttrs (linuxPackagesFor pkgs.linux_3_4 pkgs.linuxPackages_3_4);
   linuxPackages_3_5 = recurseIntoAttrs (linuxPackagesFor pkgs.linux_3_5 pkgs.linuxPackages_3_5);
   linuxPackages_3_6 = recurseIntoAttrs (linuxPackagesFor pkgs.linux_3_6 pkgs.linuxPackages_3_6);
+  linuxPackages_3_7 = recurseIntoAttrs (linuxPackagesFor pkgs.linux_3_7 pkgs.linuxPackages_3_7);
 
   # The current default kernel / kernel modules.
   linux = linuxPackages.kernel;
···
   };
 
   chromium = lowPrio (callPackage ../applications/networking/browsers/chromium {
+    channel = "stable";
     gconf = gnome.GConf;
+    pulseSupport = config.pulseaudio or false;
   });
 
-  chromeWrapper = wrapFirefox
-    { browser = chromium; browserName = chromium.packageName; desktopName = "Chromium";
-      icon = "${chromium}/share/icons/hicolor/48x48/apps/${chromium.packageName}.png";
-    };
+  chromiumBeta = chromium.override { channel = "beta"; };
+  chromiumBetaWrapper = wrapChromium chromiumBeta;
+
+  chromiumDev = chromium.override { channel = "dev"; };
+  chromiumDevWrapper = wrapChromium chromiumDev;
+
+  chromiumWrapper = wrapChromium chromium;
 
   cinelerra = callPackage ../applications/video/cinelerra { };
 
···
 
   d4x = callPackage ../applications/misc/d4x { };
 
-  darcs = haskellPackages.darcs;
+  darcs = lib.setName "darcs-${haskellPackages.darcs.version}" haskellPackages.darcs;
 
   darktable = callPackage ../applications/graphics/darktable {
     inherit (gnome) GConf libglade;
···
 
   librecad = callPackage ../applications/misc/librecad { };
 
+  librecad2 = callPackage ../applications/misc/librecad/2.0.nix { };
+
   libreoffice = callPackage ../applications/office/openoffice/libreoffice.nix {
     inherit (perlPackages) ArchiveZip CompressZlib;
     inherit (gnome) GConf ORBit2 gnome_vfs;
···
     gtk = gtk3;
   };
 
+  vbindiff = callPackage ../applications/editors/vbindiff { };
+
   vdpauinfo = callPackage ../tools/X11/vdpauinfo { };
 
   veracity = callPackage ../applications/version-management/veracity {};
···
 
   wordnet = callPackage ../applications/misc/wordnet { };
 
+  wrapChromium = browser: wrapFirefox {
+    inherit browser;
+    browserName = browser.packageName;
+    desktopName = "Chromium";
+    icon = "${browser}/share/icons/hicolor/48x48/apps/${browser.packageName}.png";
+  };
+
   wrapFirefox =
     { browser, browserName ? "firefox", desktopName ? "Firefox", nameSuffix ? ""
     , icon ? "${browser}/lib/${browser.name}/icons/mozicon128.png" }:
···
 
   xbindkeys = callPackage ../tools/X11/xbindkeys { };
 
+  xcalib = callPackage ../tools/X11/xcalib { };
+
   xchat = callPackage ../applications/networking/irc/xchat { };
 
   xchm = callPackage ../applications/misc/xchm { };
···
 
   sauerbraten = callPackage ../games/sauerbraten {};
 
+  scid = callPackage ../games/scid { };
+
   scummvm = callPackage ../games/scummvm { };
 
   scorched3d = callPackage ../games/scorched3d { };
···
 
   worldofgoo = callPackage ../games/worldofgoo { };
 
-  xboard = builderDefsPackage (import ../games/xboard) {
-    inherit (xlibs) libX11 xproto libXt libXaw libSM
-      libICE libXmu libXext libXpm;
-    inherit gnuchess texinfo;
-  };
+  xboard =  callPackage ../games/xboard { };
 
   xconq = callPackage ../games/xconq {};
 
···
 
   cvc3 = callPackage ../applications/science/logic/cvc3 {};
 
-  eprover = callPackage ../applications/science/logic/eProver {
+  eprover = callPackage ../applications/science/logic/eprover {
     texLive = texLiveAggregationFun {
       paths = [
         texLive texLiveExtra
···
     stateDir = config.nix.stateDir or "/nix/var";
   };
 
+  nixUnstable = nixStable;
+
+  /*
   nixUnstable = callPackage ../tools/package-management/nix/unstable.nix {
     storeDir = config.nix.storeDir or "/nix/store";
     stateDir = config.nix.stateDir or "/nix/var";
   };
+  */
 
   nut = callPackage ../applications/misc/nut { };
 
···
   rssglx = callPackage ../misc/screensavers/rss-glx { };
 
   xlockmore = callPackage ../misc/screensavers/xlockmore { };
+
+  samsungUnifiedLinuxDriver = import ../misc/cups/drivers/samsung {
+    inherit fetchurl stdenv;
+    inherit cups ghostscript glibc patchelf;
+    gcc = import ../development/compilers/gcc/4.4 {
+      inherit stdenv fetchurl texinfo gmp mpfr noSysDirs gettext which;
+      profiledCompiler = true;
+    };
+  };
 
   saneBackends = callPackage ../applications/graphics/sane/backends.nix {
     gt68xxFirmware = config.sane.gt68xxFirmware or null;

pkgs/top-level/haskell-packages.nix

···
 
   base64Bytestring = callPackage ../development/libraries/haskell/base64-bytestring {};
 
+  base64Conduit = callPackage ../development/libraries/haskell/base64-conduit {};
+
   baseUnicodeSymbols = callPackage ../development/libraries/haskell/base-unicode-symbols {};
 
   basicPrelude = callPackage ../development/libraries/haskell/basic-prelude {};
···
   blazeHtml = callPackage ../development/libraries/haskell/blaze-html {};
 
   blazeMarkup = callPackage ../development/libraries/haskell/blaze-markup {};
+
+  blazeSvg = callPackage ../development/libraries/haskell/blaze-svg {};
 
   blazeTextual = callPackage ../development/libraries/haskell/blaze-textual {};
 
···
   derp = callPackage ../development/libraries/haskell/derp {};
 
   diagrams = callPackage ../development/libraries/haskell/diagrams/diagrams.nix {};
-
   diagramsCairo = callPackage ../development/libraries/haskell/diagrams/cairo.nix {};
-
   diagramsCore = callPackage ../development/libraries/haskell/diagrams/core.nix {};
-
+  diagramsContrib = callPackage ../development/libraries/haskell/diagrams/contrib.nix {};
   diagramsLib = callPackage ../development/libraries/haskell/diagrams/lib.nix {};
+  diagramsSvg = callPackage ../development/libraries/haskell/diagrams/svg.nix {};
 
   Diff = callPackage ../development/libraries/haskell/Diff {};
 
···
 
   dstring = callPackage ../development/libraries/haskell/dstring {};
 
+  dualTree = callPackage ../development/libraries/haskell/dual-tree {};
+
   editDistance = callPackage ../development/libraries/haskell/edit-distance {};
 
   editline = callPackage ../development/libraries/haskell/editline {};
···
   entropy = callPackage ../development/libraries/haskell/entropy {};
 
   erf = callPackage ../development/libraries/haskell/erf {};
+
+  errors = callPackage ../development/libraries/haskell/errors {};
+
+  either = callPackage ../development/libraries/haskell/either {};
 
   exceptionMtl = callPackage ../development/libraries/haskell/exception-mtl {};
 
···
 
   fingertree = callPackage ../development/libraries/haskell/fingertree {};
 
+  forceLayout = callPackage ../development/libraries/haskell/force-layout {};
+
   fsnotify = callPackage ../development/libraries/haskell/fsnotify {};
 
   gamma = callPackage ../development/libraries/haskell/gamma {};
···
 
   jsonTypes = callPackage ../development/libraries/haskell/jsonTypes {};
 
+  kansasLava = callPackage ../development/libraries/haskell/kansas-lava {};
+
   languageC_0_4_2   = callPackage ../development/libraries/haskell/language-c/0.4.2.nix {};
   languageC_0_3_2_1 = callPackage ../development/libraries/haskell/language-c/0.3.2.1.nix {};
   languageC = self.languageC_0_4_2;
···
 
   mersenneRandomPure64 = callPackage ../development/libraries/haskell/mersenne-random-pure64 {};
 
+  minimorph = callPackage ../development/libraries/haskell/minimorph {};
+
+  miniutter = callPackage ../development/libraries/haskell/miniutter {};
+
   mimeMail = callPackage ../development/libraries/haskell/mime-mail {};
 
   mimeTypes = callPackage ../development/libraries/haskell/mime-types {};
···
 
   monadsTf = callPackage ../development/libraries/haskell/monads-tf {};
 
+  monoidExtras = callPackage ../development/libraries/haskell/monoid-extras {};
+
   mongoDB = callPackage ../development/libraries/haskell/mongoDB {};
 
   mpppc = callPackage ../development/libraries/haskell/mpppc {};
···
   mwcRandom = callPackage ../development/libraries/haskell/mwc-random {};
 
   NanoProlog = callPackage ../development/libraries/haskell/NanoProlog {};
+
+  netlist = callPackage ../development/libraries/haskell/netlist {};
+
+  netlistToVhdl = callPackage ../development/libraries/haskell/netlist-to-vhdl {};
 
   network_2_2_1_4 = callPackage ../development/libraries/haskell/network/2.2.1.4.nix {};
   network_2_2_1_7 = callPackage ../development/libraries/haskell/network/2.2.1.7.nix {};
···
   simpleSendfile = callPackage ../development/libraries/haskell/simple-sendfile {};
 
   silently = callPackage ../development/libraries/haskell/silently {};
+
+  sizedTypes = callPackage ../development/libraries/haskell/sized-types {};
 
   skein = callPackage ../development/libraries/haskell/skein {};
 

pkgs/top-level/platforms.nix

···
       ''
         # Virtualisation (KVM, Xen...).
         PARAVIRT_GUEST y
-        KVM_CLOCK y
+        KVM_CLOCK? y #Part of KVM_GUEST since linux 3.7
         KVM_GUEST y
         XEN y
         KSM y

pkgs/top-level/python-packages.nix

···
 
   buildPythonPackage = import ../development/python-modules/generic {
     inherit (pkgs) lib;
-    inherit python wrapPython setuptools;
+    inherit python wrapPython setuptools setuptoolsSite offlineDistutils;
+  };
+
+
+  recursivePthLoader = import ../development/python-modules/recursive-pth-loader {
+    inherit (pkgs) stdenv;
+    inherit python;
   };
 
 
···
     inherit python wrapPython;
   };
 
+  setuptoolsSite = import ../development/python-modules/setuptools/site.nix {
+    inherit (pkgs) stdenv;
+    inherit python setuptools;
+  };
+
+  offlineDistutils = import ../development/python-modules/offline-distutils {
+    inherit (pkgs) stdenv;
+    inherit python;
+  };
 
   ipython = import ../shells/ipython {
     inherit (pkgs) stdenv fetchurl;
     inherit buildPythonPackage pythonPackages;
   };
 
+  pil = import ../development/python-modules/pil {
+    inherit (pkgs) fetchurl stdenv libjpeg zlib freetype;
+    inherit python buildPythonPackage;
+  };
+
+  pycrypto = import ../development/python-modules/pycrypto {
+    inherit (pkgs) fetchurl stdenv gmp;
+    inherit python buildPythonPackage;
+  };
 
   wrapPython = pkgs.makeSetupHook
     { deps = pkgs.makeWrapper;
···
 
     propagatedBuildInputs = [ notmuch pkgs.dbacl ];
 
+    # error: invalid command 'test'
     doCheck = false;
 
     postInstall = ''
···
       sha256 = "b5239c4dfcd9882608fb48ef80fe9ba9223949ab7e6a2c1abe970ac307ebcd4a";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     propagatedBuildInputs = [ notmuch urwid twisted magic configobj pygpgme ];
···
       sha1 = "f124e5e4a6644bf6d1734032a01ac44db1b25a29";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
 
     buildInputs = [ pkgs.unzip pkgs.sqlite ];
 
+    # python: double free or corruption (fasttop): 0x0000000002fd4660 ***
     doCheck = false;
 
     meta = {
···
       rev = "b2c9cdcabd";
       sha256 = "b0c12b8c48ed9180c7475fab18de50d63e1b517cfb46da4d2c66fc406fe902bc";
     };
+
     installCommand = "python setup.py install --prefix=$out";
+
+    # error: invalid command 'test'
     doCheck = false;
+
     propagatedBuildInputs = [ boto ];
+
   });
 
 
···
 
     buildInputs = [ pkgs.unzip ];
 
-    # How do we run the tests?
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "1gasiy5lwbhsxw27g36d88n36xbj52434klisvqhljgckd4xqcy7";
     };
 
-    # No tests implemented
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
   };
 
 
-  bugz = buildPythonPackage (rec {
-    name = "bugz-0.9.3";
-
-    src = fetchgit {
-      url = "git://github.com/williamh/pybugz.git";
-      rev = "refs/tags/0.9.3";
-    };
-
-    propagatedBuildInputs = [ argparse python.modules.ssl ];
-
-    doCheck = false;
-
-    meta = {
-      homepage = http://www.liquidx.net/pybugz/;
-      description = "Command line interface for Bugzilla";
-    };
-  });
+  # bugz = buildPythonPackage (rec {
+  #   name = "bugz-0.9.3";
+  #
+  #   src = fetchgit {
+  #     url = "https://github.com/williamh/pybugz.git";
+  #     rev = "refs/tags/0.9.3";
+  #   };
+  #
+  #   propagatedBuildInputs = [ argparse python.modules.ssl ];
+  #
+  #   doCheck = false;
+  #
+  #   meta = {
+  #     homepage = http://www.liquidx.net/pybugz/;
+  #     description = "Command line interface for Bugzilla";
+  #   };
+  # });
 
 
   carrot = buildPythonPackage rec {
···
       sha256 = "1xlvanhnxgvwd7vvypbafyl6yqfkpnwa9rs9k3058z84gd86bz8d";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
 
     propagatedBuildInputs = [ stompclient distribute ];
 
-    doCheck = false;
+    buildInputs = [ coverage sqlalchemy ];
+
+    # ValueError: Could not parse auth file:
+    # /tmp/nix-build-.../CoilMQ-0.6.1/coilmq/tests/resources/auth.ini
+    #doCheck = false;
 
     meta = {
       description = "Simple, lightweight, and easily extensible STOMP message broker";
···
       md5 = "201dbaa732a9049c839f9bb6c27fc7b5";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
     };
   });
 
+  coverage = buildPythonPackage rec {
+    name = "coverage-3.5.3";
+
+    src = fetchurl {
+      url = "http://pypi.python.org/packages/source/c/coverage/${name}.tar.gz";
+      md5 = "5f1f523940c473faa8a9f6ca29f78efc";
+    };
+
+    meta = {
+      description = "Code coverage measurement for python";
+      homepage = http://nedbatchelder.com/code/coverage/;
+      license = pkgs.lib.licenses.bsd3;
+      maintainers = [ stdenv.lib.maintainers.shlevy ];
+      platforms = python.meta.platforms;
+    };
+  };
+
   cssutils = buildPythonPackage (rec {
     name = "cssutils-0.9.9";
 
···
       sha256 = "139yfm9yz9k33kgqw4khsljs10rkhhxyywbq9i82bh2r31cil1pp";
     };
 
-    buildInputs = [ pkgs.unzip ];
+    buildInputs = [ pkgs.unzip mock ];
 
-    # The tests fail - I don't know why
+    # couple of failing tests
     doCheck = false;
 
     meta = {
···
     # http://thread.gmane.org/gmane.comp.file-systems.tahoe.devel/3200 for a
     # discussion.
 
-    # Gives "ValueError: Empty module name" with no clue as to why.
+    # AttributeError: 'module' object has no attribute 'test_darcsver'
     doCheck = false;
 
     meta = {
···
         # ehm, YES, the --verbose flags needs to be there, otherwise it tries to patch setuptools!
         easy_install --verbose --prefix=$out .
       '';
+
+    # test for 27 fails
     doCheck = false;
 
     meta = {
···
       sha256 = "16s0anvpaccbqmdrhl71z73k0dy2sl166nnc2fbd5lshlgmj13ad";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "0snlrcvk92qj1v0n9dpycn6sw56w4zns4mpc30837q6yi7ylrx4f";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "1d8vg5a9q2ldnbxqap1893lqb66jwcsli2brbjx7mcnqrzcz449x";
     };
 
-    propagatedBuildInputs = [ pkgs.pil django_1_3 ];
+    propagatedBuildInputs = [ pil django_1_3 ];
 
     meta = {
       description = "A collection of useful extensions for Django";
···
     installCommand = ''
       python setup.py install --prefix="$out" --root=/ --record="$out/lib/${python.libPrefix}/site-packages/dulwich/list.txt" --single-version-externally-managed
     '';
-    doCheck = false;
+
+    # For some reason "python setup.py test" doesn't work with Python 2.6.
+    # pretty sure that is about import behaviour.
+    doCheck = python.majorVersion != "2.6";
 
     meta = {
       description = "Simple Python implementation of the Git file formats and protocols.";
···
       sha256 = "0wfz4nxl95jcr2f2mc5gijgighavcghg33plzbz5jyi531jpffss";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       md5 = "abfdbb25d37c28e9da05f1b5c3596d1a";
     };
 
+    buildInputs = [ nose ];
+
+    # 3 failing tests
     doCheck = false;
 
     meta = {
···
 
     propagatedBuildInputs = [ twisted pkgs.pyopenssl ];
 
-    # For some reason "python setup.py test" doesn't work with Python 2.6.
-    doCheck = false;
-
     meta = {
       homepage = http://foolscap.lothar.com/;
 
···
       sha256 = "0jrajyppdzb3swcxv3w1mpp88vcy7400gy1v2h2gm3pq0dmggaij";
     };
 
-    # two tests fail on x86_64 at least. I don't know why.
+    # FAIL: test_sanitize_remove_script_elem (genshi.filters.tests.html.HTMLSanitizerTestCase)
+    # FAIL: test_sanitize_remove_src_javascript (genshi.filters.tests.html.HTMLSanitizerTestCase)
     doCheck = false;
 
     buildInputs = [ pkgs.setuptools ];
···
       sha256 = "0bhiyx41kilvy04cgjbvjy2r4b6l7zz31fbrg3l6lvnqm26nihb0";
     };
 
-    buildInputs = [ pkgs.setuptools ];
+    buildInputs = [ pkgs.setuptools ] ++
+                  (if python.majorVersion == "2.6" then [ argparse ] else []);
 
     meta = {
       description = "automatically generated zsh completion function for Python's option parser modules";
···
 
     buildInputs = [ nose mox ];
 
+    # tests fail for python2.6
+    doCheck = python.majorVersion != "2.6";
+
     propagatedBuildInputs = [ gflags sqlalchemy webob routes eventlet ];
 
     PYTHON_EGG_CACHE = "`pwd`/.egg-cache";
···
       sha256 = "1wmd1svx5344alb8ff9vzdam1ccqdl0h7shp1xnsk843hqwc0fz0";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     postUnpack = "find . -print0 | xargs -0 touch";
···
       sha256 = "2e2ce18092c32d1ec54f8a447e14e33585e30f240b883bfeeca65f12b3bcfaf6";
     };
 
-    doCheck = false; # doesn't have a test
-
     meta = {
       homepage = "http://code.google.com/p/httplib2";
       description = "A comprehensive HTTP client library";
···
       md5 = "f4f7ddc7c5e55a47222a5cc6c0a87b6d";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       md5 = "506cf1b13020b3ed2f3c845ea0c9830e";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "11qilrs4sd4c1mkd64ikrjsc2vwrshhc54n5mh4xrark9c7ayp0y";
     };
 
-    buildInputs = [ zopeInterface ];
+    buildInputs = [ zopeInterface mock ];
 
     preConfigure = "cp test/secrets.py-dist test/secrets.py";
 
+    # failing tests for 26 and 27
+    doCheck = false;
+
     meta = {
       description = "A unified interface to many cloud providers";
       homepage = http://incubator.apache.org/libcloud/;
···
       sha1 = "1eebaee375641c9f29aeb21768f917dd2b985752";
     };
 
-    doCheck = false; # no tests
+    # error: invalid command 'test'
+    doCheck = false;
 
     meta = {
       homepage = http://code.google.com/p/pylockfile/;
···
       md5 = "751e8055be2433dfd1a82e0fb1b12f13";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "be37e1d86c65ecacae6683f8805e051e9904e5f2e02bf2b7a34262c46a6d06a7";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     propagatedBuildInputs = [ dateutil numpy pkgs.freetype pkgs.libpng pkgs.pkgconfig pkgs.tcl pkgs.tk pkgs.xlibs.libX11 ];
···
       sha1 = "b71aeaacf31898c3b38d8b9ca5bcc0664499c0de";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
   MySQL_python = buildPythonPackage {
     name = "MySQL-python-1.2.3";
 
+    # plenty of failing tests
     doCheck = false;
 
     src = fetchurl {
···
       sha256 = "0vkyg9dmj29hzk7fy77f42p7bfj28skyzsjsjry4wqr3z6xnzrkx";
     };
 
-    propagatedBuildInputs = [ pkgs.mysql pkgs.zlib nose ];
+    buildInputs = [ nose ];
+
+    propagatedBuildInputs = [ pkgs.mysql pkgs.zlib ];
 
     meta = {
       description = "MySQL database binding for Python";
···
 
     # No support of GUI yet.
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "0ssxic389rdc79zkz8dxcjpqdi5qs80h12khkag410cl9cwk11f2";
     };
 
-    doCheck = false; # there is no test command
+    # error: invalid command 'test'
+    doCheck = false;
 
     meta = {
       homepage = https://github.com/drkjam/netaddr/;
···
     version = "0.10.0";
 
     src = fetchurl {
-      url = "http://divmod.org/trac/attachment/wiki/SoftwareReleases/Nevow-${version}.tar.gz?format=raw";
+      url = "http://pypi.python.org/packages/source/N/Nevow/Nevow-${version}.tar.gz";
       sha256 = "90631f68f626c8934984908d3df15e7c198939d36be7ead1305479dfc67ff6d0";
       name = "${name}.tar.gz";
     };
 
-    propagatedBuildInputs = [ twisted ];
+   propagatedBuildInputs = [ twisted ];
 
-    postInstall = "twistd --help > /dev/null";
+   postInstall = "twistd --help > /dev/null";
 
-    meta = {
-      description = "Nevow, a web application construction kit for Python";
+   meta = {
+     description = "Nevow, a web application construction kit for Python";
 
-      longDescription = ''
-        Nevow - Pronounced as the French "nouveau", or "noo-voh", Nevow
-        is a web application construction kit written in Python.  It is
-        designed to allow the programmer to express as much of the view
-        logic as desired in Python, and includes a pure Python XML
-        expression syntax named stan to facilitate this.  However it
-        also provides rich support for designer-edited templates, using
-        a very small XML attribute language to provide bi-directional
-        template manipulation capability.
+     longDescription = ''
+       Nevow - Pronounced as the French "nouveau", or "noo-voh", Nevow
+       is a web application construction kit written in Python.  It is
+       designed to allow the programmer to express as much of the view
+       logic as desired in Python, and includes a pure Python XML
+       expression syntax named stan to facilitate this.  However it
+       also provides rich support for designer-edited templates, using
+       a very small XML attribute language to provide bi-directional
+       template manipulation capability.
 
-        Nevow also includes formless, a declarative syntax for
-        specifying the types of method parameters and exposing these
-        methods to the web.  Forms can be rendered automatically, and
-        form posts will be validated and input coerced, rendering error
-        pages if appropriate.  Once a form post has validated
-        successfully, the method will be called with the coerced values.
-      '';
+       Nevow also includes formless, a declarative syntax for
+       specifying the types of method parameters and exposing these
+       methods to the web.  Forms can be rendered automatically, and
+       form posts will be validated and input coerced, rendering error
+       pages if appropriate.  Once a form post has validated
+       successfully, the method will be called with the coerced values.
+     '';
 
-      homepage = http://divmod.org/trac/wiki/DivmodNevow;
+     homepage = http://divmod.org/trac/wiki/DivmodNevow;
 
-      license = "BSD-style";
-    };
-  });
+     license = "BSD-style";
+   };
+ });
 
   nose = buildPythonPackage rec {
-    name = "nose-1.0.0";
+    name = "nose-1.2.1";
 
     src = fetchurl {
       url = "http://pypi.python.org/packages/source/n/nose/${name}.tar.gz";
-      md5 = "47a4784c817afa6ef11a505b574584ed";
+      md5 = "735e3f1ce8b07e70ee1b742a8a53585a";
     };
 
-    # Fails with ‘This platform lacks a functioning sem_open
-    # implementation, therefore, the required synchronization
-    # primitives needed will not function, see issue 3770.’ However,
-    # our Python does seem to be built with the necessary
-    # functionality.
-    doCheck = false;
-
     meta = {
       description = "A unittest-based testing framework for python that makes writing and running tests easier";
     };
+
+    buildInputs = [ coverage ];
   };
 
   notify = pkgs.stdenv.mkDerivation (rec {
···
       python setup.py build --fcompiler="gnu95"
       python setup.py install --prefix=$out
     '';
+
+    # error: invalid command 'test'
     doCheck = false;
 
     buildInputs = [ pkgs.gfortran ];
···
   });
 
   oauth2 = buildPythonPackage (rec {
-    name = "auth2-1.5.211";
+    name = "oauth2-1.5.211";
 
     src = fetchurl {
       url = "http://pypi.python.org/packages/source/o/oauth2/oauth2-1.5.211.tar.gz";
···
     };
 
     propagatedBuildInputs = [ httplib2 ];
-    doCheck = false;
+
+    buildInputs = [ mock coverage ];
+
+    # ServerNotFoundError: Unable to find the server at oauth-sandbox.sevengoslings.net
+    #doCheck = false;
 
     meta = {
       homepage = "https://github.com/simplegeo/python-oauth2";
···
     };
   });
 
-  optfunc = buildPythonPackage ( rec {
-    name = "optfunc-git";
-
-    src = pkgs.fetchgit {
-      url = "http://github.com/simonw/optfunc.git";
-      rev = "e3fa034a545ed94ac5a039cf5b170c7d0ee21b7b";
-    };
-
-    installCommand = ''
-      dest=$(toPythonPath $out)/optfunc
-      mkdir -p $dest
-      cp * $dest/
-    '';
-
-    doCheck = false;
-
-    meta = {
-      description = "A new experimental interface to optparse which works by introspecting a function definition";
-      homepage = "http://simonwillison.net/2009/May/28/optfunc/";
-    };
-  });
+  # optfunc = buildPythonPackage ( rec {
+  #   name = "optfunc-git";
+  #
+  #   src = pkgs.fetchgit {
+  #     url = "https://github.com/simonw/optfunc.git";
+  #     rev = "e3fa034a545ed94ac5a039cf5b170c7d0ee21b7b";
+  #   };
+  #
+  #   installCommand = ''
+  #     dest=$(toPythonPath $out)/optfunc
+  #     mkdir -p $dest
+  #     cp * $dest/
+  #   '';
+  #
+  #   doCheck = false;
+  #
+  #   meta = {
+  #     description = "A new experimental interface to optparse which works by introspecting a function definition";
+  #     homepage = "http://simonwillison.net/2009/May/28/optfunc/";
+  #   };
+  # });
 
   ply = buildPythonPackage (rec {
     name = "ply-3.2";
···
       sha256 = "1bjy4jn51c50mpq51jbwk0glzd8bxz83gxdfkr9p95dmrd17c7hh";
     };
 
-    buildInputs = [ pkgs.pycrypto ];
+    buildInputs = [ pycrypto ];
 
     meta = {
       homepage = "http://www.lag.net/paramiko/";
···
       sha256 = "0x8bfjjqygriry1iyygm5048ykl5qpbpzqfp6i8dhkslm3ryf5fk";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "1sr2bb3g7rl7gr6156j5qv71kg06q1x01r1lbps9ksnyz37djn2q";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
   psycopg2 = buildPythonPackage rec {
     name = "psycopg2-2.0.13";
 
+    # error: invalid command 'test'
     doCheck = false;
 
     src = fetchurl {
···
       python setup.py install --prefix=$out
     '';
 
-    doCheck = false;
-
     meta = {
       description = "Python bindings for PortAudio";
       homepage = "http://people.csail.mit.edu/hubert/pyaudio/";
···
       sha256 = "4a3a085ecf1fcd2736573538ffa114f1f4331b3bbbdd69381e6e172c49c9750f";
     };
 
-    doCheck = false;
+    buildInputs = [ pytz ];
 
     meta = {
       homepage = http://babel.edgewall.org;
···
 
     buildInputs = [ pkgs.curl ];
 
+    # error: invalid command 'test'
     doCheck = false;
 
     preConfigure = ''
       substituteInPlace setup.py --replace '--static-libs' '--libs'
     '';
 
-    installCommand = "python setup.py install --prefix=$out";
-
     meta = {
       homepage = http://pycurl.sourceforge.net/;
       description = "Python wrapper for libcurl";
···
     };
     propagatedBuildInputs = [xe];
 
-    # tests not described in setup.py
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "5fd887c407015296a8fd3f4b867fe0fcca3179de97ccde90449853a3dfb802e1";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     propagatedBuildInputs = [ pkgs.gpgme ];
···
       url = "http://pypi.python.org/packages/source/p/pyparsing/${name}.tar.gz";
       md5 = "1e41cb219dae9fc353bd4cd47636b283";
     };
+
+    # error: invalid command 'test'
     doCheck = false;
+
     meta = {
       homepage = http://pyparsing.wikispaces.com/;
       description = "The pyparsing module is an alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions.";
···
       sha256 = "1idks7j9bn62xzsaxkvhl7bdq6ws8kv8aa0wahfh7724qlbbcf1k";
     };
 
+    # ERROR: testExtended (tests.test_acls.AclExtensions)
+    # IOError: [Errno 0] Error
     doCheck = false;
 
     buildInputs = [ pkgs.acl ];
···
       md5 = "3076164a7079891d149a23f9435581db";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
               --replace "/usr/local/lib" "${pkgs.sqlite}/lib"
     '';
 
-    # FIXME: How do we run the tests?
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sed -i -e 's|libpython2.7.dylib|lib/libpython2.7.dylib|' Makefile
     '');
 
-    # The regression test suite expects locale support, which our glibc
-    # doesn't have by default.
-    doCheck = false;
     checkPhase = "make -C ../Tests";
 
     installPhase = ''
···
       sha256 = "0jmkffik6hdzs7ng8c65bggss2ai40nm59jykswdf5lpd36cxddq";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     buildInputs = [ pkgs.attr ];
···
     };
 
     buildInputs = [freetype];
+
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
 
     propagatedBuildInputs =
       [ recaptcha_client pytz memcached dateutil paramiko flup pygments
-        djblets django_1_3 django_evolution pkgs.pycrypto python.modules.sqlite3
-        pysvn pkgs.pil psycopg2
+        djblets django_1_3 django_evolution pycrypto python.modules.sqlite3
+        pysvn pil psycopg2
       ];
   };
 
···
       sha256 = "1c7ipk5vwqnln83rmai5jzyxkjdajdzbk5cgy1z83nyr5hbkgkqr";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
 
     buildInputs = [pkgs.gfortran];
     propagatedBuildInputs = [ numpy ];
+
+    # error: invalid command 'test'
     doCheck = false;
 
     # TODO: add ATLAS=${pkgs.atlas}
···
       md5 = "9e8099b57cd27493a6988e9c9b313e23";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sourceRoot=`pwd`/`ls -d S*`
     '';
 
+    # error: invalid command 'test'
     doCheck = false;
 
     propagatedBuildInputs = [ pkgs.xlibs.libX11 pkgs.pythonDBus pkgs.pygobject ];
···
       md5 = "af0a314b6106dd80da24a918c24a1eab";
     };
 
-    doCheck = false;
+    buildInputs = [ mock nose ];
+
+    # XXX: Ran 0 tests in 0.217s
 
     meta = {
       description = "Lightweight and extensible STOMP messaging client";
···
   });
 
 
-  svneverever =  buildPythonPackage rec {
-    name = "svneverever-778489a8";
-
-    src = pkgs.fetchgit {
-      url = git://git.goodpoint.de/svneverever.git;
-      rev = "778489a8c6f07825fb18c9da3892a781c3d659ac";
-      sha256 = "41c9da1dab2be7b60bff87e618befdf5da37c0a56287385cb0cbd3f91e452bb6";
-    };
-
-    propagatedBuildInputs = [ pysvn argparse ];
-
-    doCheck = false;
-  };
+  # XXX: ValueError: ZIP does not support timestamps before 1980
+  # svneverever =  buildPythonPackage rec {
+  #   name = "svneverever-778489a8";
+  #
+  #   src = pkgs.fetchgit {
+  #     url = git://git.goodpoint.de/svneverever.git;
+  #     rev = "778489a8c6f07825fb18c9da3892a781c3d659ac";
+  #     sha256 = "41c9da1dab2be7b60bff87e618befdf5da37c0a56287385cb0cbd3f91e452bb6";
+  #   };
+  #
+  #   propagatedBuildInputs = [ pysvn argparse ];
+  #
+  #   doCheck = false;
+  # };
 
   taskcoach = buildPythonPackage rec {
     name = "TaskCoach-1.3.8";
···
         --prefix LD_LIBRARY_PATH : $libspaths
     '';
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "1ihf5031pc1wpwbxpfzzz2bcpwww795n5y22baglyim1lalivd65";
     };
 
+    # couple of failing tests
     doCheck = false;
 
     PYTHON_EGG_CACHE = "`pwd`/.egg-cache";
···
       sha256 = "c0f32fa31e2c5fa42f5cc19f3dba4e73f0438bf36bf756ba137f2423c0ac4637";
     };
 
-    propagatedBuildInputs = [ oauth2 urwid tweepy ];
+    propagatedBuildInputs = [ oauth2 urwid tweepy ] ++
+                            (if python.majorVersion == "2.6" then [ argparse ]
+                                                             else []);
+
+    #buildInputs = [ tox ];
+    # needs tox
     doCheck = false;
 
     meta = {
···
       sha256 = "66d728527ab3d5f5e4d6725654783f99169172678105f609d14353f6626c1315";
     };
 
-    doCheck = false;
-
     meta = {
       homepage = "https://github.com/tweepy/tweepy";
       description = "Twitter library for python";
···
       sha256 = "4437076c8708e5754ea04540e46c7f4f233734ee3590bb8a96389264fb0650d0";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     propagatedBuildInputs = [ pycurl ];
···
   urwid = buildPythonPackage (rec {
     name = "urwid-1.1.1";
 
+    # multiple:  NameError: name 'evl' is not defined
     doCheck = false;
 
     src = fetchurl {
···
 
     propagatedBuildInputs = [ python.modules.readline python.modules.sqlite3 ];
 
-    doCheck = false;
+    buildInputs = [ mock nose ];
+
+    # XXX: Ran 0 tests in 0.003s
 
     meta = with stdenv.lib; {
       description = "a tool to create isolated Python environments";
···
       md5 = "8492e46496e187b49fe5569b5639804e";
     };
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "0v9878cl0y9cczdsr6xjy8v9l139lc23h4m5f86p4kpf2wlnpi42";
     };
 
-    # tests not described in setup.py
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
       sha256 = "294c3c0529e84169177bce78d616c768fa1c028a2fbc1854f615d32ed88dbc6c";
     };
 
-    doCheck = false;
-
     meta = {
       description = "Zope.Interface";
       homepage = http://zope.org/Products/ZopeInterface;
···
     };
   };
 
-  hgsvn = buildPythonPackage rec {
-    name = "hgsvn-0.1.8";
-    src = fetchurl rec {
-      name = "hgsvn-0.1.8.tar.gz";
-      url = "http://pypi.python.org/packages/source/h/hgsvn/${name}.tar.gz#md5=56209eae48b955754e09185712123428";
-      sha256 = "18a7bj1i0m4shkxmdvw1ci5i0isq5vqf0bpwgrhnk305rijvbpch";
-    };
-
-    buildInputs = [ pkgs.setuptools ];
-    doCheck = false;
-
-    meta = {
-      description = "HgSVN";
-      homepage = http://pypi.python.org/pypi/hgsvn;
-    };
-  };
+  # XXX: link broken
+  # hgsvn = buildPythonPackage rec {
+  #   name = "hgsvn-0.1.8";
+  #   src = fetchurl rec {
+  #     name = "hgsvn-0.1.8.tar.gz";
+  #     url = "http://pypi.python.org/packages/source/h/hgsvn/${name}.tar.gz#md5=56209eae48b955754e09185712123428";
+  #     sha256 = "18a7bj1i0m4shkxmdvw1ci5i0isq5vqf0bpwgrhnk305rijvbpch";
+  #   };
+  #
+  #   buildInputs = [ pkgs.setuptools ];
+  #   doCheck = false;
+  #
+  #     meta = {
+  #     description = "HgSVN";
+  #     homepage = http://pypi.python.org/pypi/hgsvn;
+  #   };
+  # };
 
   cliapp = buildPythonPackage rec {
     name = "cliapp-1.20120929";
···
 
     buildInputs = [ sphinx ];
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
 
     buildInputs = [ sphinx ];
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
 
     buildInputs = [ sphinx ];
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {
···
     buildInputs = [ sphinx ];
     propagatedBuildInputs = [ tracing ttystatus cliapp ];
 
+    # error: invalid command 'test'
     doCheck = false;
 
     meta = {