commit 9fb8020e4ec2e74e39a8f28dfb3ef18a70bd1eef · pyrox.dev/nixpkgs

+2 -3

pkgs/applications/audio/fmit/default.nix

···

       7
       7
        
       assert jackSupport -> libjack2 != null;

     

       8
       8
        
       assert portaudioSupport -> portaudio != null;

     

       9
       9
        
       

     

       10
       10
       -
       let version = "1.0.8"; in

     

       11
       11
       -
       stdenv.mkDerivation {

     

       10
       10
       +
       stdenv.mkDerivation rec {

     

       12
       11
        
         name = "fmit-${version}";

     

       12
       12
       +
         version = "1.0.8";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           sha256 = "04s7xcgmi5g58lirr48vf203n1jwdxf981x1p6ysbax24qwhs2kd";

     
···

       37
       37
        
         enableParallelBuilding = true;

     

       38
       38
        
       

     

       39
       39
        
         meta = with stdenv.lib; {

     

       40
       40
       -
           inherit version;

     

       41
       40
        
           description = "Free Musical Instrument Tuner";

     

       42
       41
        
           longDescription = ''

     

       43
       42
        
             FMIT is a graphical utility for tuning musical instruments, with error

+2 -2

pkgs/applications/audio/id3v2/default.nix

···

       1
       1
        
       {stdenv, fetchurl, id3lib, groff, zlib}:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.1.12"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "id3v2-${version}";

     

       5
       5
       +
         version = "0.1.12";

     

       6
       6
       +
       

     

       6
       7
        
         src = fetchurl {

     

       7
       8
        
           url = "mirror://sourceforge/id3v2/${name}.tar.gz";

     

       8
       9
        
           sha256 = "1gr22w8gar7zh5pyyvdy7cy26i47l57jp1l1nd60xfwx339zl1c1";

     
···

       19
       20
        
         '';

     

       20
       21
        
       

     

       21
       22
        
         meta = with stdenv.lib; {

     

       22
       22
       -
           inherit version;

     

       23
       23
        
           description = "A command line editor for id3v2 tags";

     

       24
       24
        
           homepage = http://id3v2.sourceforge.net/;

     

       25
       25
        
           license = licenses.gpl2Plus;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, libav, libkeyfinder }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-09-13"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "keyfinder-cli-${version}";

     

       5
       5
       +
         version = "2015-09-13";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           repo = "keyfinder-cli";

     
···

       18
       18
        
         enableParallelBuilding = true;

     

       19
       19
        
       

     

       20
       20
        
         meta = with stdenv.lib; {

     

       21
       21
       -
           inherit version;

     

       22
       21
        
           inherit (src.meta) homepage;

     

       23
       22
        
           description = "Musical key detection for digital audio (command-line tool)";

     

       24
       23
        
           longDescription = ''

+17 -18

pkgs/applications/audio/keyfinder/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, libav_0_8, libkeyfinder, qtbase, qtxmlpatterns, taglib }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.1"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "keyfinder-${version}";

     

       5
       5
       +
         version = "2.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "0j9k90ll4cr8j8dywb6zf1bs9vijlx7m4zsh6w9hxwrr7ymz89hn";

     
···

       11
       11
        
           owner = "ibsh";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       +
         buildInputs = [ libav_0_8 libkeyfinder qtbase qtxmlpatterns taglib ];

     

       15
       15
       +
       

     

       16
       16
       +
         postPatch = ''

     

       17
       17
       +
           substituteInPlace is_KeyFinder.pro \

     

       18
       18
       +
              --replace "keyfinder.0" "keyfinder" \

     

       19
       19
       +
              --replace '$$[QT_INSTALL_PREFIX]' "$out" \

     

       20
       20
       +
              --replace "-stdlib=libc++" ""

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         configurePhase = ''

     

       24
       24
       +
           qmake

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         enableParallelBuilding = true;

     

       28
       28
       +
       

     

       14
       29
        
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       30
        
           description = "Musical key detection for digital audio (graphical UI)";

     

       17
       31
        
           longDescription = ''

     

       18
       32
        
             KeyFinder is an open source key detection tool, for DJs interested in

     
···

       28
       42
        
           platforms = platforms.linux;

     

       29
       43
        
           maintainers = with maintainers; [ nckx ];

     

       30
       44
        
         };

     

       31
       31
       -
       

     

       32
       32
       -
         buildInputs = [ libav_0_8 libkeyfinder qtbase qtxmlpatterns taglib ];

     

       33
       33
       -
       

     

       34
       34
       -
         postPatch = ''

     

       35
       35
       -
           substituteInPlace is_KeyFinder.pro \

     

       36
       36
       -
              --replace "keyfinder.0" "keyfinder" \

     

       37
       37
       -
              --replace '$$[QT_INSTALL_PREFIX]' "$out" \

     

       38
       38
       -
              --replace "-stdlib=libc++" ""

     

       39
       39
       -
         '';

     

       40
       40
       -
       

     

       41
       41
       -
         configurePhase = ''

     

       42
       42
       -
           qmake

     

       43
       43
       -
         '';

     

       44
       44
       -
       

     

       45
       45
       -
         enableParallelBuilding = true;

     

       46
       45
        
       }

+7 -4

pkgs/applications/editors/neovim/default.nix

···

       15
       15
        
       

     

       16
       16
        
       let

     

       17
       17
        
       

     

       18
       18
       -
         version = "0.1.1";

     

       19
       19
       -
       

     

       20
       18
        
         # Note: this is NOT the libvterm already in nixpkgs, but some NIH silliness:

     

       21
       21
       -
         neovimLibvterm = let version = "2015-11-06"; in stdenv.mkDerivation {

     

       19
       19
       +
         neovimLibvterm = stdenv.mkDerivation rec {

     

       22
       20
        
           name = "neovim-libvterm-${version}";

     

       21
       21
       +
           version = "2015-11-06";

     

       23
       22
        
       

     

       24
       23
        
           src = fetchFromGitHub {

     

       25
       24
        
             sha256 = "0f9r0wnr9ajcdd6as24igmch0n8s1annycb9f4k0vg6fngwaypy9";

     
···

       59
       58
        
           ignoreCollisions = true;

     

       60
       59
        
         };

     

       61
       60
        
       

     

       62
       62
       -
         neovim = stdenv.mkDerivation {

     

       61
       61
       +
         neovim = stdenv.mkDerivation rec {

     

       63
       62
        
           name = "neovim-${version}";

     

       63
       63
       +
           version = "0.1.1";

     

       64
       64
        
       

     

       65
       65
        
           src = fetchFromGitHub {

     

       66
       66
        
             sha256 = "0crswjslp687yp1cpn7nmm0j2sccqhcxryzxv1s81cgpai0fzf60";

     
···

       146
       146
        
       

     

       147
       147
        
       in if (vimAlias == false && configure == null) then neovim else stdenv.mkDerivation {

     

       148
       148
        
         name = "neovim-${version}-configured";

     

       149
       149
       +
         inherit (neovim) version;

     

       150
       150
       +
       

     

       149
       151
        
         nativeBuildInputs = [ makeWrapper ];

     

       152
       152
       +
       

     

       150
       153
        
         buildCommand = ''

     

       151
       154
        
           mkdir -p $out/bin

     

       152
       155
        
           for item in ${neovim}/bin/*; do

+2 -3

pkgs/applications/graphics/apitrace/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, cmake, libX11, procps, python, qtbase }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "7.1"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "apitrace-${version}";

     

       5
       5
       +
         version = "7.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "1n2gmsjnpyam7isg7n1ksggyh6y1l8drvx0a93bnvbcskr7jiz9a";

     
···

       20
       20
        
         '';

     

       21
       21
        
       

     

       22
       22
        
         meta = with stdenv.lib; {

     

       23
       23
       -
           inherit version;

     

       24
       23
        
           homepage = https://apitrace.github.io;

     

       25
       24
        
           description = "Tools to trace OpenGL, OpenGL ES, Direct3D, and DirectDraw APIs";

     

       26
       25
        
           license = licenses.mit;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, cairo, colord, glib, gtk3, gusb, intltool, itstool

     

       2
       2
        
       , libusb1, libxml2, pkgconfig, sane-backends, vala, wrapGAppsHook }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "3.19.4"; in

     

       5
       4
        
       stdenv.mkDerivation rec {

     

       6
       5
        
         name = "simple-scan-${version}";

     

       6
       6
       +
         version = "3.19.4";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           sha256 = "1v9sify1s38qd5sfg26m7sdg9bkrfmai2nijs4wzah7xa9p23c83";

     
···

       26
       26
        
         doCheck = true;

     

       27
       27
        
       

     

       28
       28
        
         meta = with stdenv.lib; {

     

       29
       29
       -
           inherit version;

     

       30
       29
        
           description = "Simple scanning utility";

     

       31
       30
        
           longDescription = ''

     

       32
       31
        
             A really easy way to scan both documents and photos. You can crop out the

+1 -2

pkgs/applications/graphics/swingsane/default.nix

···

       1
       1
        
       { stdenv, fetchurl, makeDesktopItem, unzip, jre }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.2"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "swingsane-${version}";

     

       5
       5
       +
         version = "0.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "15pgqgyw46yd2i367ax9940pfyvinyw2m8apmwhrn0ix5nywa7ni";

     
···

       44
       44
        
         '';

     

       45
       45
        
       

     

       46
       46
        
         meta = with stdenv.lib; {

     

       47
       47
       -
           inherit version;

     

       48
       47
        
           description = "Java GUI for SANE scanner servers (saned)";

     

       49
       48
        
           longDescription = ''

     

       50
       49
        
             SwingSane is a powerful, cross platform, open source Java front-end for

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, pythonPackages }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.21"; in

     

       4
       3
        
       pythonPackages.buildPythonPackage rec {

     

       5
       4
        
         name = "rawdog-${version}";

     

       5
       5
       +
         version = "2.21";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://offog.org/files/${name}.tar.gz";

     
···

       14
       14
        
         namePrefix = "";

     

       15
       15
        
         

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       17
        
           homepage = "http://offog.org/code/rawdog/";

     

       19
       18
        
           description = "RSS Aggregator Without Delusions Of Grandeur";

     

       20
       19
        
           license = licenses.gpl2;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, cppcheck, libmrss }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.1"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "rsstail-${version}";

     

       5
       5
       +
         version = "2.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "12p69i3g1fwlw0bds9jqsdmzkid3k5a41w31d227i7vm12wcvjf6";

     
···

       24
       24
        
         doCheck = true;

     

       25
       25
        
       

     

       26
       26
        
         meta = with stdenv.lib; {

     

       27
       27
       -
           inherit version;

     

       28
       27
        
           description = "Monitor RSS feeds for new entries";

     

       29
       28
        
           longDescription = ''

     

       30
       29
        
             RSSTail is more or less an RSS reader: it monitors an RSS feed and if it

+9 -9

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

···

       1
       1
        
       { stdenv, fetchurl, cups, libssh, libXpm, nxproxy, openldap, makeWrapper, qt4 }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "4.0.5.0"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "x2goclient-${version}";

     

       5
       5
       +
         version = "4.0.5.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://code.x2go.org/releases/source/x2goclient/${name}.tar.gz";

     

       9
       9
        
           sha256 = "18a2pszh0nq2ir64a1ah1mlzddn4qcd12b339bv30n0y1ir92bi4";

     

       10
       10
       -
         };

     

       11
       11
       -
       

     

       12
       12
       -
         meta = with stdenv.lib; {

     

       13
       13
       -
           description = "Graphical NoMachine NX3 remote desktop client";

     

       14
       14
       -
           homepage = http://x2go.org/;

     

       15
       15
       -
           license = licenses.gpl2;

     

       16
       16
       -
           platforms = platforms.linux;

     

       17
       17
       -
           maintainers = with maintainers; [ nckx ];

     

       18
       10
        
         };

     

       19
       11
        
       

     

       20
       12
        
         buildInputs = [ cups libssh libXpm nxproxy openldap qt4 ];

     
···

       35
       27
        
         postInstall = ''

     

       36
       28
        
           wrapProgram "$out/bin/x2goclient" --suffix PATH : "${nxproxy}/bin";

     

       37
       29
        
         '';

     

       30
       30
       +
       

     

       31
       31
       +
         meta = with stdenv.lib; {

     

       32
       32
       +
           description = "Graphical NoMachine NX3 remote desktop client";

     

       33
       33
       +
           homepage = http://x2go.org/;

     

       34
       34
       +
           license = licenses.gpl2;

     

       35
       35
       +
           platforms = platforms.linux;

     

       36
       36
       +
           maintainers = with maintainers; [ nckx ];

     

       37
       37
       +
         };

     

       38
       38
        
       }

+1 -2

pkgs/applications/networking/vnstat/default.nix

···

       1
       1
        
       { stdenv, fetchurl, gd, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.15"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "vnstat-${version}";

     

       5
       5
       +
         version = "1.15";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0fdw3nbrfm4acv48r0934ls6ld5lwkff3gyym2c72qlbm9dlp0f3";

     
···

       16
       16
        
         '';

     

       17
       17
        
       

     

       18
       18
        
         meta = with stdenv.lib; {

     

       19
       19
       -
           inherit version;

     

       20
       19
        
           description = "Console-based network statistics utility for Linux";

     

       21
       20
        
           longDescription = ''

     

       22
       21
        
             vnStat is a console-based network traffic monitor for Linux and BSD that

+2 -4

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

···

       2
       2
        
       , asciidoc, docbook_xml_dtd_45, docbook_xsl, libxslt, makeWrapper, xmlto

     

       3
       3
        
       , pythonPackages }:

     

       4
       4
        
       

     

       5
       5
       -
       let version = "3.2015-09-08"; in

     

       6
       6
       -
       stdenv.mkDerivation {

     

       5
       5
       +
       stdenv.mkDerivation rec {

     

       7
       6
        
         name = "git-bz-${version}";

     

       7
       7
       +
         version = "3.2015-09-08";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchgit {

     

       10
       10
        
           sha256 = "19d9c81d4eeabe87079d8f60e4cfa7303f776f5a7c9874642cf2bd188851d029";

     

       11
       11
        
           rev = "e17bbae7a2ce454d9f69c32fc40066995d44913d";

     

       12
       12
        
           url = "git://git.fishsoup.net/git-bz";

     

       13
       13
        
         };

     

       14
       14
       -
       

     

       15
       14
        
       

     

       16
       15
        
         nativeBuildInputs = [

     

       17
       16
        
           asciidoc docbook_xml_dtd_45 docbook_xsl libxslt makeWrapper xmlto

     
···

       32
       31
        
         '';

     

       33
       32
        
       

     

       34
       33
        
         meta = with stdenv.lib; {

     

       35
       35
       -
           inherit version;

     

       36
       34
        
           description = "Bugzilla integration for git";

     

       37
       35
        
           longDescription = ''

     

       38
       36
        
             git-bz is a tool for integrating the Git command line with the

+1 -2

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, docutils, python }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.9.0"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "git-hub-${version}";

     

       5
       5
       +
         version = "0.9.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "0c4kq4a906lr8nzway7qh0560n2ydvidh9rlffh44902rd48kp0h";

     
···

       29
       29
        
         '';

     

       30
       30
        
       

     

       31
       31
        
         meta = with stdenv.lib; {

     

       32
       32
       -
           inherit version;

     

       33
       32
        
           inherit (src.meta) homepage;

     

       34
       33
        
           description = "Git command line interface to GitHub";

     

       35
       34
        
           longDescription = ''

+1 -2

pkgs/applications/video/clipgrab/default.nix

···

       1
       1
        
       { stdenv, fetchurl, makeDesktopItem, ffmpeg, qt4 }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "3.5.6"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "clipgrab-${version}";

     

       5
       5
       +
         version = "3.5.6";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0wm6hqaq6ydbvvd0fqkfydxd5h7gf4di7lvq63xgxl4z40jqc25n";

     
···

       41
       41
        
         '';

     

       42
       42
        
       

     

       43
       43
        
         meta = with stdenv.lib; {

     

       44
       44
       -
           inherit version;

     

       45
       44
        
           description = "Video downloader for YouTube and other sites";

     

       46
       45
        
           longDescription = ''

     

       47
       46
        
             ClipGrab is a free downloader and converter for YouTube, Vimeo, Metacafe,

+15 -16

pkgs/applications/video/minitube/default.nix

···

       2
       2
        
       # "Free" API key generated by nckx <tobias.geerinckx.rice@gmail.com>

     

       3
       3
        
       , withAPIKey ? "AIzaSyBtFgbln3bu1swQC-naMxMtKh384D3xJZE" }:

     

       4
       4
        
       

     

       5
       5
       -
       let version = "2.4"; in

     

       6
       6
       -
       stdenv.mkDerivation {

     

       5
       5
       +
       stdenv.mkDerivation rec {

     

       7
       6
        
         name = "minitube-${version}";

     

       7
       7
       +
         version = "2.4";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           sha256 = "0mm8v2vpspwxh2fqaykb381v6r9apywc1b0x8jkcbp7s43w10lp5";

     
···

       13
       13
        
           owner = "flaviotordini";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
       -
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       18
       -
           description = "Stand-alone YouTube video player";

     

       19
       19
       -
           longDescription = ''

     

       20
       20
       -
             Watch YouTube videos in a new way: you type a keyword, Minitube gives

     

       21
       21
       -
             you an endless video stream. Minitube is not about cloning the YouTube

     

       22
       22
       -
             website, it aims to create a new TV-like experience.

     

       23
       23
       -
           '';

     

       24
       24
       -
           homepage = http://flavio.tordini.org/minitube;

     

       25
       25
       -
           license = licenses.gpl3Plus;

     

       26
       26
       -
           platforms = platforms.linux;

     

       27
       27
       -
           maintainers = with maintainers; [ nckx ];

     

       28
       28
       -
         };

     

       29
       29
       -
       

     

       30
       16
        
         buildInputs = [ phonon phonon_backend_vlc qt4 ];

     

       31
       17
        
         nativeBuildInputs = [ makeWrapper ];

     

       32
       18
        
       

     
···

       40
       26
        
           wrapProgram $out/bin/minitube \

     

       41
       27
        
             --prefix QT_PLUGIN_PATH : "${phonon_backend_vlc}/lib/kde4/plugins"

     

       42
       28
        
         '';

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with stdenv.lib; {

     

       31
       31
       +
           description = "Stand-alone YouTube video player";

     

       32
       32
       +
           longDescription = ''

     

       33
       33
       +
             Watch YouTube videos in a new way: you type a keyword, Minitube gives

     

       34
       34
       +
             you an endless video stream. Minitube is not about cloning the YouTube

     

       35
       35
       +
             website, it aims to create a new TV-like experience.

     

       36
       36
       +
           '';

     

       37
       37
       +
           homepage = http://flavio.tordini.org/minitube;

     

       38
       38
       +
           license = licenses.gpl3Plus;

     

       39
       39
       +
           platforms = platforms.linux;

     

       40
       40
       +
           maintainers = with maintainers; [ nckx ];

     

       41
       41
       +
         };

     

       43
       42
        
       }

+2 -3

pkgs/applications/virtualization/remotebox/default.nix

···

       1
       1
        
       { stdenv, fetchurl, makeWrapper, perl, perlPackages }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.0"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "remotebox-${version}";

     

       5
       5
       +
         version = "2.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://remotebox.knobgoblin.org.uk/downloads/RemoteBox-${version}.tar.bz2";

     
···

       26
       26
        
         '';

     

       27
       27
        
       

     

       28
       28
        
         meta = with stdenv.lib; {

     

       29
       29
       -
           inherit version;

     

       30
       29
        
           description = "VirtualBox client with remote management";

     

       31
       30
        
           homepage = http://remotebox.knobgoblin.org.uk/;

     

       32
       31
        
           license = licenses.gpl2Plus;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "4.04"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "man-pages-${version}";

     

       5
       5
       +
         version = "4.04";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/docs/man-pages/${name}.tar.xz";

     
···

       12
       12
        
         makeFlags = [ "MANDIR=$(out)/share/man" ];

     

       13
       13
        
       

     

       14
       14
        
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       15
        
           description = "Linux development manual pages";

     

       17
       16
        
           homepage = http://www.kernel.org/doc/man-pages/;

     

       18
       17
        
           repositories.git = http://git.kernel.org/pub/scm/docs/man-pages/man-pages;

+2 -3

pkgs/data/fonts/hack/default.nix

···

       1
       1
        
       { stdenv, fetchurl, unzip }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.019"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "hack-font-${version}";

     

       5
       5
       +
         version = "2.019";

     

       6
       6
        
       

     

       7
       7
        
         src = let

     

       8
       8
        
           version_ = with stdenv.lib;

     
···

       22
       22
        
         '';

     

       23
       23
        
       

     

       24
       24
        
         meta = with stdenv.lib; {

     

       25
       25
       -
           inherit version;

     

       26
       25
        
           description = "A typeface designed for source code";

     

       27
       26
        
           longDescription = ''

     

       28
       27
        
             Hack is hand groomed and optically balanced to be a workhorse face for

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, intltool }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.8"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "sound-theme-freedesktop-${version}";

     

       5
       5
       +
         version = "0.8";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "054abv4gmfk9maw93fis0bf605rc56dah7ys5plc4pphxqh8nlfb";

     
···

       12
       12
        
         nativeBuildInputs = [ intltool ];

     

       13
       13
        
       

     

       14
       14
        
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       15
        
           description = "Freedesktop reference sound theme";

     

       17
       16
        
           homepage = http://freedesktop.org/wiki/Specifications/sound-theme-spec;

     

       18
       17
        
           # See http://cgit.freedesktop.org/sound-theme-freedesktop/tree/CREDITS:

+2 -3

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

···

       1
       1
        
       { stdenv, fetchgit }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-12-14"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "wireless-regdb-${version}";

     

       5
       5
       +
         version = "2015-12-14";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchgit {

     

       8
       8
        
           sha256 = "1ldfcxn3mdb104czy78b7nj1clsbfp8fc6mshix98zq0bg4k7rsm";

     
···

       18
       18
        
         ];

     

       19
       19
        
       

     

       20
       20
        
         meta = with stdenv.lib; {

     

       21
       21
       -
           inherit version;

     

       22
       21
        
           description = "Wireless regulatory database for CRDA";

     

       23
       22
        
           homepage = http://wireless.kernel.org/en/developers/Regulatory/;

     

       24
       23
        
           license = licenses.isc;

+19 -20

pkgs/development/compilers/squeak/default.nix

···

       1
       1
        
       { stdenv, fetchurl, cmake, coreutils, dbus, freetype, glib, gnused

     

       2
       2
        
       , libpthreadstubs, pango, pkgconfig, libpulseaudio, which }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "4.10.2.2614"; in

     

       5
       5
       -
       stdenv.mkDerivation {

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       6
       5
        
         name = "squeak-${version}";

     

       6
       6
       +
         version = "4.10.2.2614";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           sha256 = "0bpwbnpy2sb4gylchfx50sha70z36bwgdxraym4vrr93l8pd3dix";

     

       10
       10
        
           url = "http://squeakvm.org/unix/release/Squeak-${version}-src.tar.gz";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
       +
         buildInputs = [ coreutils dbus freetype glib gnused libpthreadstubs

     

       14
       14
       +
           pango libpulseaudio which ];

     

       15
       15
       +
         nativeBuildInputs = [ cmake pkgconfig ];

     

       16
       16
       +
       

     

       17
       17
       +
         postPatch = ''

     

       18
       18
       +
           for i in squeak.in squeak.sh.in; do

     

       19
       19
       +
             substituteInPlace unix/cmake/$i --replace "PATH=" \

     

       20
       20
       +
               "PATH=${coreutils}/bin:${gnused}/bin:${which}/bin #"

     

       21
       21
       +
           done

     

       22
       22
       +
         '';

     

       23
       23
       +
       

     

       24
       24
       +
         configurePhase = ''

     

       25
       25
       +
           unix/cmake/configure --prefix=$out --enable-mpg-{mmx,pthreads}

     

       26
       26
       +
         '';

     

       27
       27
       +
       

     

       28
       28
       +
         enableParallelBuilding = true;

     

       29
       29
       +
       

     

       13
       30
        
         meta = with stdenv.lib; {

     

       14
       14
       -
           inherit version;

     

       15
       31
        
           description = "Smalltalk programming language and environment";

     

       16
       32
        
           longDescription = ''

     

       17
       33
        
             Squeak is a full-featured implementation of the Smalltalk programming

     
···

       27
       43
        
           platforms = platforms.linux;

     

       28
       44
        
           maintainers = with maintainers; [ nckx ];

     

       29
       45
        
         };

     

       30
       30
       -
       

     

       31
       31
       -
         buildInputs = [ coreutils dbus freetype glib gnused libpthreadstubs

     

       32
       32
       -
           pango libpulseaudio which ];

     

       33
       33
       -
         nativeBuildInputs = [ cmake pkgconfig ];

     

       34
       34
       -
       

     

       35
       35
       -
         postPatch = ''

     

       36
       36
       -
           for i in squeak.in squeak.sh.in; do

     

       37
       37
       -
             substituteInPlace unix/cmake/$i --replace "PATH=" \

     

       38
       38
       -
               "PATH=${coreutils}/bin:${gnused}/bin:${which}/bin #"

     

       39
       39
       -
           done

     

       40
       40
       -
         '';

     

       41
       41
       -
       

     

       42
       42
       -
         configurePhase = ''

     

       43
       43
       -
           unix/cmake/configure --prefix=$out --enable-mpg-{mmx,pthreads}

     

       44
       44
       -
         '';

     

       45
       45
       -
       

     

       46
       46
       -
         enableParallelBuilding = true;

     

       47
       46
        
       }

+21 -22

pkgs/development/interpreters/picoc/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, readline }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-05-04"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "picoc-${version}";

     

       5
       5
       +
         version = "2015-05-04";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "01w3jwl0vn9fsmh7p20ad4nl9ljzgfn576yvncd9pk9frx3pd8y4";

     
···

       11
       11
        
           owner = "zsaleeba";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       16
       -
           description = "Very small C interpreter for scripting";

     

       17
       17
       -
           longDescription = ''

     

       18
       18
       -
             PicoC is a very small C interpreter for scripting. It was originally

     

       19
       19
       -
             written as a script language for a UAV's on-board flight system. It's

     

       20
       20
       -
             also very suitable for other robotic, embedded and non-embedded

     

       21
       21
       -
             applications. The core C source code is around 3500 lines of code. It's

     

       22
       22
       -
             not intended to be a complete implementation of ISO C but it has all the

     

       23
       23
       -
             essentials. When compiled it only takes a few k of code space and is also

     

       24
       24
       -
             very sparing of data space. This means it can work well in small embedded

     

       25
       25
       -
             devices.

     

       26
       26
       -
           '';

     

       27
       27
       -
           homepage = https://github.com/zsaleeba/picoc;

     

       28
       28
       -
           downloadPage = https://code.google.com/p/picoc/downloads/list;

     

       29
       29
       -
           license = licenses.bsd3;

     

       30
       30
       -
           platforms = platforms.linux;

     

       31
       31
       -
           maintainers = with maintainers; [ nckx ];

     

       32
       32
       -
         };

     

       33
       33
       -
       

     

       34
       14
        
         buildInputs = [ readline ];

     

       35
       15
        
       

     

       36
       16
        
         postPatch = ''

     
···

       50
       30
        
           mkdir -p $out/include

     

       51
       31
        
           install -m644 *.h $out/include

     

       52
       32
        
         '';

     

       33
       33
       +
       

     

       34
       34
       +
         meta = with stdenv.lib; {

     

       35
       35
       +
           description = "Very small C interpreter for scripting";

     

       36
       36
       +
           longDescription = ''

     

       37
       37
       +
             PicoC is a very small C interpreter for scripting. It was originally

     

       38
       38
       +
             written as a script language for a UAV's on-board flight system. It's

     

       39
       39
       +
             also very suitable for other robotic, embedded and non-embedded

     

       40
       40
       +
             applications. The core C source code is around 3500 lines of code. It's

     

       41
       41
       +
             not intended to be a complete implementation of ISO C but it has all the

     

       42
       42
       +
             essentials. When compiled it only takes a few k of code space and is also

     

       43
       43
       +
             very sparing of data space. This means it can work well in small embedded

     

       44
       44
       +
             devices.

     

       45
       45
       +
           '';

     

       46
       46
       +
           homepage = https://github.com/zsaleeba/picoc;

     

       47
       47
       +
           downloadPage = https://code.google.com/p/picoc/downloads/list;

     

       48
       48
       +
           license = licenses.bsd3;

     

       49
       49
       +
           platforms = platforms.linux;

     

       50
       50
       +
           maintainers = with maintainers; [ nckx ];

     

       51
       51
       +
         };

     

       53
       52
        
       }

+9 -9

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

···

       1
       1
        
       { stdenv, fetchFromGitLab, doxygen, glib, libaccounts-glib, pkgconfig, qtbase }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.13"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "accounts-qt-${version}";

     

       5
       5
       +
         version = "1.13";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitLab {

     

       8
       8
        
           sha256 = "1gpkgw05dwsf2wk5cy3skgss3kw6mqh7iv3fadrxqxfc1za1xmyl";

     
···

       11
       11
        
           owner = "accounts-sso";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         meta = with stdenv.lib; {

     

       15
       15
       -
           description = "Qt library for accessing the online accounts database";

     

       16
       16
       -
           homepage = "http://code.google.com/p/accounts-sso/";

     

       17
       17
       -
           license = licenses.lgpl21;

     

       18
       18
       -
           maintainers = with maintainers; [ nckx ];

     

       19
       19
       -
         };

     

       20
       20
       -
       

     

       21
       14
        
         buildInputs = [ glib libaccounts-glib qtbase ];

     

       22
       15
        
         nativeBuildInputs = [ doxygen pkgconfig ];

     

       23
       16
        
       

     

       24
       17
        
         configurePhase = ''

     

       25
       18
        
           qmake PREFIX=$out LIBDIR=$out/lib CMAKE_CONFIG_PATH=$out/lib/cmake

     

       26
       19
        
         '';

     

       20
       20
       +
       

     

       21
       21
       +
         meta = with stdenv.lib; {

     

       22
       22
       +
           description = "Qt library for accessing the online accounts database";

     

       23
       23
       +
           homepage = "http://code.google.com/p/accounts-sso/";

     

       24
       24
       +
           license = licenses.lgpl21;

     

       25
       25
       +
           maintainers = with maintainers; [ nckx ];

     

       26
       26
       +
         };

     

       27
       27
        
       }

+10 -11

pkgs/development/libraries/bobcat/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, icmake, libmilter, libX11, openssl, readline

     

       2
       2
        
       , utillinux, yodl }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "4.00.00"; in

     

       5
       5
       -
       stdenv.mkDerivation {

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       6
       5
        
         name = "bobcat-${version}";

     

       6
       6
       +
         version = "4.00.00";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           sha256 = "0wdb25sgw7i3jk3lbja6b4ipqfg1sncam6adg2bn8l5fcinrpwgs";

     

       10
       10
        
           rev = version;

     

       11
       11
        
           repo = "bobcat";

     

       12
       12
        
           owner = "fbb-git";

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

       15
       15
       -
         meta = with stdenv.lib; {

     

       16
       16
       -
           inherit version;

     

       17
       17
       -
           description = "Brokken's Own Base Classes And Templates";

     

       18
       18
       -
           homepage = https://fbb-git.github.io/bobcat/;

     

       19
       19
       -
           license = licenses.gpl3;

     

       20
       20
       -
           platforms = platforms.linux;

     

       21
       21
       -
           maintainers = with maintainers; [ nckx ];

     

       22
       13
        
         };

     

       23
       14
        
       

     

       24
       15
        
         buildInputs = [ libmilter libX11 openssl readline utillinux ];

     
···

       39
       30
        
         installPhase = ''

     

       40
       31
        
           ./build install

     

       41
       32
        
         '';

     

       33
       33
       +
       

     

       34
       34
       +
         meta = with stdenv.lib; {

     

       35
       35
       +
           description = "Brokken's Own Base Classes And Templates";

     

       36
       36
       +
           homepage = https://fbb-git.github.io/bobcat/;

     

       37
       37
       +
           license = licenses.gpl3;

     

       38
       38
       +
           platforms = platforms.linux;

     

       39
       39
       +
           maintainers = with maintainers; [ nckx ];

     

       40
       40
       +
         };

     

       42
       41
        
       }

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, autoreconfHook }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "7.0.2"; in # meta.homepage might change after a major update

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "ip2location-c-${version}";

     

       5
       5
       +
         version = "7.0.2"; # meta.homepage might change after a major update

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "1gs43qgcyfn83abrkhvvw1s67d1sbkbj3hab9m17ysn6swafiycx";

     
···

       18
       18
        
         doCheck = false;

     

       19
       19
        
       

     

       20
       20
        
         meta = with stdenv.lib; {

     

       21
       21
       -
           inherit version;

     

       22
       21
        
           description = "Library to look up locations of host names and IP addresses";

     

       23
       22
        
           longDescription = ''

     

       24
       23
        
             A C library to find the country, region, city,coordinates,

+2 -2

pkgs/development/libraries/libcli/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.9.7"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "libcli-${version}";

     

       5
       5
       +
         version = "1.9.7";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "08pmjhqkwldhmcwjhi2l27slf1fk6nxxfaihnk2637pqkycy8z0c";

+10 -11

pkgs/development/libraries/libkeyfinder/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, fftw, qtbase }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.1"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "libkeyfinder-${version}";

     

       5
       5
       +
         version = "2.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "07kc0cl6kirgmpdgkgmp6r3yvyf7b1w569z01g8rfl1cig80qdc7";

     

       9
       9
        
           rev = "v${version}";

     

       10
       10
        
           repo = "libKeyFinder";

     

       11
       11
        
           owner = "ibsh";

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       16
       -
           description = "Musical key detection for digital audio (C++ library)";

     

       17
       17
       -
           homepage = http://www.ibrahimshaath.co.uk/keyfinder/;

     

       18
       18
       -
           license = licenses.gpl3Plus;

     

       19
       19
       -
           platforms = platforms.linux;

     

       20
       20
       -
           maintainers = with maintainers; [ nckx ];

     

       21
       12
        
         };

     

       22
       13
        
       

     

       23
       14
        
         buildInputs = [ fftw qtbase ];

     
···

       40
       31
        
           mkdir -p $out/lib

     

       41
       32
        
           cp -a lib*.so* $out/lib

     

       42
       33
        
         '';

     

       34
       34
       +
       

     

       35
       35
       +
         meta = with stdenv.lib; {

     

       36
       36
       +
           description = "Musical key detection for digital audio (C++ library)";

     

       37
       37
       +
           homepage = http://www.ibrahimshaath.co.uk/keyfinder/;

     

       38
       38
       +
           license = licenses.gpl3Plus;

     

       39
       39
       +
           platforms = platforms.linux;

     

       40
       40
       +
           maintainers = with maintainers; [ nckx ];

     

       41
       41
       +
         };

     

       43
       42
        
       }

+1 -2

pkgs/development/libraries/libnetfilter_conntrack/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, libnfnetlink, libmnl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.0.5"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "libnetfilter_conntrack-${version}";

     

       5
       5
       +
         version = "1.0.5";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://netfilter.org/projects/libnetfilter_conntrack/files/${name}.tar.bz2";

     
···

       14
       14
        
         nativeBuildInputs = [ pkgconfig ];

     

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       17
        
           description = "Userspace library providing an API to the in-kernel connection tracking state table";

     

       19
       18
        
           longDescription = ''

     

       20
       19
        
             libnetfilter_conntrack is a userspace library providing a programming interface (API) to the

+10 -11

pkgs/development/libraries/libxcomp/default.nix

···

       1
       1
        
       { stdenv, fetchurl, autoreconfHook, libjpeg, libpng12, libX11, zlib }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "3.5.0.32"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "libxcomp-${version}";

     

       5
       5
       +
         version = "3.5.0.32";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "02n5bdc1jsq999agb4w6dmdj5l2wlln2lka84qz6rpswwc59zaxm";

     

       9
       9
        
           url = "http://code.x2go.org/releases/source/nx-libs/nx-libs-${version}-lite.tar.gz";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         meta = with stdenv.lib; {

     

       13
       13
       -
           inherit version;

     

       14
       14
       -
           description = "NX compression library";

     

       15
       15
       -
           homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";

     

       16
       16
       -
           license = licenses.gpl2;

     

       17
       17
       -
           platforms = platforms.linux;

     

       18
       18
       -
           maintainers = with maintainers; [ nckx ];

     

       19
       19
       -
         };

     

       20
       20
       -
       

     

       21
       12
        
         buildInputs = [ libjpeg libpng12 libX11 zlib ];

     

       22
       13
        
         nativeBuildInputs = [ autoreconfHook ];

     

       23
       14
        
       

     
···

       26
       17
        
         '';

     

       27
       18
        
       

     

       28
       19
        
         enableParallelBuilding = true;

     

       20
       20
       +
       

     

       21
       21
       +
         meta = with stdenv.lib; {

     

       22
       22
       +
           description = "NX compression library";

     

       23
       23
       +
           homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";

     

       24
       24
       +
           license = licenses.gpl2;

     

       25
       25
       +
           platforms = platforms.linux;

     

       26
       26
       +
           maintainers = with maintainers; [ nckx ];

     

       27
       27
       +
         };

     

       29
       28
        
       }

+1 -2

pkgs/development/libraries/rote/default.nix

···

       1
       1
        
       { stdenv, fetchurl, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.2.8"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "rote-${version}";

     

       5
       5
       +
         version = "0.2.8";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "05v1lw99jv4cwxl7spyi7by61j2scpdsvx809x5cga7dm5dhlmky";

     
···

       14
       14
        
         enableParallelBuilding = true;

     

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       17
        
           description = "Our Own Terminal Emulation Library";

     

       19
       18
        
           longDescription = ''

     

       20
       19
        
             ROTE is a simple C library for VT102 terminal emulation. It allows the

+19 -20

pkgs/development/tools/alloy/default.nix

···

       1
       1
        
       { stdenv, fetchurl, jre, makeDesktopItem }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "4.2_2015-02-22"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "alloy-${version}";

     

       5
       5
       +
         version = "4.2_2015-02-22";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0p93v8jwx9prijpikkgmfdzb9qn8ljmvga5d9wvrkxddccjx9k28";

     

       9
       9
        
           url = "http://alloy.mit.edu/alloy/downloads/alloy${version}.jar";

     

       10
       10
       -
         };

     

       11
       11
       -
       

     

       12
       12
       -
         meta = with stdenv.lib; {

     

       13
       13
       -
           inherit version;

     

       14
       14
       -
           description = "Language & tool for relational models";

     

       15
       15
       -
           longDescription = ''

     

       16
       16
       -
             Alloy is a language for describing structures and a tool for exploring

     

       17
       17
       -
             them. An Alloy model is a collection of constraints that describes a set

     

       18
       18
       -
             of structures, e.g. all the possible security configurations of a web

     

       19
       19
       -
             application, or all the possible topologies of a switching network. The

     

       20
       20
       -
             Alloy Analyzer is a solver that takes the constraints of a model and

     

       21
       21
       -
             finds structures that satisfy them. Structures are displayed graphically,

     

       22
       22
       -
             and their appearance can be customized for the domain at hand.

     

       23
       23
       -
           '';

     

       24
       24
       -
           homepage = http://alloy.mit.edu/;

     

       25
       25
       -
           downloadPage = http://alloy.mit.edu/alloy/download.html;

     

       26
       26
       -
           license = licenses.mit;

     

       27
       27
       -
           platforms = platforms.linux;

     

       28
       28
       -
           maintainers = with maintainers; [ nckx ];

     

       29
       10
        
         };

     

       30
       11
        
       

     

       31
       12
        
         desktopItem = makeDesktopItem rec {

     
···

       57
       38
        
           install -Dm644 ${./icon.png} $out/share/pixmaps/alloy.png

     

       58
       39
        
           cp -r ${desktopItem}/share/applications $out/share

     

       59
       40
        
         '';

     

       41
       41
       +
       

     

       42
       42
       +
         meta = with stdenv.lib; {

     

       43
       43
       +
           description = "Language & tool for relational models";

     

       44
       44
       +
           longDescription = ''

     

       45
       45
       +
             Alloy is a language for describing structures and a tool for exploring

     

       46
       46
       +
             them. An Alloy model is a collection of constraints that describes a set

     

       47
       47
       +
             of structures, e.g. all the possible security configurations of a web

     

       48
       48
       +
             application, or all the possible topologies of a switching network. The

     

       49
       49
       +
             Alloy Analyzer is a solver that takes the constraints of a model and

     

       50
       50
       +
             finds structures that satisfy them. Structures are displayed graphically,

     

       51
       51
       +
             and their appearance can be customized for the domain at hand.

     

       52
       52
       +
           '';

     

       53
       53
       +
           homepage = http://alloy.mit.edu/;

     

       54
       54
       +
           downloadPage = http://alloy.mit.edu/alloy/download.html;

     

       55
       55
       +
           license = licenses.mit;

     

       56
       56
       +
           platforms = platforms.linux;

     

       57
       57
       +
           maintainers = with maintainers; [ nckx ];

     

       58
       58
       +
         };

     

       60
       59
        
       }

+5 -6

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

···

       1
       1
        
       { stdenv, fetchurl, buildPerlPackage }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.10"; in

     

       4
       3
        
       buildPerlPackage rec {

     

       5
       4
        
         name = "egypt-${version}";

     

       5
       5
       +
         version = "1.10";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0r0wj6v8z9fzlh9pb5617kyjdf92ppmlbzajaarrq729bbb6ln5m";

     

       9
       9
        
           url = "http://www.gson.org/egypt/download/${name}.tar.gz";

     

       10
       10
        
         };

     

       11
       11
       +
       

     

       12
       12
       +
         enableParallelBuilding = true;

     

       13
       13
       +
       

     

       14
       14
       +
         doCheck = true;

     

       11
       15
        
       

     

       12
       16
        
         meta = with stdenv.lib; {

     

       13
       13
       -
           inherit version;

     

       14
       17
        
           description = "Tool for making call graphs of C programmes";

     

       15
       18
        
           longDescription = ''

     

       16
       19
        
             Egypt is a simple tool for creating call graphs of C programs. It neither

     
···

       25
       28
        
           platforms = platforms.linux;

     

       26
       29
        
           maintainers = with maintainers; [ nckx ];

     

       27
       30
        
         };

     

       28
       28
       -
       

     

       29
       29
       -
         enableParallelBuilding = true;

     

       30
       30
       -
       

     

       31
       31
       -
         doCheck = true;

     

       32
       31
        
       }

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, cmake, llvmPackages }:

     

       2
       2
        
       

     

       3
       3
       -
       # Also bump llvmPackages in all-packages.nix to the supported version!

     

       4
       4
       -
       let version = "0.5"; in

     

       5
       3
        
       stdenv.mkDerivation rec {

     

       6
       4
        
         name = "include-what-you-use-${version}";

     

       5
       5
       +
         # Also bump llvmPackages in all-packages.nix to the supported version!

     

       6
       6
       +
         version = "0.5";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           sha256 = "19pwhgwvfr86n8ks099p9r02v7zh8d3qs7g7snzkhpdgq1azww85";

     
···

       18
       18
        
         enableParallelBuilding = true;

     

       19
       19
        
       

     

       20
       20
        
         meta = with stdenv.lib; {

     

       21
       21
       -
           inherit version;

     

       22
       21
        
           description = "Analyze #includes in C/C++ source files with clang";

     

       23
       22
        
           longDescription = ''

     

       24
       23
        
             For every symbol (type, function variable, or macro) that you use in

+14 -15

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

···

       1
       1
        
       { stdenv, fetchurl, jre }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0_101"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "cfr-${version}";

     

       5
       5
       +
         version = "0_101";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0zwl3whypdm2qrw3hwaqjnifkb4wcdn8fx9scrjkli54bhr6dqch";

     

       9
       9
        
           url = "http://www.benf.org/other/cfr/cfr_${version}.jar";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         meta = with stdenv.lib; {

     

       13
       13
       -
           inherit version;

     

       14
       14
       -
           description = "Another java decompiler";

     

       15
       15
       -
           longDescription = ''

     

       16
       16
       -
             CFR will decompile modern Java features - Java 8 lambdas (pre and post

     

       17
       17
       -
             Java beta 103 changes), Java 7 String switches etc, but is written

     

       18
       18
       -
             entirely in Java 6.

     

       19
       19
       -
           '';

     

       20
       20
       -
           homepage = http://www.benf.org/other/cfr/;

     

       21
       21
       -
           license = licenses.mit;

     

       22
       22
       -
           platforms = platforms.all;

     

       23
       23
       -
           maintainers = with maintainers; [ nckx ];

     

       24
       24
       -
         };

     

       25
       25
       -
       

     

       26
       12
        
         buildInputs = [ jre ];

     

       27
       13
        
       

     

       28
       14
        
         phases = [ "installPhase" ];

     
···

       38
       24
        
           EOF

     

       39
       25
        
           install -Dm755 cfr $out/bin/cfr

     

       40
       26
        
         '';

     

       27
       27
       +
       

     

       28
       28
       +
         meta = with stdenv.lib; {

     

       29
       29
       +
           description = "Another java decompiler";

     

       30
       30
       +
           longDescription = ''

     

       31
       31
       +
             CFR will decompile modern Java features - Java 8 lambdas (pre and post

     

       32
       32
       +
             Java beta 103 changes), Java 7 String switches etc, but is written

     

       33
       33
       +
             entirely in Java 6.

     

       34
       34
       +
           '';

     

       35
       35
       +
           homepage = http://www.benf.org/other/cfr/;

     

       36
       36
       +
           license = licenses.mit;

     

       37
       37
       +
           platforms = platforms.all;

     

       38
       38
       +
           maintainers = with maintainers; [ nckx ];

     

       39
       39
       +
         };

     

       41
       40
        
       }

+7 -8

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

···

       1
       1
        
       { stdenv, fetchurl, libelf, txt2man }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.2"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "bin_replace_string-${version}";

     

       5
       5
       +
         version = "0.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "1gnpddxwpsfrg4l76x5yplsvbcdbviybciqpn22yq3g3qgnr5c2a";

     

       9
       9
        
           url = "ftp://ohnopub.net/mirror/bin_replace_string-0.2.tar.bz2";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       +
         buildInputs = [ libelf ];

     

       13
       13
       +
         nativeBuildInputs = [ txt2man ];

     

       14
       14
       +
       

     

       15
       15
       +
         enableParallelBuilding = true;

     

       16
       16
       +
       

     

       12
       17
        
         meta = with stdenv.lib; {

     

       13
       13
       -
           inherit version;

     

       14
       18
        
           description = "Edit precompiled binaries";

     

       15
       19
        
           longDescription = ''

     

       16
       20
        
             bin_replace_string edits C-style strings in precompiled binaries. This is

     
···

       25
       29
        
           platforms = platforms.linux;

     

       26
       30
        
           maintainers = with maintainers; [ nckx ];

     

       27
       31
        
         };

     

       28
       28
       -
       

     

       29
       29
       -
         buildInputs = [ libelf ];

     

       30
       30
       -
         nativeBuildInputs = [ txt2man ];

     

       31
       31
       -
       

     

       32
       32
       -
         enableParallelBuilding = true;

     

       33
       32
        
       }

+15 -16

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, bobcat, icmake, yodl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.03.00"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "flexc++-${version}";

     

       5
       5
       +
         version = "2.03.00";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "1knb5h6l71n5zi9xzml5f6v7wspbk7vrcaiy2div8bnj7na3z717";

     

       9
       9
        
           rev = version;

     

       10
       10
        
           repo = "flexcpp";

     

       11
       11
        
           owner = "fbb-git";

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       16
       -
           description = "C++ tool for generating lexical scanners";

     

       17
       17
       -
           longDescription = ''

     

       18
       18
       -
             Flexc++ was designed after `flex'. Flexc++ offers a cleaner class design

     

       19
       19
       -
             and requires simpler specification files than offered by flex's C++

     

       20
       20
       -
             option.

     

       21
       21
       -
           '';

     

       22
       22
       -
           homepage = https://fbb-git.github.io/flexcpp/;

     

       23
       23
       -
           license = licenses.gpl3;

     

       24
       24
       -
           platforms = platforms.linux;

     

       25
       25
       -
           maintainers = with maintainers; [ nckx ];

     

       26
       12
        
         };

     

       27
       13
        
       

     

       28
       14
        
         sourceRoot = "flexcpp-${version}-src/flexc++";

     
···

       48
       34
        
           ./build install skel

     

       49
       35
        
           ./build install std

     

       50
       36
        
         '';

     

       37
       37
       +
       

     

       38
       38
       +
         meta = with stdenv.lib; {

     

       39
       39
       +
           description = "C++ tool for generating lexical scanners";

     

       40
       40
       +
           longDescription = ''

     

       41
       41
       +
             Flexc++ was designed after `flex'. Flexc++ offers a cleaner class design

     

       42
       42
       +
             and requires simpler specification files than offered by flex's C++

     

       43
       43
       +
             option.

     

       44
       44
       +
           '';

     

       45
       45
       +
           homepage = https://fbb-git.github.io/flexcpp/;

     

       46
       46
       +
           license = licenses.gpl3;

     

       47
       47
       +
           platforms = platforms.linux;

     

       48
       48
       +
           maintainers = with maintainers; [ nckx ];

     

       49
       49
       +
         };

     

       51
       50
        
       }

+1 -2

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-01-15"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "2048-in-terminal-${version}";

     

       5
       5
       +
         version = "2015-01-15";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "1fdfmyhh60sz0xbilxkh2y09lvbcs9lamk2jkjkhxhlhxknmnfgs";

     
···

       21
       21
        
         installFlags = [ "DESTDIR=$(out)" ];

     

       22
       22
        
       

     

       23
       23
        
         meta = with stdenv.lib; {

     

       24
       24
       -
           inherit version;

     

       25
       24
        
           inherit (src.meta) homepage;

     

       26
       25
        
           description = "Animated console version of the 2048 game";

     

       27
       26
        
           license = licenses.mit;

+1 -1

pkgs/games/soi/default.nix

···

       1
       1
        
       { stdenv, fetchurl, cmake

     

       2
       2
        
       , boost, eigen2, lua, luabind, mesa, SDL }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "0.1.2"; in

     

       5
       4
        
       stdenv.mkDerivation rec {

     

       6
       5
        
         name = "soi-${version}";

     

       6
       6
       +
         version = "0.1.2";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "mirror://sourceforge/project/soi/Spheres%20of%20Influence-${version}-Source.tar.bz2";

+3 -3

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

···

       11
       11
        
       # }

     

       12
       12
        
       # (This advice was tested on 2010 August 2.)

     

       13
       13
        
       

     

       14
       14
       -
       {stdenv, fetchurl, cups, gcc, ghostscript, glibc, patchelf}:

     

       14
       14
       +
       { stdenv, fetchurl, cups, gcc, ghostscript, glibc, patchelf }:

     

       15
       15
        
       

     

       16
       16
        
       # Do not bump lightly! Visit <http://www.bchemnet.com/suldr/supported.html>

     

       17
       17
        
       # to see what will break when upgrading. Consider a new versioned attribute.

     

       18
       18
       -
       let version = "4.00.39"; in

     

       19
       19
       -
       stdenv.mkDerivation {

     

       18
       18
       +
       stdenv.mkDerivation rec {

     

       20
       19
        
         name = "samsung-UnifiedLinuxDriver-${version}";

     

       20
       20
       +
         version = "4.00.39";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchurl {

     

       23
       23
        
           url = "http://www.bchemnet.com/suldr/driver/UnifiedLinuxDriver-${version}.tar.gz";

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, libgcrypt, libnl, pkgconfig, pythonPackages, wireless-regdb }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "3.18"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "crda-${version}";

     

       5
       5
       +
         version = "3.18";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "1gydiqgb08d9gbx4l6gv98zg3pljc984m50hmn3ysxcbkxkvkz23";

     
···

       36
       36
        
         checkTarget = "verify";

     

       37
       37
        
       

     

       38
       38
        
         meta = with stdenv.lib; {

     

       39
       39
       -
           inherit version;

     

       40
       39
        
           description = "Linux wireless Central Regulatory Domain Agent";

     

       41
       40
        
           longDescription = ''

     

       42
       41
        
             CRDA acts as the udev helper for communication between the kernel and

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, python3, which }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.11"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "fatrace-${version}";

     

       5
       5
       +
         version = "0.11";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://launchpad.net/fatrace/trunk/${version}/+download/${name}.tar.bz2";

     
···

       19
       19
        
         makeFlags = [ "PREFIX=$(out)" ];

     

       20
       20
        
       

     

       21
       21
        
         meta = with stdenv.lib; {

     

       22
       22
       -
           inherit version;

     

       23
       22
        
           description = "Report system-wide file access events";

     

       24
       23
        
           homepage = https://launchpad.net/fatrace/;

     

       25
       24
        
           license = licenses.gpl3Plus;

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, b43FirmwareCutter }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "6.30.163.46"; in

     

       4
       4
       -
       

     

       5
       5
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       6
       4
        
         name = "b43-firmware-${version}";

     

       5
       5
       +
         version = "6.30.163.46";

     

       7
       6
        
       

     

       8
       7
        
         src = fetchurl {

     

       9
       8
        
           url = "http://www.lwfinger.com/b43-firmware/broadcom-wl-${version}.tar.bz2";

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "4.3"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "freefall-${version}";

     

       5
       5
       +
         version = "4.3";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "1bpkr45i4yzp32p0vpnz8mlv9lk4q2q9awf1kg9khg4a9g42qqja";

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.0"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "ftop-${version}";

     

       5
       5
       +
         version = "1.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://ftop.googlecode.com/files/${name}.tar.bz2";

     
···

       22
       22
        
         '';

     

       23
       23
        
       

     

       24
       24
        
         meta = with stdenv.lib; {

     

       25
       25
       -
           inherit version;

     

       26
       25
        
           description = "Show progress of open files and file systems";

     

       27
       26
        
           homepage = https://code.google.com/p/ftop/;

     

       28
       27
        
           license = licenses.gpl3Plus;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, zlib }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.0.11"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "kexec-tools-${version}";

     

       5
       5
       +
         version = "2.0.11";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           urls = [

     
···

       15
       15
        
         buildInputs = [ zlib ];

     

       16
       16
        
       

     

       17
       17
        
         meta = with stdenv.lib; {

     

       18
       18
       -
           inherit version;

     

       19
       18
        
           homepage = http://horms.net/projects/kexec/kexec-tools;

     

       20
       19
        
           description = "Tools related to the kexec Linux feature";

     

       21
       20
        
           platforms = platforms.linux;

+2 -3

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

···

       1
       1
        
       { stdenv, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "129"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "mcelog-${version}";

     

       5
       5
       +
         version = "129";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "143xh5zvgax88yhg6mg6img64nrda85yybf76fgsk7a8gc57ghyk";

     
···

       25
       25
        
         installFlags = [ "DESTDIR=$(out)" "prefix=" "DOCDIR=/share/doc" ];

     

       26
       26
        
       

     

       27
       27
        
         meta = with stdenv.lib; {

     

       28
       28
       -
           inherit version;

     

       29
       28
        
           description = "Log x86 machine checks: memory, IO, and CPU hardware errors";

     

       30
       29
        
           longDescription = ''

     

       31
       30
        
             The mcelog daemon accounts memory and some other errors in various ways

+2 -3

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, pkgconfig, gettext, ncurses, libdrm, libpciaccess }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-11-24"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "radeontop-${version}";

     

       5
       5
       +
         version = "2015-11-24";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "0irwq6rps5mnban8cxbrm59wpyv4j80q3xdjm9fxvfpiyys2g2hz";

     
···

       23
       23
        
         makeFlags = [ "PREFIX=$(out)" ];

     

       24
       24
        
       

     

       25
       25
        
         meta = with stdenv.lib; {

     

       26
       26
       -
           inherit version;

     

       27
       26
        
           description = "Top-like tool for viewing AMD Radeon GPU utilization";

     

       28
       27
        
           longDescription = ''

     

       29
       28
        
             View GPU utilization, both for the total activity percent and individual

+2 -3

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

···

       1
       1
        
       { stdenv, fetchgit, cmake }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-09-25"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "uksmtools-${version}";

     

       5
       5
       +
         version = "2015-09-25";

     

       6
       6
        
       

     

       7
       7
        
         # This project uses git submodules, which fetchFromGitHub doesn't support:

     

       8
       8
        
         src = fetchgit {

     
···

       18
       18
        
         doCheck = false;

     

       19
       19
        
       

     

       20
       20
        
         meta = with stdenv.lib; {

     

       21
       21
       -
           inherit version;

     

       22
       21
        
           description = "Tools to control Linux UKSM (Ultra Kernel Same-page Merging)";

     

       23
       22
        
           homepage = https://github.com/pfactum/uksmtools/;

     

       24
       23
        
           license = licenses.gpl3Plus;

+2 -3

pkgs/shells/mksh/default.nix

···

       1
       1
        
       { stdenv, fetchurl, groff }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "52"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "mksh-${version}";

     

       5
       5
       +
         version = "52";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           urls = [

     
···

       30
       30
        
         '';

     

       31
       31
        
       

     

       32
       32
        
         meta = with stdenv.lib; {

     

       33
       33
       -
           inherit version;

     

       34
       33
        
           description = "MirBSD Korn Shell";

     

       35
       34
        
           longDescription = ''

     

       36
       35
        
             The MirBSD Korn Shell is a DFSG-free and OSD-compliant (and OSI

+10 -11

pkgs/tools/admin/nxproxy/default.nix

···

       1
       1
        
       { stdenv, fetchurl, autoreconfHook, libxcomp }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "3.5.0.32"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "nxproxy-${version}";

     

       5
       5
       +
         version = "3.5.0.32";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "02n5bdc1jsq999agb4w6dmdj5l2wlln2lka84qz6rpswwc59zaxm";

     

       9
       9
        
           url = "http://code.x2go.org/releases/source/nx-libs/nx-libs-${version}-lite.tar.gz";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         meta = with stdenv.lib; {

     

       13
       13
       -
           inherit version;

     

       14
       14
       -
           description = "NX compression proxy";

     

       15
       15
       -
           homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";

     

       16
       16
       -
           license = licenses.gpl2;

     

       17
       17
       -
           platforms = platforms.linux;

     

       18
       18
       -
           maintainers = with maintainers; [ nckx ];

     

       19
       19
       -
         };

     

       20
       20
       -
       

     

       21
       12
        
         buildInputs = [ libxcomp ];

     

       22
       13
        
         nativeBuildInputs = [ autoreconfHook ];

     

       23
       14
        
       

     
···

       28
       19
        
         makeFlags = [ "exec_prefix=$(out)" ];

     

       29
       20
        
       

     

       30
       21
        
         enableParallelBuilding = true;

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with stdenv.lib; {

     

       24
       24
       +
           description = "NX compression proxy";

     

       25
       25
       +
           homepage = "http://wiki.x2go.org/doku.php/wiki:libs:nx-libs";

     

       26
       26
       +
           license = licenses.gpl2;

     

       27
       27
       +
           platforms = platforms.linux;

     

       28
       28
       +
           maintainers = with maintainers; [ nckx ];

     

       29
       29
       +
         };

     

       31
       30
        
       }

+1 -2

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

···

       3
       3
        
       , enableSoftening ? true

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
       -
       let version = "0.79.5"; in

     

       7
       6
        
       stdenv.mkDerivation rec {

     

       8
       7
        
         name = "dvdisaster-${version}";

     

       8
       8
       +
         version = "0.79.5";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "http://dvdisaster.net/downloads/${name}.tar.bz2";

     
···

       70
       70
        
         '';

     

       71
       71
        
       

     

       72
       72
        
         meta = with stdenv.lib; {

     

       73
       73
       -
           inherit version;

     

       74
       73
        
           homepage = http://dvdisaster.net/;

     

       75
       74
        
           description = "Data loss/scratch/aging protection for CD/DVD media";

     

       76
       75
        
           longDescription = ''

+1 -2

pkgs/tools/compression/lz4/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, valgrind }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "131"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "lz4-${version}";

     

       5
       5
       +
         version = "131";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "1bhvcq8fxxsqnpg5qa6k3nsyhq0nl0iarh08sqzclww27hlpyay2";

     
···

       23
       23
        
         patches = [ ./install-on-freebsd.patch ] ;

     

       24
       24
        
       

     

       25
       25
        
         meta = with stdenv.lib; {

     

       26
       26
       -
           inherit version;

     

       27
       26
        
           description = "Extremely fast compression algorithm";

     

       28
       27
        
           longDescription = ''

     

       29
       28
        
             Very fast lossless compression algorithm, providing compression speed

+1 -2

pkgs/tools/compression/zopfli/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, fetchpatch }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.0.1"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "zopfli-${version}";

     

       5
       5
       +
         version = "1.0.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "google";

     
···

       45
       45
        
         '';

     

       46
       46
        
       

     

       47
       47
        
         meta = with stdenv.lib; {

     

       48
       48
       -
           inherit version;

     

       49
       48
        
           inherit (src.meta) homepage;

     

       50
       49
        
           description = "Very good, but slow, deflate or zlib compression";

     

       51
       50
        
           longDescription = ''

+4 -5

pkgs/tools/filesystems/duff/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, autoreconfHook, gettext }:

     

       2
       2
        
       

     

       3
       3
       -
       # The last release (0.5.2) is more than 2 years old and lacks features like -D,

     

       4
       4
       -
       # limiting its usefulness. Upstream appears comatose if not dead.

     

       5
       5
       -
       let version = "2014-07-03"; in

     

       6
       6
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       7
       4
        
         name = "duff-${version}";

     

       5
       5
       +
         # The last release (0.5.2) is more than 2 years old and lacks features like -D,

     

       6
       6
       +
         # limiting its usefulness. Upstream appears comatose if not dead.

     

       7
       7
       +
         version = "2014-07-03";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           sha256 = "1k2dx38pjzc5d624vw1cs5ipj9fprsm5vqv55agksc29m63lswnx";

     
···

       28
       28
        
         enableParallelBuilding = true;

     

       29
       29
        
       

     

       30
       30
        
         meta = with stdenv.lib; {

     

       31
       31
       -
           inherit version;

     

       32
       31
        
           description = "Quickly find duplicate files";

     

       33
       32
        
           longDescription = ''

     

       34
       33
        
             Duff is a Unix command-line utility for quickly finding duplicates in

+2 -2

pkgs/tools/filesystems/encfs/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, autoreconfHook, boost, fuse, openssl, perl

     

       2
       2
        
       , pkgconfig, rlog }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "1.8.1"; in

     

       5
       5
       -
       stdenv.mkDerivation {

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       6
       5
        
         name = "encfs-${version}";

     

       6
       6
       +
         version = "1.8.1";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           sha256 = "1cxihqwpnqbzy8qz0134199pwfnd7ikr2835p5p1yzqnl203wcdb";

+1 -2

pkgs/tools/filesystems/exfat/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, fuse }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.2.3"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "exfat-${version}";

     

       5
       5
       +
         version = "1.2.3";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "147s11sqmn5flbvz2hwpl6kdfqi2gnm1c2nsn5fxygyw7qyhpzda";

     
···

       15
       15
        
         nativeBuildInputs = [ autoreconfHook pkgconfig ];

     

       16
       16
        
       

     

       17
       17
        
         meta = with stdenv.lib; {

     

       18
       18
       -
           inherit version;

     

       19
       18
        
           inherit (src.meta) homepage;

     

       20
       19
        
           description = "Free exFAT file system implementation";

     

       21
       20
        
           platforms = platforms.linux;

+1 -2

pkgs/tools/filesystems/gpart/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, autoreconfHook }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.3"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "gpart-${version}";

     

       5
       5
       +
         version = "0.3";

     

       6
       6
        
       

     

       7
       7
        
         # GitHub repository 'collating patches for gpart from all distributions':

     

       8
       8
        
         src = fetchFromGitHub {

     
···

       19
       19
        
         doCheck = true;

     

       20
       20
        
       

     

       21
       21
        
         meta = with stdenv.lib; {

     

       22
       22
       -
           inherit version;

     

       23
       22
        
           inherit (src.meta) homepage;

     

       24
       23
        
           description = "Guess PC-type hard disk partitions";

     

       25
       24
        
           longDescription = ''

+1 -1

pkgs/tools/filesystems/mp3fs/default.nix

···

       1
       1
        
       { stdenv, fetchurl, flac, fuse, lame, libid3tag, pkgconfig }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.91"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "mp3fs-${version}";

     

       5
       5
       +
         version = "0.91";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/khenriks/mp3fs/releases/download/v${version}/${name}.tar.gz";

+5 -5

pkgs/tools/misc/clex/default.nix

···

       1
       1
        
       { stdenv, fetchurl, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "4.6.patch6"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "clex-${version}";

     

       5
       5
       +
         version = "4.6.patch6";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0bqa2hc9721d62cfsy5c7a5pzgh9b4px7g4q60xlybkwll19qbbp";

     

       9
       9
        
           url = "${meta.homepage}/download/${name}.tar.gz";

     

       10
       10
        
         };

     

       11
       11
       +
       

     

       12
       12
       +
         buildInputs = [ ncurses ];

     

       13
       13
       +
       

     

       14
       14
       +
         enableParallelBuilding = true;

     

       11
       15
        
       

     

       12
       16
        
         meta = with stdenv.lib; {

     

       13
       17
        
           description = "File manager with full-screen terminal interface";

     
···

       23
       27
        
           platforms = platforms.linux;

     

       24
       28
        
           maintainers = with maintainers; [ nckx ];

     

       25
       29
        
         };

     

       26
       26
       -
       

     

       27
       27
       -
         buildInputs = [ ncurses ];

     

       28
       28
       -
       

     

       29
       29
       -
         enableParallelBuilding = true;

     

       30
       30
        
       }

+1 -2

pkgs/tools/misc/ipad_charge/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, libusb1 }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-02-03"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "ipad_charge-${version}";

     

       5
       5
       +
         version = "2015-02-03";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "0f40hqx1dbqpwrhyf42h5982jwqv8j5zp5hwwakz6600hyqvnnz7";

     
···

       27
       27
        
         '';

     

       28
       28
        
       

     

       29
       29
        
         meta = with stdenv.lib; {

     

       30
       30
       -
           inherit version;

     

       31
       30
        
           inherit (src.meta) homepage;

     

       32
       31
        
           description = "Apple device USB charging utility for Linux";

     

       33
       32
        
           longDescription = ''

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, gettext }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.5.2"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "ms-sys-${version}";

     

       5
       5
       +
         version = "2.5.2";

     

       6
       6
        
        

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://sourceforge/ms-sys/${name}.tar.gz";

     
···

       16
       16
        
         makeFlags = [ "PREFIX=$(out)" ];

     

       17
       17
        
       

     

       18
       18
        
         meta = with stdenv.lib; {

     

       19
       19
       -
           inherit version;

     

       20
       19
        
           description = "A program for writing Microsoft compatible boot records";

     

       21
       20
        
           homepage = http://ms-sys.sourceforge.net/;

     

       22
       21
        
           license = licenses.gpl2Plus;

+2 -3

pkgs/tools/misc/tldr/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, clang, curl, libzip, pkgconfig }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.1.0"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "tldr-${version}";

     

       5
       5
       +
         version = "1.1.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "0hxkrzp5njhy7c19v8i3svcb148f1jni7dlv36gc1nmcrz5izsiz";

     
···

       23
       23
        
         '';

     

       24
       24
        
       

     

       25
       25
        
         meta = with stdenv.lib; {

     

       26
       26
       -
           inherit version;

     

       27
       26
        
           description = "Simplified and community-driven man pages";

     

       28
       27
        
           longDescription = ''

     

       29
       28
        
             tldr pages gives common use cases for commands, so you don't need to hunt

+3 -4

pkgs/tools/networking/dhcping/default.nix

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.2"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "dhcping-${version}";

     

       5
       5
       +
         version = "1.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0sk4sg3hn88n44dxikipf3ggfj3ixrp22asb7nry9p0bkfaqdvrj";

     
···

       14
       14
        
         doCheck = true;

     

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       17
        
           description = "Send DHCP request to find out if a DHCP server is running";

     

       19
       18
        
           longDescription = ''

     

       20
       19
        
             dhcping sends either a DHCPREQUEST or DHCPINFORM packet to the server

     
···

       31
       30
        
           platforms = platforms.linux;

     

       32
       31
        
           maintainers = with maintainers; [ nckx ];

     

       33
       32
        
         };

     

       34
       34
       -
        }

     

       33
       33
       +
       }

+14 -15

pkgs/tools/networking/hans/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, nettools }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.4.4"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "hans-${version}";

     

       5
       5
       +
         version = "0.4.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "1xskffmmdmg1whlrl5wpkv9z29vh0igrbmsz0b45s9v0761a7kis";

     
···

       11
       11
        
           owner = "friedrich";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       +
         buildInputs = [ nettools ];

     

       15
       15
       +
       

     

       16
       16
       +
         postPatch = ''

     

       17
       17
       +
           substituteInPlace src/tun.cpp --replace "/sbin/" "${nettools}/bin/"

     

       18
       18
       +
         '';

     

       19
       19
       +
       

     

       20
       20
       +
         enableParallelBuilding = true;

     

       21
       21
       +
       

     

       22
       22
       +
         installPhase = ''

     

       23
       23
       +
           install -D -m0755 hans $out/bin/hans

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       14
       26
        
         meta = with stdenv.lib; {

     

       15
       15
       -
           inherit version;

     

       16
       27
        
           description = "Tunnel IPv4 over ICMP";

     

       17
       28
        
           longDescription = ''

     

       18
       29
        
             Hans makes it possible to tunnel IPv4 through ICMP echo packets, so you

     
···

       25
       36
        
           platforms = platforms.linux;

     

       26
       37
        
           maintainers = with maintainers; [ nckx ];

     

       27
       38
        
         };

     

       28
       28
       -
       

     

       29
       29
       -
         buildInputs = [ nettools ];

     

       30
       30
       -
       

     

       31
       31
       -
         postPatch = ''

     

       32
       32
       -
           substituteInPlace src/tun.cpp --replace "/sbin/" "${nettools}/bin/"

     

       33
       33
       -
         '';

     

       34
       34
       -
       

     

       35
       35
       -
         enableParallelBuilding = true;

     

       36
       36
       -
       

     

       37
       37
       -
         installPhase = ''

     

       38
       38
       -
           install -D -m0755 hans $out/bin/hans

     

       39
       39
       -
         '';

     

       40
       39
        
       }

+2 -3

pkgs/tools/networking/ip2location/default.nix

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "7.0.0"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "ip2location-${version}";

     

       5
       5
       +
         version = "7.0.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "05zbc02z7vm19byafi05i1rnkxc6yrfkhnm30ly68zzyipkmzx1l";

     
···

       14
       14
        
         doCheck = true;

     

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       17
        
           description = "Look up locations of host names and IP addresses";

     

       19
       18
        
           longDescription = ''

     

       20
       19
        
             A command-line tool to find the country, region, city,coordinates,

+1 -2

pkgs/tools/networking/ipv6calc/default.nix

···

       2
       2
        
       , geoip ? null, geolite-legacy ? null

     

       3
       3
        
       , ip2location-database ? null }:

     

       4
       4
        
       

     

       5
       5
       -
       let version = "0.99.1"; in

     

       6
       5
        
       stdenv.mkDerivation rec {

     

       7
       6
        
         name = "ipv6calc-${version}";

     

       7
       7
       +
         version = "0.99.1";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "ftp://ftp.deepspace6.net/pub/ds6/sources/ipv6calc/${name}.tar.gz";

     
···

       39
       39
        
         enableParallelBuilding = true;

     

       40
       40
        
       

     

       41
       41
        
         meta = with stdenv.lib; {

     

       42
       42
       -
           inherit version;

     

       43
       42
        
           description = "Calculate/manipulate (not only) IPv6 addresses";

     

       44
       43
        
           longDescription = ''

     

       45
       44
        
             ipv6calc is a small utility to manipulate (not only) IPv6 addresses and

+2 -3

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

···

       2
       2
        
       , libnetfilter_conntrack, libnl, libpcap, libsodium, liburcu, ncurses, perl

     

       3
       3
        
       , pkgconfig, zlib }:

     

       4
       4
        
       

     

       5
       5
       -
       let version = "0.6.0"; in

     

       6
       6
       -
       stdenv.mkDerivation {

     

       5
       5
       +
       stdenv.mkDerivation rec {

     

       7
       6
        
         name = "netsniff-ng-${version}";

     

       7
       7
       +
         version = "0.6.0";

     

       8
       8
        
       

     

       9
       9
        
         # Upstream recommends and supports git

     

       10
       10
        
         src = fetchFromGitHub rec {

     
···

       41
       41
        
         '';

     

       42
       42
        
       

     

       43
       43
        
         meta = with stdenv.lib; {

     

       44
       44
       -
           inherit version;

     

       45
       44
        
           description = "Swiss army knife for daily Linux network plumbing";

     

       46
       45
        
           longDescription = ''

     

       47
       46
        
             netsniff-ng is a free Linux networking toolkit. Its gain of performance

+1 -2

pkgs/tools/networking/pcapc/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, libpcap }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2015-03-06"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "pcapc-${version}";

     

       5
       5
       +
         version = "2015-03-06";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "02j45wmxy8qcji0giwx3364pbqb6849s8y0xfvzx40g98mssl027";

     
···

       24
       24
        
         '';

     

       25
       25
        
       

     

       26
       26
        
         meta = with stdenv.lib; {

     

       27
       27
       -
           inherit version;

     

       28
       27
        
           inherit (src.meta) homepage;

     

       29
       28
        
           description = "Compile libpcap filter expressions into BPF opcodes";

     

       30
       29
        
           license = licenses.gpl3;

+2 -3

pkgs/tools/networking/pingtcp/default.nix

···

       1
       1
        
       { stdenv, fetchgit, cmake }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.0.3"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "pingtcp-${version}";

     

       5
       5
       +
         version = "0.0.3";

     

       6
       6
        
       

     

       7
       7
        
         # This project uses git submodules, which fetchFromGitHub doesn't support:

     

       8
       8
        
         src = fetchgit {

     
···

       27
       27
        
         '';

     

       28
       28
        
       

     

       29
       29
        
         meta = with stdenv.lib; {

     

       30
       30
       -
           inherit version;

     

       31
       30
        
           description = "Measure TCP handshake time";

     

       32
       31
        
           homepage = https://github.com/LanetNetwork/pingtcp;

     

       33
       32
        
           license = licenses.gpl3;

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, perl, zlib, bzip2, xz, makeWrapper }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.18.4"; in

     

       4
       4
       -
       

     

       5
       5
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       6
       4
        
         name = "dpkg-${version}";

     

       5
       5
       +
         version = "1.18.4";

     

       7
       6
        
       

     

       8
       7
        
         src = fetchurl {

     

       9
       8
        
           url = "mirror://debian/pool/main/d/dpkg/dpkg_${version}.tar.xz";

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, intltool, glib, pkgconfig, polkit, python, sqlite }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.0.8"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "packagekit-${version}";

     

       5
       5
       +
         version = "1.0.8";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "1vaxn4kwdwx6p03n88k4pnbd2l6lb0cbxpcs88kjack1jml17c3l";

     
···

       53
       53
        
         '';

     

       54
       54
        
       

     

       55
       55
        
         meta = with stdenv.lib; {

     

       56
       56
       -
           inherit version;

     

       57
       56
        
           description = "System to facilitate installing and updating packages";

     

       58
       57
        
           longDescription = ''

     

       59
       58
        
             PackageKit is a system designed to make installing and updating software

+2 -3

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

···

       1
       1
        
       { stdenv, fetchFromGitHub, autoreconfHook, gtk3, nssTools, pcsclite

     

       2
       2
        
       , pkgconfig }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "4.1.13"; in

     

       5
       5
       -
       stdenv.mkDerivation {

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       6
       5
        
         name = "eid-mw-${version}";

     

       6
       6
       +
         version = "4.1.13";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           sha256 = "1fkazhw6gs191w789fnp6mwnxrx9p38b3kh5bngb1ir0zhkgghkq";

     
···

       35
       35
        
         '';

     

       36
       36
        
       

     

       37
       37
        
         meta = with stdenv.lib; {

     

       38
       38
       -
           inherit version;

     

       39
       38
        
           description = "Belgian electronic identity card (eID) middleware";

     

       40
       39
        
           homepage = http://eid.belgium.be/en/using_your_eid/installing_the_eid_software/linux/;

     

       41
       40
        
           license = licenses.lgpl3;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl, makeWrapper, jre, pcsclite }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "4.1.9"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "eid-viewer-${version}";

     

       5
       5
       +
         version = "4.1.9";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://downloads.services.belgium.be/eid/eid-viewer-${version}-v${version}.src.tar.gz";

     
···

       29
       29
        
         doCheck = true;

     

       30
       30
        
       

     

       31
       31
        
         meta = with stdenv.lib; {

     

       32
       32
       -
           inherit version;

     

       33
       32
        
           description = "Belgian electronic identity card (eID) viewer";

     

       34
       33
        
           homepage = http://eid.belgium.be/en/using_your_eid/installing_the_eid_software/linux/;

     

       35
       34
        
           license = licenses.lgpl3;

+1 -2

pkgs/tools/system/foremost/default.nix

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.5.7"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "foremost-${version}";

     

       5
       5
       +
         version = "1.5.7";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "0d2zxw0ijg8cd3ksgm8cf8jg128zr5x7z779jar90g9f47pm882h";

     
···

       20
       20
        
         '';

     

       21
       21
        
       

     

       22
       22
        
         meta = with stdenv.lib; {

     

       23
       23
       -
           inherit version;

     

       24
       23
        
           description = "Recover files based on their contents";

     

       25
       24
        
           longDescription = ''

     

       26
       25
        
             Foremost is a console program to recover files based on their headers,

+1 -2

pkgs/tools/system/gptfdisk/default.nix

···

       1
       1
        
       { fetchurl, stdenv, libuuid, popt, icu, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.0.1"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "gptfdisk-${version}";

     

       5
       5
       +
         version = "1.0.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           # http://www.rodsbooks.com/gdisk/${name}.tar.gz also works, but the home

     
···

       36
       36
        
         '';

     

       37
       37
        
       

     

       38
       38
        
         meta = with stdenv.lib; {

     

       39
       39
       -
           inherit version;

     

       40
       39
        
           description = "Set of text-mode partitioning tools for Globally Unique Identifier (GUID) Partition Table (GPT) disks";

     

       41
       40
        
           license = licenses.gpl2;

     

       42
       41
        
           homepage = http://www.rodsbooks.com/gdisk/;

+1 -2

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

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.0.2"; in

     

       4
       3
        
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "suid-chroot-${version}";

     

       5
       5
       +
         version = "1.0.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           sha256 = "1a9xqhck0ikn8kfjk338h9v1yjn113gd83q0c50k78xa68xrnxjx";

     
···

       14
       14
        
         '';

     

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
       -
           inherit version;

     

       18
       17
        
           description = "Setuid-safe wrapper for chroot";

     

       19
       18
        
           license = licenses.gpl2Plus;

     

       20
       19
        
           maintainers = with maintainers; [ nckx ];

+2 -3

pkgs/tools/text/aha/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "0.4.8"; in

     

       4
       4
       -
       stdenv.mkDerivation {

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       5
       4
        
         name = "aha-${version}";

     

       5
       5
       +
         version = "0.4.8";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           sha256 = "1209rda6kc9x88b47y1035zs9lxk0x3qzsb87f8m5b55fdkgxqlj";

     
···

       16
       16
        
         enableParallelBuilding = true;

     

       17
       17
        
       

     

       18
       18
        
         meta = with stdenv.lib; {

     

       19
       19
       -
           inherit version;

     

       20
       19
        
           description = "ANSI HTML Adapter";

     

       21
       20
        
           longDescription = ''

     

       22
       21
        
             aha takes ANSI SGR-coloured input and produces W3C-conformant HTML code.