Add version attribute where maintainers |= nckx

This will probably be mandatory soon, and is a step in the right
direction. Removes the deprecated meta.version, and move some meta
sections to the end of the file where I should have put them in
the first place.

pkgs/applications/audio/fmit/default.nix

···
 assert jackSupport -> libjack2 != null;
 assert portaudioSupport -> portaudio != null;
 
-let version = "1.0.8"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "fmit-${version}";
+  version = "1.0.8";
 
   src = fetchFromGitHub {
     sha256 = "04s7xcgmi5g58lirr48vf203n1jwdxf981x1p6ysbax24qwhs2kd";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Free Musical Instrument Tuner";
     longDescription = ''
       FMIT is a graphical utility for tuning musical instruments, with error

pkgs/applications/audio/id3v2/default.nix

···
 {stdenv, fetchurl, id3lib, groff, zlib}:
 
-let version = "0.1.12"; in
 stdenv.mkDerivation rec {
   name = "id3v2-${version}";
+  version = "0.1.12";
+
   src = fetchurl {
     url = "mirror://sourceforge/id3v2/${name}.tar.gz";
     sha256 = "1gr22w8gar7zh5pyyvdy7cy26i47l57jp1l1nd60xfwx339zl1c1";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "A command line editor for id3v2 tags";
     homepage = http://id3v2.sourceforge.net/;
     license = licenses.gpl2Plus;

pkgs/applications/audio/keyfinder-cli/default.nix

···
 { stdenv, fetchFromGitHub, libav, libkeyfinder }:
 
-let version = "2015-09-13"; in
 stdenv.mkDerivation rec {
   name = "keyfinder-cli-${version}";
+  version = "2015-09-13";
 
   src = fetchFromGitHub {
     repo = "keyfinder-cli";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Musical key detection for digital audio (command-line tool)";
     longDescription = ''

pkgs/applications/audio/keyfinder/default.nix

···
 { stdenv, fetchFromGitHub, libav_0_8, libkeyfinder, qtbase, qtxmlpatterns, taglib }:
 
-let version = "2.1"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "keyfinder-${version}";
+  version = "2.1";
 
   src = fetchFromGitHub {
     sha256 = "0j9k90ll4cr8j8dywb6zf1bs9vijlx7m4zsh6w9hxwrr7ymz89hn";
···
     owner = "ibsh";
   };
 
+  buildInputs = [ libav_0_8 libkeyfinder qtbase qtxmlpatterns taglib ];
+
+  postPatch = ''
+    substituteInPlace is_KeyFinder.pro \
+       --replace "keyfinder.0" "keyfinder" \
+       --replace '$$[QT_INSTALL_PREFIX]' "$out" \
+       --replace "-stdlib=libc++" ""
+  '';
+
+  configurePhase = ''
+    qmake
+  '';
+
+  enableParallelBuilding = true;
+
   meta = with stdenv.lib; {
-    inherit version;
     description = "Musical key detection for digital audio (graphical UI)";
     longDescription = ''
       KeyFinder is an open source key detection tool, for DJs interested in
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
-
-  buildInputs = [ libav_0_8 libkeyfinder qtbase qtxmlpatterns taglib ];
-
-  postPatch = ''
-    substituteInPlace is_KeyFinder.pro \
-       --replace "keyfinder.0" "keyfinder" \
-       --replace '$$[QT_INSTALL_PREFIX]' "$out" \
-       --replace "-stdlib=libc++" ""
-  '';
-
-  configurePhase = ''
-    qmake
-  '';
-
-  enableParallelBuilding = true;
 }

pkgs/applications/editors/neovim/default.nix

···
 
 let
 
-  version = "0.1.1";
-
   # Note: this is NOT the libvterm already in nixpkgs, but some NIH silliness:
-  neovimLibvterm = let version = "2015-11-06"; in stdenv.mkDerivation {
+  neovimLibvterm = stdenv.mkDerivation rec {
     name = "neovim-libvterm-${version}";
+    version = "2015-11-06";
 
     src = fetchFromGitHub {
       sha256 = "0f9r0wnr9ajcdd6as24igmch0n8s1annycb9f4k0vg6fngwaypy9";
···
     ignoreCollisions = true;
   };
 
-  neovim = stdenv.mkDerivation {
+  neovim = stdenv.mkDerivation rec {
     name = "neovim-${version}";
+    version = "0.1.1";
 
     src = fetchFromGitHub {
       sha256 = "0crswjslp687yp1cpn7nmm0j2sccqhcxryzxv1s81cgpai0fzf60";
···
 
 in if (vimAlias == false && configure == null) then neovim else stdenv.mkDerivation {
   name = "neovim-${version}-configured";
+  inherit (neovim) version;
+
   nativeBuildInputs = [ makeWrapper ];
+
   buildCommand = ''
     mkdir -p $out/bin
     for item in ${neovim}/bin/*; do

pkgs/applications/graphics/apitrace/default.nix

···
 { stdenv, fetchFromGitHub, cmake, libX11, procps, python, qtbase }:
 
-let version = "7.1"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "apitrace-${version}";
+  version = "7.1";
 
   src = fetchFromGitHub {
     sha256 = "1n2gmsjnpyam7isg7n1ksggyh6y1l8drvx0a93bnvbcskr7jiz9a";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     homepage = https://apitrace.github.io;
     description = "Tools to trace OpenGL, OpenGL ES, Direct3D, and DirectDraw APIs";
     license = licenses.mit;

pkgs/applications/graphics/simple-scan/default.nix

···
 { stdenv, fetchurl, cairo, colord, glib, gtk3, gusb, intltool, itstool
 , libusb1, libxml2, pkgconfig, sane-backends, vala, wrapGAppsHook }:
 
-let version = "3.19.4"; in
 stdenv.mkDerivation rec {
   name = "simple-scan-${version}";
+  version = "3.19.4";
 
   src = fetchurl {
     sha256 = "1v9sify1s38qd5sfg26m7sdg9bkrfmai2nijs4wzah7xa9p23c83";
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Simple scanning utility";
     longDescription = ''
       A really easy way to scan both documents and photos. You can crop out the

pkgs/applications/graphics/swingsane/default.nix

···
 { stdenv, fetchurl, makeDesktopItem, unzip, jre }:
 
-let version = "0.2"; in
 stdenv.mkDerivation rec {
   name = "swingsane-${version}";
+  version = "0.2";
 
   src = fetchurl {
     sha256 = "15pgqgyw46yd2i367ax9940pfyvinyw2m8apmwhrn0ix5nywa7ni";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Java GUI for SANE scanner servers (saned)";
     longDescription = ''
       SwingSane is a powerful, cross platform, open source Java front-end for

pkgs/applications/networking/feedreaders/rawdog/default.nix

···
 { stdenv, fetchurl, pythonPackages }:
 
-let version = "2.21"; in
 pythonPackages.buildPythonPackage rec {
   name = "rawdog-${version}";
+  version = "2.21";
 
   src = fetchurl {
     url = "http://offog.org/files/${name}.tar.gz";
···
   namePrefix = "";
   
   meta = with stdenv.lib; {
-    inherit version;
     homepage = "http://offog.org/code/rawdog/";
     description = "RSS Aggregator Without Delusions Of Grandeur";
     license = licenses.gpl2;

pkgs/applications/networking/feedreaders/rsstail/default.nix

···
 { stdenv, fetchFromGitHub, cppcheck, libmrss }:
 
-let version = "2.1"; in
 stdenv.mkDerivation rec {
   name = "rsstail-${version}";
+  version = "2.1";
 
   src = fetchFromGitHub {
     sha256 = "12p69i3g1fwlw0bds9jqsdmzkid3k5a41w31d227i7vm12wcvjf6";
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Monitor RSS feeds for new entries";
     longDescription = ''
       RSSTail is more or less an RSS reader: it monitors an RSS feed and if it

pkgs/applications/networking/remote/x2goclient/default.nix

···
 { stdenv, fetchurl, cups, libssh, libXpm, nxproxy, openldap, makeWrapper, qt4 }:
 
-let version = "4.0.5.0"; in
 stdenv.mkDerivation rec {
   name = "x2goclient-${version}";
+  version = "4.0.5.0";
 
   src = fetchurl {
     url = "http://code.x2go.org/releases/source/x2goclient/${name}.tar.gz";
     sha256 = "18a2pszh0nq2ir64a1ah1mlzddn4qcd12b339bv30n0y1ir92bi4";
-  };
-
-  meta = with stdenv.lib; {
-    description = "Graphical NoMachine NX3 remote desktop client";
-    homepage = http://x2go.org/;
-    license = licenses.gpl2;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
   };
 
   buildInputs = [ cups libssh libXpm nxproxy openldap qt4 ];
···
   postInstall = ''
     wrapProgram "$out/bin/x2goclient" --suffix PATH : "${nxproxy}/bin";
   '';
+
+  meta = with stdenv.lib; {
+    description = "Graphical NoMachine NX3 remote desktop client";
+    homepage = http://x2go.org/;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/applications/networking/vnstat/default.nix

···
 { stdenv, fetchurl, gd, ncurses }:
 
-let version = "1.15"; in
 stdenv.mkDerivation rec {
   name = "vnstat-${version}";
+  version = "1.15";
 
   src = fetchurl {
     sha256 = "0fdw3nbrfm4acv48r0934ls6ld5lwkff3gyym2c72qlbm9dlp0f3";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Console-based network statistics utility for Linux";
     longDescription = ''
       vnStat is a console-based network traffic monitor for Linux and BSD that

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

···
 , asciidoc, docbook_xml_dtd_45, docbook_xsl, libxslt, makeWrapper, xmlto
 , pythonPackages }:
 
-let version = "3.2015-09-08"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "git-bz-${version}";
+  version = "3.2015-09-08";
 
   src = fetchgit {
     sha256 = "19d9c81d4eeabe87079d8f60e4cfa7303f776f5a7c9874642cf2bd188851d029";
     rev = "e17bbae7a2ce454d9f69c32fc40066995d44913d";
     url = "git://git.fishsoup.net/git-bz";
   };
-
 
   nativeBuildInputs = [
     asciidoc docbook_xml_dtd_45 docbook_xsl libxslt makeWrapper xmlto
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Bugzilla integration for git";
     longDescription = ''
       git-bz is a tool for integrating the Git command line with the

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

···
 { stdenv, fetchFromGitHub, docutils, python }:
 
-let version = "0.9.0"; in
 stdenv.mkDerivation rec {
   name = "git-hub-${version}";
+  version = "0.9.0";
 
   src = fetchFromGitHub {
     sha256 = "0c4kq4a906lr8nzway7qh0560n2ydvidh9rlffh44902rd48kp0h";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Git command line interface to GitHub";
     longDescription = ''

pkgs/applications/video/clipgrab/default.nix

···
 { stdenv, fetchurl, makeDesktopItem, ffmpeg, qt4 }:
 
-let version = "3.5.6"; in
 stdenv.mkDerivation rec {
   name = "clipgrab-${version}";
+  version = "3.5.6";
 
   src = fetchurl {
     sha256 = "0wm6hqaq6ydbvvd0fqkfydxd5h7gf4di7lvq63xgxl4z40jqc25n";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Video downloader for YouTube and other sites";
     longDescription = ''
       ClipGrab is a free downloader and converter for YouTube, Vimeo, Metacafe,

pkgs/applications/video/minitube/default.nix

···
 # "Free" API key generated by nckx <[e-mail]>
 , withAPIKey ? "AIzaSyBtFgbln3bu1swQC-naMxMtKh384D3xJZE" }:
 
-let version = "2.4"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "minitube-${version}";
+  version = "2.4";
 
   src = fetchFromGitHub {
     sha256 = "0mm8v2vpspwxh2fqaykb381v6r9apywc1b0x8jkcbp7s43w10lp5";
···
     owner = "flaviotordini";
   };
 
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "Stand-alone YouTube video player";
-    longDescription = ''
-      Watch YouTube videos in a new way: you type a keyword, Minitube gives
-      you an endless video stream. Minitube is not about cloning the YouTube
-      website, it aims to create a new TV-like experience.
-    '';
-    homepage = http://flavio.tordini.org/minitube;
-    license = licenses.gpl3Plus;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
-  };
-
   buildInputs = [ phonon phonon_backend_vlc qt4 ];
   nativeBuildInputs = [ makeWrapper ];
 
···
     wrapProgram $out/bin/minitube \
       --prefix QT_PLUGIN_PATH : "${phonon_backend_vlc}/lib/kde4/plugins"
   '';
+
+  meta = with stdenv.lib; {
+    description = "Stand-alone YouTube video player";
+    longDescription = ''
+      Watch YouTube videos in a new way: you type a keyword, Minitube gives
+      you an endless video stream. Minitube is not about cloning the YouTube
+      website, it aims to create a new TV-like experience.
+    '';
+    homepage = http://flavio.tordini.org/minitube;
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/applications/virtualization/remotebox/default.nix

···
 { stdenv, fetchurl, makeWrapper, perl, perlPackages }:
 
-let version = "2.0"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "remotebox-${version}";
+  version = "2.0";
 
   src = fetchurl {
     url = "http://remotebox.knobgoblin.org.uk/downloads/RemoteBox-${version}.tar.bz2";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "VirtualBox client with remote management";
     homepage = http://remotebox.knobgoblin.org.uk/;
     license = licenses.gpl2Plus;

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

···
 { stdenv, fetchurl }:
 
-let version = "4.04"; in
 stdenv.mkDerivation rec {
   name = "man-pages-${version}";
+  version = "4.04";
 
   src = fetchurl {
     url = "mirror://kernel/linux/docs/man-pages/${name}.tar.xz";
···
   makeFlags = [ "MANDIR=$(out)/share/man" ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Linux development manual pages";
     homepage = http://www.kernel.org/doc/man-pages/;
     repositories.git = http://git.kernel.org/pub/scm/docs/man-pages/man-pages;

pkgs/data/fonts/hack/default.nix

···
 { stdenv, fetchurl, unzip }:
 
-let version = "2.019"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "hack-font-${version}";
+  version = "2.019";
 
   src = let
     version_ = with stdenv.lib;
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "A typeface designed for source code";
     longDescription = ''
       Hack is hand groomed and optically balanced to be a workhorse face for

pkgs/data/misc/sound-theme-freedesktop/default.nix

···
 { stdenv, fetchurl, intltool }:
 
-let version = "0.8"; in
 stdenv.mkDerivation rec {
   name = "sound-theme-freedesktop-${version}";
+  version = "0.8";
 
   src = fetchurl {
     sha256 = "054abv4gmfk9maw93fis0bf605rc56dah7ys5plc4pphxqh8nlfb";
···
   nativeBuildInputs = [ intltool ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Freedesktop reference sound theme";
     homepage = http://freedesktop.org/wiki/Specifications/sound-theme-spec;
     # See http://cgit.freedesktop.org/sound-theme-freedesktop/tree/CREDITS:

pkgs/data/misc/wireless-regdb/default.nix

···
 { stdenv, fetchgit }:
 
-let version = "2015-12-14"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "wireless-regdb-${version}";
+  version = "2015-12-14";
 
   src = fetchgit {
     sha256 = "1ldfcxn3mdb104czy78b7nj1clsbfp8fc6mshix98zq0bg4k7rsm";
···
   ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Wireless regulatory database for CRDA";
     homepage = http://wireless.kernel.org/en/developers/Regulatory/;
     license = licenses.isc;

pkgs/development/compilers/squeak/default.nix

···
 { stdenv, fetchurl, cmake, coreutils, dbus, freetype, glib, gnused
 , libpthreadstubs, pango, pkgconfig, libpulseaudio, which }:
 
-let version = "4.10.2.2614"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "squeak-${version}";
+  version = "4.10.2.2614";
 
   src = fetchurl {
     sha256 = "0bpwbnpy2sb4gylchfx50sha70z36bwgdxraym4vrr93l8pd3dix";
     url = "http://squeakvm.org/unix/release/Squeak-${version}-src.tar.gz";
   };
 
+  buildInputs = [ coreutils dbus freetype glib gnused libpthreadstubs
+    pango libpulseaudio which ];
+  nativeBuildInputs = [ cmake pkgconfig ];
+
+  postPatch = ''
+    for i in squeak.in squeak.sh.in; do
+      substituteInPlace unix/cmake/$i --replace "PATH=" \
+        "PATH=${coreutils}/bin:${gnused}/bin:${which}/bin #"
+    done
+  '';
+
+  configurePhase = ''
+    unix/cmake/configure --prefix=$out --enable-mpg-{mmx,pthreads}
+  '';
+
+  enableParallelBuilding = true;
+
   meta = with stdenv.lib; {
-    inherit version;
     description = "Smalltalk programming language and environment";
     longDescription = ''
       Squeak is a full-featured implementation of the Smalltalk programming
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
-
-  buildInputs = [ coreutils dbus freetype glib gnused libpthreadstubs
-    pango libpulseaudio which ];
-  nativeBuildInputs = [ cmake pkgconfig ];
-
-  postPatch = ''
-    for i in squeak.in squeak.sh.in; do
-      substituteInPlace unix/cmake/$i --replace "PATH=" \
-        "PATH=${coreutils}/bin:${gnused}/bin:${which}/bin #"
-    done
-  '';
-
-  configurePhase = ''
-    unix/cmake/configure --prefix=$out --enable-mpg-{mmx,pthreads}
-  '';
-
-  enableParallelBuilding = true;
 }

pkgs/development/interpreters/picoc/default.nix

···
 { stdenv, fetchFromGitHub, readline }:
 
-let version = "2015-05-04"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "picoc-${version}";
+  version = "2015-05-04";
 
   src = fetchFromGitHub {
     sha256 = "01w3jwl0vn9fsmh7p20ad4nl9ljzgfn576yvncd9pk9frx3pd8y4";
···
     owner = "zsaleeba";
   };
 
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "Very small C interpreter for scripting";
-    longDescription = ''
-      PicoC is a very small C interpreter for scripting. It was originally
-      written as a script language for a UAV's on-board flight system. It's
-      also very suitable for other robotic, embedded and non-embedded
-      applications. The core C source code is around 3500 lines of code. It's
-      not intended to be a complete implementation of ISO C but it has all the
-      essentials. When compiled it only takes a few k of code space and is also
-      very sparing of data space. This means it can work well in small embedded
-      devices.
-    '';
-    homepage = https://github.com/zsaleeba/picoc;
-    downloadPage = https://code.google.com/p/picoc/downloads/list;
-    license = licenses.bsd3;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
-  };
-
   buildInputs = [ readline ];
 
   postPatch = ''
···
     mkdir -p $out/include
     install -m644 *.h $out/include
   '';
+
+  meta = with stdenv.lib; {
+    description = "Very small C interpreter for scripting";
+    longDescription = ''
+      PicoC is a very small C interpreter for scripting. It was originally
+      written as a script language for a UAV's on-board flight system. It's
+      also very suitable for other robotic, embedded and non-embedded
+      applications. The core C source code is around 3500 lines of code. It's
+      not intended to be a complete implementation of ISO C but it has all the
+      essentials. When compiled it only takes a few k of code space and is also
+      very sparing of data space. This means it can work well in small embedded
+      devices.
+    '';
+    homepage = https://github.com/zsaleeba/picoc;
+    downloadPage = https://code.google.com/p/picoc/downloads/list;
+    license = licenses.bsd3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

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

···
 { stdenv, fetchFromGitLab, doxygen, glib, libaccounts-glib, pkgconfig, qtbase }:
 
-let version = "1.13"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "accounts-qt-${version}";
+  version = "1.13";
 
   src = fetchFromGitLab {
     sha256 = "1gpkgw05dwsf2wk5cy3skgss3kw6mqh7iv3fadrxqxfc1za1xmyl";
···
     owner = "accounts-sso";
   };
 
-  meta = with stdenv.lib; {
-    description = "Qt library for accessing the online accounts database";
-    homepage = "http://code.google.com/p/accounts-sso/";
-    license = licenses.lgpl21;
-    maintainers = with maintainers; [ nckx ];
-  };
-
   buildInputs = [ glib libaccounts-glib qtbase ];
   nativeBuildInputs = [ doxygen pkgconfig ];
 
   configurePhase = ''
     qmake PREFIX=$out LIBDIR=$out/lib CMAKE_CONFIG_PATH=$out/lib/cmake
   '';
+
+  meta = with stdenv.lib; {
+    description = "Qt library for accessing the online accounts database";
+    homepage = "http://code.google.com/p/accounts-sso/";
+    license = licenses.lgpl21;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/development/libraries/bobcat/default.nix

···
 { stdenv, fetchFromGitHub, icmake, libmilter, libX11, openssl, readline
 , utillinux, yodl }:
 
-let version = "4.00.00"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "bobcat-${version}";
+  version = "4.00.00";
 
   src = fetchFromGitHub {
     sha256 = "0wdb25sgw7i3jk3lbja6b4ipqfg1sncam6adg2bn8l5fcinrpwgs";
     rev = version;
     repo = "bobcat";
     owner = "fbb-git";
-  };
-
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "Brokken's Own Base Classes And Templates";
-    homepage = https://fbb-git.github.io/bobcat/;
-    license = licenses.gpl3;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
   };
 
   buildInputs = [ libmilter libX11 openssl readline utillinux ];
···
   installPhase = ''
     ./build install
   '';
+
+  meta = with stdenv.lib; {
+    description = "Brokken's Own Base Classes And Templates";
+    homepage = https://fbb-git.github.io/bobcat/;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/development/libraries/ip2location-c/default.nix

···
 { stdenv, fetchurl, autoreconfHook }:
 
-let version = "7.0.2"; in # meta.homepage might change after a major update
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "ip2location-c-${version}";
+  version = "7.0.2"; # meta.homepage might change after a major update
 
   src = fetchurl {
     sha256 = "1gs43qgcyfn83abrkhvvw1s67d1sbkbj3hab9m17ysn6swafiycx";
···
   doCheck = false;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Library to look up locations of host names and IP addresses";
     longDescription = ''
       A C library to find the country, region, city,coordinates,

pkgs/development/libraries/libcli/default.nix

···
 { stdenv, fetchFromGitHub }:
 
-let version = "1.9.7"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "libcli-${version}";
+  version = "1.9.7";
 
   src = fetchFromGitHub {
     sha256 = "08pmjhqkwldhmcwjhi2l27slf1fk6nxxfaihnk2637pqkycy8z0c";

pkgs/development/libraries/libkeyfinder/default.nix

···
 { stdenv, fetchFromGitHub, fftw, qtbase }:
 
-let version = "2.1"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "libkeyfinder-${version}";
+  version = "2.1";
 
   src = fetchFromGitHub {
     sha256 = "07kc0cl6kirgmpdgkgmp6r3yvyf7b1w569z01g8rfl1cig80qdc7";
     rev = "v${version}";
     repo = "libKeyFinder";
     owner = "ibsh";
-  };
-
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "Musical key detection for digital audio (C++ library)";
-    homepage = http://www.ibrahimshaath.co.uk/keyfinder/;
-    license = licenses.gpl3Plus;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
   };
 
   buildInputs = [ fftw qtbase ];
···
     mkdir -p $out/lib
     cp -a lib*.so* $out/lib
   '';
+
+  meta = with stdenv.lib; {
+    description = "Musical key detection for digital audio (C++ library)";
+    homepage = http://www.ibrahimshaath.co.uk/keyfinder/;
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/development/libraries/libnetfilter_conntrack/default.nix

···
 { stdenv, fetchurl, pkgconfig, libnfnetlink, libmnl }:
 
-let version = "1.0.5"; in
 stdenv.mkDerivation rec {
   name = "libnetfilter_conntrack-${version}";
+  version = "1.0.5";
 
   src = fetchurl {
     url = "http://netfilter.org/projects/libnetfilter_conntrack/files/${name}.tar.bz2";
···
   nativeBuildInputs = [ pkgconfig ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Userspace library providing an API to the in-kernel connection tracking state table";
     longDescription = ''
       libnetfilter_conntrack is a userspace library providing a programming interface (API) to the

pkgs/development/libraries/libxcomp/default.nix

···
 { stdenv, fetchurl, autoreconfHook, libjpeg, libpng12, libX11, zlib }:
 
-let version = "3.5.0.32"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "libxcomp-${version}";
+  version = "3.5.0.32";
 
   src = fetchurl {
     sha256 = "02n5bdc1jsq999agb4w6dmdj5l2wlln2lka84qz6rpswwc59zaxm";
     url = "http://code.x2go.org/releases/source/nx-libs/nx-libs-${version}-lite.tar.gz";
   };
 
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "NX compression library";
-    homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";
-    license = licenses.gpl2;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
-  };
-
   buildInputs = [ libjpeg libpng12 libX11 zlib ];
   nativeBuildInputs = [ autoreconfHook ];
 
···
   '';
 
   enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "NX compression library";
+    homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/development/libraries/rote/default.nix

···
 { stdenv, fetchurl, ncurses }:
 
-let version = "0.2.8"; in
 stdenv.mkDerivation rec {
   name = "rote-${version}";
+  version = "0.2.8";
 
   src = fetchurl {
     sha256 = "05v1lw99jv4cwxl7spyi7by61j2scpdsvx809x5cga7dm5dhlmky";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Our Own Terminal Emulation Library";
     longDescription = ''
       ROTE is a simple C library for VT102 terminal emulation. It allows the

pkgs/development/tools/alloy/default.nix

···
 { stdenv, fetchurl, jre, makeDesktopItem }:
 
-let version = "4.2_2015-02-22"; in
 stdenv.mkDerivation rec {
   name = "alloy-${version}";
+  version = "4.2_2015-02-22";
 
   src = fetchurl {
     sha256 = "0p93v8jwx9prijpikkgmfdzb9qn8ljmvga5d9wvrkxddccjx9k28";
     url = "http://alloy.mit.edu/alloy/downloads/alloy${version}.jar";
-  };
-
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "Language & tool for relational models";
-    longDescription = ''
-      Alloy is a language for describing structures and a tool for exploring
-      them. An Alloy model is a collection of constraints that describes a set
-      of structures, e.g. all the possible security configurations of a web
-      application, or all the possible topologies of a switching network. The
-      Alloy Analyzer is a solver that takes the constraints of a model and
-      finds structures that satisfy them. Structures are displayed graphically,
-      and their appearance can be customized for the domain at hand.
-    '';
-    homepage = http://alloy.mit.edu/;
-    downloadPage = http://alloy.mit.edu/alloy/download.html;
-    license = licenses.mit;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
   };
 
   desktopItem = makeDesktopItem rec {
···
     install -Dm644 ${./icon.png} $out/share/pixmaps/alloy.png
     cp -r ${desktopItem}/share/applications $out/share
   '';
+
+  meta = with stdenv.lib; {
+    description = "Language & tool for relational models";
+    longDescription = ''
+      Alloy is a language for describing structures and a tool for exploring
+      them. An Alloy model is a collection of constraints that describes a set
+      of structures, e.g. all the possible security configurations of a web
+      application, or all the possible topologies of a switching network. The
+      Alloy Analyzer is a solver that takes the constraints of a model and
+      finds structures that satisfy them. Structures are displayed graphically,
+      and their appearance can be customized for the domain at hand.
+    '';
+    homepage = http://alloy.mit.edu/;
+    downloadPage = http://alloy.mit.edu/alloy/download.html;
+    license = licenses.mit;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

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

···
 { stdenv, fetchurl, buildPerlPackage }:
 
-let version = "1.10"; in
 buildPerlPackage rec {
   name = "egypt-${version}";
+  version = "1.10";
 
   src = fetchurl {
     sha256 = "0r0wj6v8z9fzlh9pb5617kyjdf92ppmlbzajaarrq729bbb6ln5m";
     url = "http://www.gson.org/egypt/download/${name}.tar.gz";
   };
+
+  enableParallelBuilding = true;
+
+  doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Tool for making call graphs of C programmes";
     longDescription = ''
       Egypt is a simple tool for creating call graphs of C programs. It neither
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
-
-  enableParallelBuilding = true;
-
-  doCheck = true;
 }

pkgs/development/tools/analysis/include-what-you-use/default.nix

···
 { stdenv, fetchurl, cmake, llvmPackages }:
 
-# Also bump llvmPackages in all-packages.nix to the supported version!
-let version = "0.5"; in
 stdenv.mkDerivation rec {
   name = "include-what-you-use-${version}";
+  # Also bump llvmPackages in all-packages.nix to the supported version!
+  version = "0.5";
 
   src = fetchurl {
     sha256 = "19pwhgwvfr86n8ks099p9r02v7zh8d3qs7g7snzkhpdgq1azww85";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Analyze #includes in C/C++ source files with clang";
     longDescription = ''
       For every symbol (type, function variable, or macro) that you use in

pkgs/development/tools/java/cfr/default.nix

···
 { stdenv, fetchurl, jre }:
 
-let version = "0_101"; in
 stdenv.mkDerivation rec {
   name = "cfr-${version}";
+  version = "0_101";
 
   src = fetchurl {
     sha256 = "0zwl3whypdm2qrw3hwaqjnifkb4wcdn8fx9scrjkli54bhr6dqch";
     url = "http://www.benf.org/other/cfr/cfr_${version}.jar";
   };
 
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "Another java decompiler";
-    longDescription = ''
-      CFR will decompile modern Java features - Java 8 lambdas (pre and post
-      Java beta 103 changes), Java 7 String switches etc, but is written
-      entirely in Java 6.
-    '';
-    homepage = http://www.benf.org/other/cfr/;
-    license = licenses.mit;
-    platforms = platforms.all;
-    maintainers = with maintainers; [ nckx ];
-  };
-
   buildInputs = [ jre ];
 
   phases = [ "installPhase" ];
···
     EOF
     install -Dm755 cfr $out/bin/cfr
   '';
+
+  meta = with stdenv.lib; {
+    description = "Another java decompiler";
+    longDescription = ''
+      CFR will decompile modern Java features - Java 8 lambdas (pre and post
+      Java beta 103 changes), Java 7 String switches etc, but is written
+      entirely in Java 6.
+    '';
+    homepage = http://www.benf.org/other/cfr/;
+    license = licenses.mit;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

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

···
 { stdenv, fetchurl, libelf, txt2man }:
 
-let version = "0.2"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "bin_replace_string-${version}";
+  version = "0.2";
 
   src = fetchurl {
     sha256 = "1gnpddxwpsfrg4l76x5yplsvbcdbviybciqpn22yq3g3qgnr5c2a";
     url = "ftp://ohnopub.net/mirror/bin_replace_string-0.2.tar.bz2";
   };
 
+  buildInputs = [ libelf ];
+  nativeBuildInputs = [ txt2man ];
+
+  enableParallelBuilding = true;
+
   meta = with stdenv.lib; {
-    inherit version;
     description = "Edit precompiled binaries";
     longDescription = ''
       bin_replace_string edits C-style strings in precompiled binaries. This is
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
-
-  buildInputs = [ libelf ];
-  nativeBuildInputs = [ txt2man ];
-
-  enableParallelBuilding = true;
 }

pkgs/development/tools/parsing/flexc++/default.nix

···
 { stdenv, fetchFromGitHub, bobcat, icmake, yodl }:
 
-let version = "2.03.00"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "flexc++-${version}";
+  version = "2.03.00";
 
   src = fetchFromGitHub {
     sha256 = "1knb5h6l71n5zi9xzml5f6v7wspbk7vrcaiy2div8bnj7na3z717";
     rev = version;
     repo = "flexcpp";
     owner = "fbb-git";
-  };
-
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "C++ tool for generating lexical scanners";
-    longDescription = ''
-      Flexc++ was designed after `flex'. Flexc++ offers a cleaner class design
-      and requires simpler specification files than offered by flex's C++
-      option.
-    '';
-    homepage = https://fbb-git.github.io/flexcpp/;
-    license = licenses.gpl3;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
   };
 
   sourceRoot = "flexcpp-${version}-src/flexc++";
···
     ./build install skel
     ./build install std
   '';
+
+  meta = with stdenv.lib; {
+    description = "C++ tool for generating lexical scanners";
+    longDescription = ''
+      Flexc++ was designed after `flex'. Flexc++ offers a cleaner class design
+      and requires simpler specification files than offered by flex's C++
+      option.
+    '';
+    homepage = https://fbb-git.github.io/flexcpp/;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/games/2048-in-terminal/default.nix

···
 { stdenv, fetchFromGitHub, ncurses }:
 
-let version = "2015-01-15"; in
 stdenv.mkDerivation rec {
   name = "2048-in-terminal-${version}";
+  version = "2015-01-15";
 
   src = fetchFromGitHub {
     sha256 = "1fdfmyhh60sz0xbilxkh2y09lvbcs9lamk2jkjkhxhlhxknmnfgs";
···
   installFlags = [ "DESTDIR=$(out)" ];
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Animated console version of the 2048 game";
     license = licenses.mit;

pkgs/games/soi/default.nix

···
 { stdenv, fetchurl, cmake
 , boost, eigen2, lua, luabind, mesa, SDL }:
 
-let version = "0.1.2"; in
 stdenv.mkDerivation rec {
   name = "soi-${version}";
+  version = "0.1.2";
 
   src = fetchurl {
     url = "mirror://sourceforge/project/soi/Spheres%20of%20Influence-${version}-Source.tar.bz2";

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

···
 # }
 # (This advice was tested on 2010 August 2.)
 
-{stdenv, fetchurl, cups, gcc, ghostscript, glibc, patchelf}:
+{ stdenv, fetchurl, cups, gcc, ghostscript, glibc, patchelf }:
 
 # Do not bump lightly! Visit <http://www.bchemnet.com/suldr/supported.html>
 # to see what will break when upgrading. Consider a new versioned attribute.
-let version = "4.00.39"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "samsung-UnifiedLinuxDriver-${version}";
+  version = "4.00.39";
 
   src = fetchurl {
     url = "http://www.bchemnet.com/suldr/driver/UnifiedLinuxDriver-${version}.tar.gz";

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

···
 { stdenv, fetchurl, libgcrypt, libnl, pkgconfig, pythonPackages, wireless-regdb }:
 
-let version = "3.18"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "crda-${version}";
+  version = "3.18";
 
   src = fetchurl {
     sha256 = "1gydiqgb08d9gbx4l6gv98zg3pljc984m50hmn3ysxcbkxkvkz23";
···
   checkTarget = "verify";
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Linux wireless Central Regulatory Domain Agent";
     longDescription = ''
       CRDA acts as the udev helper for communication between the kernel and

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

···
 { stdenv, fetchurl, python3, which }:
 
-let version = "0.11"; in
 stdenv.mkDerivation rec {
   name = "fatrace-${version}";
+  version = "0.11";
 
   src = fetchurl {
     url = "http://launchpad.net/fatrace/trunk/${version}/+download/${name}.tar.bz2";
···
   makeFlags = [ "PREFIX=$(out)" ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Report system-wide file access events";
     homepage = https://launchpad.net/fatrace/;
     license = licenses.gpl3Plus;

pkgs/os-specific/linux/firmware/b43-firmware/6.30.163.46.nix

···
 { stdenv, fetchurl, b43FirmwareCutter }:
 
-let version = "6.30.163.46"; in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "b43-firmware-${version}";
+  version = "6.30.163.46";
 
   src = fetchurl {
     url = "http://www.lwfinger.com/b43-firmware/broadcom-wl-${version}.tar.bz2";

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

···
 { stdenv, fetchurl }:
 
-let version = "4.3"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "freefall-${version}";
+  version = "4.3";
 
   src = fetchurl {
     sha256 = "1bpkr45i4yzp32p0vpnz8mlv9lk4q2q9awf1kg9khg4a9g42qqja";

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

···
 { stdenv, fetchurl, ncurses }:
 
-let version = "1.0"; in
 stdenv.mkDerivation rec {
   name = "ftop-${version}";
+  version = "1.0";
 
   src = fetchurl {
     url = "http://ftop.googlecode.com/files/${name}.tar.bz2";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Show progress of open files and file systems";
     homepage = https://code.google.com/p/ftop/;
     license = licenses.gpl3Plus;

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

···
 { stdenv, fetchurl, zlib }:
 
-let version = "2.0.11"; in
 stdenv.mkDerivation rec {
   name = "kexec-tools-${version}";
+  version = "2.0.11";
 
   src = fetchurl {
     urls = [
···
   buildInputs = [ zlib ];
 
   meta = with stdenv.lib; {
-    inherit version;
     homepage = http://horms.net/projects/kexec/kexec-tools;
     description = "Tools related to the kexec Linux feature";
     platforms = platforms.linux;

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

···
 { stdenv, fetchFromGitHub }:
 
-let version = "129"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "mcelog-${version}";
+  version = "129";
 
   src = fetchFromGitHub {
     sha256 = "143xh5zvgax88yhg6mg6img64nrda85yybf76fgsk7a8gc57ghyk";
···
   installFlags = [ "DESTDIR=$(out)" "prefix=" "DOCDIR=/share/doc" ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Log x86 machine checks: memory, IO, and CPU hardware errors";
     longDescription = ''
       The mcelog daemon accounts memory and some other errors in various ways

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

···
 { stdenv, fetchFromGitHub, pkgconfig, gettext, ncurses, libdrm, libpciaccess }:
 
-let version = "2015-11-24"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "radeontop-${version}";
+  version = "2015-11-24";
 
   src = fetchFromGitHub {
     sha256 = "0irwq6rps5mnban8cxbrm59wpyv4j80q3xdjm9fxvfpiyys2g2hz";
···
   makeFlags = [ "PREFIX=$(out)" ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Top-like tool for viewing AMD Radeon GPU utilization";
     longDescription = ''
       View GPU utilization, both for the total activity percent and individual

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

···
 { stdenv, fetchgit, cmake }:
 
-let version = "2015-09-25"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "uksmtools-${version}";
+  version = "2015-09-25";
 
   # This project uses git submodules, which fetchFromGitHub doesn't support:
   src = fetchgit {
···
   doCheck = false;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Tools to control Linux UKSM (Ultra Kernel Same-page Merging)";
     homepage = https://github.com/pfactum/uksmtools/;
     license = licenses.gpl3Plus;

pkgs/shells/mksh/default.nix

···
 { stdenv, fetchurl, groff }:
 
-let version = "52"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "mksh-${version}";
+  version = "52";
 
   src = fetchurl {
     urls = [
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "MirBSD Korn Shell";
     longDescription = ''
       The MirBSD Korn Shell is a DFSG-free and OSD-compliant (and OSI

pkgs/tools/admin/nxproxy/default.nix

···
 { stdenv, fetchurl, autoreconfHook, libxcomp }:
 
-let version = "3.5.0.32"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "nxproxy-${version}";
+  version = "3.5.0.32";
 
   src = fetchurl {
     sha256 = "02n5bdc1jsq999agb4w6dmdj5l2wlln2lka84qz6rpswwc59zaxm";
     url = "http://code.x2go.org/releases/source/nx-libs/nx-libs-${version}-lite.tar.gz";
   };
 
-  meta = with stdenv.lib; {
-    inherit version;
-    description = "NX compression proxy";
-    homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";
-    license = licenses.gpl2;
-    platforms = platforms.linux;
-    maintainers = with maintainers; [ nckx ];
-  };
-
   buildInputs = [ libxcomp ];
   nativeBuildInputs = [ autoreconfHook ];
 
···
   makeFlags = [ "exec_prefix=$(out)" ];
 
   enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "NX compression proxy";
+    homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
 }

pkgs/tools/cd-dvd/dvdisaster/default.nix

···
 , enableSoftening ? true
 }:
 
-let version = "0.79.5"; in
 stdenv.mkDerivation rec {
   name = "dvdisaster-${version}";
+  version = "0.79.5";
 
   src = fetchurl {
     url = "http://dvdisaster.net/downloads/${name}.tar.bz2";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     homepage = http://dvdisaster.net/;
     description = "Data loss/scratch/aging protection for CD/DVD media";
     longDescription = ''

pkgs/tools/compression/lz4/default.nix

···
 { stdenv, fetchFromGitHub, valgrind }:
 
-let version = "131"; in
 stdenv.mkDerivation rec {
   name = "lz4-${version}";
+  version = "131";
 
   src = fetchFromGitHub {
     sha256 = "1bhvcq8fxxsqnpg5qa6k3nsyhq0nl0iarh08sqzclww27hlpyay2";
···
   patches = [ ./install-on-freebsd.patch ] ;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Extremely fast compression algorithm";
     longDescription = ''
       Very fast lossless compression algorithm, providing compression speed

pkgs/tools/compression/zopfli/default.nix

···
 { stdenv, fetchFromGitHub, fetchpatch }:
 
-let version = "1.0.1"; in
 stdenv.mkDerivation rec {
   name = "zopfli-${version}";
+  version = "1.0.1";
 
   src = fetchFromGitHub {
     owner = "google";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Very good, but slow, deflate or zlib compression";
     longDescription = ''

pkgs/tools/filesystems/duff/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, gettext }:
 
-# The last release (0.5.2) is more than 2 years old and lacks features like -D,
-# limiting its usefulness. Upstream appears comatose if not dead.
-let version = "2014-07-03"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "duff-${version}";
+  # The last release (0.5.2) is more than 2 years old and lacks features like -D,
+  # limiting its usefulness. Upstream appears comatose if not dead.
+  version = "2014-07-03";
 
   src = fetchFromGitHub {
     sha256 = "1k2dx38pjzc5d624vw1cs5ipj9fprsm5vqv55agksc29m63lswnx";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Quickly find duplicate files";
     longDescription = ''
       Duff is a Unix command-line utility for quickly finding duplicates in

pkgs/tools/filesystems/encfs/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, boost, fuse, openssl, perl
 , pkgconfig, rlog }:
 
-let version = "1.8.1"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "encfs-${version}";
+  version = "1.8.1";
 
   src = fetchFromGitHub {
     sha256 = "1cxihqwpnqbzy8qz0134199pwfnd7ikr2835p5p1yzqnl203wcdb";

pkgs/tools/filesystems/exfat/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, fuse }:
 
-let version = "1.2.3"; in
 stdenv.mkDerivation rec {
   name = "exfat-${version}";
+  version = "1.2.3";
 
   src = fetchFromGitHub {
     sha256 = "147s11sqmn5flbvz2hwpl6kdfqi2gnm1c2nsn5fxygyw7qyhpzda";
···
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Free exFAT file system implementation";
     platforms = platforms.linux;

pkgs/tools/filesystems/gpart/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook }:
 
-let version = "0.3"; in
 stdenv.mkDerivation rec {
   name = "gpart-${version}";
+  version = "0.3";
 
   # GitHub repository 'collating patches for gpart from all distributions':
   src = fetchFromGitHub {
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Guess PC-type hard disk partitions";
     longDescription = ''

pkgs/tools/filesystems/mp3fs/default.nix

···
 { stdenv, fetchurl, flac, fuse, lame, libid3tag, pkgconfig }:
 
-let version = "0.91"; in
 stdenv.mkDerivation rec {
   name = "mp3fs-${version}";
+  version = "0.91";
 
   src = fetchurl {
     url = "https://github.com/khenriks/mp3fs/releases/download/v${version}/${name}.tar.gz";

pkgs/tools/misc/clex/default.nix

···
 { stdenv, fetchurl, ncurses }:
 
-let version = "4.6.patch6"; in
 stdenv.mkDerivation rec {
   name = "clex-${version}";
+  version = "4.6.patch6";
 
   src = fetchurl {
     sha256 = "0bqa2hc9721d62cfsy5c7a5pzgh9b4px7g4q60xlybkwll19qbbp";
     url = "${meta.homepage}/download/${name}.tar.gz";
   };
+
+  buildInputs = [ ncurses ];
+
+  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     description = "File manager with full-screen terminal interface";
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
-
-  buildInputs = [ ncurses ];
-
-  enableParallelBuilding = true;
 }

pkgs/tools/misc/ipad_charge/default.nix

···
 { stdenv, fetchFromGitHub, libusb1 }:
 
-let version = "2015-02-03"; in
 stdenv.mkDerivation rec {
   name = "ipad_charge-${version}";
+  version = "2015-02-03";
 
   src = fetchFromGitHub {
     sha256 = "0f40hqx1dbqpwrhyf42h5982jwqv8j5zp5hwwakz6600hyqvnnz7";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Apple device USB charging utility for Linux";
     longDescription = ''

pkgs/tools/misc/ms-sys/default.nix

···
 { stdenv, fetchurl, gettext }:
 
-let version = "2.5.2"; in
 stdenv.mkDerivation rec {
   name = "ms-sys-${version}";
+  version = "2.5.2";
  
   src = fetchurl {
     url = "mirror://sourceforge/ms-sys/${name}.tar.gz";
···
   makeFlags = [ "PREFIX=$(out)" ];
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "A program for writing Microsoft compatible boot records";
     homepage = http://ms-sys.sourceforge.net/;
     license = licenses.gpl2Plus;

pkgs/tools/misc/tldr/default.nix

···
 { stdenv, fetchFromGitHub, clang, curl, libzip, pkgconfig }:
 
-let version = "1.1.0"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "tldr-${version}";
+  version = "1.1.0";
 
   src = fetchFromGitHub {
     sha256 = "0hxkrzp5njhy7c19v8i3svcb148f1jni7dlv36gc1nmcrz5izsiz";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Simplified and community-driven man pages";
     longDescription = ''
       tldr pages gives common use cases for commands, so you don't need to hunt

pkgs/tools/networking/dhcping/default.nix

···
 { stdenv, fetchurl }:
 
-let version = "1.2"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "dhcping-${version}";
+  version = "1.2";
 
   src = fetchurl {
     sha256 = "0sk4sg3hn88n44dxikipf3ggfj3ixrp22asb7nry9p0bkfaqdvrj";
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Send DHCP request to find out if a DHCP server is running";
     longDescription = ''
       dhcping sends either a DHCPREQUEST or DHCPINFORM packet to the server
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
- }
+}

pkgs/tools/networking/hans/default.nix

···
 { stdenv, fetchFromGitHub, nettools }:
 
-let version = "0.4.4"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "hans-${version}";
+  version = "0.4.4";
 
   src = fetchFromGitHub {
     sha256 = "1xskffmmdmg1whlrl5wpkv9z29vh0igrbmsz0b45s9v0761a7kis";
···
     owner = "friedrich";
   };
 
+  buildInputs = [ nettools ];
+
+  postPatch = ''
+    substituteInPlace src/tun.cpp --replace "/sbin/" "${nettools}/bin/"
+  '';
+
+  enableParallelBuilding = true;
+
+  installPhase = ''
+    install -D -m0755 hans $out/bin/hans
+  '';
+
   meta = with stdenv.lib; {
-    inherit version;
     description = "Tunnel IPv4 over ICMP";
     longDescription = ''
       Hans makes it possible to tunnel IPv4 through ICMP echo packets, so you
···
     platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
-
-  buildInputs = [ nettools ];
-
-  postPatch = ''
-    substituteInPlace src/tun.cpp --replace "/sbin/" "${nettools}/bin/"
-  '';
-
-  enableParallelBuilding = true;
-
-  installPhase = ''
-    install -D -m0755 hans $out/bin/hans
-  '';
 }

pkgs/tools/networking/ip2location/default.nix

···
 { stdenv, fetchurl }:
 
-let version = "7.0.0"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "ip2location-${version}";
+  version = "7.0.0";
 
   src = fetchurl {
     sha256 = "05zbc02z7vm19byafi05i1rnkxc6yrfkhnm30ly68zzyipkmzx1l";
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Look up locations of host names and IP addresses";
     longDescription = ''
       A command-line tool to find the country, region, city,coordinates,

pkgs/tools/networking/ipv6calc/default.nix

···
 , geoip ? null, geolite-legacy ? null
 , ip2location-database ? null }:
 
-let version = "0.99.1"; in
 stdenv.mkDerivation rec {
   name = "ipv6calc-${version}";
+  version = "0.99.1";
 
   src = fetchurl {
     url = "ftp://ftp.deepspace6.net/pub/ds6/sources/ipv6calc/${name}.tar.gz";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Calculate/manipulate (not only) IPv6 addresses";
     longDescription = ''
       ipv6calc is a small utility to manipulate (not only) IPv6 addresses and

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

···
 , libnetfilter_conntrack, libnl, libpcap, libsodium, liburcu, ncurses, perl
 , pkgconfig, zlib }:
 
-let version = "0.6.0"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "netsniff-ng-${version}";
+  version = "0.6.0";
 
   # Upstream recommends and supports git
   src = fetchFromGitHub rec {
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Swiss army knife for daily Linux network plumbing";
     longDescription = ''
       netsniff-ng is a free Linux networking toolkit. Its gain of performance

pkgs/tools/networking/pcapc/default.nix

···
 { stdenv, fetchFromGitHub, libpcap }:
 
-let version = "2015-03-06"; in
 stdenv.mkDerivation rec {
   name = "pcapc-${version}";
+  version = "2015-03-06";
 
   src = fetchFromGitHub {
     sha256 = "02j45wmxy8qcji0giwx3364pbqb6849s8y0xfvzx40g98mssl027";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     inherit (src.meta) homepage;
     description = "Compile libpcap filter expressions into BPF opcodes";
     license = licenses.gpl3;

pkgs/tools/networking/pingtcp/default.nix

···
 { stdenv, fetchgit, cmake }:
 
-let version = "0.0.3"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "pingtcp-${version}";
+  version = "0.0.3";
 
   # This project uses git submodules, which fetchFromGitHub doesn't support:
   src = fetchgit {
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Measure TCP handshake time";
     homepage = https://github.com/LanetNetwork/pingtcp;
     license = licenses.gpl3;

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

···
 { stdenv, fetchurl, perl, zlib, bzip2, xz, makeWrapper }:
 
-let version = "1.18.4"; in
-
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "dpkg-${version}";
+  version = "1.18.4";
 
   src = fetchurl {
     url = "mirror://debian/pool/main/d/dpkg/dpkg_${version}.tar.xz";

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

···
 { stdenv, fetchurl, intltool, glib, pkgconfig, polkit, python, sqlite }:
 
-let version = "1.0.8"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "packagekit-${version}";
+  version = "1.0.8";
 
   src = fetchurl {
     sha256 = "1vaxn4kwdwx6p03n88k4pnbd2l6lb0cbxpcs88kjack1jml17c3l";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "System to facilitate installing and updating packages";
     longDescription = ''
       PackageKit is a system designed to make installing and updating software

pkgs/tools/security/eid-mw/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, gtk3, nssTools, pcsclite
 , pkgconfig }:
 
-let version = "4.1.13"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "eid-mw-${version}";
+  version = "4.1.13";
 
   src = fetchFromGitHub {
     sha256 = "1fkazhw6gs191w789fnp6mwnxrx9p38b3kh5bngb1ir0zhkgghkq";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Belgian electronic identity card (eID) middleware";
     homepage = http://eid.belgium.be/en/using_your_eid/installing_the_eid_software/linux/;
     license = licenses.lgpl3;

pkgs/tools/security/eid-viewer/default.nix

···
 { stdenv, fetchurl, makeWrapper, jre, pcsclite }:
 
-let version = "4.1.9"; in
 stdenv.mkDerivation rec {
   name = "eid-viewer-${version}";
+  version = "4.1.9";
 
   src = fetchurl {
     url = "https://downloads.services.belgium.be/eid/eid-viewer-${version}-v${version}.src.tar.gz";
···
   doCheck = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Belgian electronic identity card (eID) viewer";
     homepage = http://eid.belgium.be/en/using_your_eid/installing_the_eid_software/linux/;
     license = licenses.lgpl3;

pkgs/tools/system/foremost/default.nix

···
 { stdenv, fetchurl }:
 
-let version = "1.5.7"; in
 stdenv.mkDerivation rec {
   name = "foremost-${version}";
+  version = "1.5.7";
 
   src = fetchurl {
     sha256 = "0d2zxw0ijg8cd3ksgm8cf8jg128zr5x7z779jar90g9f47pm882h";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Recover files based on their contents";
     longDescription = ''
       Foremost is a console program to recover files based on their headers,

pkgs/tools/system/gptfdisk/default.nix

···
 { fetchurl, stdenv, libuuid, popt, icu, ncurses }:
 
-let version = "1.0.1"; in
 stdenv.mkDerivation rec {
   name = "gptfdisk-${version}";
+  version = "1.0.1";
 
   src = fetchurl {
     # http://www.rodsbooks.com/gdisk/${name}.tar.gz also works, but the home
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Set of text-mode partitioning tools for Globally Unique Identifier (GUID) Partition Table (GPT) disks";
     license = licenses.gpl2;
     homepage = http://www.rodsbooks.com/gdisk/;

pkgs/tools/system/suid-chroot/default.nix

···
 { stdenv, fetchurl }:
 
-let version = "1.0.2"; in
 stdenv.mkDerivation rec {
   name = "suid-chroot-${version}";
+  version = "1.0.2";
 
   src = fetchurl {
     sha256 = "1a9xqhck0ikn8kfjk338h9v1yjn113gd83q0c50k78xa68xrnxjx";
···
   '';
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "Setuid-safe wrapper for chroot";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ nckx ];

pkgs/tools/text/aha/default.nix

···
 { stdenv, fetchFromGitHub }:
 
-let version = "0.4.8"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "aha-${version}";
+  version = "0.4.8";
 
   src = fetchFromGitHub {
     sha256 = "1209rda6kc9x88b47y1035zs9lxk0x3qzsb87f8m5b55fdkgxqlj";
···
   enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
-    inherit version;
     description = "ANSI HTML Adapter";
     longDescription = ''
       aha takes ANSI SGR-coloured input and produces W3C-conformant HTML code.