commit 2cf17b080206ef008d7b0d8f443f3cebd2c052ea · pyrox.dev/nixpkgs

+1 -1

.version

lib/customisation.nix

···

       62
       62
        
                   makeOverridable f (origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs));

     

       63
       63
        
                 deepOverride = newArgs:

     

       64
       64
        
                   makeOverridable f (lib.overrideExisting (lib.mapAttrs (deepOverrider newArgs) origArgs) newArgs);

     

       65
       65
       +
                 overrideDerivation = fdrv:

     

       66
       66
       +
                   makeOverridable (args: overrideDerivation (f args) fdrv) origArgs;

     

       65
       67
        
               })

     

       66
       68
        
             else ff;

     

       67
       69

lib/licenses.nix

···

       285
       285
        
       

     

       286
       286
        
         unfreeRedistributableFirmware = "unfree-redistributable-firmware";

     

       287
       287
        
       

     

       288
       288
       +
         unlicense = {

     

       289
       289
       +
           shortName = "Unlicense";

     

       290
       290
       +
           fullName = "Unlicense";

     

       291
       291
       +
           url = http://unlicense.org/;

     

       292
       292
       +
         };

     

       293
       293
       +
       

     

       288
       294
        
         wadalab = {

     

       289
       295
        
           shortName = "wadalab";

     

       290
       296
        
           fullName = "Wadalab Font License";

lib/maintainers.nix

···

       57
       57
        
         ertes = "Ertugrul Söylemez <ertesx@gmx.de>";

     

       58
       58
        
         falsifian = "James Cook <james.cook@utoronto.ca>";

     

       59
       59
        
         flosse = "Markus Kohlhase <mail@markus-kohlhase.de>";

     

       60
       60
       +
         fpletz = "Franz Pletz <fpletz@fnordicwalking.de>";

     

       60
       61
        
         ftrvxmtrx = "Siarhei Zirukin <ftrvxmtrx@gmail.com>";

     

       61
       62
        
         funfunctor = "Edward O'Callaghan <eocallaghan@alterapraxis.com>";

     

       62
       63
        
         fuuzetsu = "Mateusz Kowalczyk <fuuzetsu@fuuzetsu.co.uk>";

+1 -1

nixos/doc/manual/release-notes/release-notes.xml

···

       10
       10
        
       <para>This section lists the release notes for each stable version of NixOS.</para>

     

       11
       11
        
       </partintro>

     

       12
       12
        
       

     

       13
       13
       -
       <xi:include href="rl-1410.xml" />

     

       13
       13
       +
       <xi:include href="rl-1411.xml" />

     

       14
       14
        
       <xi:include href="rl-1404.xml" />

     

       15
       15
        
       <xi:include href="rl-1310.xml" />

     

       16
       16

+3 -3

nixos/doc/manual/release-notes/rl-1410.xml nixos/doc/manual/release-notes/rl-1411.xml

···

       2
       2
        
               xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       3
        
               xmlns:xi="http://www.w3.org/2001/XInclude"

     

       4
       4
        
               version="5.0"

     

       5
       5
       -
               xml:id="sec-release-14.10">

     

       5
       5
       +
               xml:id="sec-release-14.11">

     

       6
       6
        
       

     

       7
       7
       -
       <title>Release 14.10 (“Caterpillar”, 2014/10/??)</title>

     

       7
       7
       +
       <title>Release 14.11 (“Caterpillar”, 2014/11/??)</title>

     

       8
       8
        
       

     

       9
       9
        
       <para>When upgrading from a previous release, please be aware of the

     

       10
       10
        
       following incompatible changes:

     
···

       19
       19
        
       

     

       20
       20
        
       </para>

     

       21
       21
        
       

     

       22
       22
       -
       </chapter>
     

       22
       22
       +
       </chapter>

+1 -1

nixos/modules/installer/tools/tools.nix

···

       1
       1
        
       # This module generates nixos-install, nixos-rebuild,

     

       2
       2
        
       # nixos-generate-config, etc.

     

       3
       3
        
       

     

       4
       4
       -
       { config, pkgs, modulesPath, lib, ... }:

     

       4
       4
       +
       { config, pkgs, modulesPath, ... }:

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7

+2 -4

nixos/modules/misc/ids.nix

···

       156
       156
        
             mailpile = 146;

     

       157
       157
        
             redmine = 147;

     

       158
       158
        
             seeks = 148;

     

       159
       159
       -
       

     

       160
       160
       -
             prosody = 148;

     

       159
       159
       +
             prosody = 149;

     

       161
       160
        
       

     

       162
       161
        
             # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!

     

       163
       162
        
       

     
···

       281
       280
        
             mailpile = 146;

     

       282
       281
        
             redmine = 147;

     

       283
       282
        
             seeks = 148;

     

       284
       284
       -
       

     

       285
       285
       -
             prosody = 148;

     

       283
       283
       +
             prosody = 149;

     

       286
       284
        
       

     

       287
       285
        
             # When adding a gid, make sure it doesn't match an existing uid. And don't use gids above 399!

     

       288
       286

nixos/modules/module-list.nix

···

       364
       364
        
         ./tasks/filesystems/cifs.nix

     

       365
       365
        
         ./tasks/filesystems/ext.nix

     

       366
       366
        
         ./tasks/filesystems/f2fs.nix

     

       367
       367
       +
         ./tasks/filesystems/jfs.nix

     

       367
       368
        
         ./tasks/filesystems/nfs.nix

     

       368
       369
        
         ./tasks/filesystems/reiserfs.nix

     

       369
       370
        
         ./tasks/filesystems/unionfs-fuse.nix

+2 -2

nixos/modules/security/grsecurity.nix

···

       30
       30
        
               type = types.bool;

     

       31
       31
        
               default = false;

     

       32
       32
        
               description = ''

     

       33
       33
       -
                 Enable the stable grsecurity patch, based on Linux 3.2.

     

       33
       33
       +
                 Enable the stable grsecurity patch, based on Linux 3.14.

     

       34
       34
        
               '';

     

       35
       35
        
             };

     

       36
       36
        
       

     
···

       38
       38
        
               type = types.bool;

     

       39
       39
        
               default = false;

     

       40
       40
        
               description = ''

     

       41
       41
       -
                 Enable the testing grsecurity patch, based on Linux 3.13.

     

       41
       41
       +
                 Enable the testing grsecurity patch, based on Linux 3.17.

     

       42
       42
        
               '';

     

       43
       43
        
             };

     

       44
       44

+8 -2

nixos/modules/services/databases/neo4j.nix

···

       19
       19
        
           org.neo4j.server.webadmin.rrdb.location=${cfg.dataDir}/data/rrd

     

       20
       20
        
           org.neo4j.server.webadmin.data.uri=/db/data/

     

       21
       21
        
           org.neo4j.server.webadmin.management.uri=/db/manage/

     

       22
       22
       -
           org.neo4j.server.db.tuning.properties=${pkgs.neo4j}/share/neo4j/conf/neo4j.properties

     

       22
       22
       +
           org.neo4j.server.db.tuning.properties=${cfg.package}/share/neo4j/conf/neo4j.properties

     

       23
       23
        
           org.neo4j.server.manage.console_engines=shell

     

       24
       24
        
           ${cfg.extraServerConfig}

     

       25
       25
        
         '';

     
···

       44
       44
        
             description = "Whether to enable neo4j.";

     

       45
       45
        
             default = false;

     

       46
       46
        
             type = types.uniq types.bool;

     

       47
       47
       +
           };

     

       48
       48
       +
       

     

       49
       49
       +
           package = mkOption {

     

       50
       50
       +
             description = "Neo4j package to use.";

     

       51
       51
       +
             default = pkgs.neo4j;

     

       52
       52
       +
             type = types.package;

     

       47
       53
        
           };

     

       48
       54
        
       

     

       49
       55
        
           host = mkOption {

     
···

       119
       125
        
             after = [ "network-interfaces.target" ];

     

       120
       126
        
             environment = { NEO4J_INSTANCE = cfg.dataDir; };

     

       121
       127
        
             serviceConfig = {

     

       122
       122
       -
               ExecStart = "${pkgs.neo4j}/bin/neo4j console";

     

       128
       128
       +
               ExecStart = "${cfg.package}/bin/neo4j console";

     

       123
       129
        
               User = "neo4j";

     

       124
       130
        
               PermissionsStartOnly = true;

     

       125
       131
        
             };

+9 -5

nixos/modules/services/hardware/udev.nix

···

       169
       169
        
           hardware.firmware = mkOption {

     

       170
       170
        
             type = types.listOf types.path;

     

       171
       171
        
             default = [];

     

       172
       172
       -
             example = [ "/root/my-firmware" ];

     

       173
       172
        
             description = ''

     

       174
       173
        
               List of directories containing firmware files.  Such files

     

       175
       174
        
               will be loaded automatically if the kernel asks for them

     
···

       178
       177
        
               firmware file with the same name, the first path in the list

     

       179
       178
        
               takes precedence.  Note that you must rebuild your system if

     

       180
       179
        
               you add files to any of these directories.  For quick testing,

     

       181
       181
       -
               put firmware files in /root/test-firmware and add that

     

       182
       182
       -
               directory to the list.

     

       183
       183
       -
               Note that you can also add firmware packages to this

     

       184
       184
       -
               list as these are directories in the nix store.

     

       180
       180
       +
               put firmware files in <filename>/root/test-firmware</filename>

     

       181
       181
       +
               and add that directory to the list.  Note that you can also

     

       182
       182
       +
               add firmware packages to this list as these are directories in

     

       183
       183
       +
               the nix store.

     

       185
       184
        
             '';

     

       186
       185
        
             apply = list: pkgs.buildEnv {

     

       187
       186
        
               name = "firmware";

     
···

       244
       243
        
               if [ ! -e /var/lib/udev/prev-systemd -o "$(readlink /var/lib/udev/prev-systemd)" != ${config.systemd.package} ]; then

     

       245
       244
        
                 echo "regenerating udev hardware database..."

     

       246
       245
        
                 ${config.systemd.package}/bin/udevadm hwdb --update && ln -sfn ${config.systemd.package} /var/lib/udev/prev-systemd

     

       246
       246
       +
               fi

     

       247
       247
       +
       

     

       248
       248
       +
               # Allow the kernel to find our firmware.

     

       249
       249
       +
               if [ -e /sys/module/firmware_class/parameters/path ]; then

     

       250
       250
       +
                 echo -n "${config.hardware.firmware}" > /sys/module/firmware_class/parameters/path

     

       247
       251
        
               fi

     

       248
       252
        
             '';

     

       249
       253

+220 -142

nixos/modules/services/monitoring/graphite.nix

···

       24
       24
        
           GRAPHITE_URL = cfg.seyren.graphiteUrl;

     

       25
       25
        
         } // cfg.seyren.extraConfig;

     

       26
       26
        
       

     

       27
       27
       +
         pagerConfig = pkgs.writeText "alarms.yaml" cfg.pager.alerts;

     

       28
       28
       +
       

     

       27
       29
        
         configDir = pkgs.buildEnv {

     

       28
       30
        
           name = "graphite-config";

     

       29
       31
        
           paths = lists.filter (el: el != null) [

     
···

       83
       85
        
       

     

       84
       86
        
           api = {

     

       85
       87
        
             enable = mkOption {

     

       86
       86
       -
               description = "Whether to enable graphite api.";

     

       88
       88
       +
               description = ''

     

       89
       89
       +
                 Whether to enable graphite api. Graphite api is lightweight alternative

     

       90
       90
       +
                 to graphite web, with api and without dashboard. It's advised to use

     

       91
       91
       +
                 grafana as alternative dashboard and influxdb as alternative to

     

       92
       92
       +
                 graphite carbon.

     

       93
       93
       +
       

     

       94
       94
       +
                 For more information visit

     

       95
       95
       +
                 <link xlink:href="http://graphite-api.readthedocs.org/en/latest/"/>

     

       96
       96
       +
               '';

     

       87
       97
        
               default = false;

     

       88
       98
        
               type = types.uniq types.bool;

     

       89
       99
        
             };

     

       90
       100
        
       

     

       91
       101
        
             finders = mkOption {

     

       92
       92
       -
               description = "List of finder plugins load.";

     

       102
       102
       +
               description = "List of finder plugins to load.";

     

       93
       103
        
               default = [];

     

       94
       104
        
               example = [ pkgs.python27Packages.graphite_influxdb ];

     

       95
       105
        
               type = types.listOf types.package;

     
···

       301
       311
        
               '';

     

       302
       312
        
             };

     

       303
       313
        
           };

     

       304
       304
       -
         };

     

       305
       314
        
       

     

       306
       306
       -
         ###### implementation

     

       315
       315
       +
           pager = {

     

       316
       316
       +
             enable = mkOption {

     

       317
       317
       +
               description = ''

     

       318
       318
       +
                 Whether to enable graphite-pager service. For more information visit

     

       319
       319
       +
                 <link xlink:href="https://github.com/seatgeek/graphite-pager"/>

     

       320
       320
       +
               '';

     

       321
       321
       +
               default = false;

     

       322
       322
       +
               type = types.uniq types.bool;

     

       323
       323
       +
             };

     

       307
       324
        
       

     

       308
       308
       -
         config = mkIf (

     

       309
       309
       -
           cfg.carbon.enableAggregator ||

     

       310
       310
       -
           cfg.carbon.enableCache ||

     

       311
       311
       -
           cfg.carbon.enableRelay ||

     

       312
       312
       -
           cfg.web.enable ||

     

       313
       313
       -
           cfg.api.enable ||

     

       314
       314
       -
           cfg.seyren.enable

     

       315
       315
       -
         ) {

     

       316
       316
       -
           systemd.services.carbonCache = {

     

       317
       317
       -
             enable = cfg.carbon.enableCache;

     

       318
       318
       -
             description = "Graphite Data Storage Backend";

     

       319
       319
       -
             wantedBy = [ "multi-user.target" ];

     

       320
       320
       -
             after = [ "network-interfaces.target" ];

     

       321
       321
       -
             environment = carbonEnv;

     

       322
       322
       -
             serviceConfig = {

     

       323
       323
       -
               ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-cache"}";

     

       324
       324
       -
               User = "graphite";

     

       325
       325
       -
               Group = "graphite";

     

       326
       326
       -
               PermissionsStartOnly = true;

     

       325
       325
       +
             redisUrl = mkOption {

     

       326
       326
       +
               description = "Redis connection string.";

     

       327
       327
       +
               default = "redis://localhost:${toString config.services.redis.port}/";

     

       328
       328
       +
               type = types.str;

     

       327
       329
        
             };

     

       328
       328
       -
             preStart = ''

     

       329
       329
       -
               mkdir -p ${cfg.dataDir}/whisper

     

       330
       330
       -
               chmod 0700 ${cfg.dataDir}/whisper

     

       331
       331
       -
               chown -R graphite:graphite ${cfg.dataDir}

     

       332
       332
       -
             '';

     

       333
       333
       -
           };

     

       334
       330
        
       

     

       335
       335
       -
           systemd.services.carbonAggregator = {

     

       336
       336
       -
             enable = cfg.carbon.enableAggregator;

     

       337
       337
       -
             description = "Carbon Data Aggregator";

     

       338
       338
       -
             wantedBy = [ "multi-user.target" ];

     

       339
       339
       -
             after = [ "network-interfaces.target" ];

     

       340
       340
       -
             environment = carbonEnv;

     

       341
       341
       -
             serviceConfig = {

     

       342
       342
       -
               ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-aggregator"}";

     

       343
       343
       -
               User = "graphite";

     

       344
       344
       -
               Group = "graphite";

     

       331
       331
       +
             graphiteUrl = mkOption {

     

       332
       332
       +
               description = "URL to your graphite service.";

     

       333
       333
       +
               default = "http://${cfg.web.host}:${toString cfg.web.port}";

     

       334
       334
       +
               type = types.str;

     

       345
       335
        
             };

     

       346
       346
       -
           };

     

       347
       336
        
       

     

       348
       348
       -
           systemd.services.carbonRelay = {

     

       349
       349
       -
             enable = cfg.carbon.enableRelay;

     

       350
       350
       -
             description = "Carbon Data Relay";

     

       351
       351
       -
             wantedBy = [ "multi-user.target" ];

     

       352
       352
       -
             after = [ "network-interfaces.target" ];

     

       353
       353
       -
             environment = carbonEnv;

     

       354
       354
       -
             serviceConfig = {

     

       355
       355
       -
               ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-relay"}";

     

       356
       356
       -
               User = "graphite";

     

       357
       357
       -
               Group = "graphite";

     

       337
       337
       +
             alerts = mkOption {

     

       338
       338
       +
               description = "Alerts configuration for graphite-pager.";

     

       339
       339
       +
               default = ''

     

       340
       340
       +
                 alerts:

     

       341
       341
       +
                   - target: constantLine(100)

     

       342
       342
       +
                     warning: 90

     

       343
       343
       +
                     critical: 200

     

       344
       344
       +
                     name: Test

     

       345
       345
       +
               '';

     

       346
       346
       +
               example = literalExample ''

     

       347
       347
       +
                 pushbullet_key: pushbullet_api_key 

     

       348
       348
       +
                 alerts:

     

       349
       349
       +
                   - target: stats.seatgeek.app.deal_quality.venue_info_cache.hit

     

       350
       350
       +
                     warning: .5

     

       351
       351
       +
                     critical: 1

     

       352
       352
       +
                     name: Deal quality venue cache hits

     

       353
       353
       +
               '';

     

       354
       354
       +
               type = types.lines;

     

       358
       355
        
             };

     

       359
       356
        
           };

     

       357
       357
       +
         };

     

       360
       358
        
       

     

       361
       361
       -
           systemd.services.graphiteWeb = {

     

       362
       362
       -
             enable = cfg.web.enable;

     

       363
       363
       -
             description = "Graphite Web Interface";

     

       364
       364
       -
             wantedBy = [ "multi-user.target" ];

     

       365
       365
       -
             after = [ "network-interfaces.target" ];

     

       366
       366
       -
             path = [ pkgs.perl ];

     

       367
       367
       -
             environment = {

     

       368
       368
       -
               PYTHONPATH = "${pkgs.python27Packages.graphite_web}/lib/python2.7/site-packages";

     

       369
       369
       -
               DJANGO_SETTINGS_MODULE = "graphite.settings";

     

       370
       370
       -
               GRAPHITE_CONF_DIR = configDir;

     

       371
       371
       -
               GRAPHITE_STORAGE_DIR = dataDir;

     

       359
       359
       +
         ###### implementation

     

       360
       360
       +
       

     

       361
       361
       +
         config = mkMerge [

     

       362
       362
       +
           (mkIf cfg.carbon.enableCache {

     

       363
       363
       +
             systemd.services.carbonCache = {

     

       364
       364
       +
               description = "Graphite Data Storage Backend";

     

       365
       365
       +
               wantedBy = [ "multi-user.target" ];

     

       366
       366
       +
               after = [ "network-interfaces.target" ];

     

       367
       367
       +
               environment = carbonEnv;

     

       368
       368
       +
               serviceConfig = {

     

       369
       369
       +
                 ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-cache"}";

     

       370
       370
       +
                 User = "graphite";

     

       371
       371
       +
                 Group = "graphite";

     

       372
       372
       +
                 PermissionsStartOnly = true;

     

       373
       373
       +
               };

     

       374
       374
       +
               preStart = ''

     

       375
       375
       +
                 mkdir -p ${cfg.dataDir}/whisper

     

       376
       376
       +
                 chmod 0700 ${cfg.dataDir}/whisper

     

       377
       377
       +
                 chown -R graphite:graphite ${cfg.dataDir}

     

       378
       378
       +
               '';

     

       372
       379
        
             };

     

       373
       373
       -
             serviceConfig = {

     

       374
       374
       -
               ExecStart = ''

     

       375
       375
       -
                 ${pkgs.python27Packages.waitress}/bin/waitress-serve \

     

       376
       376
       -
                 --host=${cfg.web.host} --port=${toString cfg.web.port} \

     

       377
       377
       -
                 --call django.core.handlers.wsgi:WSGIHandler'';

     

       378
       378
       -
               User = "graphite";

     

       379
       379
       -
               Group = "graphite";

     

       380
       380
       -
               PermissionsStartOnly = true;

     

       380
       380
       +
           })

     

       381
       381
       +
       

     

       382
       382
       +
           (mkIf cfg.carbon.enableAggregator {

     

       383
       383
       +
             systemd.services.carbonAggregator = {

     

       384
       384
       +
               enable = cfg.carbon.enableAggregator;

     

       385
       385
       +
               description = "Carbon Data Aggregator";

     

       386
       386
       +
               wantedBy = [ "multi-user.target" ];

     

       387
       387
       +
               after = [ "network-interfaces.target" ];

     

       388
       388
       +
               environment = carbonEnv;

     

       389
       389
       +
               serviceConfig = {

     

       390
       390
       +
                 ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-aggregator"}";

     

       391
       391
       +
                 User = "graphite";

     

       392
       392
       +
                 Group = "graphite";

     

       393
       393
       +
               };

     

       381
       394
        
             };

     

       382
       382
       -
             preStart = ''

     

       383
       383
       -
               if ! test -e ${dataDir}/db-created; then

     

       384
       384
       -
                 mkdir -p ${dataDir}/{whisper/,log/webapp/}

     

       385
       385
       -
                 chmod 0700 ${dataDir}/{whisper/,log/webapp/}

     

       395
       395
       +
           })

     

       386
       396
        
       

     

       387
       387
       -
                 # populate database

     

       388
       388
       -
                 ${pkgs.python27Packages.graphite_web}/bin/manage-graphite.py syncdb --noinput

     

       397
       397
       +
           (mkIf cfg.carbon.enableRelay {

     

       398
       398
       +
             systemd.services.carbonRelay = {

     

       399
       399
       +
               description = "Carbon Data Relay";

     

       400
       400
       +
               wantedBy = [ "multi-user.target" ];

     

       401
       401
       +
               after = [ "network-interfaces.target" ];

     

       402
       402
       +
               environment = carbonEnv;

     

       403
       403
       +
               serviceConfig = {

     

       404
       404
       +
                 ExecStart = "${pkgs.twisted}/bin/twistd ${carbonOpts "carbon-relay"}";

     

       405
       405
       +
                 User = "graphite";

     

       406
       406
       +
                 Group = "graphite";

     

       407
       407
       +
               };

     

       408
       408
       +
             };

     

       409
       409
       +
           })

     

       389
       410
        
       

     

       390
       390
       -
                 # create index

     

       391
       391
       -
                 ${pkgs.python27Packages.graphite_web}/bin/build-index.sh

     

       411
       411
       +
           (mkIf (cfg.carbon.enableCache || cfg.carbon.enableAggregator || cfg.carbon.enableRelay) {

     

       412
       412
       +
             environment.systemPackages = [

     

       413
       413
       +
               pkgs.pythonPackages.carbon

     

       414
       414
       +
             ];

     

       415
       415
       +
           })

     

       392
       416
        
       

     

       393
       393
       -
                 touch ${dataDir}/db-created

     

       417
       417
       +
           (mkIf cfg.web.enable {

     

       418
       418
       +
             systemd.services.graphiteWeb = {

     

       419
       419
       +
               description = "Graphite Web Interface";

     

       420
       420
       +
               wantedBy = [ "multi-user.target" ];

     

       421
       421
       +
               after = [ "network-interfaces.target" ];

     

       422
       422
       +
               path = [ pkgs.perl ];

     

       423
       423
       +
               environment = {

     

       424
       424
       +
                 PYTHONPATH = "${pkgs.python27Packages.graphite_web}/lib/python2.7/site-packages";

     

       425
       425
       +
                 DJANGO_SETTINGS_MODULE = "graphite.settings";

     

       426
       426
       +
                 GRAPHITE_CONF_DIR = configDir;

     

       427
       427
       +
                 GRAPHITE_STORAGE_DIR = dataDir;

     

       428
       428
       +
               };

     

       429
       429
       +
               serviceConfig = {

     

       430
       430
       +
                 ExecStart = ''

     

       431
       431
       +
                   ${pkgs.python27Packages.waitress}/bin/waitress-serve \

     

       432
       432
       +
                   --host=${cfg.web.host} --port=${toString cfg.web.port} \

     

       433
       433
       +
                   --call django.core.handlers.wsgi:WSGIHandler'';

     

       434
       434
       +
                 User = "graphite";

     

       435
       435
       +
                 Group = "graphite";

     

       436
       436
       +
                 PermissionsStartOnly = true;

     

       437
       437
       +
               };

     

       438
       438
       +
               preStart = ''

     

       439
       439
       +
                 if ! test -e ${dataDir}/db-created; then

     

       440
       440
       +
                   mkdir -p ${dataDir}/{whisper/,log/webapp/}

     

       441
       441
       +
                   chmod 0700 ${dataDir}/{whisper/,log/webapp/}

     

       394
       442
        
       

     

       395
       395
       -
                 chown -R graphite:graphite ${cfg.dataDir}

     

       396
       396
       -
               fi

     

       397
       397
       -
             '';

     

       398
       398
       -
           };

     

       443
       443
       +
                   # populate database

     

       444
       444
       +
                   ${pkgs.python27Packages.graphite_web}/bin/manage-graphite.py syncdb --noinput

     

       399
       445
        
       

     

       400
       400
       -
           systemd.services.graphiteApi = {

     

       401
       401
       -
             enable = cfg.api.enable;

     

       402
       402
       -
             description = "Graphite Api Interface";

     

       403
       403
       -
             wantedBy = [ "multi-user.target" ];

     

       404
       404
       -
             after = [ "network-interfaces.target" ];

     

       405
       405
       -
             environment = {

     

       406
       406
       -
               PYTHONPATH =

     

       407
       407
       -
                 "${cfg.api.package}/lib/python2.7/site-packages:" +

     

       408
       408
       -
                 concatMapStringsSep ":" (f: f + "/lib/python2.7/site-packages") cfg.api.finders;

     

       409
       409
       -
               GRAPHITE_API_CONFIG = graphiteApiConfig;

     

       410
       410
       -
               LD_LIBRARY_PATH = "${pkgs.cairo}/lib";

     

       446
       446
       +
                   # create index

     

       447
       447
       +
                   ${pkgs.python27Packages.graphite_web}/bin/build-index.sh

     

       448
       448
       +
       

     

       449
       449
       +
                   touch ${dataDir}/db-created

     

       450
       450
       +
       

     

       451
       451
       +
                   chown -R graphite:graphite ${cfg.dataDir}

     

       452
       452
       +
                 fi

     

       453
       453
       +
               '';

     

       411
       454
        
             };

     

       412
       412
       -
             serviceConfig = {

     

       413
       413
       -
               ExecStart = ''

     

       414
       414
       -
                 ${pkgs.python27Packages.waitress}/bin/waitress-serve \

     

       415
       415
       -
                 --host=${cfg.api.host} --port=${toString cfg.api.port} \

     

       416
       416
       -
                 graphite_api.app:app 

     

       455
       455
       +
       

     

       456
       456
       +
             environment.systemPackages = [ pkgs.python27Packages.graphite_web ];

     

       457
       457
       +
           })

     

       458
       458
       +
       

     

       459
       459
       +
           (mkIf cfg.api.enable { 

     

       460
       460
       +
             systemd.services.graphiteApi = {

     

       461
       461
       +
               description = "Graphite Api Interface";

     

       462
       462
       +
               wantedBy = [ "multi-user.target" ];

     

       463
       463
       +
               after = [ "network-interfaces.target" ];

     

       464
       464
       +
               environment = {

     

       465
       465
       +
                 PYTHONPATH =

     

       466
       466
       +
                   "${cfg.api.package}/lib/python2.7/site-packages:" +

     

       467
       467
       +
                   concatMapStringsSep ":" (f: f + "/lib/python2.7/site-packages") cfg.api.finders;

     

       468
       468
       +
                 GRAPHITE_API_CONFIG = graphiteApiConfig;

     

       469
       469
       +
                 LD_LIBRARY_PATH = "${pkgs.cairo}/lib";

     

       470
       470
       +
               };

     

       471
       471
       +
               serviceConfig = {

     

       472
       472
       +
                 ExecStart = ''

     

       473
       473
       +
                   ${pkgs.python27Packages.waitress}/bin/waitress-serve \

     

       474
       474
       +
                   --host=${cfg.api.host} --port=${toString cfg.api.port} \

     

       475
       475
       +
                   graphite_api.app:app 

     

       476
       476
       +
                 '';

     

       477
       477
       +
                 User = "graphite";

     

       478
       478
       +
                 Group = "graphite";

     

       479
       479
       +
                 PermissionsStartOnly = true;

     

       480
       480
       +
               };

     

       481
       481
       +
               preStart = ''

     

       482
       482
       +
                 if ! test -e ${dataDir}/db-created; then

     

       483
       483
       +
                   mkdir -p ${dataDir}/cache/

     

       484
       484
       +
                   chmod 0700 ${dataDir}/cache/

     

       485
       485
       +
       

     

       486
       486
       +
                   touch ${dataDir}/db-created

     

       487
       487
       +
       

     

       488
       488
       +
                   chown -R graphite:graphite ${cfg.dataDir}

     

       489
       489
       +
                 fi

     

       417
       490
        
               '';

     

       418
       418
       -
               User = "graphite";

     

       419
       419
       -
               Group = "graphite";

     

       420
       420
       -
               PermissionsStartOnly = true;

     

       421
       491
        
             };

     

       422
       422
       -
             preStart = ''

     

       423
       423
       -
               if ! test -e ${dataDir}/db-created; then

     

       424
       424
       -
                 mkdir -p ${dataDir}/cache/

     

       425
       425
       -
                 chmod 0700 ${dataDir}/cache/

     

       492
       492
       +
           })

     

       426
       493
        
       

     

       427
       427
       -
                 touch ${dataDir}/db-created

     

       494
       494
       +
           (mkIf cfg.seyren.enable {

     

       495
       495
       +
             systemd.services.seyren = {

     

       496
       496
       +
               description = "Graphite Alerting Dashboard";

     

       497
       497
       +
               wantedBy = [ "multi-user.target" ];

     

       498
       498
       +
               after = [ "network-interfaces.target" "mongodb.service" ];

     

       499
       499
       +
               environment = seyrenConfig;

     

       500
       500
       +
               serviceConfig = {

     

       501
       501
       +
                 ExecStart = "${pkgs.seyren}/bin/seyren -httpPort ${toString cfg.seyren.port}";

     

       502
       502
       +
                 WorkingDirectory = dataDir;

     

       503
       503
       +
                 User = "graphite";

     

       504
       504
       +
                 Group = "graphite"; 

     

       505
       505
       +
               };

     

       506
       506
       +
               preStart = ''

     

       507
       507
       +
                 if ! test -e ${dataDir}/db-created; then

     

       508
       508
       +
                   mkdir -p ${dataDir}

     

       509
       509
       +
                   chown -R graphite:graphite ${dataDir}

     

       510
       510
       +
                 fi

     

       511
       511
       +
               '';

     

       512
       512
       +
             };

     

       428
       513
        
       

     

       429
       429
       -
                 chown -R graphite:graphite ${cfg.dataDir}

     

       430
       430
       -
               fi

     

       431
       431
       -
             '';

     

       432
       432
       -
           };

     

       514
       514
       +
             services.mongodb.enable = mkDefault true;

     

       515
       515
       +
           })

     

       433
       516
        
       

     

       434
       434
       -
           systemd.services.seyren = {

     

       435
       435
       -
             enable = cfg.seyren.enable;

     

       436
       436
       -
             description = "Graphite Alerting Dashboard";

     

       437
       437
       -
             wantedBy = [ "multi-user.target" ];

     

       438
       438
       -
             after = [ "network-interfaces.target" "mongodb.service" ];

     

       439
       439
       -
             environment = seyrenConfig;

     

       440
       440
       -
             serviceConfig = {

     

       441
       441
       -
               ExecStart = "${pkgs.seyren}/bin/seyren -httpPort ${toString cfg.seyren.port}";

     

       442
       442
       -
               WorkingDirectory = dataDir;

     

       443
       443
       -
               User = "graphite";

     

       444
       444
       -
               Group = "graphite"; 

     

       517
       517
       +
           (mkIf cfg.pager.enable {

     

       518
       518
       +
             systemd.services.graphitePager = {

     

       519
       519
       +
               description = "Graphite Pager Alerting Daemon";

     

       520
       520
       +
               wantedBy = [ "multi-user.target" ];

     

       521
       521
       +
               after = [ "network-interfaces.target" "redis.service" ];

     

       522
       522
       +
               environment = {

     

       523
       523
       +
                 REDIS_URL = cfg.pager.redisUrl;

     

       524
       524
       +
                 GRAPHITE_URL = cfg.pager.graphiteUrl;

     

       525
       525
       +
               };

     

       526
       526
       +
               serviceConfig = {

     

       527
       527
       +
                 ExecStart = "${pkgs.pythonPackages.graphite_pager}/bin/graphite-pager --config ${pagerConfig}";

     

       528
       528
       +
                 User = "graphite";

     

       529
       529
       +
                 Group = "graphite"; 

     

       530
       530
       +
               };

     

       445
       531
        
             };

     

       446
       446
       -
             preStart = ''

     

       447
       447
       -
               if ! test -e ${dataDir}/db-created; then

     

       448
       448
       -
                 mkdir -p ${dataDir}

     

       449
       449
       -
                 chown -R graphite:graphite ${dataDir}

     

       450
       450
       -
               fi

     

       451
       451
       -
             '';

     

       452
       452
       -
           };

     

       453
       532
        
       

     

       454
       454
       -
           services.mongodb.enable = mkDefault cfg.seyren.enable;

     

       533
       533
       +
             services.redis.enable = mkDefault true;

     

       455
       534
        
       

     

       456
       456
       -
           environment.systemPackages = [

     

       457
       457
       -
             pkgs.pythonPackages.carbon

     

       458
       458
       -
             pkgs.python27Packages.graphite_web

     

       459
       459
       -
             pkgs.python27Packages.waitress

     

       460
       460
       -
           ];

     

       535
       535
       +
             environment.systemPackages = [ pkgs.pythonPackages.graphite_pager ];

     

       536
       536
       +
           })

     

       461
       537
        
       

     

       462
       462
       -
           users.extraUsers = singleton {

     

       463
       463
       -
             name = "graphite";

     

       464
       464
       -
             uid = config.ids.uids.graphite;

     

       465
       465
       -
             description = "Graphite daemon user";

     

       466
       466
       -
             home = dataDir;

     

       467
       467
       -
           };

     

       468
       468
       -
           users.extraGroups.graphite.gid = config.ids.gids.graphite;

     

       469
       469
       -
         };

     

       538
       538
       +
           {

     

       539
       539
       +
             users.extraUsers = singleton {

     

       540
       540
       +
               name = "graphite";

     

       541
       541
       +
               uid = config.ids.uids.graphite;

     

       542
       542
       +
               description = "Graphite daemon user";

     

       543
       543
       +
               home = dataDir;

     

       544
       544
       +
             };

     

       545
       545
       +
             users.extraGroups.graphite.gid = config.ids.gids.graphite;

     

       546
       546
       +
           }

     

       547
       547
       +
         ];

     

       470
       548
        
       }

+11

nixos/modules/services/networking/cjdns-hosts.sh

···

       1
       1
       +
       pubs=($pubs)

     

       2
       2
       +
       hosts=($hosts)

     

       3
       3
       +
       

     

       4
       4
       +
       lines="''\n"

     

       5
       5
       +
       for ((i = 0; i < ${#pubs[*]}; i++)); do

     

       6
       6
       +
           addr=$($cjdns/bin/publictoip6 ${pubs[i]})

     

       7
       7
       +
           lines="${lines}$addr ${hosts[i]}\n"

     

       8
       8
       +
       done

     

       9
       9
       +
       lines="${lines}''"

     

       10
       10
       +
       

     

       11
       11
       +
       echo -ne $lines > $out

+115 -79

nixos/modules/services/networking/cjdns.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
       

     

       7
       7
       +
         pkg = pkgs.cjdns;

     

       8
       8
       +
       

     

       7
       9
        
         cfg = config.services.cjdns;

     

       8
       10
        
       

     

       11
       11
       +
         connectToSubmodule =

     

       12
       12
       +
         { options, ... }:

     

       13
       13
       +
         { options =

     

       14
       14
       +
           { password = mkOption {

     

       15
       15
       +
             type = types.str;

     

       16
       16
       +
             description = "Authorized password to the opposite end of the tunnel.";

     

       17
       17
       +
             };

     

       18
       18
       +
             publicKey = mkOption {

     

       19
       19
       +
               type = types.str;

     

       20
       20
       +
               description = "Public key at the opposite end of the tunnel.";

     

       21
       21
       +
             };

     

       22
       22
       +
             hostname = mkOption {

     

       23
       23
       +
               default = "";

     

       24
       24
       +
               example = "foobar.hype";

     

       25
       25
       +
               type = types.str;

     

       26
       26
       +
               description = "Optional hostname to add to /etc/hosts; prevents reverse lookup failures.";

     

       27
       27
       +
             };

     

       28
       28
       +
           };

     

       29
       29
       +
         };

     

       30
       30
       +
       

     

       31
       31
       +
         peers = mapAttrsToList (n: v: v) (cfg.ETHInterface.connectTo // cfg.UDPInterface.connectTo);

     

       32
       32
       +
       

     

       33
       33
       +
         pubs  = toString (map (p: if p.hostname == "" then "" else p.publicKey) peers);

     

       34
       34
       +
         hosts = toString (map (p: if p.hostname == "" then "" else p.hostname)  peers);

     

       35
       35
       +
       

     

       36
       36
       +
         cjdnsHosts =

     

       37
       37
       +
           if hosts != "" then

     

       38
       38
       +
             import (pkgs.stdenv.mkDerivation {

     

       39
       39
       +
               name = "cjdns-hosts";

     

       40
       40
       +
               builder = ./cjdns-hosts.sh;

     

       41
       41
       +
       

     

       42
       42
       +
               inherit (pkgs) cjdns;

     

       43
       43
       +
               inherit pubs hosts;

     

       44
       44
       +
             })

     

       45
       45
       +
           else "";

     

       46
       46
       +
       

     

       9
       47
        
         # would be nice to  merge 'cfg' with a //,

     

       10
       48
        
         # but the json nesting is wacky.

     

       11
       49
        
         cjdrouteConf = builtins.toJSON ( {

     
···

       44
       82
        
       

     

       45
       83
        
             enable = mkOption {

     

       46
       84
        
               type = types.bool;

     

       47
       47
       -
       	default = false;

     

       85
       85
       +
               default = false;

     

       48
       86
        
               description = ''

     

       49
       87
        
                 Whether to enable the cjdns network encryption

     

       50
       88
        
                 and routing engine. A file at /etc/cjdns.keys will

     

       51
       89
        
                 be created if it does not exist to contain a random

     

       52
       90
        
                 secret key that your IPv6 address will be derived from.

     

       91
       91
       +
               '';

     

       92
       92
       +
             };

     

       93
       93
       +
       

     

       94
       94
       +
             confFile = mkOption {

     

       95
       95
       +
               type = types.str;

     

       96
       96
       +
               default = "";

     

       97
       97
       +
               example = "/etc/cjdroute.conf";

     

       98
       98
       +
               description = ''

     

       99
       99
       +
                 Ignore all other cjdns options and load configuration from this file.

     

       53
       100
        
               '';

     

       54
       101
        
             };

     

       55
       102
        
       

     

       56
       103
        
             authorizedPasswords = mkOption {

     

       57
       104
        
               type = types.listOf types.str;

     

       58
       58
       -
       	default = [ ];

     

       59
       59
       -
       	example = [

     

       105
       105
       +
               default = [ ];

     

       106
       106
       +
               example = [

     

       60
       107
        
                 "snyrfgkqsc98qh1y4s5hbu0j57xw5s0"

     

       61
       61
       -
       	  "z9md3t4p45mfrjzdjurxn4wuj0d8swv"

     

       62
       62
       -
       	  "49275fut6tmzu354pq70sr5b95qq0vj"

     

       108
       108
       +
                 "z9md3t4p45mfrjzdjurxn4wuj0d8swv"

     

       109
       109
       +
                 "49275fut6tmzu354pq70sr5b95qq0vj"

     

       63
       110
        
               ];

     

       64
       64
       -
       	description = ''

     

       65
       65
       -
       	  Any remote cjdns nodes that offer these passwords on 

     

       66
       66
       -
       	  connection will be allowed to route through this node.

     

       111
       111
       +
               description = ''

     

       112
       112
       +
                 Any remote cjdns nodes that offer these passwords on 

     

       113
       113
       +
                 connection will be allowed to route through this node.

     

       67
       114
        
               '';

     

       68
       115
        
             };

     

       69
       116
        
           

     

       70
       117
        
             admin = {

     

       71
       118
        
               bind = mkOption {

     

       72
       119
        
                 type = types.string;

     

       73
       73
       -
       	  default = "127.0.0.1:11234";

     

       74
       74
       -
       	  description = ''

     

       120
       120
       +
                 default = "127.0.0.1:11234";

     

       121
       121
       +
                 description = ''

     

       75
       122
        
                   Bind the administration port to this address and port.

     

       76
       76
       -
       	  '';

     

       123
       123
       +
                 '';

     

       77
       124
        
               };

     

       78
       125
        
             };

     

       79
       126
        
       

     

       80
       127
        
             UDPInterface = {

     

       81
       128
        
               bind = mkOption {

     

       82
       129
        
                 type = types.string;

     

       83
       83
       -
       	  default = "";

     

       130
       130
       +
                 default = "";

     

       84
       131
        
                 example = "192.168.1.32:43211";

     

       85
       132
        
                 description = ''

     

       86
       86
       -
       	    Address and port to bind UDP tunnels to.

     

       87
       87
       -
       	  '';

     

       88
       88
       -
        	};

     

       133
       133
       +
                   Address and port to bind UDP tunnels to.

     

       134
       134
       +
                 '';

     

       135
       135
       +
                };

     

       89
       136
        
               connectTo = mkOption {

     

       90
       90
       -
                 type = types.attrsOf ( types.submodule (

     

       91
       91
       -
       	    { options, ... }:

     

       92
       92
       -
                   { options = {

     

       93
       93
       -
                       # TODO make host an option, and add it to networking.extraHosts

     

       94
       94
       -
                       password = mkOption {

     

       95
       95
       -
                         type = types.str;

     

       96
       96
       -
                         description = "Authorized password to the opposite end of the tunnel.";

     

       97
       97
       -
                       };

     

       98
       98
       -
                       publicKey = mkOption {

     

       99
       99
       -
                         type = types.str;

     

       100
       100
       -
                         description = "Public key at the opposite end of the tunnel.";

     

       101
       101
       -
                       };

     

       102
       102
       -
                     };

     

       103
       103
       -
                   }

     

       104
       104
       -
                 ));

     

       105
       105
       -
       	  default = { };

     

       137
       137
       +
                 type = types.attrsOf ( types.submodule ( connectToSubmodule ) );

     

       138
       138
       +
                 default = { };

     

       106
       139
        
                 example = {

     

       107
       140
        
                   "192.168.1.1:27313" = {

     

       108
       108
       -
       	      password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";

     

       141
       141
       +
                     hostname = "homer.hype";

     

       142
       142
       +
                     password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";

     

       109
       143
        
                     publicKey = "371zpkgs8ss387tmr81q04mp0hg1skb51hw34vk1cq644mjqhup0.k";

     

       110
       144
        
                   };

     

       111
       145
        
                 };

     

       112
       146
        
                 description = ''

     

       113
       113
       -
       	    Credentials for making UDP tunnels.

     

       114
       114
       -
       	  '';

     

       115
       115
       -
       	};

     

       147
       147
       +
                   Credentials for making UDP tunnels.

     

       148
       148
       +
                 '';

     

       149
       149
       +
               };

     

       116
       150
        
             };

     

       117
       151
        
       

     

       118
       152
        
             ETHInterface = {

     

       119
       153
        
               bind = mkOption {

     

       120
       120
       -
       	  default = "";

     

       121
       121
       -
       	  example = "eth0";

     

       122
       122
       -
       	  description = ''

     

       123
       123
       -
       	    Bind to this device for native ethernet operation.

     

       124
       124
       -
       	  '';

     

       125
       125
       -
               };

     

       154
       154
       +
               default = "";

     

       155
       155
       +
               example = "eth0";

     

       156
       156
       +
               description = ''

     

       157
       157
       +
                 Bind to this device for native ethernet operation.

     

       158
       158
       +
               '';

     

       159
       159
       +
             };

     

       126
       160
        
       

     

       127
       161
        
               beacon = mkOption {

     

       128
       128
       -
       	  type = types.int;

     

       162
       162
       +
                 type = types.int;

     

       129
       163
        
                 default = 2;

     

       130
       164
        
                 description = ''

     

       131
       165
        
                   Auto-connect to other cjdns nodes on the same network.

     

       132
       166
        
                   Options:

     

       133
       133
       -
       	      0: Disabled.

     

       167
       167
       +
                     0: Disabled.

     

       134
       168
        
                     1: Accept beacons, this will cause cjdns to accept incoming

     

       135
       169
        
                        beacon messages and try connecting to the sender.

     

       136
       170
        
                     2: Accept and send beacons, this will cause cjdns to broadcast

     
···

       142
       176
        
               };

     

       143
       177
        
       

     

       144
       178
        
               connectTo = mkOption {

     

       145
       145
       -
                 type = types.attrsOf ( types.submodule (

     

       146
       146
       -
       	    { options, ... }:

     

       147
       147
       -
                   { options = {

     

       148
       148
       -
                       password = mkOption {

     

       149
       149
       -
                         type = types.str;

     

       150
       150
       -
                         description = "Authorized password to the opposite end of the tunnel.";

     

       151
       151
       -
                       };

     

       152
       152
       -
                       publicKey = mkOption {

     

       153
       153
       -
                         type = types.str;

     

       154
       154
       -
                         description = "Public key at the opposite end of the tunnel.";

     

       155
       155
       -
                       };

     

       156
       156
       -
                     };

     

       157
       157
       -
                   }

     

       158
       158
       -
                 ));

     

       159
       159
       -
       	  default = { };

     

       179
       179
       +
                 type = types.attrsOf ( types.submodule ( connectToSubmodule ) );

     

       180
       180
       +
                 default = { };

     

       160
       181
        
                 example = {

     

       161
       182
        
                   "01:02:03:04:05:06" = {

     

       162
       162
       -
       	      password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";

     

       183
       183
       +
                     hostname = "homer.hype";

     

       184
       184
       +
                     password = "5kG15EfpdcKNX3f2GSQ0H1HC7yIfxoCoImnO5FHM";

     

       163
       185
        
                     publicKey = "371zpkgs8ss387tmr81q04mp0hg1skb51hw34vk1cq644mjqhup0.k";

     

       164
       186
        
                   };

     

       165
       187
        
                 };

     

       166
       166
       -
       	  description = ''

     

       167
       167
       -
       	    Credentials for connecting look similar to UDP credientials

     

       188
       188
       +
                 description = ''

     

       189
       189
       +
                   Credentials for connecting look similar to UDP credientials

     

       168
       190
        
                   except they begin with the mac address.

     

       169
       169
       -
       	  '';

     

       170
       170
       -
       	};

     

       191
       191
       +
                 '';

     

       192
       192
       +
               };

     

       171
       193
        
             };

     

       172
       194
        
       

     

       173
       195
        
           };

     
···

       185
       207
        
             wantedBy = [ "multi-user.target" ];

     

       186
       208
        
             after = [ "network-interfaces.target" ];

     

       187
       209
        
       

     

       188
       188
       -
             script = ''

     

       189
       189
       -
               source /etc/cjdns.keys

     

       190
       190
       -
               echo '${cjdrouteConf}' | sed \

     

       191
       191
       -
       	  -e "s/@CJDNS_ADMIN_PASSWORD@/$CJDNS_ADMIN_PASSWORD/g" \

     

       192
       192
       -
                 -e "s/@CJDNS_PRIVATE_KEY@/$CJDNS_PRIVATE_KEY/g" \

     

       193
       193
       -
                   | ${pkgs.cjdns}/bin/cjdroute

     

       194
       194
       -
             '';

     

       210
       210
       +
             script = (

     

       211
       211
       +
               if cfg.confFile != "" then "${pkg}/bin/cjdroute < ${cfg.confFile}" else

     

       212
       212
       +
                 ''

     

       213
       213
       +
                   source /etc/cjdns.keys

     

       214
       214
       +
                   echo '${cjdrouteConf}' | sed \

     

       215
       215
       +
                       -e "s/@CJDNS_ADMIN_PASSWORD@/$CJDNS_ADMIN_PASSWORD/g" \

     

       216
       216
       +
                       -e "s/@CJDNS_PRIVATE_KEY@/$CJDNS_PRIVATE_KEY/g" \

     

       217
       217
       +
                       | ${pkg}/bin/cjdroute

     

       218
       218
       +
                ''

     

       219
       219
       +
             );

     

       195
       220
        
       

     

       196
       221
        
             serviceConfig = {

     

       197
       222
        
               Type = "forking";

     

       198
       198
       -
       	Restart = "on-failure";

     

       223
       223
       +
               Restart = "on-failure";

     

       199
       224
        
             };

     

       200
       225
        
           };

     

       201
       226
        
       

     

       202
       202
       -
           system.activationScripts.cjdns = ''

     

       227
       227
       +
           system.activationScripts.cjdns = if (cfg.confFile == "") then "" else ''

     

       228
       228
       +
             cjdnsWriteKeys() {

     

       229
       229
       +
               private=$1

     

       230
       230
       +
               ipv6=$2

     

       231
       231
       +
               public=$3

     

       232
       232
       +
       

     

       233
       233
       +
               echo "CJDNS_PRIVATE_KEY=$1" >> /etc/cjdns.keys

     

       234
       234
       +
               echo -e "CJDNS_IPV6=$2\nCJDNS_PUBLIC_KEY=$3" > /etc/cjdns.public

     

       235
       235
       +
       

     

       236
       236
       +
               chmod 600 /etc/cjdns.keys

     

       237
       237
       +
               chmod 444 /etc/cjdns.public

     

       238
       238
       +
             }

     

       239
       239
       +
       

     

       203
       240
        
             grep -q "CJDNS_PRIVATE_KEY=" /etc/cjdns.keys || \

     

       204
       204
       -
               echo "CJDNS_PRIVATE_KEY=$(${pkgs.cjdns}/bin/makekey)" \

     

       205
       205
       -
       	  >> /etc/cjdns.keys

     

       241
       241
       +
                 cjdnsWriteKeys $(${pkg}/bin/makekeys)

     

       206
       242
        
       

     

       207
       243
        
             grep -q "CJDNS_ADMIN_PASSWORD=" /etc/cjdns.keys || \

     

       208
       208
       -
               echo "CJDNS_ADMIN_PASSWORD=$(${pkgs.coreutils}/bin/head -c 96 /dev/urandom | ${pkgs.coreutils}/bin/tr -dc A-Za-z0-9)" \

     

       209
       209
       -
       	  >> /etc/cjdns.keys

     

       210
       210
       -
       

     

       211
       211
       -
             chmod 600 /etc/cjdns.keys

     

       244
       244
       +
                 echo "CJDNS_ADMIN_PASSWORD=$(${pkgs.coreutils}/bin/head -c 96 /dev/urandom | ${pkgs.coreutils}/bin/tr -dc A-Za-z0-9)" \

     

       245
       245
       +
                 >> /etc/cjdns.keys

     

       212
       246
        
           '';

     

       213
       247
        
       

     

       248
       248
       +
           networking.extraHosts = "${cjdnsHosts}";

     

       249
       249
       +
       

     

       214
       250
        
           assertions = [

     

       215
       215
       -
             { assertion = ( cfg.ETHInterface.bind != "" || cfg.UDPInterface.bind != "" );

     

       251
       251
       +
             { assertion = ( cfg.ETHInterface.bind != "" || cfg.UDPInterface.bind != "" || cfg.confFile == "" );

     

       216
       252
        
               message = "Neither cjdns.ETHInterface.bind nor cjdns.UDPInterface.bind defined.";

     

       217
       253
        
             }

     

       218
       254
        
             { assertion = config.networking.enableIPv6;

+1 -1

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

···

       18
       18
        
         # determines the default: later modules (if enabled) are preferred.

     

       19
       19
        
         # E.g., if KDE is enabled, it supersedes xterm.

     

       20
       20
        
         imports = [

     

       21
       21
       -
           ./none.nix ./xterm.nix ./xfce.nix ./kde4.nix ./kde4_next.nix

     

       21
       21
       +
           ./none.nix ./xterm.nix ./xfce.nix ./kde4.nix

     

       22
       22
        
           ./e17.nix ./e18.nix ./e19.nix ./gnome3.nix ./xbmc.nix

     

       23
       23
        
         ];

     

       24
       24

+4 -2

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

···

       146
       146
        
                 pkgs.strigi # used by nepomuk

     

       147
       147
        
                 pkgs.mysql # used by akonadi

     

       148
       148
        
               ]

     

       149
       149
       -
             ++ [ nepomukConfig ] ++ phononBackendPackages

     

       150
       150
       -
             ++ config.environment.kdePackages;

     

       149
       149
       +
             ++ lib.optional config.hardware.pulseaudio.enable pkgs.kde4.kmix  # Perhaps this should always be enabled

     

       150
       150
       +
             ++ lib.optional config.hardware.bluetooth.enable pkgs.kde4.bluedevil

     

       151
       151
       +
             ++ lib.optional config.networking.networkmanager.enable pkgs.kde4.networkmanagement

     

       152
       152
       +
             ++ [ nepomukConfig ] ++ phononBackendPackages;

     

       151
       153
        
       

     

       152
       154
        
           environment.pathsToLink = [ "/share" ];

     

       153
       155

-163

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

···

       1
       1
       -
       { config, lib, pkgs, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
       

     

       7
       7
       -
         xcfg = config.services.xserver;

     

       8
       8
       -
         cfg = xcfg.desktopManager.kde4_next;

     

       9
       9
       -
         xorg = pkgs.xorg;

     

       10
       10
       -
         kde = pkgs.kde4_next;

     

       11
       11
       -
       

     

       12
       12
       -
         # Disable Nepomuk and Strigi by default.  As of KDE 4.7, they don't

     

       13
       13
       -
         # really work very well (e.g. searching files often fails to find

     

       14
       14
       -
         # files), segfault sometimes and consume significant resources.

     

       15
       15
       -
         # They can be re-enabled in the KDE System Settings under "Desktop

     

       16
       16
       -
         # Search".

     

       17
       17
       -
         nepomukConfig = pkgs.writeTextFile

     

       18
       18
       -
           { name = "nepomuk-config";

     

       19
       19
       -
             destination = "/share/config/nepomukserverrc";

     

       20
       20
       -
             text =

     

       21
       21
       -
               ''

     

       22
       22
       -
                 [Basic Settings]

     

       23
       23
       -
                 Start Nepomuk=false

     

       24
       24
       -
       

     

       25
       25
       -
                 [Service-nepomukstrigiservice]

     

       26
       26
       -
                 autostart=false

     

       27
       27
       -
               '';

     

       28
       28
       -
           };

     

       29
       29
       -
       

     

       30
       30
       -
         phononBackends = {

     

       31
       31
       -
           gstreamer = [

     

       32
       32
       -
             pkgs.phonon_backend_gstreamer

     

       33
       33
       -
             pkgs.gst_all.gstPluginsBase

     

       34
       34
       -
             pkgs.gst_all.gstPluginsGood

     

       35
       35
       -
             pkgs.gst_all.gstPluginsUgly

     

       36
       36
       -
             pkgs.gst_all.gstPluginsBad

     

       37
       37
       -
             pkgs.gst_all.gstFfmpeg # for mp3 playback

     

       38
       38
       -
             pkgs.gst_all.gstreamer # needed?

     

       39
       39
       -
           ];

     

       40
       40
       -
       

     

       41
       41
       -
           vlc = [pkgs.phonon_backend_vlc];

     

       42
       42
       -
         };

     

       43
       43
       -
       

     

       44
       44
       -
         phononBackendPackages = flip concatMap cfg.phononBackends

     

       45
       45
       -
           (name: attrByPath [name] (throw "unknown phonon backend `${name}'") phononBackends);

     

       46
       46
       -
       

     

       47
       47
       -
       in

     

       48
       48
       -
       

     

       49
       49
       -
       {

     

       50
       50
       -
         options = {

     

       51
       51
       -
       

     

       52
       52
       -
           services.xserver.desktopManager.kde4_next = {

     

       53
       53
       -
             enable = mkOption {

     

       54
       54
       -
               type = types.bool;

     

       55
       55
       -
               default = false;

     

       56
       56
       -
               description = "Enable the KDE 4 desktop environment.";

     

       57
       57
       -
             };

     

       58
       58
       -
       

     

       59
       59
       -
             phononBackends = mkOption {

     

       60
       60
       -
               type = types.listOf types.str;

     

       61
       61
       -
               default = ["gstreamer"];

     

       62
       62
       -
               example = ["gstreamer" "vlc"];

     

       63
       63
       -
               description = "Which phonon multimedia backend kde should use";

     

       64
       64
       -
             };

     

       65
       65
       -
           };

     

       66
       66
       -
       

     

       67
       67
       -
         };

     

       68
       68
       -
       

     

       69
       69
       -
       

     

       70
       70
       -
         config = mkIf (xcfg.enable && cfg.enable) {

     

       71
       71
       -
       

     

       72
       72
       -
           # If KDE 4 is enabled, make it the default desktop manager (unless

     

       73
       73
       -
           # overridden by the user's configuration).

     

       74
       74
       -
           # !!! doesn't work yet ("Multiple definitions. Only one is allowed

     

       75
       75
       -
           # for this option.")

     

       76
       76
       -
           # services.xserver.desktopManager.default = mkOverride 900 "kde4";

     

       77
       77
       -
       

     

       78
       78
       -
           services.xserver.desktopManager.session = singleton

     

       79
       79
       -
             { name = "kde4_next";

     

       80
       80
       -
               bgSupport = true;

     

       81
       81
       -
               start =

     

       82
       82
       -
                 ''

     

       83
       83
       -
                   # The KDE icon cache is supposed to update itself

     

       84
       84
       -
                   # automatically, but it uses the timestamp on the icon

     

       85
       85
       -
                   # theme directory as a trigger.  Since in Nix the

     

       86
       86
       -
                   # timestamp is always the same, this doesn't work.  So as

     

       87
       87
       -
                   # a workaround, nuke the icon cache on login.  This isn't

     

       88
       88
       -
                   # perfect, since it may require logging out after

     

       89
       89
       -
                   # installing new applications to update the cache.

     

       90
       90
       -
                   # See http://lists-archives.org/kde-devel/26175-what-when-will-icon-cache-refresh.html

     

       91
       91
       -
                   rm -fv $HOME/.kde/cache-*/icon-cache.kcache

     

       92
       92
       -
       

     

       93
       93
       -
                   # Qt writes a weird ‘libraryPath’ line to

     

       94
       94
       -
                   # ~/.config/Trolltech.conf that causes the KDE plugin

     

       95
       95
       -
                   # paths of previous KDE invocations to be searched.

     

       96
       96
       -
                   # Obviously using mismatching KDE libraries is potentially

     

       97
       97
       -
                   # disastrous, so here we nuke references to the Nix store

     

       98
       98
       -
                   # in Trolltech.conf.  A better solution would be to stop

     

       99
       99
       -
                   # Qt from doing this wackiness in the first place.

     

       100
       100
       -
                   if [ -e $HOME/.config/Trolltech.conf ]; then

     

       101
       101
       -
                       sed -e '/nix\\store\|nix\/store/ d' -i $HOME/.config/Trolltech.conf

     

       102
       102
       -
                   fi

     

       103
       103
       -
       

     

       104
       104
       -
                   # Start KDE.

     

       105
       105
       -
                   exec ${kde.kdebase_workspace}/bin/startkde

     

       106
       106
       -
                 '';

     

       107
       107
       -
             };

     

       108
       108
       -
       

     

       109
       109
       -
           security.setuidOwners = singleton

     

       110
       110
       -
             { program = "kcheckpass";

     

       111
       111
       -
               source = "${kde.kdebase_workspace}/lib/kde4/libexec/kcheckpass";

     

       112
       112
       -
               owner = "root";

     

       113
       113
       -
               group = "root";

     

       114
       114
       -
               setuid = true;

     

       115
       115
       -
             };

     

       116
       116
       -
       

     

       117
       117
       -
           environment.systemPackages =

     

       118
       118
       -
               [ kde.kdelibs

     

       119
       119
       -
       

     

       120
       120
       -
                 kde.kde_baseapps # Splitted kdebase

     

       121
       121
       -
                 kde.kde_workspace

     

       122
       122
       -
                 kde.kde_runtime

     

       123
       123
       -
                 kde.konsole

     

       124
       124
       -
                 kde.kate

     

       125
       125
       -
       

     

       126
       126
       -
                 kde.kde_wallpapers # contains kdm's default background

     

       127
       127
       -
                 kde.oxygen_icons

     

       128
       128
       -
                 pkgs.virtuoso # to enable Nepomuk to find Virtuoso

     

       129
       129
       -
       

     

       130
       130
       -
                 # Starts KDE's Polkit authentication agent.

     

       131
       131
       -
                 kde.polkit_kde_agent

     

       132
       132
       -
       

     

       133
       133
       -
                 # Miscellaneous runtime dependencies.

     

       134
       134
       -
                 kde.qt4 # needed for qdbus

     

       135
       135
       -
                 pkgs.shared_mime_info

     

       136
       136
       -
                 xorg.xmessage # so that startkde can show error messages

     

       137
       137
       -
                 xorg.xset # used by startkde, non-essential

     

       138
       138
       -
                 xorg.xauth # used by kdesu

     

       139
       139
       -
                 pkgs.shared_desktop_ontologies # used by nepomuk

     

       140
       140
       -
                 pkgs.strigi # used by nepomuk

     

       141
       141
       -
                 pkgs.mysql # used by akonadi

     

       142
       142
       -
               ]

     

       143
       143
       -
             ++ lib.optional config.hardware.pulseaudio.enable kde.kmix  # Perhaps this should always be enabled

     

       144
       144
       -
             ++ lib.optional config.hardware.bluetooth.enable kde.bluedevil

     

       145
       145
       -
             ++ lib.optional config.networking.networkmanager.enable kde.networkmanagement

     

       146
       146
       -
             ++ [ nepomukConfig ] ++ phononBackendPackages;

     

       147
       147
       -
       

     

       148
       148
       -
           environment.pathsToLink = [ "/share" ];

     

       149
       149
       -
       

     

       150
       150
       -
           environment.etc = singleton

     

       151
       151
       -
             { source = "${pkgs.xkeyboard_config}/etc/X11/xkb";

     

       152
       152
       -
               target = "X11/xkb";

     

       153
       153
       -
             };

     

       154
       154
       -
       

     

       155
       155
       -
           # Enable helpful DBus services.

     

       156
       156
       -
           services.udisks2.enable = true;

     

       157
       157
       -
           services.upower.enable = config.powerManagement.enable;

     

       158
       158
       -
       

     

       159
       159
       -
           security.pam.services.kde = { allowNullPassword = true; };

     

       160
       160
       -
       

     

       161
       161
       -
         };

     

       162
       162
       -
       

     

       163
       163
       -
       }

+6 -2

nixos/modules/system/boot/systemd.nix

···

       10
       10
        
       

     

       11
       11
        
         systemd = cfg.package;

     

       12
       12
        
       

     

       13
       13
       +
       

     

       13
       14
        
         makeUnit = name: unit:

     

       15
       15
       +
           let

     

       16
       16
       +
             pathSafeName = lib.replaceChars ["@" "\\"] ["-" "-"] name;

     

       17
       17
       +
           in

     

       14
       18
        
           if unit.enable then

     

       15
       15
       -
             pkgs.runCommand "unit" { preferLocalBuild = true; inherit (unit) text; }

     

       19
       19
       +
             pkgs.runCommand "unit-${pathSafeName}" { preferLocalBuild = true; inherit (unit) text; }

     

       16
       20
        
               ''

     

       17
       21
        
                 mkdir -p $out

     

       18
       22
        
                 echo -n "$text" > $out/${shellEscape name}

     

       19
       23
        
               ''

     

       20
       24
        
           else

     

       21
       21
       -
             pkgs.runCommand "unit" { preferLocalBuild = true; }

     

       25
       25
       +
             pkgs.runCommand "unit-${pathSafeName}-disabled" { preferLocalBuild = true; }

     

       22
       26
        
               ''

     

       23
       27
        
                 mkdir -p $out

     

       24
       28
        
                 ln -s /dev/null $out/${shellEscape name}

+19

nixos/modules/tasks/filesystems/jfs.nix

···

       1
       1
       +
       { config, lib, pkgs, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         inInitrd = any (fs: fs == "jfs") config.boot.initrd.supportedFilesystems;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         config = mkIf (any (fs: fs == "jfs") config.boot.supportedFilesystems) {

     

       10
       10
       +
       

     

       11
       11
       +
           system.fsPackages = [ pkgs.jfsutils ];

     

       12
       12
       +
       

     

       13
       13
       +
           boot.initrd.kernelModules = mkIf inInitrd [ "jfs" ];

     

       14
       14
       +
       

     

       15
       15
       +
           boot.initrd.extraUtilsCommands = mkIf inInitrd ''

     

       16
       16
       +
             cp -v ${pkgs.jfsutils}/sbin/fsck.jfs "$out/bin/"

     

       17
       17
       +
           '';

     

       18
       18
       +
         };

     

       19
       19
       +
       }

nixos/release-small.nix

···

       65
       65
        
             mysql51

     

       66
       66
        
             mysql55

     

       67
       67
        
             nginx

     

       68
       68
       +
             openjdk

     

       68
       69
        
             openssh

     

       69
       70
        
             php

     

       70
       71
        
             postgresql92

nixos/release.nix

···

       234
       234
        
         # ‘nix-build tests/login.nix -A result’.

     

       235
       235
        
         tests.avahi = callTest tests/avahi.nix {};

     

       236
       236
        
         tests.bittorrent = callTest tests/bittorrent.nix {};

     

       237
       237
       +
         tests.blivet = callTest tests/blivet.nix {};

     

       237
       238
        
         tests.containers = callTest tests/containers.nix {};

     

       238
       239
        
         tests.firefox = callTest tests/firefox.nix {};

     

       239
       240
        
         tests.firewall = callTest tests/firewall.nix {};

+85

nixos/tests/blivet.nix

···

       1
       1
       +
       import ./make-test.nix ({ pkgs, ... }: with pkgs.pythonPackages; rec {

     

       2
       2
       +
         name = "blivet";

     

       3
       3
       +
       

     

       4
       4
       +
         machine = {

     

       5
       5
       +
           environment.systemPackages = [ pkgs.python blivet mock ];

     

       6
       6
       +
           boot.supportedFilesystems = [ "btrfs" "jfs" "reiserfs" "xfs" ];

     

       7
       7
       +
           virtualisation.memorySize = 768;

     

       8
       8
       +
         };

     

       9
       9
       +
       

     

       10
       10
       +
         debugBlivet       = false;

     

       11
       11
       +
         debugProgramCalls = false;

     

       12
       12
       +
       

     

       13
       13
       +
         pythonTestRunner = pkgs.writeText "run-blivet-tests.py" ''

     

       14
       14
       +
           import sys

     

       15
       15
       +
           import logging

     

       16
       16
       +
       

     

       17
       17
       +
           from unittest import TestLoader

     

       18
       18
       +
           from unittest.runner import TextTestRunner

     

       19
       19
       +
       

     

       20
       20
       +
           ${pkgs.lib.optionalString debugProgramCalls ''

     

       21
       21
       +
             blivet_program_log = logging.getLogger("program")

     

       22
       22
       +
             blivet_program_log.setLevel(logging.DEBUG)

     

       23
       23
       +
             blivet_program_log.addHandler(logging.StreamHandler(sys.stderr))

     

       24
       24
       +
           ''}

     

       25
       25
       +
       

     

       26
       26
       +
           ${pkgs.lib.optionalString debugBlivet ''

     

       27
       27
       +
             blivet_log = logging.getLogger("blivet")

     

       28
       28
       +
             blivet_log.setLevel(logging.DEBUG)

     

       29
       29
       +
             blivet_log.addHandler(logging.StreamHandler(sys.stderr))

     

       30
       30
       +
           ''}

     

       31
       31
       +
       

     

       32
       32
       +
           runner = TextTestRunner(verbosity=2, failfast=False, buffer=False)

     

       33
       33
       +
           result = runner.run(TestLoader().discover('tests/', pattern='*_test.py'))

     

       34
       34
       +
           sys.exit(not result.wasSuccessful())

     

       35
       35
       +
         '';

     

       36
       36
       +
       

     

       37
       37
       +
         blivetTest = pkgs.writeScript "blivet-test.sh" ''

     

       38
       38
       +
           #!${pkgs.stdenv.shell} -e

     

       39
       39
       +
       

     

       40
       40
       +
           # Use the hosts temporary directory, because we have a tmpfs within the VM

     

       41
       41
       +
           # and we don't want to increase the memory size of the VM for no reason.

     

       42
       42
       +
           mkdir -p /tmp/xchg/bigtmp

     

       43
       43
       +
           TMPDIR=/tmp/xchg/bigtmp

     

       44
       44
       +
           export TMPDIR

     

       45
       45
       +
       

     

       46
       46
       +
           mkPythonPath() {

     

       47
       47
       +
             nix-store -qR "$@" \

     

       48
       48
       +
               | sed -e 's|$|/lib/${pkgs.python.libPrefix}/site-packages|'

     

       49
       49
       +
           }

     

       50
       50
       +
       

     

       51
       51
       +
           cp -Rd "${blivet.src}/tests" .

     

       52
       52
       +
       

     

       53
       53
       +
           # Skip SELinux tests

     

       54
       54
       +
           rm -f tests/formats_test/selinux_test.py

     

       55
       55
       +
       

     

       56
       56
       +
           # Race conditions in growing/shrinking during resync

     

       57
       57
       +
           rm -f tests/devicelibs_test/mdraid_*

     

       58
       58
       +
       

     

       59
       59
       +
           # Deactivate small BTRFS device test, because it fails with newer btrfsprogs

     

       60
       60
       +
           sed -i -e '/^class *BTRFSAsRootTestCase3(/,/^[^ ]/ {

     

       61
       61
       +
             /^class *BTRFSAsRootTestCase3(/d

     

       62
       62
       +
             /^$/d

     

       63
       63
       +
             /^ /d

     

       64
       64
       +
           }' tests/devicelibs_test/btrfs_test.py

     

       65
       65
       +
       

     

       66
       66
       +
           # How on earth can these tests ever work even upstream? O_o

     

       67
       67
       +
           sed -i -e '/def testDiskChunk[12]/,/^ *[^ ]/{n; s/^ */&return # /}' \

     

       68
       68
       +
             tests/partitioning_test.py

     

       69
       69
       +
       

     

       70
       70
       +
           # fix hardcoded temporary directory

     

       71
       71
       +
           sed -i \

     

       72
       72
       +
             -e '1i import tempfile' \

     

       73
       73
       +
             -e 's|_STORE_FILE_PATH = .*|_STORE_FILE_PATH = tempfile.gettempdir()|' \

     

       74
       74
       +
             tests/loopbackedtestcase.py

     

       75
       75
       +
       

     

       76
       76
       +
           PYTHONPATH=".:$(mkPythonPath "${blivet}" "${mock}" | paste -sd :)" \

     

       77
       77
       +
             python "${pythonTestRunner}"

     

       78
       78
       +
         '';

     

       79
       79
       +
       

     

       80
       80
       +
         testScript = ''

     

       81
       81
       +
           $machine->waitForUnit("multi-user.target");

     

       82
       82
       +
           $machine->succeed("${blivetTest}");

     

       83
       83
       +
           $machine->execute("rm -rf /tmp/xchg/bigtmp");

     

       84
       84
       +
         '';

     

       85
       85
       +
       })

+2 -2

nixos/tests/partition.nix

···

       67
       67
        
       

     

       68
       68
        
         machine = { config, pkgs, ... }: {

     

       69
       69
        
           environment.systemPackages = [

     

       70
       70
       -
             pkgs.pythonPackages.nixpart

     

       70
       70
       +
             pkgs.pythonPackages.nixpart0

     

       71
       71
        
             pkgs.file pkgs.btrfsProgs pkgs.xfsprogs pkgs.lvm2

     

       72
       72
        
           ];

     

       73
       73
        
           virtualisation.emptyDiskImages = [ 4096 4096 ];

     
···

       209
       209
        
             ensurePartition("swap", "swap");

     

       210
       210
        
             ensurePartition("boot", "f2fs");

     

       211
       211
        
             ensurePartition("root", "f2fs");

     

       212
       212
       -
             remoteAndCheck;

     

       212
       212
       +
             remountAndCheck;

     

       213
       213
        
             ensureMountPoint("/mnt/boot", "f2fs");

     

       214
       214
        
           };

     

       215
       215

+30

pkgs/applications/audio/ncmpcpp/beta.nix

···

       1
       1
       +
       { stdenv, fetchurl, ncurses, curl, taglib, fftw, mpd_clientlib, pkgconfig

     

       2
       2
       +
       , boost, readline, libiconvOrEmpty }:

     

       3
       3
       +
       

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       5
       5
       +
         version = "0.6_beta5";

     

       6
       6
       +
         name = "ncmpcpp-${version}";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchurl {

     

       9
       9
       +
           url = "http://ncmpcpp.rybczak.net/stable/ncmpcpp-${version}.tar.bz2";

     

       10
       10
       +
           sha256 = "05h4mahnh39y9ab333whsgspj5mnbdkqfssgfi4r0zf1fvjwlwj6";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         buildInputs = [ ncurses curl taglib fftw mpd_clientlib pkgconfig boost readline ]

     

       14
       14
       +
           ++ libiconvOrEmpty;

     

       15
       15
       +
       

     

       16
       16
       +
         configureFlags = [

     

       17
       17
       +
           "BOOST_LIB_SUFFIX="

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         enableParallelBuilding = true;

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with stdenv.lib; {

     

       23
       23
       +
           description = "Curses-based interface for MPD (music player daemon)";

     

       24
       24
       +
           homepage    = http://unkart.ovh.org/ncmpcpp/;

     

       25
       25
       +
           license     = licenses.gpl2Plus;

     

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

     

       27
       27
       +
           platforms   = platforms.all;

     

       28
       28
       +
         };

     

       29
       29
       +
       }

     

       30
       30
       +

+2 -2

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

···

       9
       9
        
       assert stdenv.isDarwin -> libXaw != null;	# fails to link otherwise

     

       10
       10
        
       

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
       -
         name = "emacs-24.3";

     

       12
       12
       +
         name = "emacs-24.4";

     

       13
       13
        
       

     

       14
       14
        
         builder = ./builder.sh;

     

       15
       15
        
       

     

       16
       16
        
         src = fetchurl {

     

       17
       17
        
           url    = "mirror://gnu/emacs/${name}.tar.xz";

     

       18
       18
       -
           sha256 = "1385qzs3bsa52s5rcncbrkxlydkw0ajzrvfxgv8rws5fx512kakh";

     

       18
       18
       +
           sha256 = "1zflm6ac34s6v166p58ilxrxbxjm0q2wfc25f8y0mjml1lbr3qs7";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         patches = [ ./darwin-new-sections.patch ];

+4 -4

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

···

       2
       2
        
       }:

     

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
       -
         emacsName = "emacs-24.3";

     

       6
       6
       -
         name = "${emacsName}-mac-4.8";

     

       5
       5
       +
         emacsName = "emacs-24.4";

     

       6
       6
       +
         name = "${emacsName}-mac-5.0";

     

       7
       7
        
       

     

       8
       8
        
         #builder = ./builder.sh;

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "mirror://gnu/emacs/${emacsName}.tar.xz";

     

       12
       12
       -
           sha256 = "1385qzs3bsa52s5rcncbrkxlydkw0ajzrvfxgv8rws5fx512kakh";

     

       12
       12
       +
           sha256 = "1zflm6ac34s6v166p58ilxrxbxjm0q2wfc25f8y0mjml1lbr3qs7";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         macportSrc = fetchurl {

     

       16
       16
        
           url = "ftp://ftp.math.s.chiba-u.ac.jp/emacs/${name}.tar.gz";

     

       17
       17
       -
           sha256 = "194y341zrpjp75mc3099kjc0inr1d379wwsnav257bwsc967h8yx";

     

       17
       17
       +
           sha256 = "14ipkwmzv0b02sclhgp2xj0cvhl3gk40sc2l21s87621kk640dzv";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         patches = [ ./darwin-new-sections.patch ];

+29

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

···

       1
       1
       +
       { stdenv, fetchFromGitHub, emacs }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         version = "0.15.0-8-g4e10851";

     

       5
       5
       +
       in

     

       6
       6
       +
       stdenv.mkDerivation {

     

       7
       7
       +
         name = "git-modes-${version}";

     

       8
       8
       +
       

     

       9
       9
       +
         src = fetchFromGitHub {

     

       10
       10
       +
           owner = "magit";

     

       11
       11
       +
           repo = "git-modes";

     

       12
       12
       +
           rev = "4e10851843145e0c05fc665683d3b487a57ad114";

     

       13
       13
       +
           sha256 = "13j794a2p4ql9dnw2z0c1m0ybclxsicbk8cmmfqcchs4ygiyc6ag";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [ emacs ];

     

       17
       17
       +
       

     

       18
       18
       +
         installPhase = ''

     

       19
       19
       +
           mkdir -p $out/share/emacs/site-lisp

     

       20
       20
       +
           mv *.el *.elc $out/share/emacs/site-lisp/

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         meta = {

     

       24
       24
       +
           homepage = "https://github.com/magit/git-modes";

     

       25
       25
       +
           description = "Emacs modes for various Git-related files";

     

       26
       26
       +
           license = stdenv.lib.licenses.gpl3Plus;

     

       27
       27
       +
           maintainers = with stdenv.lib.maintainers; [ simons ];

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+21 -12

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

···

       1
       1
       -
       { stdenv, fetchurl, emacs, texinfo }:

     

       1
       1
       +
       { stdenv, fetchFromGitHub, emacs, texinfo, gitModes, git }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         version = "1.2.0";

     

       4
       4
       +
         version = "90141016";

     

       5
       5
        
       in

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         name = "magit-${version}";

     

       8
       8
        
       

     

       9
       9
       -
         src = fetchurl {

     

       10
       10
       -
           url = "https://github.com/downloads/magit/magit/${name}.tar.gz";

     

       11
       11
       -
           sha256 = "1a8vvilhd5y5vmlpsh194qpl4qlg0a1brylfscxcacpfp0cmhlzg";

     

       9
       9
       +
         src = fetchFromGitHub {

     

       10
       10
       +
           owner = "magit";

     

       11
       11
       +
           repo = "magit";

     

       12
       12
       +
           rev = version;

     

       13
       13
       +
           sha256 = "11d3gzj0hlb7wqsjzjb0vf9i0ik4xzwdyayjy4hfgx0gjmymkfx3";

     

       12
       14
        
         };

     

       13
       15
        
       

     

       14
       14
       -
         buildInputs = [ emacs texinfo ];

     

       16
       16
       +
         buildInputs = [ emacs texinfo git ];

     

       17
       17
       +
         propagatedUserEnvPkgs = [ gitModes ];

     

       18
       18
       +
       

     

       19
       19
       +
         configurePhase = ''

     

       20
       20
       +
           makeFlagsArray=(

     

       21
       21
       +
             PREFIX="$out"

     

       22
       22
       +
             EFLAGS="-L ${gitModes}/share/emacs/site-lisp"

     

       23
       23
       +
             lispdir="$out/share/emacs/site-lisp"

     

       24
       24
       +
           )

     

       25
       25
       +
         '';

     

       15
       26
        
       

     

       16
       16
       -
         configurePhase = "makeFlagsArray=( PREFIX=$out SYSCONFDIR=$out/etc )";

     

       27
       27
       +
         doCheck = true;

     

       28
       28
       +
         checkTarget = "test";

     

       17
       29
        
       

     

       18
       18
       -
         # Add (require 'magit-site-init) to your ~/.emacs file to set-up magit mode.

     

       19
       30
        
         postInstall = ''

     

       20
       20
       -
           mv $out/etc/emacs/site-start.d/50magit.el $out/share/emacs/site-lisp/magit-site-init.el

     

       21
       21
       -
           sed -i -e 's|50magit|magit-site-init|' $out/share/emacs/site-lisp/magit-site-init.el

     

       22
       22
       -
           rmdir $out/etc/emacs/site-start.d $out/etc/emacs $out/etc

     

       31
       31
       +
           mkdir -p $out/bin

     

       32
       32
       +
           mv "bin/"* $out/bin/

     

       23
       33
        
         '';

     

       24
       34
        
       

     

       25
       35
        
         meta = {

     
···

       39
       49
        
             save you from learning Git itself.

     

       40
       50
        
           '';

     

       41
       51
        
       

     

       42
       42
       -
           platforms = stdenv.lib.platforms.all;

     

       43
       52
        
           maintainers = with stdenv.lib.maintainers; [ simons ];

     

       44
       53
        
         };

     

       45
       54
        
       }

+7 -5

pkgs/applications/editors/vim/macvim.nix

···

       1
       1
       -
       { stdenv, stdenvAdapters, gccApple, fetchFromGitHub, ncurses, gettext,

     

       1
       1
       +
       { stdenv, fetchFromGitHub, ncurses, gettext,

     

       2
       2
        
         pkgconfig, cscope, python, ruby, tcl, perl, luajit

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
       -
       let inherit (stdenvAdapters.overrideGCC stdenv gccApple) mkDerivation;

     

       6
       6
       -
       in mkDerivation rec {

     

       5
       5
       +
       stdenv.mkDerivation rec {

     

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

     

       8
       7
        
       

     

       9
       9
       -
         version = "7.4.355";

     

       8
       8
       +
         version = "7.4.479";

     

       10
       9
        
       

     

       11
       10
        
         src = fetchFromGitHub {

     

       12
       11
        
           owner = "genoma";

     

       13
       12
        
           repo = "macvim";

     

       14
       14
       -
           rev = "c18a61f9723565664ffc2eda9179e96c95860e25";

     

       13
       13
       +
           rev = "f9c084b97fa9d5cad2448dfd3eff3d9b7f0fac59";

     

       15
       14
        
           sha256 = "190bngg8m4bwqcia7w24gn7mmqkhk0mavxy81ziwysam1f652ymf";

     

       16
       15
        
         };

     

       17
       16
        
       

     
···

       46
       45
        
             "--enable-perlinterp=dynamic"

     

       47
       46
        
             "--enable-rubyinterp=dynamic"

     

       48
       47
        
             "--enable-tclinterp=yes"

     

       48
       48
       +
             "--without-local-dir"

     

       49
       49
        
             "--with-luajit"

     

       50
       50
        
             "--with-lua-prefix=${luajit}"

     

       51
       51
        
             "--with-ruby-command=${ruby}/bin/ruby"

     
···

       53
       53
        
             "--with-tlib=ncurses"

     

       54
       54
        
             "--with-compiledby=Nix"

     

       55
       55
        
         ];

     

       56
       56
       +
       

     

       57
       57
       +
         makeFlags = ''PREFIX=$(out) CPPFLAGS="-Wno-error"'';

     

       56
       58
        
       

     

       57
       59
        
         preConfigure = ''

     

       58
       60
        
           DEV_DIR=$(/usr/bin/xcode-select -print-path)/Platforms/MacOSX.platform/Developer

+33

pkgs/applications/editors/vim/macvim.patch

···

       187
       187
        
          # Use ||, not &&, to avoid exiting from the if with $? = 1, which

     

       188
       188
        
          # would make configure fail if this is the last instruction.

     

       189
       189
        
          $ac_cs_success || as_fn_exit 1

     

       190
       190
       +
       

     

       191
       191
       +
       diff --git a/src/Makefile b/src/Makefile

     

       192
       192
       +
       index 1c4d104..fff2015 100644

     

       193
       193
       +
       --- a/src/Makefile

     

       194
       194
       +
       +++ b/src/Makefile

     

       195
       195
       +
       @@ -1298,7 +1298,7 @@ MACVIMGUI_SRC	= gui.c gui_beval.c MacVim/gui_macvim.m MacVim/MMBackend.m \

     

       196
       196
       +
        		  MacVim/MacVim.m

     

       197
       197
       +
        MACVIMGUI_OBJ	= objects/gui.o objects/gui_beval.o objects/pty.o \

     

       198
       198
       +
        		  objects/gui_macvim.o objects/MMBackend.o objects/MacVim.o

     

       199
       199
       +
       -MACVIMGUI_DEFS	= -DFEAT_GUI_MACVIM -Wall -Wno-unknown-pragmas -pipe

     

       200
       200
       +
       +MACVIMGUI_DEFS	= -DMACOS_X_UNIX -DFEAT_GUI_MACVIM -Wall -Wno-unknown-pragmas -pipe

     

       201
       201
       +
        MACVIMGUI_IPATH	=

     

       202
       202
       +
        MACVIMGUI_LIBS_DIR =

     

       203
       203
       +
        MACVIMGUI_LIBS1	= -framework Cocoa -framework Carbon

     

       204
       204
       +
       

     

       205
       205
       +
       diff --git a/src/if_python.c b/src/if_python.c

     

       206
       206
       +
       index b356bf7..b7bfa78 100644

     

       207
       207
       +
       --- a/src/if_python.c

     

       208
       208
       +
       +++ b/src/if_python.c

     

       209
       209
       +
       @@ -55,11 +55,7 @@

     

       210
       210
       +
        

     

       211
       211
       +
        #define PY_SSIZE_T_CLEAN

     

       212
       212
       +
        

     

       213
       213
       +
       -#ifdef FEAT_GUI_MACVIM

     

       214
       214
       +
       -# include <Python/Python.h>

     

       215
       215
       +
       -#else

     

       216
       216
       +
       -# include <Python.h>

     

       217
       217
       +
       -#endif

     

       218
       218
       +
       +#include <Python.h>

     

       219
       219
       +
        

     

       220
       220
       +
        #if !defined(PY_VERSION_HEX) || PY_VERSION_HEX < 0x02050000

     

       221
       221
       +
        # undef PY_SSIZE_T_CLEAN

     

       222
       222
       +
        MACVIMGUI_LIBS1	= -framework Cocoa -framework Carbon

+9 -11

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

···

       9
       9
        
       # ‘reload’ and similar functions should all work as long as the user

     

       10
       10
        
       # doesn't need new libraries at which point they should add them to

     

       11
       11
        
       # extraPackages and rebuild from the expression.

     

       12
       12
       -
       { cabal, yi, extraPackages, makeWrapper }:

     

       13
       13
       -
       

     

       12
       12
       +
       { cabal, yi, extraPackages, makeWrapper, ghcWithPackages }:

     

       13
       13
       +
       let

     

       14
       14
       +
         w = ghcWithPackages (self: [ yi ] ++ extraPackages self);

     

       15
       15
       +
         wrappedGhc = w.override { ignoreCollisions = true; };

     

       16
       16
       +
       in

     

       14
       17
        
       cabal.mkDerivation (self: rec {

     

       15
       18
        
         pname = "yi-custom";

     

       16
       19
        
         version = "0.0.0.1";

     

       17
       20
        
         src = ./yi-custom-cabal;

     

       18
       21
        
         isLibrary = true;

     

       19
       19
       -
         buildDepends = extraPackages ++ [ yi ];

     

       22
       22
       +
         buildDepends = [ yi ];

     

       20
       23
        
         buildTools = [ makeWrapper ];

     

       21
       24
        
         noHaddock = true;

     

       22
       25
        
         doCheck = false;

     

       23
       26
        
       

     

       24
       24
       -
         # Allows Yi to find the libraries it needs at runtime. We drop ‘:’

     

       25
       25
       -
         # from this GHC_PACKAGE_PATH because we're wrapping over a different

     

       26
       26
       -
         # wrapper that used --prefix: if we didn't, we end up with a

     

       27
       27
       -
         # double-colon, confusing GHC.

     

       27
       27
       +
         # put custom GHC env in front which stops crap from being picked up

     

       28
       28
       +
         # from user database

     

       28
       29
        
         postInstall = ''

     

       29
       29
       -
           makeWrapper ${yi}/bin/yi $out/bin/yi --set GHC_PACKAGE_PATH ''${GHC_PACKAGE_PATH%?}

     

       30
       30
       +
           makeWrapper ${yi}/bin/yi $out/bin/yi --prefix PATH : ${wrappedGhc}/bin

     

       30
       31
        
         '';

     

       31
       31
       -
       

     

       32
       32
        
         meta = {

     

       33
       33
        
           homepage = "http://haskell.org/haskellwiki/Yi";

     

       34
       34
        
           description = "Wrapper over user-specified Haskell libraries for use in Yi config";

     

       35
       35
        
           license = self.stdenv.lib.licenses.publicDomain;

     

       36
       36
        
           platforms = self.ghc.meta.platforms;

     

       37
       37
        
           maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];

     

       38
       38
       -
           # The wrapper does not yet work properly if we actually try to use it.

     

       39
       39
       -
           broken = true;

     

       40
       38
        
         };

     

       41
       39
        
       

     

       42
       40
        
       })

+5 -9

pkgs/applications/editors/yi/yi.nix

···

       2
       2
        
       

     

       3
       3
        
       { cabal, binary, Cabal, cautiousFile, dataDefault, derive, dlist

     

       4
       4
        
       , dynamicState, dyre, filepath, glib, gtk, hashable, hint, HUnit

     

       5
       5
       -
       , lens, makeWrapper, mtl, ooPrototypes, pango, parsec, pointedlist

     

       6
       6
       -
       , QuickCheck, random, regexBase, regexTdfa, safe, semigroups, split

     

       7
       7
       -
       , tagged, tasty, tastyHunit, tastyQuickcheck, text, time

     

       8
       8
       -
       , transformersBase, unixCompat, unorderedContainers, utf8String

     

       9
       9
       -
       , vty, wordTrie, xdgBasedir, yiLanguage, yiRope

     

       5
       5
       +
       , lens, mtl, ooPrototypes, pango, parsec, pointedlist, QuickCheck

     

       6
       6
       +
       , random, regexBase, regexTdfa, safe, semigroups, split, tagged

     

       7
       7
       +
       , tasty, tastyHunit, tastyQuickcheck, text, time, transformersBase

     

       8
       8
       +
       , unixCompat, unorderedContainers, utf8String, vty, wordTrie

     

       9
       9
       +
       , xdgBasedir, yiLanguage, yiRope

     

       10
       10
        
       }:

     

       11
       11
        
       

     

       12
       12
        
       cabal.mkDerivation (self: {

     
···

       27
       27
        
           filepath HUnit lens QuickCheck semigroups tasty tastyHunit

     

       28
       28
        
           tastyQuickcheck text yiLanguage yiRope

     

       29
       29
        
         ];

     

       30
       30
       -
         buildTools = [ makeWrapper ];

     

       31
       30
        
         configureFlags = "-fpango -fvty";

     

       32
       31
        
         noHaddock = self.stdenv.lib.versionOlder self.ghc.version "7.8";

     

       33
       33
       -
         postInstall = ''

     

       34
       34
       -
           wrapProgram $out/bin/yi --suffix GHC_PACKAGE_PATH : $out/lib/ghc-${self.ghc.version}/package.conf.d/yi-$version.installedconf:$GHC_PACKAGE_PATH

     

       35
       35
       -
         '';

     

       36
       32
        
         meta = {

     

       37
       33
        
           homepage = "http://haskell.org/haskellwiki/Yi";

     

       38
       34
        
           description = "The Haskell-Scriptable Editor";

+2 -2

pkgs/applications/graphics/ImageMagick/default.nix

···

       18
       18
        
       }:

     

       19
       19
        
       

     

       20
       20
        
       let

     

       21
       21
       -
         version = "6.8.9-0";

     

       21
       21
       +
         version = "6.8.9-8";

     

       22
       22
        
       in

     

       23
       23
        
       stdenv.mkDerivation rec {

     

       24
       24
        
         name = "ImageMagick-${version}";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchurl {

     

       27
       27
        
           url = "mirror://imagemagick/${name}.tar.xz";

     

       28
       28
       -
           sha256 = "1lapn2798fkc2wn81slpms5p21kq4dsyg45khsk7n8p69cvrmw2b";

     

       28
       28
       +
           sha256 = "1c792hbwi308lm9xkml319xaa4w3bz6hwy6i92jwrm7kqr4h8di7";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         enableParallelBuilding = true;

pkgs/applications/graphics/sxiv/default.nix

···

       20
       20
        
           homepage = "https://github.com/muennich/sxiv";

     

       21
       21
        
           license = stdenv.lib.licenses.gpl2Plus;

     

       22
       22
        
           platforms = stdenv.lib.platforms.linux;

     

       23
       23
       +
           maintainers = with stdenv.lib.maintainers; [ fuuzetsu ];

     

       23
       24
        
         };

     

       24
       25
        
       }

+2 -2

pkgs/applications/misc/blender/default.nix

···

       9
       9
        
       with lib;

     

       10
       10
        
       

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
       -
         name = "blender-2.72";

     

       12
       12
       +
         name = "blender-2.72b";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "http://download.blender.org/source/${name}.tar.gz";

     

       16
       16
       -
           sha256 = "0wydh5bs1pxnx3ya65lfy3val1s8wz027a5kb4va6wg3aqnwlvlv";

     

       16
       16
       +
           sha256 = "0ixz8h3c08p4f84x8r85nzddwvc0h5lw1ci8gdg2x3m2mw2cfdj4";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         buildInputs =

+2 -2

pkgs/applications/misc/calibre/default.nix

···

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       stdenv.mkDerivation rec {

     

       8
       8
       -
         name = "calibre-2.5.0";

     

       8
       8
       +
         name = "calibre-2.6.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "mirror://sourceforge/calibre/${name}.tar.xz";

     

       12
       12
       -
           sha256 = "0zl2rpwn5xdgwm4ffb5pizk3247wfghl8ilz0i80hyp36zzxgl8p";

     

       12
       12
       +
           sha256 = "0z7nnqsal8yfi83fqari7z9xywq6l84jm0nma2mw0gvybysys4cv";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         inherit python;

+110

pkgs/applications/misc/k2pdfopt/default.nix

···

       1
       1
       +
       # Build procedure lifted from https://aur.archlinux.org/packages/k2/k2pdfopt/PKGBUILD

     

       2
       2
       +
       { stdenv, fetchzip, fetchurl, writeScript, libX11, libXext, autoconf, automake, libtool

     

       3
       3
       +
             , leptonica, libpng, libtiff, zlib, openjpeg, freetype, jbig2dec, djvulibre

     

       4
       4
       +
             , openssl }:

     

       5
       5
       +
       

     

       6
       6
       +
       let

     

       7
       7
       +
         mupdf_src = fetchurl {

     

       8
       8
       +
           url = http://www.mupdf.com/downloads/archive/mupdf-1.5-source.tar.gz;

     

       9
       9
       +
           sha256 = "0sl47zqf4c9fhs4h5zg046vixjmwgy4vhljhr5g4md733nash7z4";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         tess_src = fetchurl {

     

       13
       13
       +
           url = http://tesseract-ocr.googlecode.com/files/tesseract-ocr-3.02.02.tar.gz;

     

       14
       14
       +
           sha256 = "0g81m9y4iydp7kgr56mlkvjdwpp3mb01q385yhdnyvra7z5kkk96";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         gocr_src = fetchurl {

     

       18
       18
       +
           url = http://www-e.uni-magdeburg.de/jschulen/ocr/gocr-0.49.tar.gz;

     

       19
       19
       +
           sha256 = "06hpzp7rkkwfr1fvmc8kcfz9v490i9yir7f7imh13gmka0fr6afc";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
       in stdenv.mkDerivation rec {

     

       23
       23
       +
         name = "k2pdfopt";

     

       24
       24
       +
         src = fetchzip {

     

       25
       25
       +
           url = http://www.willus.com/k2pdfopt/src/k2pdfopt_v2.21_src.zip;

     

       26
       26
       +
           sha256 = "1vy0yw41z6p95gmivjk4r534zbg0kqap4lr9ps56kvjw51q8r54j";

     

       27
       27
       +
         };

     

       28
       28
       +
       

     

       29
       29
       +
         buildInputs = [ libX11 libXext autoconf automake libtool leptonica libpng libtiff zlib

     

       30
       30
       +
                           openjpeg freetype jbig2dec djvulibre openssl ];

     

       31
       31
       +
         NIX_LDFLAGS = "-lX11 -lXext";

     

       32
       32
       +
       

     

       33
       33
       +
         k2_pa = ./k2pdfopt.patch;

     

       34
       34
       +
         tess_pa = ./tesseract.patch;

     

       35
       35
       +
       

     

       36
       36
       +
         builder = writeScript "builder.sh" ''

     

       37
       37
       +
           . ${stdenv}/setup

     

       38
       38
       +
           set -e

     

       39
       39
       +
       

     

       40
       40
       +
           plibs=`pwd`/patched_libraries

     

       41
       41
       +
       

     

       42
       42
       +
           tar zxf ${mupdf_src}

     

       43
       43
       +
           cp $src/mupdf_mod/font.c $src/mupdf_mod/string.c mupdf-1.5-source/source/fitz/

     

       44
       44
       +
           cp $src/mupdf_mod/pdf-* mupdf-1.5-source/source/pdf

     

       45
       45
       +
       

     

       46
       46
       +
           tar zxf ${tess_src}

     

       47
       47
       +
           cp $src/tesseract_mod/dawg.cpp tesseract-ocr/dict

     

       48
       48
       +
           cp $src/tesseract_mod/tessdatamanager.cpp tesseract-ocr/ccutil

     

       49
       49
       +
           cp $src/tesseract_mod/tessedit.cpp tesseract-ocr/ccmain

     

       50
       50
       +
           cp $src/tesseract_mod/tesscapi.cpp tesseract-ocr/api

     

       51
       51
       +
           cp $src/include_mod/tesseract.h $src/include_mod/leptonica.h tesseract-ocr/api

     

       52
       52
       +
       

     

       53
       53
       +
           cp -a $src k2pdfopt_v2.21

     

       54
       54
       +
           chmod -R +w k2pdfopt_v2.21

     

       55
       55
       +
       

     

       56
       56
       +
           patch -p0 -i $tess_pa

     

       57
       57
       +
           patch -p0 -i $k2_pa

     

       58
       58
       +
       

     

       59
       59
       +
           cd tesseract-ocr

     

       60
       60
       +
           ./autogen.sh

     

       61
       61
       +
           substituteInPlace "configure" \

     

       62
       62
       +
                   --replace 'LIBLEPT_HEADERSDIR="/usr/local/include /usr/include"' \

     

       63
       63
       +
                   'LIBLEPT_HEADERSDIR=${leptonica}/include'

     

       64
       64
       +
           ./configure --prefix=$plibs --disable-shared

     

       65
       65
       +
           make install

     

       66
       66
       +
       

     

       67
       67
       +
           cd ..

     

       68
       68
       +
           tar zxf ${gocr_src}

     

       69
       69
       +
           cd gocr-0.49

     

       70
       70
       +
           ./configure

     

       71
       71
       +
           cp src/{gocr.h,pnm.h,unicode.h,list.h} $plibs/include

     

       72
       72
       +
           cp include/config.h $plibs/include

     

       73
       73
       +
           make libs

     

       74
       74
       +
           cp src/libPgm2asc.a $plibs/lib

     

       75
       75
       +
       

     

       76
       76
       +
           cd ../mupdf-1.5-source

     

       77
       77
       +
           make prefix=$plibs install

     

       78
       78
       +
           install -Dm644 build/debug/libmujs.a $plibs/lib

     

       79
       79
       +
       

     

       80
       80
       +
           cd ../k2pdfopt_v2.21/k2pdfoptlib

     

       81
       81
       +
           gcc -Ofast -Wall -c *.c -I ../include_mod/ -I $plibs/include \

     

       82
       82
       +
               -I . -I ../willuslib

     

       83
       83
       +
           ar rcs libk2pdfopt.a *.o

     

       84
       84
       +
       

     

       85
       85
       +
           cd ../willuslib

     

       86
       86
       +
           gcc -Ofast -Wall -c *.c -I ../include_mod/ -I $plibs/include

     

       87
       87
       +
           ar rcs libwillus.a *.o

     

       88
       88
       +
       

     

       89
       89
       +
           cd ..

     

       90
       90
       +
           gcc -Wall -Ofast -o k2pdfopt.o -c k2pdfopt.c -I k2pdfoptlib/ -I willuslib/ \

     

       91
       91
       +
                   -I include_mod/ -I $plibs/include

     

       92
       92
       +
           g++ -Ofast k2pdfopt.o -o k2pdfopt -I willuslib/ -I k2pdfoptlib/ -I include_mod/ \

     

       93
       93
       +
                   -I $plibs/include -L $plibs/lib/ \

     

       94
       94
       +
                   -L willuslib/ -L k2pdfoptlib/ -lk2pdfopt -lwillus -ldjvulibre -lz -lmupdf  \

     

       95
       95
       +
                   -ljbig2dec -ljpeg -lopenjp2 -lpng -lfreetype -lpthread -lmujs \

     

       96
       96
       +
                   -lPgm2asc -llept -ltesseract -lcrypto

     

       97
       97
       +
       

     

       98
       98
       +
           mkdir -p $out/bin

     

       99
       99
       +
           cp k2pdfopt $out/bin

     

       100
       100
       +
         '';

     

       101
       101
       +
       

     

       102
       102
       +
         meta = with stdenv.lib; {

     

       103
       103
       +
           description = "K2pdfopt optimizes PDF/DJVU files for mobile e-readers (e.g. the Kindle) and smartphones.";

     

       104
       104
       +
           homepage = http://www.willus.com/k2pdfopt;

     

       105
       105
       +
           license = licenses.gpl3;

     

       106
       106
       +
           platforms = platforms.linux;

     

       107
       107
       +
           maintainers = [ maintainers.bosu ];

     

       108
       108
       +
         };

     

       109
       109
       +
       }

     

       110
       110
       +

+95

pkgs/applications/misc/k2pdfopt/k2pdfopt.patch

···

       1
       1
       +
       diff -aur k2pdfopt_v2.21/willuslib/array.c k2pdfopt_v2.21.new/willuslib/array.c

     

       2
       2
       +
       --- k2pdfopt_v2.21/willuslib/array.c	2014-05-23 16:29:58.000000000 -0300

     

       3
       3
       +
       +++ k2pdfopt_v2.21.new/willuslib/array.c	2014-07-26 11:35:49.829825567 -0300

     

       4
       4
       +
       @@ -1055,7 +1055,7 @@

     

       5
       5
       +
        void arrayf_sort(float *a,int n)

     

       6
       6
       +
        

     

       7
       7
       +
            {

     

       8
       8
       +
       -    sort(a,(long)n);

     

       9
       9
       +
       +    willus_sort(a,(long)n);

     

       10
       10
       +
            }

     

       11
       11
       +
        

     

       12
       12
       +
        

     

       13
       13
       +
       diff -aur k2pdfopt_v2.21/willuslib/math.c k2pdfopt_v2.21.new/willuslib/math.c

     

       14
       14
       +
       --- k2pdfopt_v2.21/willuslib/math.c	2013-08-15 21:33:50.000000000 -0300

     

       15
       15
       +
       +++ k2pdfopt_v2.21.new/willuslib/math.c	2014-07-26 11:36:02.853170659 -0300

     

       16
       16
       +
       @@ -532,7 +532,7 @@

     

       17
       17
       +
        

     

       18
       18
       +
        

     

       19
       19
       +
        

     

       20
       20
       +
       -void sort(float *x,int n)

     

       21
       21
       +
       +void willus_sort(float *x,int n)

     

       22
       22
       +
        

     

       23
       23
       +
            {

     

       24
       24
       +
            int top,n1;

     

       25
       25
       +
       diff -aur k2pdfopt_v2.21/willuslib/ocrjocr.c k2pdfopt_v2.21.new/willuslib/ocrjocr.c

     

       26
       26
       +
       --- k2pdfopt_v2.21/willuslib/ocrjocr.c	2012-11-12 13:09:42.000000000 -0300

     

       27
       27
       +
       +++ k2pdfopt_v2.21.new/willuslib/ocrjocr.c	2014-07-26 11:36:46.699837185 -0300

     

       28
       28
       +
       @@ -29,6 +29,8 @@

     

       29
       29
       +
        #ifdef HAVE_GOCR_LIB

     

       30
       30
       +
        #include <gocr.h>

     

       31
       31
       +
        

     

       32
       32
       +
       +job_t *JOB;

     

       33
       33
       +
       +

     

       34
       34
       +
        /*

     

       35
       35
       +
        ** bmp8 must be grayscale

     

       36
       36
       +
        ** (x1,y1) and (x2,y2) from top left of bitmap

     

       37
       37
       +
       @@ -66,6 +68,7 @@

     

       38
       38
       +
            h=y2-y1+1;

     

       39
       39
       +
            dh=h+bw*2;

     

       40
       40
       +
            job=&_job;

     

       41
       41
       +
       +    JOB=job;

     

       42
       42
       +
            job_init(job);

     

       43
       43
       +
            job_init_image(job);

     

       44
       44
       +
            // willus_mem_alloc_warn((void **)&job->src.p.p,w*h,funcname,10);

     

       45
       45
       +
       diff -aur k2pdfopt_v2.21/willuslib/string.c k2pdfopt_v2.21.new/willuslib/string.c

     

       46
       46
       +
       --- k2pdfopt_v2.21/willuslib/string.c	2014-02-03 00:37:44.000000000 -0300

     

       47
       47
       +
       +++ k2pdfopt_v2.21.new/willuslib/string.c	2014-07-26 11:37:01.766506277 -0300

     

       48
       48
       +
       @@ -81,7 +81,7 @@

     

       49
       49
       +
        ** Returns NULL if EOF, otherwise returns pointer to the string.

     

       50
       50
       +
        **

     

       51
       51
       +
        */

     

       52
       52
       +
       -char *get_line(char *buf,int max,FILE *f)

     

       53
       53
       +
       +char *willus_get_line(char *buf,int max,FILE *f)

     

       54
       54
       +
        

     

       55
       55
       +
            {

     

       56
       56
       +
            int     i;

     

       57
       57
       +
       diff -aur k2pdfopt_v2.21/willuslib/willus.h k2pdfopt_v2.21.new/willuslib/willus.h

     

       58
       58
       +
       --- k2pdfopt_v2.21/willuslib/willus.h	2014-07-25 15:03:51.000000000 -0300

     

       59
       59
       +
       +++ k2pdfopt_v2.21.new/willuslib/willus.h	2014-07-26 11:37:56.316506038 -0300

     

       60
       60
       +
       @@ -214,9 +214,6 @@

     

       61
       61
       +
        ** CMAKE handles the defines, not this source

     

       62
       62
       +
        ** (Mod from Dirk Thierbach, 31-Dec-2013)

     

       63
       63
       +
        */

     

       64
       64
       +
       -#ifdef USE_CMAKE

     

       65
       65
       +
       -#include "config.h"

     

       66
       66
       +
       -#else /* USE_CMAKE */

     

       67
       67
       +
        

     

       68
       68
       +
        #ifndef HAVE_Z_LIB

     

       69
       69
       +
        #define HAVE_Z_LIB

     

       70
       70
       +
       @@ -268,7 +265,6 @@

     

       71
       71
       +
        #undef HAVE_GSL_LIB

     

       72
       72
       +
        #endif

     

       73
       73
       +
        

     

       74
       74
       +
       -#endif /* USE_CMAKE */

     

       75
       75
       +
        /*

     

       76
       76
       +
        ** Consistency check

     

       77
       77
       +
        */

     

       78
       78
       +
       @@ -533,7 +529,7 @@

     

       79
       79
       +
                              int *n,FILE *err);

     

       80
       80
       +
        int    readxyz_ex    (char *filename,double **x,double **y,double **z,

     

       81
       81
       +
                              int *n,FILE *err,int ignore_after_semicolon);

     

       82
       82
       +
       -void   sort          (float *x,int n);

     

       83
       83
       +
       +void   willus_sort          (float *x,int n);

     

       84
       84
       +
        void   sortd         (double *x,int n);

     

       85
       85
       +
        void   sorti         (int *x,int n);

     

       86
       86
       +
        void   sortxy        (float *x,float *y,int n);

     

       87
       87
       +
       @@ -602,7 +598,7 @@

     

       88
       88
       +
        /* string.c */

     

       89
       89
       +
        void   clean_line    (char *buf);

     

       90
       90
       +
        void   clean_line_end(char *buf);

     

       91
       91
       +
       -char  *get_line      (char *buf,int max,FILE *f);

     

       92
       92
       +
       +char  *willus_get_line      (char *buf,int max,FILE *f);

     

       93
       93
       +
        char  *get_line_cf   (char *buf,int max,FILE *f);

     

       94
       94
       +
        int   mem_get_line_cf(char *buf,int maxlen,char *cptr,long *cindex,long csize);

     

       95
       95
       +
        int    in_string     (char *buffer,char *pattern);

+12

pkgs/applications/misc/k2pdfopt/tesseract.patch

···

       1
       1
       +
       diff -aur tesseract-ocr/api/Makefile.am tesseract-ocr.new/api/Makefile.am

     

       2
       2
       +
       --- tesseract-ocr/api/Makefile.am	2012-10-09 14:18:39.000000000 -0300

     

       3
       3
       +
       +++ tesseract-ocr.new/api/Makefile.am	2014-03-20 18:43:13.926030341 -0300

     

       4
       4
       +
       @@ -36,7 +36,7 @@

     

       5
       5
       +
        if VISIBILITY

     

       6
       6
       +
        libtesseract_api_la_CPPFLAGS += -DTESS_EXPORTS

     

       7
       7
       +
        endif

     

       8
       8
       +
       -libtesseract_api_la_SOURCES = baseapi.cpp capi.cpp

     

       9
       9
       +
       +libtesseract_api_la_SOURCES = baseapi.cpp capi.cpp tesscapi.cpp

     

       10
       10
       +
        

     

       11
       11
       +
        lib_LTLIBRARIES += libtesseract.la

     

       12
       12
       +
        libtesseract_la_LDFLAGS =

+39

pkgs/applications/misc/qpdfview/default.nix

···

       1
       1
       +
       {stdenv, fetchurl, qt4, pkgconfig, popplerQt4, djvulibre, libspectre, cups

     

       2
       2
       +
       , file, ghostscript

     

       3
       3
       +
       }:

     

       4
       4
       +
       let

     

       5
       5
       +
         s = # Generated upstream information

     

       6
       6
       +
         rec {

     

       7
       7
       +
           baseName="qpdfview";

     

       8
       8
       +
           version="0.4.12";

     

       9
       9
       +
           name="${baseName}-${version}";

     

       10
       10
       +
           url="https://launchpad.net/qpdfview/trunk/${version}/+download/qpdfview-${version}.tar.gz";

     

       11
       11
       +
           sha256="1h6lrrh1vblqkxrd89nmid7d21anyn30iahj24z62yny35lidf0g";

     

       12
       12
       +
         };

     

       13
       13
       +
         buildInputs = [

     

       14
       14
       +
           qt4 popplerQt4 pkgconfig djvulibre libspectre cups file ghostscript

     

       15
       15
       +
         ];

     

       16
       16
       +
       in

     

       17
       17
       +
       stdenv.mkDerivation {

     

       18
       18
       +
         inherit (s) name version;

     

       19
       19
       +
         inherit buildInputs;

     

       20
       20
       +
         src = fetchurl {

     

       21
       21
       +
           inherit (s) url sha256;

     

       22
       22
       +
         };

     

       23
       23
       +
         configurePhase = ''

     

       24
       24
       +
           qmake *.pro

     

       25
       25
       +
           for i in *.pro; do 

     

       26
       26
       +
             qmake "$i" -o "Makefile.$(basename "$i" .pro)"

     

       27
       27
       +
           done

     

       28
       28
       +
           sed -e "s@/usr/@$out/@g" -i Makefile*

     

       29
       29
       +
         '';

     

       30
       30
       +
         meta = {

     

       31
       31
       +
           inherit (s) version;

     

       32
       32
       +
           description = "A tabbed document viewer";

     

       33
       33
       +
           license = stdenv.lib.licenses.gpl2;

     

       34
       34
       +
           maintainers = [stdenv.lib.maintainers.raskin];

     

       35
       35
       +
           platforms = stdenv.lib.platforms.linux;

     

       36
       36
       +
           homepage = "https://launchpad.net/qpdfview";

     

       37
       37
       +
           updateWalker = true;

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+5 -5

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

···

       1
       1
       -
       { stdenv, fetchgit, unzip, xulrunner, makeWrapper }:

     

       1
       1
       +
       { stdenv, fetchgit, unzip, firefox, makeWrapper }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation {

     

       4
       4
        
         name = "conkeror-1.0pre-20140616";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchgit {

     

       7
       7
        
           url = git://repo.or.cz/conkeror.git;

     

       8
       8
       -
           rev = "8a26fff5896a3360549e2adfbf06b1d57e909266";

     

       9
       9
       -
           sha256 = "56f1c71ca1753a63d7599d3e8bf52277711b2693e7709ed7c146f34940441cb4";

     

       8
       8
       +
           rev = "98e89c7e5ff3a1069a0984338da01273cdb189a2";

     

       9
       9
       +
           sha256 = "284ba966efebfa0aaa768abc1a4f901e2ecf5db9d0391d904a49118b0b94fcd7";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ unzip makeWrapper ];

     
···

       15
       15
        
           mkdir -p $out/libexec/conkeror

     

       16
       16
        
           cp -r * $out/libexec/conkeror

     

       17
       17
        
       

     

       18
       18
       -
           makeWrapper ${xulrunner}/bin/xulrunner $out/bin/conkeror \

     

       19
       19
       -
             --add-flags $out/libexec/conkeror/application.ini

     

       18
       18
       +
           makeWrapper ${firefox}/bin/firefox $out/bin/conkeror \

     

       19
       19
       +
             --add-flags "-app $out/libexec/conkeror/application.ini"

     

       20
       20
        
         '';

     

       21
       21
        
       

     

       22
       22
        
         meta = {

+1 -1

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

···

       66
       66
        
           ]

     

       67
       67
        
           ++ (if debugBuild then [ "--enable-debug" "--enable-profiling"]

     

       68
       68
        
                             else [ "--disable-debug" "--enable-release"

     

       69
       69
       -
                                    "--enable-optimize${lib.optionalString (stdenv.system == "i686-linux") "=-O3"}"

     

       69
       69
       +
                                    "--enable-optimize${lib.optionalString (stdenv.system == "i686-linux") "=-O1"}"

     

       70
       70
        
                                    "--enable-strip" ])

     

       71
       71
        
           ++ lib.optional enableOfficialBranding "--enable-official-branding";

     

       72
       72

+3 -3

pkgs/applications/networking/browsers/mozilla-plugins/flashplayer-11/default.nix

···

       36
       36
        
       

     

       37
       37
        
       let

     

       38
       38
        
         # -> http://get.adobe.com/flashplayer/

     

       39
       39
       -
         version = "11.2.202.406";

     

       39
       39
       +
         version = "11.2.202.411";

     

       40
       40
        
       

     

       41
       41
        
         src =

     

       42
       42
        
           if stdenv.system == "x86_64-linux" then

     
···

       47
       47
        
             else rec {

     

       48
       48
        
               inherit version;

     

       49
       49
        
               url = "http://fpdownload.macromedia.com/get/flashplayer/pdc/${version}/install_flash_player_11_linux.x86_64.tar.gz";

     

       50
       50
       -
               sha256 = "05akcw89kz0cnhan6wp72banz2asmvqfhb2cw1krn66qgd7bl0x0";

     

       50
       50
       +
               sha256 = "1983rj824bhzk48yhgminsiil778vwq0217hfrhbmymhrq3p7gzd";

     

       51
       51
        
             }

     

       52
       52
        
           else if stdenv.system == "i686-linux" then

     

       53
       53
        
             if debug then

     
···

       60
       60
        
             else rec {

     

       61
       61
        
               inherit version;

     

       62
       62
        
               url = "http://fpdownload.macromedia.com/get/flashplayer/pdc/${version}/install_flash_player_11_linux.i386.tar.gz";

     

       63
       63
       -
               sha256 = "10f3842vi80kszj42f4c8sw7plrmvsin5k860cqvlzgdhndz8i4b";

     

       63
       63
       +
               sha256 = "1bxp94s63i3136pjxgcm8106mqzaj4h096mkf7iq6ddkcvi0cxzn";

     

       64
       64
        
             }

     

       65
       65
        
           else throw "Flash Player is not supported on this platform";

     

       66
       66

+27

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

···

       1
       1
       +
       { stdenv, fetchurl, pythonPackages, pyqt4, cython, libvncserver, zlib, twisted, gnutls }:

     

       2
       2
       +
       

     

       3
       3
       +
       pythonPackages.buildPythonPackage rec {

     

       4
       4
       +
         name = "blink-${version}";

     

       5
       5
       +
         version = "0.9.1";

     

       6
       6
       +
         

     

       7
       7
       +
         src = fetchurl {

     

       8
       8
       +
           url = "http://download.ag-projects.com/BlinkQt/${name}.tar.gz";

     

       9
       9
       +
           sha256 = "f578e5186893c3488e7773fbb775028ae54540433a0c51aefa5af983ca2bfdae";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         patches = [ ./pythonpath.patch ];

     

       13
       13
       +
       

     

       14
       14
       +
         propagatedBuildInputs = [ pyqt4 pythonPackages.cjson pythonPackages.sipsimple twisted ];

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [ cython zlib libvncserver ];

     

       17
       17
       +
       

     

       18
       18
       +
         postInstall = ''

     

       19
       19
       +
           wrapProgram $out/bin/blink \

     

       20
       20
       +
             --prefix LD_LIBRARY_PATH : ${gnutls}/lib

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         meta = {

     

       24
       24
       +
           homepage = http://icanblink.com/;

     

       25
       25
       +
           description = "A state of the art, easy to use SIP client";

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+12

pkgs/applications/networking/instant-messengers/blink/pythonpath.patch

···

       1
       1
       +
       diff --git a/blink/resources.py b/blink/resources.py

     

       2
       2
       +
       index 524d9e5..c271887 100644

     

       3
       3
       +
       --- a/blink/resources.py

     

       4
       4
       +
       +++ b/blink/resources.py

     

       5
       5
       +
       @@ -64,6 +64,7 @@ class Resources(object):

     

       6
       6
       +
                    if script == '':

     

       7
       7
       +
                        application_directory = os.path.realpath(script) # executed in interactive interpreter

     

       8
       8
       +
                    else:

     

       9
       9
       +
       +                script = os.path.join(sys.path[0], script)

     

       10
       10
       +
                        binary_directory = os.path.dirname(os.path.realpath(script))

     

       11
       11
       +
                        if os.path.basename(binary_directory) == 'bin':

     

       12
       12
       +
                            application_directory = os.path.dirname(binary_directory)

+5 -5

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

···

       1
       1
       -
       { stdenv, fetchurl, unzip, xulrunner, makeWrapper }:

     

       1
       1
       +
       { stdenv, fetchurl, unzip, firefox, makeWrapper }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "chatzilla-0.9.90.1";

     

       4
       4
       +
         name = "chatzilla-0.9.91";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           # Obtained from http://chatzilla.rdmsoft.com/xulrunner/.

     

       8
       8
        
           url = "http://chatzilla.rdmsoft.com/xulrunner/download/${name}.en-US.xulapp";

     

       9
       9
       -
           sha256 = "0z38jig91h10cb14rvs30rpg2pgn3v890nyxyy8lxzbv5ncxmngw";

     

       9
       9
       +
           sha256 = "1bmjw2wvp8gh7fdl8czkxc55iari6dy672446hps20xixrh8hl8r";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ unzip makeWrapper ];

     
···

       15
       15
        
           mkdir -p $out/libexec/chatzilla

     

       16
       16
        
           unzip $src -d $out/libexec/chatzilla

     

       17
       17
        
       

     

       18
       18
       -
           makeWrapper ${xulrunner}/bin/xulrunner $out/bin/chatzilla \

     

       19
       19
       -
             --add-flags $out/libexec/chatzilla/application.ini

     

       18
       18
       +
           makeWrapper ${firefox}/bin/firefox $out/bin/chatzilla \

     

       19
       19
       +
             --add-flags "-app $out/libexec/chatzilla/application.ini"

     

       20
       20
        
       

     

       21
       21
        
           sed -i $out/libexec/chatzilla/application.ini -e 's/.*MaxVersion.*/MaxVersion=99.*/'

     

       22
       22
        
         '';

+18 -44

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

···

       1
       1
       -
       { fetchurl, stdenv, bash, emacs, gdb, glib, gmime, gnupg,

     

       1
       1
       +
       { fetchurl, stdenv, bash, emacs, fixDarwinDylibNames,

     

       2
       2
       +
         gdb, glib, gmime, gnupg,

     

       2
       3
        
         pkgconfig, talloc, xapian

     

       3
       4
        
       }:

     

       4
       5
        
       

     
···

       10
       11
        
           sha256 = "1pdp9l7yv71d3fjb30qyccva8h03hvg88q4a00yi50v2j70kvmgj";

     

       11
       12
        
         };

     

       12
       13
        
       

     

       13
       13
       -
         buildInputs = [ bash emacs gdb glib gmime gnupg pkgconfig talloc xapian ];

     

       14
       14
       +
         buildInputs = [ bash emacs gdb glib gmime gnupg pkgconfig talloc xapian ]

     

       15
       15
       +
           ++ stdenv.lib.optionals stdenv.isDarwin [ fixDarwinDylibNames ];

     

       14
       16
        
       

     

       15
       17
        
         patchPhase = ''

     

       16
       16
       -
           (cd test && for prg in \

     

       17
       17
       -
               aggregate-results.sh \

     

       18
       18
       -
               argument-parsing \

     

       19
       19
       -
               atomicity \

     

       20
       20
       -
               author-order \

     

       21
       21
       -
               basic \

     

       22
       22
       -
               crypto \

     

       23
       23
       -
               count \

     

       24
       24
       -
               dump-restore \

     

       25
       25
       -
               emacs \

     

       26
       26
       -
               emacs-large-search-buffer \

     

       27
       27
       -
               encoding \

     

       28
       28
       -
               from-guessing \

     

       29
       29
       -
               help-test \

     

       30
       30
       -
               hooks \

     

       31
       31
       -
               json \

     

       32
       32
       -
               long-id \

     

       33
       33
       -
               maildir-sync \

     

       34
       34
       -
               multipart \

     

       35
       35
       -
               new \

     

       36
       36
       -
               notmuch-test \

     

       37
       37
       -
               python \

     

       38
       38
       -
               raw \

     

       39
       39
       -
               reply \

     

       40
       40
       -
               search \

     

       41
       41
       -
               search-by-folder \

     

       42
       42
       -
               search-insufficient-from-quoting \

     

       43
       43
       -
               search-folder-coherence \

     

       44
       44
       -
               search-limiting \

     

       45
       45
       -
               search-output \

     

       46
       46
       -
               search-position-overlap-bug \

     

       47
       47
       -
               symbol-hiding \

     

       48
       48
       -
               tagging \

     

       49
       49
       -
               test-lib.sh \

     

       50
       50
       -
               test-verbose \

     

       51
       51
       -
               thread-naming \

     

       52
       52
       -
               thread-order \

     

       53
       53
       -
               uuencode \

     

       54
       54
       -
           ;do

     

       55
       55
       -
             substituteInPlace "$prg" \

     

       56
       56
       -
               --replace "#!/usr/bin/env bash" "#!${bash}/bin/bash"

     

       57
       57
       -
           done)

     

       18
       18
       +
           find test -type f -exec \

     

       19
       19
       +
             sed -i \

     

       20
       20
       +
               "1s_#!/usr/bin/env bash_#!${bash}/bin/bash_" \

     

       21
       21
       +
               "{}" ";"

     

       58
       22
        
       

     

       59
       23
        
           for src in \

     

       60
       24
        
             crypto.c \

     
···

       64
       28
        
               --replace \"gpg\" \"${gnupg}/bin/gpg2\"

     

       65
       29
        
           done

     

       66
       30
        
         '';

     

       31
       31
       +
       

     

       32
       32
       +
         preFixup = if stdenv.isDarwin then

     

       33
       33
       +
           ''

     

       34
       34
       +
             prg="$out/bin/notmuch"

     

       35
       35
       +
             target="libnotmuch.3.dylib"

     

       36
       36
       +
             echo "$prg: fixing link to $target"

     

       37
       37
       +
             install_name_tool -change "$target" "$out/lib/$target" "$prg"

     

       38
       38
       +
           ''

     

       39
       39
       +
         else

     

       40
       40
       +
           "";

     

       67
       41
        
       

     

       68
       42
        
         # XXX: emacs tests broken

     

       69
       43
        
         doCheck = false;

+2 -2

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

···

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
        
       let pname = "liferea";

     

       9
       9
       -
           version = "1.10.11";

     

       9
       9
       +
           version = "1.10.12";

     

       10
       10
        
       in

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
        
         name = "${pname}-${version}";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "https://github.com/lwindolf/${pname}/releases/download/v${version}/${name}.tar.bz2";

     

       16
       16
       -
           sha256 = "0mf5mpdj60j8if4qi5656l4pzhgwzhshf31yp0h53l1j442v109a";

     

       16
       16
       +
           sha256 = "0c046r3cgf2adcjkgcny1gf2yj3hs0fhrc1zmcz2ja7grcbx46si";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         buildInputs = with gst_all_1; [

+22 -57

pkgs/applications/networking/remote/freerdp/unstable.nix

···

       1
       1
       -
       { stdenv

     

       2
       2
       -
       , fetchgit

     

       3
       3
       -
       , cmake

     

       4
       4
       -
       , openssl

     

       5
       5
       -
       , printerSupport ? true, cups

     

       6
       6
       -
       , pkgconfig

     

       7
       7
       -
       , zlib

     

       8
       8
       -
       , libX11

     

       9
       9
       -
       , libXcursor

     

       10
       10
       -
       , libXdamage

     

       11
       11
       -
       , libXext

     

       12
       12
       -
       , alsaLib

     

       13
       13
       -
       , ffmpeg

     

       14
       14
       -
       , libxkbfile

     

       15
       15
       -
       #, xmlto, docbook_xml_dtd_412, docbook_xml_xslt

     

       16
       16
       -
       , libXinerama

     

       17
       17
       -
       #, directfb

     

       18
       18
       -
       #, cunit

     

       19
       19
       -
       , libXv

     

       20
       20
       -
       , pulseaudioSupport ? true, pulseaudio

     

       1
       1
       +
       { stdenv, fetchFromGitHub, cmake, pkgconfig, openssl, zlib, libX11, libXcursor

     

       2
       2
       +
       , libXdamage, libXext, glib, alsaLib, ffmpeg, libxkbfile, libXinerama, libXv

     

       3
       3
       +
       , pulseaudio ? null, cups ? null, pcsclite ? null

     

       21
       4
        
       }:

     

       22
       5
        
       

     

       23
       23
       -
       assert printerSupport -> cups != null;

     

       24
       24
       -
       

     

       25
       25
       -
       let rev = "ec6effcb1e7759551cf31f5b18d768afc67db97d"; in

     

       26
       26
       -
       

     

       27
       6
        
       stdenv.mkDerivation rec {

     

       28
       28
       -
         name = "freerdp-1.1pre-${stdenv.lib.strings.substring 0 7 rev}";

     

       7
       7
       +
         name = "freerdp-1.2.0-beta1";

     

       29
       8
        
       

     

       30
       30
       -
         src = fetchgit {

     

       31
       31
       -
           url = git://github.com/FreeRDP/FreeRDP.git;

     

       32
       32
       -
           inherit rev;

     

       33
       33
       -
           sha256 = "4e5af9a6769c4b34c6b75dffe83a385d1d86068c523ea9f62fabc651a2958455";

     

       9
       9
       +
         src = fetchFromGitHub {

     

       10
       10
       +
           owner = "FreeRDP";

     

       11
       11
       +
           repo = "FreeRDP";

     

       12
       12
       +
           rev = "1.2.0-beta1+android7";

     

       13
       13
       +
           sha256 = "08nn18jydblrif1qs92pakzd3ww7inr0i378ssn1bjp09lm1bkk0";

     

       34
       14
        
         };

     

       35
       15
        
       

     

       36
       16
        
         buildInputs = [

     

       37
       37
       -
           cmake

     

       38
       38
       -
           openssl

     

       39
       39
       -
           pkgconfig

     

       40
       40
       -
           zlib

     

       41
       41
       -
           libX11

     

       42
       42
       -
           libXcursor

     

       43
       43
       -
           libXdamage

     

       44
       44
       -
           libXext

     

       45
       45
       -
       #    directfb

     

       46
       46
       -
       #    cunit

     

       47
       47
       -
           alsaLib

     

       48
       48
       -
           ffmpeg

     

       49
       49
       -
           libxkbfile

     

       50
       50
       -
       #    xmlto docbook_xml_dtd_412 docbook_xml_xslt

     

       51
       51
       -
           libXinerama

     

       52
       52
       -
           libXv

     

       53
       53
       -
         ] ++ stdenv.lib.optional printerSupport cups;

     

       17
       17
       +
           cmake pkgconfig openssl zlib libX11 libXcursor libXdamage libXext glib

     

       18
       18
       +
           alsaLib ffmpeg libxkbfile libXinerama libXv cups pulseaudio pcsclite

     

       19
       19
       +
         ];

     

       54
       20
        
       

     

       55
       21
        
         doCheck = false;

     

       56
       22
        
       

     

       57
       57
       -
         checkPhase = ''LD_LIBRARY_PATH="libfreerdp-cache:libfreerdp-chanman:libfreerdp-common:libfreerdp-core:libfreerdp-gdi:libfreerdp-kbd:libfreerdp-rail:libfreerdp-rfx:libfreerdp-utils" cunit/test_freerdp'';

     

       58
       58
       -
       

     

       59
       59
       -
         cmakeFlags = [ "-DWITH_DIRECTFB=OFF" "-DWITH_CUNIT=OFF" "-DWITH_MANPAGES=OFF" 

     

       60
       60
       -
         ] ++ stdenv.lib.optional pulseaudioSupport "-DWITH_PULSEAUDIO=ON";

     

       23
       23
       +
         cmakeFlags = [

     

       24
       24
       +
           "-DCMAKE_INSTALL_LIBDIR=lib"

     

       25
       25
       +
           "-DWITH_CUNIT=OFF"

     

       26
       26
       +
         ] ++ stdenv.lib.optional (pulseaudio != null) "-DWITH_PULSE=ON"

     

       27
       27
       +
           ++ stdenv.lib.optional (cups != null) "-DWITH_CUPS=ON"

     

       28
       28
       +
           ++ stdenv.lib.optional (pcsclite != null) "-DWITH_PCSC=ON";

     

       61
       29
        
       

     

       62
       62
       -
         meta = {

     

       30
       30
       +
         meta = with stdenv.lib; {

     

       63
       31
        
           description = "A Remote Desktop Protocol Client";

     

       64
       64
       -
       

     

       65
       32
        
           longDescription = ''

     

       66
       33
        
             FreeRDP is a client-side implementation of the Remote Desktop Protocol (RDP)

     

       67
       34
        
             following the Microsoft Open Specifications.

     

       68
       35
        
           '';

     

       69
       69
       -
       

     

       70
       36
        
           homepage = http://www.freerdp.com/;

     

       71
       71
       -
       

     

       72
       72
       -
           license = "free-non-copyleft";

     

       73
       73
       -
       

     

       74
       74
       -
           broken = true;  # fails to build

     

       37
       37
       +
           license = licenses.asl20;

     

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

     

       39
       39
       +
           platforms = platforms.unix;

     

       75
       40
        
         };

     

       76
       41
        
       }

     

       77
       42

+3 -3

pkgs/applications/office/zotero/default.nix

···

       3
       3
        
       assert (stdenv.system == "x86_64-linux" || stdenv.system == "i686-linux");

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         version = "4.0.22";

     

       6
       6
       +
         version = "4.0.23";

     

       7
       7
        
         arch = if stdenv.system == "x86_64-linux"

     

       8
       8
        
                  then "linux-x86_64"

     

       9
       9
        
                  else "linux-i686";

     
···

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "https://download.zotero.org/standalone/${version}/Zotero-${version}_${arch}.tar.bz2";

     

       16
       16
        
           sha256 = if stdenv.system == "x86_64-linux"

     

       17
       17
       -
                      then "0dq4x1cc0lnhs7g6w85qjdlb7sajr13mr2zcf4yvrciwhwy3r1i1"

     

       18
       18
       -
                      else "0s4j2karaq85fwnd1niz8hzx5k71cqs493g38pg337i3iwxad9hg";

     

       17
       17
       +
                      then "1fz5xn69vapfw8d20207zr9p5r1h9x5kahh334pl2dn1h8il0sm8"

     

       18
       18
       +
                      else "1kmsvvg2lh881rzy3rxbigzivixjamyrwf5x7vmn1kzhvsvifrng";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         # Strip the bundled xulrunner

+2 -3

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

···

       17
       17
        
       

     

       18
       18
        
       cabal.mkDerivation (self: {

     

       19
       19
        
         pname = "git-annex";

     

       20
       20
       -
         version = "5.20140927";

     

       21
       21
       -
         sha256 = "02zmg8pcrdavfna2xy51n6chn6i5g0b8p20rba1vj29rlfj3cask";

     

       20
       20
       +
         version = "5.20141013";

     

       21
       21
       +
         sha256 = "1p2hvw2x0rm9nhk176mzwisl75xphqxv7mhd43mvwlb3q9f57lnc";

     

       22
       22
        
         isLibrary = false;

     

       23
       23
        
         isExecutable = true;

     

       24
       24
        
         buildDepends = [

     
···

       48
       48
        
           license = self.stdenv.lib.licenses.gpl3;

     

       49
       49
        
           platforms = self.ghc.meta.platforms;

     

       50
       50
        
           maintainers = with self.stdenv.lib.maintainers; [ simons ];

     

       51
       51
       -
           broken = true;

     

       52
       51
        
         };

     

       53
       52
        
       })

+3 -3

pkgs/applications/video/xbmc/plugins.nix

···

       81
       81
        
       

     

       82
       82
        
           plugin = "svtplay";

     

       83
       83
        
           namespace = "plugin.video.svtplay";

     

       84
       84
       -
           version = "4.0.6";

     

       84
       84
       +
           version = "4.0.8";

     

       85
       85
        
       

     

       86
       86
        
           src = fetchFromGitHub {

     

       87
       87
        
             owner = "nilzen";

     

       88
       88
        
             repo = "xbmc-" + plugin;

     

       89
       89
       -
             rev = "4f27254edbd6dc48350152832833c5b164ca58de";

     

       90
       90
       -
             sha256 = "11r8vljpx9fxwdx20cvkb5szlaypfrn6c235jwcg61s4hmjy4kl8";

     

       89
       89
       +
             rev = "967dc429201200200dba0e755ede3a0e9cb1b137";

     

       90
       90
       +
             sha256 = "0kaxcci9zbblpkn1mrmdl49844r90agww41frz9vw6q2ajq1z16k";

     

       91
       91
        
           };

     

       92
       92
        
       

     

       93
       93
        
           meta = with stdenv.lib; {

+3 -3

pkgs/applications/virtualization/docker/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         name = "docker-${version}";

     

       6
       6
       -
         version = "1.2.0";

     

       6
       6
       +
         version = "1.3.0";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "https://github.com/dotcloud/docker/archive/v${version}.tar.gz";

     

       10
       10
       -
           sha256 = "1nk74p9k17bllgw4992ixx7z3w87icp2wabbpbgfyi20k2q9mayp";

     

       10
       10
       +
           sha256 = "09bn88i8acv7kw39js1p7mgf3sglq7d782xnafkp0i97svf0x4y9";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         buildInputs = [ makeWrapper go sqlite lxc iproute bridge_utils devicemapper btrfsProgs iptables e2fsprogs];

     
···

       17
       17
        
         buildPhase = ''

     

       18
       18
        
           patchShebangs ./hack

     

       19
       19
        
           export AUTO_GOPATH=1

     

       20
       20
       -
           export DOCKER_GITCOMMIT="fa7b24f"

     

       20
       20
       +
           export DOCKER_GITCOMMIT="c78088f"

     

       21
       21
        
           ./hack/make.sh dynbinary

     

       22
       22
        
         '';

     

       23
       23

+5 -2

pkgs/applications/virtualization/virtualbox/default.nix

···

       5
       5
        
       , javaBindings ? false, jdk ? null

     

       6
       6
        
       , pythonBindings ? false, python ? null

     

       7
       7
        
       , enableExtensionPack ? false, requireFile ? null, patchelf ? null

     

       8
       8
       +
       , pulseSupport ? false, pulseaudio ? null

     

       8
       9
        
       }:

     

       9
       10
        
       

     

       10
       11
        
       with stdenv.lib;

     
···

       64
       65
        
             libcap glib lvm2 python alsaLib curl libvpx pam xorriso makeself perl

     

       65
       66
        
             pkgconfig which libXmu ]

     

       66
       67
        
           ++ optional javaBindings jdk

     

       67
       67
       -
           ++ optional pythonBindings python;

     

       68
       68
       +
           ++ optional pythonBindings python

     

       69
       69
       +
           ++ optional pulseSupport pulseaudio;

     

       68
       70
        
       

     

       69
       71
        
         prePatch = ''

     

       70
       72
        
           set -x

     
···

       86
       88
        
           ./configure --with-qt4-dir=${qt4} \

     

       87
       89
        
             ${optionalString (!javaBindings) "--disable-java"} \

     

       88
       90
        
             ${optionalString (!pythonBindings) "--disable-python"} \

     

       89
       89
       -
             --disable-pulse --disable-hardening --disable-kmods \

     

       91
       91
       +
             ${optionalString (!pulseSupport) "--disable-pulse"} \

     

       92
       92
       +
             --disable-hardening --disable-kmods \

     

       90
       93
        
             --with-mkisofs=${xorriso}/bin/xorrisofs

     

       91
       94
        
           sed -e 's@PKG_CONFIG_PATH=.*@PKG_CONFIG_PATH=${libIDL}/lib/pkgconfig:${glib}/lib/pkgconfig ${libIDL}/bin/libIDL-config-2@' \

     

       92
       95
        
               -i AutoConfig.kmk

+25 -14

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

···

       1
       1
       -
       { stdenv, fetchurl, pkgconfig, wayland, mesa, libxkbcommon

     

       2
       2
       -
       , cairo, libxcb, libXcursor, x11, udev, libdrm, mtdev

     

       3
       3
       -
       , libjpeg, pam, autoconf, automake, libtool, dbus }:

     

       1
       1
       +
       { stdenv, fetchurl, pkgconfig, wayland, mesa, libxkbcommon, cairo, libxcb

     

       2
       2
       +
       , libXcursor, x11, udev, libdrm, mtdev, libjpeg, pam, dbus, libinput

     

       3
       3
       +
       , pango ? null, libunwind ? null, freerdp ? null, vaapi ? null, libva ? null

     

       4
       4
       +
       , libwebp ? null

     

       5
       5
       +
       }:

     

       4
       6
        
       

     

       5
       5
       -
       let version = "1.5.0"; in

     

       7
       7
       +
       let version = "1.6.0"; in

     

       6
       8
        
       

     

       7
       9
        
       stdenv.mkDerivation rec {

     

       8
       10
        
         name = "weston-${version}";

     

       9
       11
        
       

     

       10
       12
        
         src = fetchurl {

     

       11
       13
        
           url = "http://wayland.freedesktop.org/releases/${name}.tar.xz";

     

       12
       12
       -
           sha256 = "113nig2dmbgrjhi79k0zw77vicnx8vkaihawd0nsg6n79ah8nf06";

     

       14
       14
       +
           sha256 = "0kb1mb54l7adihmr2y77xgsdb00dvifnq886q2mmy0mz7g8sagnw";

     

       13
       15
        
         };

     

       14
       16
        
       

     

       15
       15
       -
         #ToDo: libinput can be split away

     

       16
       17
        
         buildInputs = [

     

       17
       17
       -
           pkgconfig wayland mesa libxkbcommon

     

       18
       18
       -
           cairo libxcb libXcursor x11 udev libdrm mtdev libjpeg pam dbus.libs

     

       18
       18
       +
           pkgconfig wayland mesa libxkbcommon cairo libxcb libXcursor x11 udev libdrm

     

       19
       19
       +
           mtdev libjpeg pam dbus.libs libinput pango libunwind freerdp vaapi libva

     

       20
       20
       +
           libwebp

     

       19
       21
        
         ];

     

       20
       20
       -
       

     

       21
       21
       -
         NIX_CFLAGS_COMPILE = "-I${libdrm}/include/libdrm";

     

       22
       22
        
       

     

       23
       23
        
         configureFlags = [

     

       24
       24
       +
           "--enable-xwayland"

     

       25
       25
       +
           "--enable-x11-compositor"

     

       26
       26
       +
           "--enable-drm-compositor"

     

       27
       27
       +
           "--enable-wayland-compositor"

     

       28
       28
       +
           "--enable-headless-compositor"

     

       29
       29
       +
           "--enable-fbdev-compositor"

     

       30
       30
       +
           "--enable-screen-sharing"

     

       31
       31
       +
           "--enable-clients"

     

       32
       32
       +
           "--enable-weston-launch"

     

       24
       33
        
           "--disable-setuid-install" # prevent install target to chown root weston-launch, which fails

     

       25
       25
       -
         ];

     

       34
       34
       +
         ] ++ stdenv.lib.optional (freerdp != null) "--enable-rdp-compositor"

     

       35
       35
       +
           ++ stdenv.lib.optional (vaapi != null) "--enabe-vaapi-recorder";

     

       26
       36
        
       

     

       27
       27
       -
         meta = {

     

       37
       37
       +
         meta = with stdenv.lib; {

     

       28
       38
        
           description = "Reference implementation of a Wayland compositor";

     

       29
       39
        
           homepage = http://wayland.freedesktop.org/;

     

       30
       30
       -
           license = stdenv.lib.licenses.mit;

     

       31
       31
       -
           platforms = stdenv.lib.platforms.linux;

     

       40
       40
       +
           license = licenses.mit;

     

       41
       41
       +
           platforms = platforms.linux;

     

       42
       42
       +
           maintainers = with maintainers; [ wkennington ];

     

       32
       43
        
         };

     

       33
       44
        
       }

+1 -1

pkgs/build-support/build-fhs-chrootenv/mount.sh.in

···

       23
       23
        
       mount --bind /etc $chrootenvDest/host-etc

     

       24
       24
        
       

     

       25
       25
        
       # Bind mount /tmp

     

       26
       26
       -
       mount --bind /tmp/chrootenv-@name@ /run/chrootenv/steam/tmp

     

       26
       26
       +
       mount --bind /tmp/chrootenv-@name@ $chrootenvDest/tmp

+7 -3

pkgs/build-support/cabal/default.nix

···

       57
       57
        
                       propagatedUserEnvPkgs = filter (y : ! (y == null)) x.propagatedUserEnvPkgs;

     

       58
       58
        
                       doCheck               = enableCheckPhase && x.doCheck;

     

       59
       59
        
                       hyperlinkSource       = enableHyperlinkSource && x.hyperlinkSource;

     

       60
       60
       +
                       # Disable Darwin builds: <https://github.com/NixOS/nixpkgs/issues/2689>.

     

       61
       61
       +
                       meta                  = let meta = x.meta or {};

     

       62
       62
       +
                                                   hydraPlatforms = meta.hydraPlatforms or meta.platforms or [];

     

       63
       63
       +
                                                   noElem         = p: ps: !stdenv.lib.elem p ps;

     

       64
       64
       +
                                                   noDarwin       = p: noElem p stdenv.lib.platforms.darwin;

     

       65
       65
       +
                                               in

     

       66
       66
       +
                                               meta // { hydraPlatforms = filter noDarwin hydraPlatforms; };

     

       60
       67
        
                     };

     

       61
       68
        
       

     

       62
       69
        
               defaults =

     
···

       209
       216
        
                     ''}

     

       210
       217
        
                     ${optionalString (self.enableSharedExecutables && self.stdenv.isDarwin) ''

     

       211
       218
        
                       configureFlags+=" --ghc-option=-optl=-Wl,-headerpad_max_install_names"

     

       212
       212
       -
                     ''}

     

       213
       213
       -
                     ${optionalString (versionOlder "7.8" ghc.version) ''

     

       214
       214
       -
                       configureFlags+=" --ghc-option=-j$NIX_BUILD_CORES"

     

       215
       219
        
                     ''}

     

       216
       220
        
       

     

       217
       221
        
                     echo "configure flags: $extraConfigureFlags $configureFlags"

+1 -1

pkgs/build-support/grsecurity/default.nix

···

       32
       32
        
       

     

       33
       33
        
           grKernel = if cfg.stable

     

       34
       34
        
                      then mkKernel pkgs.linux_3_14 stable-patch

     

       35
       35
       -
                      else mkKernel pkgs.linux_3_16 test-patch;

     

       35
       35
       +
                      else mkKernel pkgs.linux_3_17 test-patch;

     

       36
       36
        
       

     

       37
       37
        
           ## -- grsecurity configuration ---------------------------------------------

     

       38
       38

+22

pkgs/build-support/substitute-files/substitute-all-files.nix

···

       1
       1
       +
       { stdenv }:

     

       2
       2
       +
       

     

       3
       3
       +
       args:

     

       4
       4
       +
       

     

       5
       5
       +
       stdenv.mkDerivation ({

     

       6
       6
       +
         name = if args ? name then args.name else baseNameOf (toString args.src);

     

       7
       7
       +
         builder = with stdenv.lib; builtins.toFile "builder.sh" ''

     

       8
       8
       +
           source $stdenv/setup

     

       9
       9
       +
           set -o pipefail

     

       10
       10
       +
       

     

       11
       11
       +
           eval "$preInstall"

     

       12
       12
       +
       

     

       13
       13
       +
           args=

     

       14
       14
       +
       

     

       15
       15
       +
           cd "$src"

     

       16
       16
       +
           echo -ne "${concatStringsSep "\\0" args.files}" | xargs -0 -n1 -I {} -- find {} -type f -print0 | while read -d "" line; do

     

       17
       17
       +
             mkdir -p "$out/$(dirname "$line")"

     

       18
       18
       +
             substituteAll "$line" "$out/$line"

     

       19
       19
       +
           done

     

       20
       20
       +
         '';

     

       21
       21
       +
         preferLocalBuild = true;

     

       22
       22
       +
       } // args)

+2 -2

pkgs/build-support/vm/default.nix

···

       1586
       1586
        
             fullName = "Debian 7.6 Wheezy (i386)";

     

       1587
       1587
        
             packagesList = fetchurl {

     

       1588
       1588
        
               url = mirror://debian/dists/wheezy/main/binary-i386/Packages.bz2;

     

       1589
       1589
       -
               sha256 = "773ba601513cd7ef1d5192ad8baa795fa050573d82568c577cdf79adade698a3";

     

       1589
       1589
       +
               sha256 = "1j093d6dwixyrk87sdvaayh3ffcn5aqwik36blndiw5njw2qkzgj";

     

       1590
       1590
        
             };

     

       1591
       1591
        
             urlPrefix = mirror://debian;

     

       1592
       1592
        
             packages = commonDebianPackages;

     
···

       1597
       1597
        
             fullName = "Debian 7.6 Wheezy (amd64)";

     

       1598
       1598
        
             packagesList = fetchurl {

     

       1599
       1599
        
               url = mirror://debian/dists/wheezy/main/binary-amd64/Packages.bz2;

     

       1600
       1600
       -
               sha256 = "11a8bd3648d51f51e56c9f5382168cc47267d67ef6a050826e1cd358ed46cc17";

     

       1600
       1600
       +
               sha256 = "1n46fxq8a2dm1i7ysc80s5lg10z5dh0hyd8k3h532n5wzs44xqcc";

     

       1601
       1601
        
             };

     

       1602
       1602
        
             urlPrefix = mirror://debian;

     

       1603
       1603
        
             packages = commonDebianPackages;

+1 -1

pkgs/desktops/e19/econnman.nix

···

       16
       16
        
         meta = {

     

       17
       17
        
           description = "Econnman is a user interface for the connman network connection manager";

     

       18
       18
        
           homepage = http://enlightenment.org/;

     

       19
       19
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       19
       19
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       20
       20
        
           platforms = stdenv.lib.platforms.linux;

     

       21
       21
        
           license = stdenv.lib.licenses.lgpl3;

     

       22
       22
        
         };

+3 -3

pkgs/desktops/e19/efl.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         name = "efl-${version}";

     

       6
       6
       -
         version = "1.11.2";

     

       6
       6
       +
         version = "1.11.3";

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://download.enlightenment.org/rel/libs/efl/${name}.tar.gz";

     

       9
       9
       -
           sha256 = "123jrcifd7i0r9zh8qllqiz3d378fyy7fzkanyki9wbxlz91rk7k";

     

       9
       9
       +
           sha256 = "0s9pm3lfp7f2yf877xywjw8ihgr2yrns3gibak0gcwx7d8bfljfr";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ pkgconfig openssl zlib freetype fontconfig fribidi SDL2 SDL mesa giflib libpng libtiff glib gst_all_1.gstreamer gst_all_1.gst-plugins-base gst_all_1.gst-libav pulseaudio libsndfile xlibs.libXcursor xlibs.printproto xlibs.libX11 libdrm udev utillinuxCurses luajit ];

     
···

       26
       26
        
         meta = {

     

       27
       27
        
           description = "Enlightenment Core libraries";

     

       28
       28
        
           homepage = http://enlightenment.org/;

     

       29
       29
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       29
       29
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       30
       30
        
           platforms = stdenv.lib.platforms.linux;

     

       31
       31
        
           license = stdenv.lib.licenses.lgpl3;

     

       32
       32
        
         };

+3 -3

pkgs/desktops/e19/elementary.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, e19, libcap, gdbm }:

     

       2
       2
        
       stdenv.mkDerivation rec {

     

       3
       3
        
         name = "elementary-${version}";

     

       4
       4
       -
         version = "1.11.2";

     

       4
       4
       +
         version = "1.11.3";

     

       5
       5
        
         src = fetchurl {

     

       6
       6
        
           url = "http://download.enlightenment.org/rel/libs/elementary/${name}.tar.gz";

     

       7
       7
       -
           sha256 = "041hwp81qyq4wsw483g2jh52gcanqg046f91pmd0vzgwcgxyixqq";

     

       7
       7
       +
           sha256 = "1yr96imam9sckgagnp7wdvwmvr1xwakw29dih3gxp7nz7xsa0j8k";

     

       8
       8
        
         };

     

       9
       9
        
         buildInputs = [ pkgconfig e19.efl gdbm ] ++ stdenv.lib.optionals stdenv.isLinux [ libcap ];

     

       10
       10
        
         preConfigure = ''

     
···

       13
       13
        
         meta = {

     

       14
       14
        
           description = "Widget set/toolkit";

     

       15
       15
        
           homepage = http://enlightenment.org/;

     

       16
       16
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       16
       16
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       17
       17
        
           platforms = stdenv.lib.platforms.linux;

     

       18
       18
        
           license = stdenv.lib.licenses.lgpl2;

     

       19
       19
        
         };

+1 -1

pkgs/desktops/e19/emotion.nix

···

       13
       13
        
         meta = {

     

       14
       14
        
           description = "Extra video decoders";

     

       15
       15
        
           homepage = http://enlightenment.org/;

     

       16
       16
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       16
       16
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       17
       17
        
           platforms = stdenv.lib.platforms.linux;

     

       18
       18
        
           license = stdenv.lib.licenses.bsd2;

     

       19
       19
        
         };

+3 -3

pkgs/desktops/e19/enlightenment.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "enlightenment-${version}";

     

       7
       7
       -
         version = "0.19.0";

     

       7
       7
       +
         version = "0.19.1";

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "http://download.enlightenment.org/rel/apps/enlightenment/${name}.tar.xz";

     

       10
       10
       -
           sha256 = "0d9s8gwma32hj8h000k1bzibr3zj8qajcf14va3w81k87gkilxfp";

     

       10
       10
       +
           sha256 = "016z1vilhjarpxzn5bwcw696d8b66rklnhkrwzfa5mcxn8gpmvap";

     

       11
       11
        
         };

     

       12
       12
        
         buildInputs = [ pkgconfig e19.efl e19.elementary xlibs.libXdmcp xlibs.libxcb xlibs.xcbutilkeysyms xlibs.libXrandr libffi pam alsaLib luajit bzip2 libpthreadstubs gdbm ] ++ stdenv.lib.optionals stdenv.isLinux [ libcap ];

     

       13
       13
        
         preConfigure = ''

     
···

       31
       31
        
         meta = {

     

       32
       32
        
           description = "The Compositing Window Manager and Desktop Shell";

     

       33
       33
        
           homepage = http://enlightenment.org/;

     

       34
       34
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       34
       34
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       35
       35
        
           platforms = stdenv.lib.platforms.linux;

     

       36
       36
        
           license = stdenv.lib.licenses.bsd2;

     

       37
       37
        
         };

+1 -1

pkgs/desktops/e19/evas.nix

···

       10
       10
        
         meta = {

     

       11
       11
        
           description = "Extra image decoders";

     

       12
       12
        
           homepage = http://enlightenment.org/;

     

       13
       13
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       13
       13
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       14
       14
        
           platforms = stdenv.lib.platforms.linux;

     

       15
       15
        
           license = stdenv.lib.licenses.gpl2;

     

       16
       16
        
         };

+3 -3

pkgs/desktops/e19/terminology.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, e19 }:

     

       2
       2
        
       stdenv.mkDerivation rec {

     

       3
       3
        
         name = "terminology-${version}";

     

       4
       4
       -
         version = "0.6.1";

     

       4
       4
       +
         version = "0.7.0";

     

       5
       5
        
         src = fetchurl {

     

       6
       6
        
           url = "http://download.enlightenment.org/rel/apps/terminology/${name}.tar.gz";

     

       7
       7
       -
           sha256 = "1wi9njyfs95y4nb9jd30032qqka5cg7k0wacck8s1yqxwg5ng38x";

     

       7
       7
       +
           sha256 = "1x248dh9r292r8ycvf43vrfk4l8wpli50sgywp0zy3q93f8ljgs5";

     

       8
       8
        
         };

     

       9
       9
        
         buildInputs = [ pkgconfig e19.efl e19.elementary ];

     

       10
       10
        
         preConfigure = ''

     
···

       16
       16
        
         meta = {

     

       17
       17
        
           description = "The best terminal emulator written with the EFL";

     

       18
       18
        
           homepage = http://enlightenment.org/;

     

       19
       19
       -
           maintainers = [ stdenv.lib.maintainers.matejc ];

     

       19
       19
       +
           maintainers = with stdenv.lib.maintainers; [ matejc tstrobel ];

     

       20
       20
        
           platforms = stdenv.lib.platforms.linux;

     

       21
       21
        
           license = stdenv.lib.licenses.bsd2;

     

       22
       22
        
         };

+1 -1

pkgs/desktops/gnome-3/3.10/core/libgnome-keyring/default.nix

···

       14
       14
        
         meta = {

     

       15
       15
        
           description = "Framework for managing passwords and other secrets";

     

       16
       16
        
           homepage = http://live.gnome.org/GnomeKeyring;

     

       17
       17
       -
           # TODO license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];

     

       17
       17
       +
           license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];

     

       18
       18
        
           inherit (glib.meta) platforms maintainers;

     

       19
       19
        
       

     

       20
       20
        
           longDescription = ''

+1 -1

pkgs/desktops/gnome-3/3.10/core/yelp-xsl/default.nix

···

       17
       17
        
           homepage = https://wiki.gnome.org/Apps/Yelp;

     

       18
       18
        
           description = "Yelp's universal stylesheets for Mallard and DocBook";

     

       19
       19
        
           maintainers = with maintainers; [ lethalman ];

     

       20
       20
       -
           # TODO license = [licenses.gpl2 licenses.lgpl2];

     

       20
       20
       +
           license = [licenses.gpl2 licenses.lgpl2];

     

       21
       21
        
           platforms = platforms.linux;

     

       22
       22
        
         };

     

       23
       23
        
       }

+3 -1

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

···

       184
       184
        
       

     

       185
       185
        
         gitg = callPackage ./misc/gitg { };

     

       186
       186
        
       

     

       187
       187
       -
         libgit2-glib = callPackage ./misc/libgit2-glib { };

     

       187
       187
       +
         libgit2-glib = callPackage ./misc/libgit2-glib {

     

       188
       188
       +
           libgit2 = pkgs.libgit2.override { libssh2 = null; };

     

       189
       189
       +
         };

     

       188
       190
        
       

     

       189
       191
        
         libmediaart = callPackage ./misc/libmediaart { };

     

       190
       192

+1 -1

pkgs/desktops/gnome-3/3.12/core/libgnome-keyring/default.nix

···

       14
       14
        
         meta = {

     

       15
       15
        
           description = "Framework for managing passwords and other secrets";

     

       16
       16
        
           homepage = http://live.gnome.org/GnomeKeyring;

     

       17
       17
       -
           # TODO license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];

     

       17
       17
       +
           license = with stdenv.lib.licenses; [ gpl2Plus lgpl2Plus ];

     

       18
       18
        
           inherit (glib.meta) platforms maintainers;

     

       19
       19
        
       

     

       20
       20
        
           longDescription = ''

+1 -1

pkgs/desktops/gnome-3/3.12/core/yelp-xsl/default.nix

···

       17
       17
        
           homepage = https://wiki.gnome.org/Apps/Yelp;

     

       18
       18
        
           description = "Yelp's universal stylesheets for Mallard and DocBook";

     

       19
       19
        
           maintainers = with maintainers; [ lethalman ];

     

       20
       20
       -
           # TODO license = [licenses.gpl2 licenses.lgpl2];

     

       20
       20
       +
           license = [licenses.gpl2 licenses.lgpl2];

     

       21
       21
        
           platforms = platforms.linux;

     

       22
       22
        
         };

     

       23
       23
        
       }

+3 -1

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

···

       233
       233
        
       

     

       234
       234
        
         libgda = callPackage ./misc/libgda { };

     

       235
       235
        
       

     

       236
       236
       -
         libgit2-glib = callPackage ./misc/libgit2-glib { };

     

       236
       236
       +
         libgit2-glib = callPackage ./misc/libgit2-glib {

     

       237
       237
       +
           libgit2 = pkgs.libgit2.override { libssh2 = null; };

     

       238
       238
       +
         };

     

       237
       239
        
       

     

       238
       240
        
         libmediaart = callPackage ./misc/libmediaart { };

     

       239
       241

+7 -7

pkgs/development/compilers/ghc/7.8.3.nix

···

       32
       32
        
         # that in turn causes GHCi to abort

     

       33
       33
        
         stripDebugFlags = [ "-S" "--keep-file-symbols" ];

     

       34
       34
        
       

     

       35
       35
       -
         meta = {

     

       35
       35
       +
         meta = with stdenv.lib; {

     

       36
       36
        
           homepage = "http://haskell.org/ghc";

     

       37
       37
        
           description = "The Glasgow Haskell Compiler";

     

       38
       38
       -
           maintainers = [

     

       39
       39
       -
             stdenv.lib.maintainers.marcweber

     

       40
       40
       -
             stdenv.lib.maintainers.andres

     

       41
       41
       -
             stdenv.lib.maintainers.simons

     

       42
       42
       -
           ];

     

       43
       43
       -
           inherit (ghc.meta) license platforms;

     

       38
       38
       +
           maintainers = [ maintainers.marcweber maintainers.andres maintainers.simons ];

     

       39
       39
       +
           inherit (ghc.meta) license;

     

       40
       40
       +
           # Filter old "i686-darwin" platform which is unsupported these days.

     

       41
       41
       +
           platforms = filter (x: elem x platforms.all) ghc.meta.platforms;

     

       42
       42
       +
           # Disable Darwin builds: <https://github.com/NixOS/nixpkgs/issues/2689>.

     

       43
       43
       +
           hydraPlatforms = filter (x: !elem x platforms.darwin) meta.platforms;

     

       44
       44
        
         };

     

       45
       45
        
       

     

       46
       46
        
       }

+1 -1

pkgs/development/compilers/idris/default.nix

···

       33
       33
        
           platforms = self.ghc.meta.platforms;

     

       34
       34
        
           maintainers = with self.stdenv.lib.maintainers; [ aycanirican ];

     

       35
       35
        
         };

     

       36
       36
       -
       })
     

       36
       36
       +
       })

+157

pkgs/development/compilers/julia/0.3.1.nix

···

       1
       1
       +
       { stdenv, fetchgit, gfortran, perl, m4, llvm, gmp, pcre, zlib

     

       2
       2
       +
        , readline, fftwSinglePrec, fftw, libunwind, suitesparse, glpk, fetchurl

     

       3
       3
       +
        , ncurses, libunistring, lighttpd, patchelf, openblas, liblapack

     

       4
       4
       +
        , tcl, tk, xproto, libX11, git, mpfr, which

     

       5
       5
       +
        } :

     

       6
       6
       +
       

     

       7
       7
       +
       assert stdenv.isLinux; 

     

       8
       8
       +
       

     

       9
       9
       +
       let

     

       10
       10
       +
         realGcc = stdenv.gcc.gcc;

     

       11
       11
       +
       in

     

       12
       12
       +
       stdenv.mkDerivation rec {

     

       13
       13
       +
         pname = "julia";

     

       14
       14
       +
         version = "0.3.1";

     

       15
       15
       +
         name = "${pname}-${version}";

     

       16
       16
       +
       

     

       17
       17
       +
         dsfmt_ver = "2.2";

     

       18
       18
       +
         grisu_ver = "1.1.1";

     

       19
       19
       +
         openblas_ver = "v0.2.10";

     

       20
       20
       +
         lapack_ver = "3.5.0";

     

       21
       21
       +
         arpack_ver = "3.1.5";

     

       22
       22
       +
         lighttpd_ver = "1.4.29";

     

       23
       23
       +
         patchelf_ver = "0.6";

     

       24
       24
       +
         pcre_ver = "8.31";

     

       25
       25
       +
         utf8proc_ver = "1.1.6";

     

       26
       26
       +
       

     

       27
       27
       +
         dsfmt_src = fetchurl {

     

       28
       28
       +
           url = "http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/dSFMT-src-${dsfmt_ver}.tar.gz";

     

       29
       29
       +
           name = "dsfmt-${dsfmt_ver}.tar.gz";

     

       30
       30
       +
           sha256 = "bc3947a9b2253a869fcbab8ff395416cb12958be9dba10793db2cd7e37b26899";

     

       31
       31
       +
         };

     

       32
       32
       +
         grisu_src = fetchurl {

     

       33
       33
       +
           url = "http://double-conversion.googlecode.com/files/double-conversion-${grisu_ver}.tar.gz";

     

       34
       34
       +
           sha256 = "e1cabb73fd69e74f145aea91100cde483aef8b79dc730fcda0a34466730d4d1d";

     

       35
       35
       +
         };

     

       36
       36
       +
         openblas_src = fetchurl {

     

       37
       37
       +
           url = "https://github.com/xianyi/OpenBLAS/tarball/${openblas_ver}";

     

       38
       38
       +
           name = "openblas-${openblas_ver}.tar.gz";

     

       39
       39
       +
           sha256 = "06i0q4qnd5q5xljzrgvda0gjsczc6l2pl9hw6dn2qjpw38al73za";

     

       40
       40
       +
         };

     

       41
       41
       +
         arpack_src = fetchurl rec {

     

       42
       42
       +
           url = "http://forge.scilab.org/index.php/p/arpack-ng/downloads/get/arpack-ng_${arpack_ver}.tar.gz";

     

       43
       43
       +
           sha256 = "05fmg4m0yri47rzgsl2mnr1qbzrs7qyd557p3v9wwxxw0rwcwsd2";

     

       44
       44
       +
         };

     

       45
       45
       +
         lapack_src = fetchurl {

     

       46
       46
       +
           url = "http://www.netlib.org/lapack/lapack-${lapack_ver}.tgz";

     

       47
       47
       +
           name = "lapack-${lapack_ver}.tgz";

     

       48
       48
       +
           sha256 = "0lk3f97i9imqascnlf6wr5mjpyxqcdj73pgj97dj2mgvyg9z1n4s";

     

       49
       49
       +
         };

     

       50
       50
       +
         lighttpd_src = fetchurl {

     

       51
       51
       +
           url = "http://download.lighttpd.net/lighttpd/releases-1.4.x/lighttpd-${lighttpd_ver}.tar.gz";

     

       52
       52
       +
           sha256 = "ff9f4de3901d03bb285634c5b149191223d17f1c269a16c863bac44238119c85";

     

       53
       53
       +
         };

     

       54
       54
       +
         patchelf_src = fetchurl {

     

       55
       55
       +
           url = "http://hydra.nixos.org/build/1524660/download/2/patchelf-${patchelf_ver}.tar.bz2";

     

       56
       56
       +
           sha256 = "00bw29vdsscsili65wcb5ay0gvg1w0ljd00sb5xc6br8bylpyzpw";

     

       57
       57
       +
         };

     

       58
       58
       +
         pcre_src = fetchurl {

     

       59
       59
       +
           url = "ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-${pcre_ver}.tar.bz2";

     

       60
       60
       +
           sha256 = "0g4c0z4h30v8g8qg02zcbv7n67j5kz0ri9cfhgkpwg276ljs0y2p";

     

       61
       61
       +
         };

     

       62
       62
       +
         utf8proc_src = fetchurl {

     

       63
       63
       +
           url = "http://www.public-software-group.org/pub/projects/utf8proc/v${utf8proc_ver}/utf8proc-v${utf8proc_ver}.tar.gz";

     

       64
       64
       +
           sha256 = "1rwr84pw92ajjlbcxq0da7yxgg3ijngmrj7vhh2qzsr2h2kqzp7y";

     

       65
       65
       +
         };

     

       66
       66
       +
       

     

       67
       67
       +
         src = fetchgit {

     

       68
       68
       +
           url = "git://github.com/JuliaLang/julia.git";

     

       69
       69
       +
           rev = "refs/tags/v0.3.1";

     

       70
       70
       +
           sha256 = "1m6jyh7dn03q00gpwb64pq6dypglj4yqac7rkw21z2jknb5x33vb";

     

       71
       71
       +
         };

     

       72
       72
       +
       

     

       73
       73
       +
         buildInputs = [ gfortran perl m4 gmp pcre llvm readline zlib

     

       74
       74
       +
           fftw fftwSinglePrec libunwind suitesparse glpk ncurses libunistring patchelf

     

       75
       75
       +
           openblas liblapack tcl tk xproto libX11 git mpfr which

     

       76
       76
       +
           ];

     

       77
       77
       +
       

     

       78
       78
       +
         configurePhase = ''

     

       79
       79
       +
           for i in GMP LLVM PCRE READLINE FFTW LIBUNWIND SUITESPARSE GLPK LIGHTTPD ZLIB MPFR;

     

       80
       80
       +
           do

     

       81
       81
       +
             makeFlags="$makeFlags USE_SYSTEM_$i=1 "

     

       82
       82
       +
           done

     

       83
       83
       +
       

     

       84
       84
       +
           copy_kill_hash(){

     

       85
       85
       +
             cp "$1" "$2/$(basename "$1" | sed -e 's/^[a-z0-9]*-//')"

     

       86
       86
       +
           }

     

       87
       87
       +
       

     

       88
       88
       +
           for i in "${grisu_src}" "${dsfmt_src}" "${arpack_src}" "${patchelf_src}" \

     

       89
       89
       +
               "${pcre_src}" "${utf8proc_src}" "${lapack_src}" "${openblas_src}"; do

     

       90
       90
       +
             copy_kill_hash "$i" deps

     

       91
       91
       +
           done

     

       92
       92
       +
       

     

       93
       93
       +
           ${if realGcc ==null then "" else 

     

       94
       94
       +
           ''export NIX_LDFLAGS="$NIX_LDFLAGS -L${realGcc}/lib -L${realGcc}/lib64 -lpcre -llapack -lm -lfftw3f -lfftw3 -lglpk -lunistring -lz -lgmp -lmpfr -lblas -lopenblas -L$out/lib"''}

     

       95
       95
       +
           export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -fPIC "

     

       96
       96
       +
       

     

       97
       97
       +
           export LDFLAGS="-L${suitesparse}/lib -L$out/lib/julia -Wl,-rpath,$out/lib/julia"

     

       98
       98
       +
       

     

       99
       99
       +
           export GLPK_PREFIX="${glpk}/include"

     

       100
       100
       +
       

     

       101
       101
       +
           mkdir -p "$out/lib"

     

       102
       102
       +
           sed -e "s@/usr/local/lib@$out/lib@g" -i deps/Makefile

     

       103
       103
       +
           sed -e "s@/usr/lib@$out/lib@g" -i deps/Makefile

     

       104
       104
       +
       

     

       105
       105
       +
           export makeFlags="$makeFlags PREFIX=$out SHELL=${stdenv.shell} prefix=$out"

     

       106
       106
       +
       

     

       107
       107
       +
           export dontPatchELF=1

     

       108
       108
       +
       

     

       109
       109
       +
           export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$PWD/usr/lib:$PWD/usr/lib/julia"

     

       110
       110
       +
       

     

       111
       111
       +
           patchShebangs . contrib

     

       112
       112
       +
       

     

       113
       113
       +
           export PATH="$PATH:${stdenv.gcc.libc}/sbin"

     

       114
       114
       +
       

     

       115
       115
       +
           # ldconfig doesn't seem to ever work on NixOS; system-wide ldconfig cache

     

       116
       116
       +
           # is probably not what we want anyway on non-NixOS

     

       117
       117
       +
           sed -e "s@/sbin/ldconfig@true@" -i src/ccall.*

     

       118
       118
       +
       

     

       119
       119
       +
           ln -s "${openblas}/lib/libopenblas.so" "$out/lib/libblas.so"

     

       120
       120
       +
         '';

     

       121
       121
       +
       

     

       122
       122
       +
         preBuild = ''

     

       123
       123
       +
           mkdir -p usr/lib

     

       124
       124
       +
           

     

       125
       125
       +
           echo "$out"

     

       126
       126
       +
           mkdir -p "$out/lib"

     

       127
       127
       +
           (

     

       128
       128
       +
           cd "$(mktemp -d)"

     

       129
       129
       +
           for i in "${suitesparse}"/lib/lib*.a; do

     

       130
       130
       +
             ar -x $i

     

       131
       131
       +
           done

     

       132
       132
       +
           gcc *.o --shared -o "$out/lib/libsuitesparse.so"

     

       133
       133
       +
           )

     

       134
       134
       +
           cp "$out/lib/libsuitesparse.so" usr/lib

     

       135
       135
       +
           for i in umfpack cholmod amd camd colamd spqr; do

     

       136
       136
       +
             ln -s libsuitesparse.so "$out"/lib/lib$i.so;

     

       137
       137
       +
             ln -s libsuitesparse.so "usr"/lib/lib$i.so;

     

       138
       138
       +
           done

     

       139
       139
       +
         '';

     

       140
       140
       +
       

     

       141
       141
       +
         dontStrip = true;

     

       142
       142
       +
       

     

       143
       143
       +
         enableParallelBuilding = true;

     

       144
       144
       +
       

     

       145
       145
       +
         postInstall = ''

     

       146
       146
       +
           rm -f "$out"/lib/julia/sys.{so,dylib,dll}

     

       147
       147
       +
         '';

     

       148
       148
       +
       

     

       149
       149
       +
         meta = {

     

       150
       150
       +
           description = "High-level performance-oriented dynamical language for technical computing";

     

       151
       151
       +
           homepage = "http://julialang.org/";

     

       152
       152
       +
           license = stdenv.lib.licenses.mit;

     

       153
       153
       +
           maintainers = [ stdenv.lib.maintainers.raskin ];

     

       154
       154
       +
           platforms = with stdenv.lib.platforms; linux;

     

       155
       155
       +
           broken = false;

     

       156
       156
       +
         };

     

       157
       157
       +
       }

+2 -2

pkgs/development/compilers/lessc/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "lessc-${version}";

     

       5
       5
       -
         version = "1.4.2";

     

       5
       5
       +
         version = "1.7.5";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchgit {

     

       8
       8
        
           url = https://github.com/less/less.js.git;

     

       9
       9
        
           rev = "refs/tags/v${version}";

     

       10
       10
       -
           sha256 = "1v3b4f1np3mxkj0irh1pk52r26nzpf4k2ax14cbn7mxx16mqjp50";

     

       10
       10
       +
           sha256 = "0r8bcad247v5fyh543a7dppmfbf49ai4my3vcizk42fsbnjs8q2x";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         phases = [ "installPhase" ];

+3 -3

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

···

       1
       1
        
       import ./jdk-linux-base.nix {

     

       2
       2
        
         productVersion = "7";

     

       3
       3
       -
         patchVersion = "67";

     

       3
       3
       +
         patchVersion = "72";

     

       4
       4
        
         downloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html;

     

       5
       5
       -
         sha256_i686 = "0p58pag1x85r911lxhmr4blk687ivjqigflx175vp7rcmmj108xn";

     

       6
       6
       -
         sha256_x86_64 = "0db36jg08qy8712qy6lgyifdqlqb468rrnjm3aa6937ixl9ixpal";

     

       5
       5
       +
         sha256_i686 = "01zl82hnb9pynxw04zaq4745av42cga97cbckcwb8lh752hchxh3";

     

       6
       6
       +
         sha256_x86_64 = "13nyx8p27crnnybkzdaiv9l1azap7c8g4na6xasrnjvx3f7467fx";

     

       7
       7
        
         jceName = "UnlimitedJCEPolicyJDK7.zip";

     

       8
       8
        
         jceDownloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html;

     

       9
       9
        
         sha256JCE = "7a8d790e7bd9c2f82a83baddfae765797a4a56ea603c9150c87b7cdb7800194d";

+11 -10

pkgs/development/compilers/rustc/0.11.nix pkgs/development/compilers/rustc/0.12.nix

···

       16
       16
        
       

     

       17
       17
        
       */

     

       18
       18
        
       

     

       19
       19
       -
       with ((import ./common.nix) {inherit stdenv; version = "0.11.0"; });

     

       19
       19
       +
       with ((import ./common.nix) {inherit stdenv; version = "0.12.0"; });

     

       20
       20
        
       

     

       21
       21
        
       let snapshot = if stdenv.system == "i686-linux"

     

       22
       22
       -
             then "84339ea0f796ae468ef86797ef4587274bec19ea"

     

       22
       22
       +
             then "555aca74f9a268f80cab2df1147dc6406403e9e4"

     

       23
       23
        
             else if stdenv.system == "x86_64-linux"

     

       24
       24
       -
             then "bd8a6bc1f28845b7f4b768f6bfa06e7fbdcfcaae"

     

       24
       24
       +
             then "6a43c2f6c8ba2cbbcb9da1f7b58f748aef99f431"

     

       25
       25
        
             else if stdenv.system == "i686-darwin"

     

       26
       26
       -
             then "3f25b2680efbab16ad074477a19d49dcce475977"

     

       26
       26
       +
             then "331bd7ef519cbb424188c546273e8c7d738f0894"

     

       27
       27
        
             else if stdenv.system == "x86_64-darwin"

     

       28
       28
       -
             then "4a8c2e1b7634d73406bac32a1a97893ec3ed818d"

     

       28
       28
       +
             then "2c83a79a9febfe1d326acb17c3af76ba053c6ca9"

     

       29
       29
        
             else abort "no-snapshot for platform ${stdenv.system}";

     

       30
       30
       -
           snapshotDate = "2014-06-21";

     

       31
       31
       -
           snapshotRev = "db9af1d";

     

       30
       30
       +
           snapshotDate = "2014-10-04";

     

       31
       31
       +
           snapshotRev = "749ff5e";

     

       32
       32
        
           snapshotName = "rust-stage0-${snapshotDate}-${snapshotRev}-${platform}-${snapshot}.tar.bz2";

     

       33
       33
        
       

     

       34
       34
        
       in stdenv.mkDerivation {

     
···

       37
       37
        
         inherit meta;

     

       38
       38
        
       

     

       39
       39
        
         src = fetchurl {

     

       40
       40
       -
           url = http://static.rust-lang.org/dist/rust-0.11.0.tar.gz;

     

       41
       41
       -
           sha256 = "1fhi8iiyyj5j48fpnp93sfv781z1dm0xy94h534vh4mz91jf7cyi";

     

       40
       40
       +
           url = http://static.rust-lang.org/dist/rust-0.12.0.tar.gz;

     

       41
       41
       +
           sha256 = "1dv9wxh41230zknbwj34zgjnh1kgvvy6k12kbiy9bnch9nr6cgl8";

     

       42
       42
        
         };

     

       43
       43
        
       

     

       44
       44
        
         # We need rust to build rust. If we don't provide it, configure will try to download it.

     
···

       65
       65
        
         patches = [ ./hardcode_paths.patch ./local_stage0.patch ];

     

       66
       66
        
         postPatch = ''

     

       67
       67
        
           substituteInPlace src/librustc/back/link.rs \

     

       68
       68
       -
             --subst-var-by "ccPath" "${stdenv.gcc}/bin/cc" \

     

       68
       68
       +
             --subst-var-by "ccPath" "${stdenv.gcc}/bin/cc"

     

       69
       69
       +
           substituteInPlace src/librustc_back/archive.rs \

     

       69
       70
        
             --subst-var-by "arPath" "${stdenv.gcc.binutils}/bin/ar"

     

       70
       71
        
         '';

     

       71
       72

+17 -12

pkgs/development/compilers/rustc/hardcode_paths.patch

···

       1
       1
        
       diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs

     

       2
       2
       -
       index 7a3e912..ced75fa 100644

     

       2
       2
       +
       index 1cc60fc..2e94b99 100644

     

       3
       3
        
       --- a/src/librustc/back/link.rs

     

       4
       4
        
       +++ b/src/librustc/back/link.rs

     

       5
       5
       -
       @@ -766,24 +766,15 @@ pub fn output_lib_filename(id: &CrateId) -> String {

     

       5
       5
       +
       @@ -383,18 +383,9 @@ pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> Stri

     

       6
       6
        
        

     

       7
       7
        
        pub fn get_cc_prog(sess: &Session) -> String {

     

       8
       8
        
            match sess.opts.cg.linker {

     
···

       15
       15
        
       -    // In the future, FreeBSD will use clang as default compiler.

     

       16
       16
        
       -    // It would be flexible to use cc (system's default C compiler)

     

       17
       17
        
       -    // instead of hard-coded gcc.

     

       18
       18
       -
       -    // For win32, there is no cc command, so we add a condition to make it use gcc.

     

       18
       18
       +
       -    // For Windows, there is no cc command, so we add a condition to make it use gcc.

     

       19
       19
        
       -    match sess.targ_cfg.os {

     

       20
       20
       -
       -        abi::OsWin32 => "gcc",

     

       20
       20
       +
       -        abi::OsWindows => "gcc",

     

       21
       21
        
       -        _ => "cc",

     

       22
       22
        
       -    }.to_string()

     

       23
       23
        
        }

     

       24
       24
        
        

     

       25
       25
       -
        pub fn get_ar_prog(sess: &Session) -> String {

     

       26
       26
       -
            match sess.opts.cg.ar {

     

       27
       27
       -
                Some(ref ar) => (*ar).clone(),

     

       28
       28
       -
       -        None => "ar".to_string()

     

       29
       29
       -
       +        None => "@arPath@".to_string()

     

       30
       30
       -
            }

     

       31
       31
       -
        }

     

       32
       32
       -
        

     

       25
       25
       +
        pub fn remove(sess: &Session, path: &Path) {

     

       26
       26
       +
       diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs

     

       27
       27
       +
       index 060dda5..fecf76b 100644

     

       28
       28
       +
       --- a/src/librustc_back/archive.rs

     

       29
       29
       +
       +++ b/src/librustc_back/archive.rs

     

       30
       30
       +
       @@ -53,7 +53,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>,

     

       31
       31
       +
                  paths: &[&Path]) -> ProcessOutput {

     

       32
       32
       +
            let ar = match *maybe_ar_prog {

     

       33
       33
       +
                Some(ref ar) => ar.as_slice(),

     

       34
       34
       +
       -        None => "ar"

     

       35
       35
       +
       +        None => "@arPath@"

     

       36
       36
       +
            };

     

       37
       37
       +
            let mut cmd = Command::new(ar);

+5 -2

pkgs/development/compilers/rustc/local_stage0.patch

···

       2
       2
        
       index e78f231..6b6773b 100755

     

       3
       3
        
       --- a/src/etc/local_stage0.sh

     

       4
       4
        
       +++ b/src/etc/local_stage0.sh

     

       5
       5
       -
       @@ -53,8 +53,3 @@ if [ -z $TARG_DIR ]; then

     

       5
       5
       +
       @@ -53,11 +53,6 @@

     

       6
       6
        
        fi

     

       7
       7
       -
       

     

       7
       7
       +
        

     

       8
       8
        
        cp ${PREFIX}/bin/rustc${BIN_SUF} ${TARG_DIR}/stage0/bin/

     

       9
       9
        
       -cp ${PREFIX}/${LIB_DIR}/${RUSTLIBDIR}/${TARG_DIR}/${LIB_DIR}/* ${TARG_DIR}/stage0/${LIB_DIR}/

     

       10
       10
        
       -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}extra*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/

     

       11
       11
        
       -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}rust*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/

     

       12
       12
        
       -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}std*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/

     

       13
       13
        
       -cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}syntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/

     

       14
       14
       +
        

     

       15
       15
       +
        # do not fail if one of the above fails, as all we need is a working rustc!

     

       16
       16
       +
        exit 0

+2 -2

pkgs/development/compilers/scala/default.nix

···

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

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "scala-2.11.1";

     

       4
       4
       +
         name = "scala-2.11.2";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "http://www.scala-lang.org/files/archive/${name}.tgz";

     

       8
       8
       -
           sha256 = "1vjsmqjwpxavyj29wrbvvx7799fsa65d4iha5mj63cgs8qp605gk";

     

       8
       8
       +
           sha256 = "0mnjhjiixjphr9v101v408815hkl6hlghx9h7lmmylv5z7gk3p8k";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         buildInputs = [ jre makeWrapper ] ;

+33

pkgs/development/coq-modules/flocq/default.nix

···

       1
       1
       +
       {stdenv, bash, which, autoconf, automake, fetchurl, coq}:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
       

     

       5
       5
       +
         name = "coq-flocq-${coq.coq-version}-${version}";

     

       6
       6
       +
         version = "2.4.0";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchurl {

     

       9
       9
       +
           url = https://gforge.inria.fr/frs/download.php/file/33979/flocq-2.4.0.tar.gz;

     

       10
       10
       +
           sha256 = "020x4nkkrvndkvp5zwb9vads8a2jh603khcwrm40yhqldgfd8zlv";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         buildInputs = [ coq.ocaml coq.camlp5 bash which autoconf automake ];

     

       14
       14
       +
         propagatedBuildInputs = [ coq ];

     

       15
       15
       +
       

     

       16
       16
       +
         buildPhase = ''

     

       17
       17
       +
           ${bash}/bin/bash autogen.sh

     

       18
       18
       +
           ${bash}/bin/bash configure --libdir=$out/lib/coq/${coq.coq-version}/user-contrib/Flocq

     

       19
       19
       +
           ./remake

     

       20
       20
       +
         '';

     

       21
       21
       +
       

     

       22
       22
       +
         installPhase = ''

     

       23
       23
       +
           ./remake install

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with stdenv.lib; {

     

       27
       27
       +
           homepage = http://flocq.gforge.inria.fr/;

     

       28
       28
       +
           description = "Flocq (Floats for Coq) is a floating-point formalization for the Coq system";

     

       29
       29
       +
           maintainers = with maintainers; [ jwiegley ];

     

       30
       30
       +
           platforms = coq.meta.platforms;

     

       31
       31
       +
         };

     

       32
       32
       +
       

     

       33
       33
       +
       }

+66

pkgs/development/interpreters/clisp/2.33.2.nix

···

       1
       1
       +
       { stdenv, fetchurl, libsigsegv, gettext, ncurses, readline, libX11

     

       2
       2
       +
       , libXau, libXt, pcre, zlib, libXpm, xproto, libXext, xextproto

     

       3
       3
       +
       , libffi, libffcall, coreutils, automake, autoconf, linuxHeaders

     

       4
       4
       +
       , groff

     

       5
       5
       +
       }:

     

       6
       6
       +
               

     

       7
       7
       +
       stdenv.mkDerivation rec {

     

       8
       8
       +
         version = "2.33.2";

     

       9
       9
       +
         name = "clisp-${version}";

     

       10
       10
       +
         

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://gnu/clisp/release/${version}/${name}.tar.gz";

     

       13
       13
       +
           sha256 = "0rqyggviixaa68n5ll092ll4a2xy4y7jraq65l0gn0hkjhjnm5zh";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs =

     

       17
       17
       +
           [ libsigsegv gettext ncurses readline libX11 libXau libXt pcre

     

       18
       18
       +
             zlib libXpm xproto libXext xextproto libffi libffcall 

     

       19
       19
       +
             automake autoconf groff

     

       20
       20
       +
           ]

     

       21
       21
       +
           ++ (stdenv.lib.optional stdenv.isLinux linuxHeaders)

     

       22
       22
       +
           ;

     

       23
       23
       +
       

     

       24
       24
       +
         # First, replace port 9090 (rather low, can be used)

     

       25
       25
       +
         # with 64237 (much higher, IANA private area, not

     

       26
       26
       +
         # anything rememberable).

     

       27
       27
       +
         # Also remove reference to a type that disappeared from recent glibc

     

       28
       28
       +
         # (seems the correct thing to do, found no reference to any solution)

     

       29
       29
       +
         postPatch = ''

     

       30
       30
       +
           sed -i 's@/bin/pwd@${coreutils}&@' src/clisp-link.in

     

       31
       31
       +
           find . -type f | xargs sed -e 's/-lICE/-lXau &/' -i

     

       32
       32
       +
       

     

       33
       33
       +
           substituteInPlace modules/bindings/glibc/linux.lisp --replace "(def-c-type __swblk_t)" ""

     

       34
       34
       +
         '';

     

       35
       35
       +
         

     

       36
       36
       +
         configureFlags =

     

       37
       37
       +
           ''

     

       38
       38
       +
             builddir

     

       39
       39
       +
             --with-readline --with-ffcall --with-dynamic-ffi

     

       40
       40
       +
             --with-module=readline --with-module=i18n --with-module=pcre

     

       41
       41
       +
             --with-module=syscalls --with-modules=zlib --with-module=curses

     

       42
       42
       +
           '';

     

       43
       43
       +
       

     

       44
       44
       +
         preBuild = ''

     

       45
       45
       +
           echo Pre-build starting!

     

       46
       46
       +
           sed -e '/avcall.h/a\#include "config.h"' -i src/foreign.d

     

       47
       47
       +
           sed -e '/asm\/page.h/d' -i src/unix.d

     

       48
       48
       +
           cd builddir

     

       49
       49
       +
           ./makemake $configureFlags > Makefile

     

       50
       50
       +
           make config.lisp

     

       51
       51
       +
           cat config.lisp

     

       52
       52
       +
         '';

     

       53
       53
       +
       

     

       54
       54
       +
         NIX_CFLAGS_COMPILE="-O0 -lreadline -lncursesw";

     

       55
       55
       +
       

     

       56
       56
       +
         # TODO : make mod-check fails

     

       57
       57
       +
         doCheck = false;

     

       58
       58
       +
       

     

       59
       59
       +
         meta = {

     

       60
       60
       +
           description = "ANSI Common Lisp Implementation";

     

       61
       61
       +
           homepage = http://clisp.cons.org;

     

       62
       62
       +
           maintainers = [stdenv.lib.maintainers.raskin];

     

       63
       63
       +
           platforms = stdenv.lib.platforms.linux;

     

       64
       64
       +
           branch = "2.44";

     

       65
       65
       +
         };

     

       66
       66
       +
       }

+2 -2

pkgs/development/interpreters/elixir/default.nix

···

       1
       1
        
       { stdenv, fetchurl, erlang, rebar, makeWrapper, coreutils, curl, bash, cacert }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         version = "1.0.0";

     

       4
       4
       +
         version = "1.0.2";

     

       5
       5
        
       in

     

       6
       6
        
       stdenv.mkDerivation {

     

       7
       7
        
         name = "elixir-${version}";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://github.com/elixir-lang/elixir/archive/v${version}.tar.gz";

     

       11
       11
       -
           sha256 = "1ci8g6nh89xnn0ax9kazcs47w406nqsj1d4rf8sb1b6abfq78xsj";

     

       11
       11
       +
           sha256 = "6156ee396e85045358d11a6839e157e8fa9573b7414bddbd2c91843ed2b4b962";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         buildInputs = [ erlang rebar makeWrapper ];

+6 -6

pkgs/development/interpreters/j/default.nix

···

       29
       29
        
         /* doConfigure should be removed if not needed */

     

       30
       30
        
         phaseNames = ["doUnpack" "doBuildJ" "doDeploy"];

     

       31
       31
        
       

     

       32
       32
       -
         bits = if a.stdenv.system == "i686-linux" then 

     

       33
       33
       -
           "32"

     

       34
       34
       -
         else if a.stdenv.system == "x86_64-linux" then

     

       32
       32
       +
         bits = if a.stdenv.is64bit then

     

       35
       33
        
           "64"

     

       36
       36
       -
         else 

     

       37
       37
       -
           throw "Oops, unknown system: ${a.stdenv.system}";

     

       34
       34
       +
         else if a.stdenv.isi686 then

     

       35
       35
       +
           "32"

     

       36
       36
       +
         else

     

       37
       37
       +
           builtins.trace "assuming ${a.stdenv.system} is 32 bits" "32";

     

       38
       38
        
       

     

       39
       39
        
         doBuildJ = a.fullDepEntry ''

     

       40
       40
        
           sed -i bin/jconfig -e 's@bits=32@bits=${bits}@g; s@readline=0@readline=1@; s@LIBREADLINE=""@LIBREADLINE=" -lreadline "@'

     
···

       69
       69
        
             raskin

     

       70
       70
        
           ];

     

       71
       71
        
           platforms = with a.lib.platforms;

     

       72
       72
       -
             linux;

     

       72
       72
       +
             unix;

     

       73
       73
        
           license = a.lib.licenses.gpl3Plus;

     

       74
       74
        
         };

     

       75
       75
        
         passthru = {

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, nix }: let

     

       2
       2
       -
         version = "1.0.0";

     

       2
       2
       +
         version = "1.1.0";

     

       3
       3
        
       in stdenv.mkDerivation {

     

       4
       4
        
         name = "nix-exec-${version}";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "https://github.com/shlevy/nix-exec/releases/download/v${version}/nix-exec-${version}.tar.xz";

     

       8
       8
        
       

     

       9
       9
       -
           sha256 = "0w89ma69iil1ki68zvs1l0ii0d87in64791l3a4yzyv9d3ncl3w6";

     

       9
       9
       +
           sha256 = "0w1dq2svv1l8x18q5syraf80xpyyrcxbrab51cszc3v4m04b4saa";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ pkgconfig nix ];

+2 -1

pkgs/development/interpreters/pypy/2.4/default.nix

···

       1
       1
        
       { stdenv, fetchurl, zlib ? null, zlibSupport ? true, bzip2, pkgconfig, libffi

     

       2
       2
        
       , sqlite, openssl, ncurses, pythonFull, expat, tcl, tk, x11, libX11

     

       3
       3
       -
       , makeWrapper }:

     

       3
       3
       +
       , makeWrapper, callPackage, self }:

     

       4
       4
        
       

     

       5
       5
        
       assert zlibSupport -> zlib != null;

     

       6
       6
        
       

     
···

       99
       99
        
             inherit zlibSupport libPrefix;

     

       100
       100
        
             executable = "pypy";

     

       101
       101
        
             isPypy = true;

     

       102
       102
       +
             buildEnv = callPackage ../../python/wrapper.nix { python = self; };

     

       102
       103
        
           };

     

       103
       104
        
       

     

       104
       105
        
           enableParallelBuilding = true;

+2 -1

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

···

       1
       1
        
       { stdenv, fetchurl, zlib ? null, zlibSupport ? true, bzip2, includeModules ? false

     

       2
       2
       -
       , sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm}:

     

       2
       2
       +
       , sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm, self, callPackage }:

     

       3
       3
        
       

     

       4
       4
        
       assert zlibSupport -> zlib != null;

     

       5
       5
        
       

     
···

       82
       82
        
             inherit zlibSupport;

     

       83
       83
        
             isPy2 = true;

     

       84
       84
        
             isPy26 = true;

     

       85
       85
       +
             buildEnv = callPackage ../wrapper.nix { python = self; };

     

       85
       86
        
             libPrefix = "python${majorVersion}";

     

       86
       87
        
             executable = libPrefix;

     

       87
       88
        
             sitePackages = "lib/${libPrefix}/site-packages";

+2 -1

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

···

       1
       1
        
       { stdenv, fetchurl, zlib ? null, zlibSupport ? true, bzip2, includeModules ? false

     

       2
       2
       -
       , sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm, libX11 }:

     

       2
       2
       +
       , sqlite, tcl, tk, x11, openssl, readline, db, ncurses, gdbm, libX11, self, callPackage }:

     

       3
       3
        
       

     

       4
       4
        
       assert zlibSupport -> zlib != null;

     

       5
       5
        
       

     
···

       88
       88
        
             inherit zlibSupport;

     

       89
       89
        
             isPy2 = true;

     

       90
       90
        
             isPy27 = true;

     

       91
       91
       +
             buildEnv = callPackage ../wrapper.nix { python = self; };

     

       91
       92
        
             libPrefix = "python${majorVersion}";

     

       92
       93
        
             executable = libPrefix;

     

       93
       94
        
             sitePackages = "lib/${libPrefix}/site-packages";

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

···

       9
       9
        
       , sqlite

     

       10
       10
        
       , tcl, tk

     

       11
       11
        
       , zlib

     

       12
       12
       +
       , callPackage

     

       13
       13
       +
       , self

     

       12
       14
        
       }:

     

       13
       15
        
       

     

       14
       16
        
       assert readline != null -> ncurses != null;

     
···

       64
       66
        
           zlibSupport = zlib != null;

     

       65
       67
        
           sqliteSupport = sqlite != null;

     

       66
       68
        
           dbSupport = db != null;

     

       69
       69
       +
           buildEnv = callPackage ../wrapper.nix { python = self; };

     

       67
       70
        
           readlineSupport = readline != null;

     

       68
       71
        
           opensslSupport = openssl != null;

     

       69
       72
        
           tkSupport = (tk != null) && (tcl != null) && (libX11 != null) && (xproto != null);

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

···

       10
       10
        
       , sqlite

     

       11
       11
        
       , tcl, tk

     

       12
       12
        
       , zlib

     

       13
       13
       +
       , callPackage

     

       14
       14
       +
       , self

     

       13
       15
        
       }:

     

       14
       16
        
       

     

       15
       17
        
       assert readline != null -> ncurses != null;

     
···

       66
       68
        
           tkSupport = (tk != null) && (tcl != null) && (libX11 != null) && (xproto != null);

     

       67
       69
        
           libPrefix = "python${majorVersion}";

     

       68
       70
        
           executable = "python3.3m";

     

       71
       71
       +
           buildEnv = callPackage ../wrapper.nix { python = self; };

     

       69
       72
        
           isPy3 = true;

     

       70
       73
        
           isPy33 = true;

     

       71
       74
        
           is_py3k = true;  # deprecated

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

···

       10
       10
        
       , sqlite

     

       11
       11
        
       , tcl, tk

     

       12
       12
        
       , zlib

     

       13
       13
       +
       , callPackage

     

       14
       14
       +
       , self

     

       13
       15
        
       }:

     

       14
       16
        
       

     

       15
       17
        
       assert readline != null -> ncurses != null;

     
···

       67
       69
        
           tkSupport = (tk != null) && (tcl != null) && (libX11 != null) && (xproto != null);

     

       68
       70
        
           libPrefix = "python${majorVersion}";

     

       69
       71
        
           executable = "python3.4m";

     

       72
       72
       +
           buildEnv = callPackage ../wrapper.nix { python = self; };

     

       70
       73
        
           isPy3 = true;

     

       71
       74
        
           isPy34 = true;

     

       72
       75
        
           is_py3k = true;  # deprecated

+7 -3

pkgs/development/interpreters/python/wrapper.nix

···

       1
       1
       -
       { stdenv, python, buildEnv, makeWrapper, recursivePthLoader, extraLibs ? [], postBuild ? ""

     

       1
       1
       +
       { stdenv, python, buildEnv, makeWrapper

     

       2
       2
       +
       , extraLibs ? []

     

       3
       3
       +
       , postBuild ? ""

     

       2
       4
        
       , ignoreCollisions ? false }:

     

       3
       5
        
       

     

       4
       6
        
       # Create a python executable that knows about additional packages.

     

       5
       5
       -
       

     

       7
       7
       +
       let

     

       8
       8
       +
         recursivePthLoader = import ../../python-modules/recursive-pth-loader/default.nix { stdenv = stdenv; python = python; };

     

       9
       9
       +
       in

     

       6
       10
        
       (buildEnv {

     

       7
       7
       -
         name = "python-${python.version}-env";

     

       11
       11
       +
         name = "${python.name}-env";

     

       8
       12
        
         paths = stdenv.lib.filter (x : x ? pythonPath) (stdenv.lib.closePropagation extraLibs) ++ [ python recursivePthLoader ];

     

       9
       13
        
       

     

       10
       14
        
         inherit ignoreCollisions;

+2 -2

pkgs/development/interpreters/racket/default.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         pname = "racket";

     

       7
       7
       -
         version = "6.0.1";

     

       7
       7
       +
         version = "6.1";

     

       8
       8
        
         name = "${pname}-${version}";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "http://mirror.racket-lang.org/installers/${version}/${name}-src.tgz";

     

       12
       12
       -
           sha256 = "e2bc0d4d0fcdfc3327a58c931f203c07a06d4724703f9708ba2e4c8ea0f9694d";

     

       12
       12
       +
           sha256 = "fde283bf5899bb9266ce721db44631c9bac4a4864a7c3211de413fd9503178c6";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         # Various racket executables do run-time searches for these.

+7 -9

pkgs/development/interpreters/xulrunner/default.nix

···

       3
       3
        
       , freetype, fontconfig, file, alsaLib, nspr, nss, libnotify

     

       4
       4
        
       , yasm, mesa, sqlite, unzip, makeWrapper, pysqlite

     

       5
       5
        
       , hunspell, libevent, libstartup_notification, libvpx

     

       6
       6
       -
       , cairo, gstreamer, gst_plugins_base, icu

     

       6
       6
       +
       , cairo, gstreamer, gst_plugins_base, icu, firefox

     

       7
       7
        
       , debugBuild ? false

     

       8
       8
        
       }:

     

       9
       9
        
       

     

       10
       10
        
       assert stdenv.gcc ? libc && stdenv.gcc.libc != null;

     

       11
       11
        
       

     

       12
       12
       -
       let version = "31.0"; in

     

       12
       12
       +
       let version = firefox.version; in

     

       13
       13
        
       

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
        
         name = "xulrunner-${version}";

     

       16
       16
        
       

     

       17
       17
       -
         src = fetchurl {

     

       18
       18
       -
           url = "http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/${version}/source/firefox-${version}.source.tar.bz2";

     

       19
       19
       -
           sha1 = "a6c3e25ee3aeb7da42db2aaeb50a385d63532beb";

     

       20
       20
       -
         };

     

       17
       17
       +
         src = firefox.src;

     

       21
       18
        
       

     

       22
       19
        
         buildInputs =

     

       23
       20
        
           [ pkgconfig gtk perl zip libIDL libjpeg zlib bzip2

     
···

       58
       55
        
             "--disable-updater"

     

       59
       56
        
             "--disable-pulseaudio"

     

       60
       57
        
           ]

     

       61
       61
       -
           ++ (if debugBuild then [ "--enable-debug" "--enable-profiling"]

     

       62
       62
       -
                             else [ "--disable-debug" "--enable-release"

     

       63
       63
       -
                                    "--enable-optimize" "--enable-strip" ]);

     

       58
       58
       +
           ++ (if debugBuild

     

       59
       59
       +
               then [ "--enable-debug" "--enable-profiling"]

     

       60
       60
       +
               else [ "--disable-debug" "--enable-release" "--enable-strip"

     

       61
       61
       +
                      "--enable-optimize${lib.optionalString (stdenv.system == "i686-linux") "=-O1"}" ]);

     

       64
       62
        
       

     

       65
       63
        
         enableParallelBuilding = true;

     

       66
       64

+4 -2

pkgs/development/libraries/ffmpeg/1.x.nix

···

       31
       31
        
       assert freetypeSupport -> freetype != null;

     

       32
       32
        
       

     

       33
       33
        
       stdenv.mkDerivation rec {

     

       34
       34
       -
         name = "ffmpeg-1.2.8";

     

       34
       34
       +
         name = "ffmpeg-1.2.9";

     

       35
       35
        
       

     

       36
       36
        
         src = fetchurl {

     

       37
       37
        
           url = "http://www.ffmpeg.org/releases/${name}.tar.bz2";

     

       38
       38
       -
           sha256 = "0n9fklr8zqkd60dc5ai161l6k4dbiac5hqy0pi1w82yamc25k6s2";

     

       38
       38
       +
           sha256 = "02wsnlix92a9k8wf3b4bad3a14v1c5iiz0fv6wlk1zn82cp93paw";

     

       39
       39
        
         };

     

       40
       40
        
       

     

       41
       41
        
         # `--enable-gpl' (as well as the `postproc' and `swscale') mean that

     
···

       100
       100
        
         meta = {

     

       101
       101
        
           homepage = http://www.ffmpeg.org/;

     

       102
       102
        
           description = "A complete, cross-platform solution to record, convert and stream audio and video";

     

       103
       103
       +
           license = if faacSupport then stdenv.lib.licenses.unfree else stdenv.lib.licenses.gpl2Plus;

     

       103
       104
        
           maintainers = with stdenv.lib.maintainers; [ the-kenny ];

     

       105
       105
       +
           platforms = stdenv.lib.platforms.unix;

     

       104
       106
        
           branch = "1";

     

       105
       107
        
         };

     

       106
       108
        
       }

+2 -2

pkgs/development/libraries/git2/default.nix

···

       1
       1
       -
       {stdenv, fetchurl, cmake, zlib, python}:

     

       1
       1
       +
       {stdenv, fetchurl, cmake, zlib, python, libssh2, openssl, http-parser}:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         version = "0.21.1";

     
···

       13
       13
        
         cmakeFlags = "-DTHREADSAFE=ON";

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ cmake python ];

     

       16
       16
       -
         buildInputs = [ zlib ];

     

       16
       16
       +
         buildInputs = [ zlib libssh2 openssl http-parser ];

     

       17
       17
        
       

     

       18
       18
        
         meta = {

     

       19
       19
        
           description = "the Git linkable library";

+22

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

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, deepseq, HUnit, QuickCheck, testFramework

     

       4
       4
       +
       , testFrameworkHunit, testFrameworkQuickcheck2

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       cabal.mkDerivation (self: {

     

       8
       8
       +
         pname = "Decimal";

     

       9
       9
       +
         version = "0.4.2";

     

       10
       10
       +
         sha256 = "0qa2z2lq1hrvakhyhj624mg8sd05ikhb66zwpa6x9vcyji93dxf5";

     

       11
       11
       +
         buildDepends = [ deepseq ];

     

       12
       12
       +
         testDepends = [

     

       13
       13
       +
           deepseq HUnit QuickCheck testFramework testFrameworkHunit

     

       14
       14
       +
           testFrameworkQuickcheck2

     

       15
       15
       +
         ];

     

       16
       16
       +
         meta = {

     

       17
       17
       +
           homepage = "https://github.com/PaulJohnson/Haskell-Decimal";

     

       18
       18
       +
           description = "Decimal numbers with variable precision";

     

       19
       19
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       20
       20
       +
           platforms = self.ghc.meta.platforms;

     

       21
       21
       +
         };

     

       22
       22
       +
       })

pkgs/development/libraries/haskell/Extra/default.nix pkgs/development/libraries/haskell/Extra-lib/default.nix

+11 -11

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, aeson, base64Bytestring, cpphs, Diff, filepath

     

       4
       4
       -
       , haskellSrcExts, HUnit, liftedBase, monadControl, mtl, QuickCheck

     

       5
       5
       -
       , random, regexCompat, temporary, text, time, unorderedContainers

     

       6
       6
       -
       , vector, xmlgen

     

       3
       3
       +
       { cabal, aeson, aesonPretty, base64Bytestring, cpphs, Diff

     

       4
       4
       +
       , filepath, haskellLexer, haskellSrc, HUnit, liftedBase

     

       5
       5
       +
       , monadControl, mtl, QuickCheck, random, regexCompat, temporary

     

       6
       6
       +
       , text, time, unorderedContainers, vector, xmlgen

     

       7
       7
        
       }:

     

       8
       8
        
       

     

       9
       9
        
       cabal.mkDerivation (self: {

     

       10
       10
        
         pname = "HTF";

     

       11
       11
       -
         version = "0.12.1.0";

     

       12
       12
       -
         sha256 = "1symg1y6i47rd1jshj84cwpn5vgmvh6v07jidjg5w5w3syyxqnz4";

     

       11
       11
       +
         version = "0.12.2.2";

     

       12
       12
       +
         sha256 = "02n3nqghcl9wmcr2iar9bg8nziddsvp43rzyasq4fnh166y87gc4";

     

       13
       13
        
         isLibrary = true;

     

       14
       14
        
         isExecutable = true;

     

       15
       15
        
         buildDepends = [

     

       16
       16
       -
           aeson base64Bytestring cpphs Diff haskellSrcExts HUnit liftedBase

     

       17
       17
       -
           monadControl mtl QuickCheck random regexCompat text time vector

     

       18
       18
       -
           xmlgen

     

       16
       16
       +
           aeson base64Bytestring cpphs Diff haskellLexer haskellSrc HUnit

     

       17
       17
       +
           liftedBase monadControl mtl QuickCheck random regexCompat text time

     

       18
       18
       +
           vector xmlgen

     

       19
       19
        
         ];

     

       20
       20
        
         testDepends = [

     

       21
       21
       -
           aeson filepath HUnit mtl random regexCompat temporary text

     

       22
       22
       -
           unorderedContainers

     

       21
       21
       +
           aeson aesonPretty filepath HUnit mtl random regexCompat temporary

     

       22
       22
       +
           text unorderedContainers

     

       23
       23
        
         ];

     

       24
       24
        
         doCheck = false;

     

       25
       25
        
         meta = {

+9 -6

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, HTTP, hxt, hxtHttp, MaybeT, mtl, network, parsec

     

       4
       4
       -
       , transformers

     

       3
       3
       +
       { cabal, hspec, HTTP, hxt, hxtHttp, MaybeT, mtl, network

     

       4
       4
       +
       , networkUri, parsec, transformers

     

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "HandsomeSoup";

     

       9
       9
       -
         version = "0.3.2";

     

       10
       10
       -
         sha256 = "0ixqk32sfv6kj41vc6fzflv6f6jwvnkvcdf9pmgkc675218ggh53";

     

       9
       9
       +
         version = "0.3.3";

     

       10
       10
       +
         sha256 = "0g2b3mw0asam005kz77zm3bsrjaa7q3n6wdj3ahr7hppivsdwizk";

     

       11
       11
       +
         isLibrary = true;

     

       12
       12
       +
         isExecutable = true;

     

       11
       13
        
         buildDepends = [

     

       12
       12
       -
           HTTP hxt hxtHttp MaybeT mtl network parsec transformers

     

       14
       14
       +
           HTTP hxt hxtHttp MaybeT mtl network networkUri parsec transformers

     

       13
       15
        
         ];

     

       16
       16
       +
         testDepends = [ hspec hxt ];

     

       17
       17
       +
         doCheck = false;

     

       14
       18
        
         meta = {

     

       15
       19
        
           homepage = "https://github.com/egonSchiele/HandsomeSoup";

     

       16
       20
        
           description = "Work with HTML more easily in HXT";

     

       17
       21
        
           license = self.stdenv.lib.licenses.bsd3;

     

       18
       22
        
           platforms = self.ghc.meta.platforms;

     

       19
       19
       -
           broken = true;

     

       20
       23
        
         };

     

       21
       24
        
       })

+2 -2

pkgs/development/libraries/haskell/JuicyPixels-util/default.nix

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "JuicyPixels-util";

     

       7
       7
       -
         version = "0.1";

     

       8
       8
       -
         sha256 = "181wryax2k43qlblink9vcg2hk8f2qxn02ifmgxa2fl95z5ar0dc";

     

       7
       7
       +
         version = "0.2";

     

       8
       8
       +
         sha256 = "1b2rx5g8kd83hl50carr02mz21gvkasnsddw1f3pfvfsyfv3yyrc";

     

       9
       9
        
         buildDepends = [ JuicyPixels vector ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "https://github.com/fumieval/JuicyPixels-util";

+2 -2

pkgs/development/libraries/haskell/aeson/0.8.0.1.nix pkgs/development/libraries/haskell/aeson/0.8.0.2.nix

···

       8
       8
        
       

     

       9
       9
        
       cabal.mkDerivation (self: {

     

       10
       10
        
         pname = "aeson";

     

       11
       11
       -
         version = "0.8.0.1";

     

       12
       12
       -
         sha256 = "0363pzla3kjk2ckmm7j07hav3bgq31jkrya5jhl9dn0nv4l4slxk";

     

       11
       11
       +
         version = "0.8.0.2";

     

       12
       12
       +
         sha256 = "1mc8cwmswx69r77wv7dfim525jqajnlxbcx5xf3ygpszzf6mh1q7";

     

       13
       13
        
         buildDepends = [

     

       14
       14
        
           attoparsec blazeBuilder deepseq dlist hashable mtl scientific syb

     

       15
       15
        
           text time unorderedContainers vector

+8 -6

pkgs/development/libraries/haskell/asn1-encoding/default.nix

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, asn1Types, mtl, text, time }:

     

       3
       3
       +
       { cabal, asn1Types, hourglass, mtl, tasty, tastyQuickcheck, text }:

     

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "asn1-encoding";

     

       7
       7
       -
         version = "0.8.1.3";

     

       8
       8
       -
         sha256 = "000rajx9gdxfyx521yg2mvp1z8h61sr96w1lzwawiw7n5ng6v8ni";

     

       9
       9
       -
         isLibrary = true;

     

       10
       10
       -
         isExecutable = true;

     

       11
       11
       -
         buildDepends = [ asn1Types mtl text time ];

     

       7
       7
       +
         version = "0.9.0";

     

       8
       8
       +
         sha256 = "02x3lzyl4gavl3lc2lrg8rknyvs6r2hf8kmm7xrmma5m857iks8p";

     

       9
       9
       +
         buildDepends = [ asn1Types hourglass mtl ];

     

       10
       10
       +
         testDepends = [

     

       11
       11
       +
           asn1Types hourglass mtl tasty tastyQuickcheck text

     

       12
       12
       +
         ];

     

       13
       13
       +
         doCheck = false;

     

       12
       14
        
         meta = {

     

       13
       15
        
           homepage = "http://github.com/vincenthz/hs-asn1";

     

       14
       16
        
           description = "ASN1 data reader and writer in RAW, BER and DER forms";

+4 -4

pkgs/development/libraries/haskell/asn1-parse/default.nix

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, asn1Encoding, asn1Types, mtl, text, time }:

     

       3
       3
       +
       { cabal, asn1Encoding, asn1Types, mtl, text }:

     

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "asn1-parse";

     

       7
       7
       -
         version = "0.8.1";

     

       8
       8
       -
         sha256 = "021mbm5aayfx9vhxq4x1jj3gpnzq0bqaqcl1zsaa2a6l0qzpnmh9";

     

       9
       9
       -
         buildDepends = [ asn1Encoding asn1Types mtl text time ];

     

       7
       7
       +
         version = "0.9.0";

     

       8
       8
       +
         sha256 = "0m093wwndyxvy72qlnb70bp8w5ahimrlv1dp972l9s9l5jc4pjg3";

     

       9
       9
       +
         buildDepends = [ asn1Encoding asn1Types mtl text ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "http://github.com/vincenthz/hs-asn1";

     

       12
       12
        
           description = "Simple monadic parser for ASN1 stream types";

+4 -4

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, time }:

     

       3
       3
       +
       { cabal, hourglass }:

     

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "asn1-types";

     

       7
       7
       -
         version = "0.2.3";

     

       8
       8
       -
         sha256 = "1cdzhj6zls6qmy82218cj2a25b7rkxsjbcqnx4zng3wp6s5pghw4";

     

       9
       9
       -
         buildDepends = [ time ];

     

       7
       7
       +
         version = "0.3.0";

     

       8
       8
       +
         sha256 = "1am8nmfarv7ymy3rqm0js2i82v6n6qwz0lnzb1qdmy4ligcdm65r";

     

       9
       9
       +
         buildDepends = [ hourglass ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "http://github.com/vincenthz/hs-asn1-types";

     

       12
       12
        
           description = "ASN.1 types";

+2 -2

pkgs/development/libraries/haskell/auto-update/default.nix

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "auto-update";

     

       7
       7
       -
         version = "0.1.1.5";

     

       8
       8
       -
         sha256 = "1gwx9k953nhw6n4d8a4jw3sfp51761s5qjsql73pr8i6gri0849h";

     

       7
       7
       +
         version = "0.1.2";

     

       8
       8
       +
         sha256 = "0ccix41jjpqkzvnfr5md1cbhsa9fkv6dy7yw73j8dnvqbqnz1z0l";

     

       9
       9
        
         meta = {

     

       10
       10
        
           homepage = "https://github.com/yesodweb/wai";

     

       11
       11
        
           description = "Efficiently run periodic, on-demand actions";

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "basic-prelude";

     

       9
       9
       -
         version = "0.3.9";

     

       10
       10
       -
         sha256 = "0f2l8xryagl1f0d30gq1hhydjnn77qhhwgg9l44gvqn30y2n66h7";

     

       9
       9
       +
         version = "0.3.10";

     

       10
       10
       +
         sha256 = "10013ni7kpqlc6s3ryfvmklw3ic5h48rm4wsrb31pcp5xja0qk59";

     

       11
       11
        
         buildDepends = [

     

       12
       12
        
           hashable liftedBase ReadArgs safe systemFilepath text transformers

     

       13
       13
        
           unorderedContainers vector

+3 -3

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "binary-conduit";

     

       9
       9
       -
         version = "1.2.2";

     

       10
       10
       -
         sha256 = "12dgqydc4zj1ffrcfqpd1dg40dc9hpynj1j69611kzpcqbj275pf";

     

       9
       9
       +
         version = "1.2.3";

     

       10
       10
       +
         sha256 = "0ymhxyf754j1pki7ap2vay8f9j49rzsjzp5yr253sn5wpw3qg8fr";

     

       11
       11
        
         buildDepends = [ binary conduit resourcet vector ];

     

       12
       12
        
         testDepends = [

     

       13
       13
        
           binary conduit hspec QuickCheck quickcheckAssertions resourcet

     

       14
       14
        
         ];

     

       15
       15
        
         jailbreak = true;

     

       16
       16
        
         meta = {

     

       17
       17
       -
           homepage = "http://github.com/qnikst/binary-conduit";

     

       17
       17
       +
           homepage = "http://github.com/qnikst/binary-conduit/";

     

       18
       18
        
           description = "data serialization/deserialization conduit library";

     

       19
       19
        
           license = self.stdenv.lib.licenses.mit;

     

       20
       20
        
           platforms = self.ghc.meta.platforms;

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "cairo";

     

       9
       9
       -
         version = "0.13.0.3";

     

       10
       10
       -
         sha256 = "0jlxgxsby8qscyfq517xlaib8xkp310gbjbmk9yyi7sd5bnmblh9";

     

       9
       9
       +
         version = "0.13.0.4";

     

       10
       10
       +
         sha256 = "0sj6c83md51qvjpp3dckv3hvg9dm2qkiw1wzlvdypdd1c09957n2";

     

       11
       11
        
         buildDepends = [ mtl text utf8String ];

     

       12
       12
        
         buildTools = [ gtk2hsBuildtools ];

     

       13
       13
        
         extraLibraries = [ cairo libc pkgconfig zlib ];

+16

pkgs/development/libraries/haskell/charsetdetect-ae/default.nix

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal }:

     

       4
       4
       +
       

     

       5
       5
       +
       cabal.mkDerivation (self: {

     

       6
       6
       +
         pname = "charsetdetect-ae";

     

       7
       7
       +
         version = "1.0.1";

     

       8
       8
       +
         sha256 = "0bvdnv608glim8yn4dvh3av7x0fxxp3z6719j0n005bygdfgjxna";

     

       9
       9
       +
         meta = {

     

       10
       10
       +
           homepage = "http://github.com/Aelve/charsetdetect-ae";

     

       11
       11
       +
           description = "Character set detection using Mozilla's Universal Character Set Detector";

     

       12
       12
       +
           license = "LGPL";

     

       13
       13
       +
           platforms = self.ghc.meta.platforms;

     

       14
       14
       +
           maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];

     

       15
       15
       +
         };

     

       16
       16
       +
       })

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "classy-prelude-conduit";

     

       10
       10
       -
         version = "0.10.0";

     

       11
       11
       -
         sha256 = "0ziggymy37iz68c2rjdjdzjsamnvn81r836a6xx2nhqjivmfmlav";

     

       10
       10
       +
         version = "0.10.1";

     

       11
       11
       +
         sha256 = "0q6x0mb24yslgqjazg443v9w15x3j4xn32m6p9iwbmafyfbp9vs4";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           classyPrelude conduit conduitCombinators monadControl resourcet

     

       14
       14
        
           systemFileio transformers void

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       cabal.mkDerivation (self: {

     

       10
       10
        
         pname = "classy-prelude";

     

       11
       11
       -
         version = "0.10.0";

     

       12
       12
       -
         sha256 = "007a1gs9wgfw7gkm4jyh0fndcnxwkffzdm5rgxw08f1g8s0yqwf3";

     

       11
       11
       +
         version = "0.10.1";

     

       12
       12
       +
         sha256 = "1x22kq808ncgbi32idwn2232fy0hji3a7p9l9ardpg7hb6q1w76g";

     

       13
       13
        
         buildDepends = [

     

       14
       14
        
           basicPrelude bifunctors chunkedData enclosedExceptions exceptions

     

       15
       15
        
           hashable liftedBase monoTraversable mtl primitive semigroups stm

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

···

       12
       12
        
         testDepends = [

     

       13
       13
        
           binary hashable QuickCheck testFramework testFrameworkQuickcheck2

     

       14
       14
        
         ];

     

       15
       15
       +
         doCheck = false;

     

       15
       16
        
         meta = {

     

       16
       17
        
           description = "Binary and Hashable instances for TypeRep";

     

       17
       18
        
           license = self.stdenv.lib.licenses.bsd3;

+2 -2

pkgs/development/libraries/haskell/crypto-pubkey-types/default.nix

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "crypto-pubkey-types";

     

       7
       7
       -
         version = "0.4.2.2";

     

       8
       8
       -
         sha256 = "18z1fnh2xjq600ya8m175m64nwr6bwscr2q47zjy7k38zlm9c8h5";

     

       7
       7
       +
         version = "0.4.2.3";

     

       8
       8
       +
         sha256 = "1isfyr1ly9hv8idslpjbyc9hhgb1zqd9gfc1s4kvwy4gcdsvrx52";

     

       9
       9
        
         buildDepends = [ asn1Types ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";

+2 -2

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

···

       5
       5
        
       

     

       6
       6
        
       cabal.mkDerivation (self: {

     

       7
       7
        
         pname = "digestive-functors-heist";

     

       8
       8
       -
         version = "0.8.6.0";

     

       9
       9
       -
         sha256 = "0n73hw8xl70x7c3hn4hz1qqijvvhv0qk30q0c22lnbjaf4n8dki2";

     

       8
       8
       +
         version = "0.8.6.1";

     

       9
       9
       +
         sha256 = "1l8ppn2h1nxzn5wxnglc2fyi7r90177v75yf4n7cyvzrcxdaz4bb";

     

       10
       10
        
         buildDepends = [

     

       11
       11
        
           blazeBuilder digestiveFunctors heist mtl text xmlhtml

     

       12
       12
        
         ];

+2 -2

pkgs/development/libraries/haskell/dynamic-cabal/default.nix

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "dynamic-cabal";

     

       9
       9
       -
         version = "0.3.2";

     

       10
       10
       -
         sha256 = "0f0g4kml17j1j101gnpjjpdmny4m2wgr0dbjq18fw1s3nxc3jagm";

     

       9
       9
       +
         version = "0.3.3";

     

       10
       10
       +
         sha256 = "0fq6q0j2fx7ygarzgsvb7scssjnrxjrq188d0habfar6bdm0vqdg";

     

       11
       11
        
         buildDepends = [

     

       12
       12
        
           dataDefault filepath ghcPaths haskellGenerate haskellSrcExts time

     

       13
       13
        
           void

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "ekg";

     

       9
       9
       -
         version = "0.4.0.3";

     

       10
       10
       -
         sha256 = "0fynng6r0aj25k4j8ba3fvq4a6kgijil4m9ygd99xq8c1cvj2zyy";

     

       9
       9
       +
         version = "0.4.0.4";

     

       10
       10
       +
         sha256 = "1v1kskl1fwwpv72lay8c7nlvg2dswf6wij176fjfml1v8lmll2lr";

     

       11
       11
        
         buildDepends = [

     

       12
       12
        
           aeson ekgCore filepath network snapCore snapServer text time

     

       13
       13
        
           transformers unorderedContainers

+18

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

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, filepath, QuickCheck, time }:

     

       4
       4
       +
       

     

       5
       5
       +
       cabal.mkDerivation (self: {

     

       6
       6
       +
         pname = "extra";

     

       7
       7
       +
         version = "0.3.2";

     

       8
       8
       +
         sha256 = "0in340mmbgqkafj60pas7dm6bn080nimxk8b9b6xzv0giih6dx66";

     

       9
       9
       +
         buildDepends = [ filepath time ];

     

       10
       10
       +
         testDepends = [ QuickCheck time ];

     

       11
       11
       +
         meta = {

     

       12
       12
       +
           homepage = "https://github.com/ndmitchell/extra#readme";

     

       13
       13
       +
           description = "Extra functions I use";

     

       14
       14
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       15
       15
       +
           platforms = self.ghc.meta.platforms;

     

       16
       16
       +
           maintainers = with self.stdenv.lib.maintainers; [ aycanirican ];

     

       17
       17
       +
         };

     

       18
       18
       +
       })

+2 -2

pkgs/development/libraries/haskell/fast-logger/default.nix

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "fast-logger";

     

       7
       7
       -
         version = "2.2.0";

     

       8
       8
       -
         sha256 = "02gc5f7vgwfdlhfawki4xxrl33lbdl05wh64qm3mb3h2dv1gnwrr";

     

       7
       7
       +
         version = "2.2.3";

     

       8
       8
       +
         sha256 = "0zap61gz0snbq42h8nyjh637fr2cm1ny9f77sqd6v3yfqjq0ljh3";

     

       9
       9
        
         buildDepends = [ autoUpdate blazeBuilder filepath text ];

     

       10
       10
        
         testDepends = [ hspec ];

     

       11
       11
        
         meta = {

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       cabal.mkDerivation (self: {

     

       11
       11
        
         pname = "fay";

     

       12
       12
       -
         version = "0.21.0.1";

     

       13
       13
       -
         sha256 = "0lrnn73xqgkgh5zd4ngvl0lyzqbx5kp52j14dj2xbkbxnnivwgl4";

     

       12
       12
       +
         version = "0.21.0.2";

     

       13
       13
       +
         sha256 = "0hq9jfyl5ki3jcwffb9q7cxrgpchajgwk4j44kz37y1wji63lk96";

     

       14
       14
        
         isLibrary = true;

     

       15
       15
        
         isExecutable = true;

     

       16
       16
        
         buildDepends = [

+2 -2

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

···

       10
       10
        
       

     

       11
       11
        
       cabal.mkDerivation (self: {

     

       12
       12
        
         pname = "fb";

     

       13
       13
       -
         version = "1.0.6";

     

       14
       14
       -
         sha256 = "16dwvh2xn14gpni0qpabqfifywrkdz1p0mmq6yyf3k19ix3xg9im";

     

       13
       13
       +
         version = "1.0.7";

     

       14
       14
       +
         sha256 = "0ghyddxf4aqidqvbm93pjgaban0whfj4y1w11b7nxy89srhyjhh8";

     

       15
       15
        
         buildDepends = [

     

       16
       16
        
           aeson attoparsec base16Bytestring base64Bytestring cereal conduit

     

       17
       17
        
           conduitExtra cryptoApi cryptohash cryptohashCryptoapi dataDefault

+3 -4

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, lochTh, placeholders }:

     

       3
       3
       +
       { cabal }:

     

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "focus";

     

       7
       7
       -
         version = "0.1.2";

     

       8
       8
       -
         sha256 = "0j157nv668621i94iqg923bfg7594bpfn0q9scb62cik2yikc1p0";

     

       9
       9
       -
         buildDepends = [ lochTh placeholders ];

     

       7
       7
       +
         version = "0.1.3";

     

       8
       8
       +
         sha256 = "11l6rlr22m0z41c9fynpisj0cnx70zzcxhsakz9b09ap8wj0raqy";

     

       10
       9
        
         meta = {

     

       11
       10
        
           homepage = "https://github.com/nikita-volkov/focus";

     

       12
       11
        
           description = "A general abstraction for manipulating elements of container data structures";

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "gio";

     

       7
       7
       -
         version = "0.13.0.1";

     

       8
       8
       -
         sha256 = "03194npzv48flg6pba3m8c5gfmmy34z0545y84wa979z21fbv22m";

     

       7
       7
       +
         version = "0.13.0.2";

     

       8
       8
       +
         sha256 = "12wcgycljlrxbf9hdp0c9n6d2h709wb3jk94v3lngwc7z5lnv5hs";

     

       9
       9
        
         buildDepends = [ glib mtl ];

     

       10
       10
        
         buildTools = [ gtk2hsBuildtools ];

     

       11
       11
        
         pkgconfigDepends = [ glib ];

+2 -2

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

···

       5
       5
        
       

     

       6
       6
        
       cabal.mkDerivation (self: {

     

       7
       7
        
         pname = "glib";

     

       8
       8
       -
         version = "0.13.0.4";

     

       9
       9
       -
         sha256 = "1ckl6liw6x4hqirki1vcxrvdca0cf17kpxnngrfnxvndlwghly68";

     

       8
       8
       +
         version = "0.13.0.5";

     

       9
       9
       +
         sha256 = "0drpsdzdk47qkcn9jca8i4xrhhcql5gphm9wx2xaavqs8g7aqkg3";

     

       10
       10
        
         buildDepends = [ text utf8String ];

     

       11
       11
        
         buildTools = [ gtk2hsBuildtools ];

     

       12
       12
        
         extraLibraries = [ libc pkgconfig ];

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "gtk";

     

       9
       9
       -
         version = "0.13.0.2";

     

       10
       10
       -
         sha256 = "0m5gvs2zsm8y742yvfcd8h6qqihgjjyhhz8f4dxg589bhckv3amj";

     

       9
       9
       +
         version = "0.13.0.3";

     

       10
       10
       +
         sha256 = "1l42hn3mhycq2b7z517jjyz3s8kvf5nyy0m674da0h2rixw9r5fh";

     

       11
       11
        
         buildDepends = [ cairo gio glib mtl pango text ];

     

       12
       12
        
         buildTools = [ gtk2hsBuildtools ];

     

       13
       13
        
         extraLibraries = [ libc pkgconfig ];

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "gtk3";

     

       9
       9
       -
         version = "0.13.0.2";

     

       10
       10
       -
         sha256 = "0j5df9xah5ya91x3d7cyy5zw7mkw3j2y7n0vv5s78w0adchaxzzl";

     

       9
       9
       +
         version = "0.13.0.3";

     

       10
       10
       +
         sha256 = "12ywqxvmakcdmfj5y4jpn91rxa4xskd0w3hn2l679dk6lxyl15q7";

     

       11
       11
        
         isLibrary = true;

     

       12
       12
        
         isExecutable = true;

     

       13
       13
        
         buildDepends = [ cairo gio glib mtl pango text time transformers ];

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "gtksourceview2";

     

       9
       9
       -
         version = "0.13.1.0";

     

       10
       10
       -
         sha256 = "1znmr694jxam9n5lgikrhf8wb4jwdml82a3mgnpfr482a8knndbn";

     

       9
       9
       +
         version = "0.13.1.1";

     

       10
       10
       +
         sha256 = "09439drmwfy5bqni1clcn0nng30irn9x43fjak9jljggg1yij9xw";

     

       11
       11
        
         buildDepends = [ glib gtk mtl text ];

     

       12
       12
        
         buildTools = [ gtk2hsBuildtools ];

     

       13
       13
        
         extraLibraries = [ libc pkgconfig ];

+5 -3

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

···

       15
       15
        
         sha256 = "1igna446dsidlq3f9myclgcdawgvyyjxjk3r3icjra6zgdqd6j4l";

     

       16
       16
        
         isLibrary = true;

     

       17
       17
        
         isExecutable = true;

     

       18
       18
       +
         patches = [ ./deps.patch ];

     

       19
       19
       +
         doCheck = !self.stdenv.isDarwin;

     

       18
       20
        
         buildDepends = [

     

       19
       21
        
           binary blazeHtml blazeMarkup cmdargs cryptohash dataDefault deepseq

     

       20
       22
        
           filepath fsnotify httpConduit httpTypes lrucache mtl network

     
···

       26
       28
        
           filepath fsnotify httpConduit httpTypes HUnit lrucache mtl network

     

       27
       29
        
           networkUri pandoc pandocCiteproc parsec QuickCheck random regexBase

     

       28
       30
        
           regexTdfa snapCore snapServer systemFilepath tagsoup testFramework

     

       29
       29
       -
           testFrameworkHunit testFrameworkQuickcheck2 text time utillinux

     

       30
       30
       -
         ];

     

       31
       31
       +
           testFrameworkHunit testFrameworkQuickcheck2 text time

     

       32
       32
       +
         ] ++ (self.stdenv.lib.optional self.stdenv.isLinux utillinux);

     

       31
       33
        
         meta = {

     

       32
       34
        
           homepage = "http://jaspervdj.be/hakyll";

     

       33
       35
        
           description = "A static website compiler library";

     

       34
       36
        
           license = self.stdenv.lib.licenses.bsd3;

     

       35
       37
        
           platforms = self.ghc.meta.platforms;

     

       36
       38
        
           maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];

     

       37
       37
       -
           broken = true;

     

       39
       39
       +
           broken = self.stdenv.lib.versionOlder "7.7" self.ghc.version;

     

       38
       40
        
         };

     

       39
       41
        
       })

+20

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

···

       1
       1
       +
       --- a/hakyll.cabal.orig	2014-10-16 17:34:22.000000000 -0500

     

       2
       2
       +
       +++ b/hakyll.cabal	2014-10-16 17:34:30.000000000 -0500

     

       3
       3
       +
       @@ -163,7 +163,7 @@

     

       4
       4
       +
            pandoc-citeproc >= 0.4    && < 0.5,

     

       5
       5
       +
            parsec          >= 3.0    && < 3.2,

     

       6
       6
       +
            process         >= 1.0    && < 1.3,

     

       7
       7
       +
       -    random          >= 1.0    && < 1.1,

     

       8
       8
       +
       +    random          >= 1.0    && < 1.2,

     

       9
       9
       +
            regex-base      >= 0.93   && < 0.94,

     

       10
       10
       +
            regex-tdfa      >= 1.1    && < 1.3,

     

       11
       11
       +
            tagsoup         >= 0.13.1 && < 0.14,

     

       12
       12
       +
       @@ -250,7 +250,7 @@

     

       13
       13
       +
            pandoc-citeproc >= 0.4    && < 0.5,

     

       14
       14
       +
            parsec          >= 3.0    && < 3.2,

     

       15
       15
       +
            process         >= 1.0    && < 1.3,

     

       16
       16
       +
       -    random          >= 1.0    && < 1.1,

     

       17
       17
       +
       +    random          >= 1.0    && < 1.2,

     

       18
       18
       +
            regex-base      >= 0.93   && < 0.94,

     

       19
       19
       +
            regex-tdfa      >= 1.1    && < 1.3,

     

       20
       20
       +
            tagsoup         >= 0.13.1 && < 0.14,

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "haskell-generate";

     

       7
       7
       -
         version = "0.2.1";

     

       8
       8
       -
         sha256 = "1b7jy4a83lv9zwkzsgbipv7vlzcj27g1h3az7nxxc2gbmyrc15f4";

     

       7
       7
       +
         version = "0.2.2";

     

       8
       8
       +
         sha256 = "1wdfs28p195szg6jxq0qbyj4jdbqnsp9frgjnp25mzf14y9i1yid";

     

       9
       9
        
         buildDepends = [ haskellSrcExts transformers ];

     

       10
       10
        
         testDepends = [ doctest filepath ];

     

       11
       11
        
         meta = {

+2 -4

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

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "hcltest";

     

       10
       10
       -
         version = "0.3.4";

     

       11
       11
       -
         sha256 = "0p8skabp6z4i5xr22qxk1sij2ayla2iqylvlzxfxa8yw1fxs8wsq";

     

       10
       10
       +
         version = "0.3.6";

     

       11
       11
       +
         sha256 = "145l3kfxi1slngcmh4dnn09hhpr5v6s5nppk0i5a5jzxpp2yx6sd";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           dlist either filepath free lens mmorph monadControl mtl

     

       14
       14
        
           optparseApplicative randomShuffle split stm tagged tasty temporary

     
···

       20
       20
        
           description = "A testing library for command line applications";

     

       21
       21
        
           license = self.stdenv.lib.licenses.bsd3;

     

       22
       22
        
           platforms = self.ghc.meta.platforms;

     

       23
       23
       -
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       24
       24
       -
           broken = true;

     

       25
       23
        
         };

     

       26
       24
        
       })

+3 -3

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

···

       5
       5
        
       

     

       6
       6
        
       cabal.mkDerivation (self: {

     

       7
       7
        
         pname = "hindent";

     

       8
       8
       -
         version = "3.8";

     

       9
       9
       -
         sha256 = "015madajwljh2an3djla0qdds8bg7kgcdn3xb30cdf6gb77mf1xv";

     

       8
       8
       +
         version = "3.9";

     

       9
       9
       +
         sha256 = "0x8qm39rmaw1s0fbljr9zp6vnqxfcs1w6a3ylrknwqgwbzzr5hbn";

     

       10
       10
        
         isLibrary = true;

     

       11
       11
        
         isExecutable = true;

     

       12
       12
        
         buildDepends = [ dataDefault haskellSrcExts monadLoops mtl text ];

     

       13
       13
        
         testDepends = [

     

       14
       14
        
           dataDefault haskellSrcExts hspec monadLoops mtl text

     

       15
       15
        
         ];

     

       16
       16
       +
         doCheck = false;

     

       16
       17
        
         meta = {

     

       17
       18
        
           description = "Extensible Haskell pretty printer";

     

       18
       19
        
           license = self.stdenv.lib.licenses.bsd3;

     

       19
       20
        
           platforms = self.ghc.meta.platforms;

     

       20
       20
       -
           broken = true;

     

       21
       21
        
         };

     

       22
       22
        
       })

+30

pkgs/development/libraries/haskell/hoogle/4.2.34.nix

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, aeson, binary, blazeBuilder, Cabal, caseInsensitive

     

       4
       4
       +
       , cmdargs, conduit, deepseq, filepath, haskellSrcExts, httpTypes

     

       5
       5
       +
       , parsec, QuickCheck, random, resourcet, safe, shake, tagsoup, text

     

       6
       6
       +
       , time, transformers, uniplate, vector, vectorAlgorithms, wai, warp

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       cabal.mkDerivation (self: {

     

       10
       10
       +
         pname = "hoogle";

     

       11
       11
       +
         version = "4.2.34";

     

       12
       12
       +
         sha256 = "0vldc7s3nq70jxmnxdzlfrlwg0pxw0lq1lcd53klj2ksjkqhm5jg";

     

       13
       13
       +
         isLibrary = true;

     

       14
       14
       +
         isExecutable = true;

     

       15
       15
       +
         buildDepends = [

     

       16
       16
       +
           aeson binary blazeBuilder Cabal caseInsensitive cmdargs conduit

     

       17
       17
       +
           deepseq filepath haskellSrcExts httpTypes parsec QuickCheck random

     

       18
       18
       +
           resourcet safe shake tagsoup text time transformers uniplate vector

     

       19
       19
       +
           vectorAlgorithms wai warp

     

       20
       20
       +
         ];

     

       21
       21
       +
         testDepends = [ filepath ];

     

       22
       22
       +
         testTarget = "--test-option=--no-net";

     

       23
       23
       +
         meta = {

     

       24
       24
       +
           homepage = "http://www.haskell.org/hoogle/";

     

       25
       25
       +
           description = "Haskell API Search";

     

       26
       26
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       27
       27
       +
           platforms = self.ghc.meta.platforms;

     

       28
       28
       +
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       29
       29
       +
         };

     

       30
       30
       +
       })

pkgs/development/libraries/haskell/hoogle/default.nix pkgs/development/libraries/haskell/hoogle/4.2.36.nix

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "hourglass";

     

       7
       7
       -
         version = "0.2.5";

     

       8
       8
       -
         sha256 = "08nw9zqa0y09lw0c6qlh9pn8vr6h03mw1i7n7w0y3fv94az9vg9v";

     

       7
       7
       +
         version = "0.2.6";

     

       8
       8
       +
         sha256 = "029fmx5r6krj7y7mn4b4m2lpaa3iw6vhyznrib5lhf469i1jp9m3";

     

       9
       9
        
         buildDepends = [ deepseq ];

     

       10
       10
        
         testDepends = [

     

       11
       11
        
           deepseq mtl tasty tastyHunit tastyQuickcheck time

+16

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

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, checkers, hspec }:

     

       4
       4
       +
       

     

       5
       5
       +
       cabal.mkDerivation (self: {

     

       6
       6
       +
         pname = "hspec-checkers";

     

       7
       7
       +
         version = "0.1.0";

     

       8
       8
       +
         sha256 = "043qzgjp9ch9wqm269dd87jn8wk5c90q25098hnz8ilv5pnywk6d";

     

       9
       9
       +
         buildDepends = [ checkers hspec ];

     

       10
       10
       +
         testDepends = [ checkers hspec ];

     

       11
       11
       +
         meta = {

     

       12
       12
       +
           description = "Allows to use checkers properties from hspec";

     

       13
       13
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       14
       14
       +
           platforms = self.ghc.meta.platforms;

     

       15
       15
       +
         };

     

       16
       16
       +
       })

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "hspec-meta";

     

       10
       10
       -
         version = "1.11.4";

     

       11
       11
       -
         sha256 = "047vp6wibkwgs9rryjpys2qqn4s5p91mh36w0gnxwhggp8nhfqg3";

     

       10
       10
       +
         version = "1.12.1";

     

       11
       11
       +
         sha256 = "1920gpcam7y3slg1an8ywhw6lxammgy21nmxbxlh77iz65rldzls";

     

       12
       12
        
         isLibrary = true;

     

       13
       13
        
         isExecutable = true;

     

       14
       14
        
         buildDepends = [

+5 -4

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

···

       2
       2
        
       

     

       3
       3
        
       { cabal, ansiTerminal, async, deepseq, filepath, ghcPaths

     

       4
       4
        
       , hspecExpectations, hspecMeta, HUnit, QuickCheck, quickcheckIo

     

       5
       5
       -
       , random, setenv, silently, tfRandom, time, transformers

     

       5
       5
       +
       , random, setenv, silently, stringbuilder, tfRandom, time

     

       6
       6
       +
       , transformers

     

       6
       7
        
       }:

     

       7
       8
        
       

     

       8
       9
        
       cabal.mkDerivation (self: {

     

       9
       10
        
         pname = "hspec";

     

       10
       10
       -
         version = "1.11.4";

     

       11
       11
       -
         sha256 = "044vr6xyk0ih20faa4gbl4y4v6vkss0x2gmxgkk96ha6chws2svn";

     

       11
       11
       +
         version = "1.12.1";

     

       12
       12
       +
         sha256 = "0w42lsl5qs452f04qpbr6nvs4qgp7cwd9262f34vzjq8m83nhjwk";

     

       12
       13
        
         isLibrary = true;

     

       13
       14
        
         isExecutable = true;

     

       14
       15
        
         buildDepends = [

     
···

       18
       19
        
         testDepends = [

     

       19
       20
        
           ansiTerminal async deepseq filepath ghcPaths hspecExpectations

     

       20
       21
        
           hspecMeta HUnit QuickCheck quickcheckIo random setenv silently

     

       21
       21
       -
           tfRandom time transformers

     

       22
       22
       +
           stringbuilder tfRandom time transformers

     

       22
       23
        
         ];

     

       23
       24
        
         doCheck = false;

     

       24
       25
        
         meta = {

+5 -4

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

···

       2
       2
        
       

     

       3
       3
        
       { cabal, ansiTerminal, async, deepseq, filepath, ghcPaths

     

       4
       4
        
       , hspecExpectations, hspecMeta, HUnit, QuickCheck, quickcheckIo

     

       5
       5
       -
       , random, setenv, silently, tfRandom, time, transformers

     

       5
       5
       +
       , random, setenv, silently, stringbuilder, tfRandom, time

     

       6
       6
       +
       , transformers

     

       6
       7
        
       }:

     

       7
       8
        
       

     

       8
       9
        
       cabal.mkDerivation (self: {

     

       9
       10
        
         pname = "hspec2";

     

       10
       10
       -
         version = "0.4.2";

     

       11
       11
       -
         sha256 = "1wk1lvy3lngfa60n0dyllfqbj4gd4v0qxjw7gpvzknfk2y10536x";

     

       11
       11
       +
         version = "0.5.1";

     

       12
       12
       +
         sha256 = "1ax507vb0zm5jalp6pvlk1fjfil766pf7w61d1igpxr0s00lnvlq";

     

       12
       13
        
         isLibrary = true;

     

       13
       14
        
         isExecutable = true;

     

       14
       15
        
         buildDepends = [

     
···

       18
       19
        
         testDepends = [

     

       19
       20
        
           ansiTerminal async deepseq filepath ghcPaths hspecExpectations

     

       20
       21
        
           hspecMeta HUnit QuickCheck quickcheckIo random setenv silently

     

       21
       21
       -
           tfRandom time transformers

     

       22
       22
       +
           stringbuilder tfRandom time transformers

     

       22
       23
        
         ];

     

       23
       24
        
         meta = {

     

       24
       25
        
           homepage = "http://hspec.github.io/";

+5 -4

pkgs/development/libraries/haskell/hxt-regex-xmlschema/default.nix

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, hxtCharproperties, parsec }:

     

       3
       3
       +
       { cabal, HUnit, hxtCharproperties, parsec, text }:

     

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "hxt-regex-xmlschema";

     

       7
       7
       -
         version = "9.1.0";

     

       8
       8
       -
         sha256 = "0l97rkrvl6pmxdgiwbwh2s3l00lyaihrhsffhh69639bgs67zgwr";

     

       9
       9
       -
         buildDepends = [ hxtCharproperties parsec ];

     

       7
       7
       +
         version = "9.2.0";

     

       8
       8
       +
         sha256 = "0pcbyvc71173ad0zkgpdpyyljngrk4p1jjjaw5wbwcvm4ijh44g3";

     

       9
       9
       +
         buildDepends = [ hxtCharproperties parsec text ];

     

       10
       10
       +
         testDepends = [ HUnit parsec text ];

     

       10
       11
        
         meta = {

     

       11
       12
        
           homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema";

     

       12
       13
        
           description = "A regular expression library for W3C XML Schema regular expressions";

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       cabal.mkDerivation (self: {

     

       10
       10
        
         pname = "io-streams";

     

       11
       11
       -
         version = "1.2.0.0";

     

       12
       12
       -
         sha256 = "1lisvwy4pj0ywm1i61qan3vxisl4xazz7z8i8iybww1dv3j6mrn2";

     

       11
       11
       +
         version = "1.2.0.1";

     

       12
       12
       +
         sha256 = "12r7j8dzj80f4s9942a6pi60pd9jh44sqyl6hcn0npzmdyl7hg1k";

     

       13
       13
        
         buildDepends = [

     

       14
       14
        
           attoparsec blazeBuilder network primitive text time transformers

     

       15
       15
        
           vector zlibBindings

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "ixset";

     

       7
       7
       -
         version = "1.0.5";

     

       8
       8
       -
         sha256 = "1hznn7f8f13x5125n76dchayi16z72050qbwifnkrca54nf9q2ns";

     

       7
       7
       +
         version = "1.0.6";

     

       8
       8
       +
         sha256 = "097f9fkm9a2n67bzagr9h2v7acdn8h1ayv9c83n7nv1dh157bpyv";

     

       9
       9
        
         buildDepends = [ safecopy syb sybWithClass ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "http://happstack.com";

+2 -2

pkgs/development/libraries/haskell/json-rpc/default.nix

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "json-rpc";

     

       10
       10
       -
         version = "0.2.0.2";

     

       11
       11
       -
         sha256 = "00ha6hjg9ccwa48ab5ibnkiiri7ki3rv7ms2h9qbwr30lxyb0r88";

     

       10
       10
       +
         version = "0.2.1.1";

     

       11
       11
       +
         sha256 = "0h6dkb1rgd6qxzcxvqvgwilmibkdbqpjvflijwf54fx2z687fjld";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           aeson async conduit conduitExtra deepseq hashable mtl stm

     

       14
       14
        
           stmConduit text unorderedContainers

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

···

       16
       16
        
         sha256 = "19pkm4m2xk9ziai3ka4scxjavi0as8dmivz9q6vg3npmv0kyhkhb";

     

       17
       17
        
         isLibrary = true;

     

       18
       18
        
         isExecutable = true;

     

       19
       19
       +
         patches = [ ./deps.patch ];

     

       19
       20
        
         buildDepends = [

     

       20
       21
        
           arrows binary brainfuck dataMemocombinators dependentMap

     

       21
       22
        
           dependentSum dependentSumTemplate dice editDistance filepath

+21

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

···

       1
       1
       +
       --- a/lambdabot.cabal.orig	2014-10-16 17:39:16.000000000 -0500

     

       2
       2
       +
       +++ b/lambdabot.cabal	2014-10-16 18:26:58.000000000 -0500

     

       3
       3
       +
       @@ -166,7 +166,7 @@

     

       4
       4
       +
                                edit-distance           >= 0.2,

     

       5
       5
       +
                                filepath                >= 1.3,

     

       6
       6
       +
                                haskeline               >= 0.7,

     

       7
       7
       +
       -                        haskell-src-exts        >= 1.14.0,

     

       8
       8
       +
       +                        haskell-src-exts        >= 1.14.0 && < 1.16,

     

       9
       9
       +
                                hstatsd                 >= 0.1,

     

       10
       10
       +
                                hslogger                >= 1.2.1,

     

       11
       11
       +
                                HTTP                    >= 4000,

     

       12
       12
       +
       @@ -174,7 +174,8 @@

     

       13
       13
       +
                                misfortune              >= 0.1,

     

       14
       14
       +
                                monad-control           >= 0.3,

     

       15
       15
       +
                                mtl                     >= 2,

     

       16
       16
       +
       -                        network                 >= 2.3.0.13,

     

       17
       17
       +
       +                        network                 >= 2.6,

     

       18
       18
       +
       +                        network-uri             >= 2.6,

     

       19
       19
       +
                                oeis                    >= 0.3.1,

     

       20
       20
       +
                                time                    >= 1.4,

     

       21
       21
       +
                                parsec                  >= 3,

+3 -4

pkgs/development/libraries/haskell/monadloc-pp/default.nix

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "monadloc-pp";

     

       7
       7
       -
         version = "0.3";

     

       8
       8
       -
         sha256 = "0jr9ngcj3l6kd5cscll5kr3a4bp52sdjgrdxd1j5a21jyc3gdyvn";

     

       7
       7
       +
         version = "0.3.1";

     

       8
       8
       +
         sha256 = "0ch25kcz63xhinwd6mjqbhm282hfh280s3z910wnvdp3krgx0mpc";

     

       9
       9
        
         isLibrary = false;

     

       10
       10
        
         isExecutable = true;

     

       11
       11
        
         buildDepends = [ filepath haskellSrcExts monadloc syb ];

     

       12
       12
        
         jailbreak = true;

     

       13
       13
        
         meta = {

     

       14
       14
       -
           homepage = "http://github.com/pepeiborra/monadloc";

     

       14
       14
       +
           homepage = "http://github.com/pepeiborra/monadloc-pp";

     

       15
       15
        
           description = "A preprocessor for generating monadic call traces";

     

       16
       16
        
           license = self.stdenv.lib.licenses.publicDomain;

     

       17
       17
        
           platforms = self.ghc.meta.platforms;

     

       18
       18
        
           maintainers = with self.stdenv.lib.maintainers; [ tomberek ];

     

       19
       19
       -
           broken = true;

     

       20
       19
        
         };

     

       21
       20
        
       })

+17

pkgs/development/libraries/haskell/mtl/2.1.3.1.nix

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, transformers }:

     

       4
       4
       +
       

     

       5
       5
       +
       cabal.mkDerivation (self: {

     

       6
       6
       +
         pname = "mtl";

     

       7
       7
       +
         version = "2.1.3.1";

     

       8
       8
       +
         sha256 = "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp";

     

       9
       9
       +
         buildDepends = [ transformers ];

     

       10
       10
       +
         meta = {

     

       11
       11
       +
           homepage = "http://github.com/ekmett/mtl";

     

       12
       12
       +
           description = "Monad classes, using functional dependencies";

     

       13
       13
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       14
       14
       +
           platforms = self.ghc.meta.platforms;

     

       15
       15
       +
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       16
       16
       +
         };

     

       17
       17
       +
       })

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "mysql";

     

       7
       7
       -
         version = "0.1.1.6";

     

       8
       8
       -
         sha256 = "1sxzx5f4ysxhq1nimkj4xwf87i7prwp5wg0kjbhv9pbn65zc9mmj";

     

       7
       7
       +
         version = "0.1.1.7";

     

       8
       8
       +
         sha256 = "0hl8z8ynadvvhn4garjrax2b59iqddj884mv3s6804lcjjyc49d0";

     

       9
       9
        
         buildTools = [ mysqlConfig ];

     

       10
       10
        
         extraLibraries = [ zlib ];

     

       11
       11
        
         meta = {

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "network-simple";

     

       7
       7
       -
         version = "0.4.0.1";

     

       8
       8
       -
         sha256 = "113vaxgsfny9iv6hnbywk97qr1y6qkap49p803anakamss4bdmyj";

     

       7
       7
       +
         version = "0.4.0.2";

     

       8
       8
       +
         sha256 = "0k155m1s7k157rpsz8ww9cs7jyw3faybwfmw97agvskhb4axw6hf";

     

       9
       9
        
         buildDepends = [ exceptions network transformers ];

     

       10
       10
        
         jailbreak = true;

     

       11
       11
        
         meta = {

+29

pkgs/development/libraries/haskell/pandoc-citeproc/0.4.nix

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, aeson, aesonPretty, attoparsec, filepath, hexpat

     

       4
       4
       +
       , hsBibutils, mtl, pandoc, pandocTypes, parsec, rfc5051, split, syb

     

       5
       5
       +
       , tagsoup, temporary, text, time, vector, yaml

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       cabal.mkDerivation (self: {

     

       9
       9
       +
         pname = "pandoc-citeproc";

     

       10
       10
       +
         version = "0.4.0.1";

     

       11
       11
       +
         sha256 = "1z21mdxa2hrwqdclriyn3s1qqij3ccbkg7hb0acxrk3pzgidcinx";

     

       12
       12
       +
         isLibrary = true;

     

       13
       13
       +
         isExecutable = true;

     

       14
       14
       +
         buildDepends = [

     

       15
       15
       +
           aeson aesonPretty attoparsec filepath hexpat hsBibutils mtl pandoc

     

       16
       16
       +
           pandocTypes parsec rfc5051 split syb tagsoup temporary text time

     

       17
       17
       +
           vector yaml

     

       18
       18
       +
         ];

     

       19
       19
       +
         testDepends = [

     

       20
       20
       +
           aeson filepath pandoc pandocTypes temporary text yaml

     

       21
       21
       +
         ];

     

       22
       22
       +
         doCheck = false;

     

       23
       23
       +
         meta = {

     

       24
       24
       +
           description = "Supports using pandoc with citeproc";

     

       25
       25
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       26
       26
       +
           platforms = self.ghc.meta.platforms;

     

       27
       27
       +
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       28
       28
       +
         };

     

       29
       29
       +
       })

+29

pkgs/development/libraries/haskell/pandoc-citeproc/0.5.nix

···

       1
       1
       +
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       +
       

     

       3
       3
       +
       { cabal, aeson, aesonPretty, attoparsec, filepath, hexpat

     

       4
       4
       +
       , hsBibutils, mtl, pandoc, pandocTypes, parsec, rfc5051, split, syb

     

       5
       5
       +
       , tagsoup, temporary, text, time, vector, yaml

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       cabal.mkDerivation (self: {

     

       9
       9
       +
         pname = "pandoc-citeproc";

     

       10
       10
       +
         version = "0.5";

     

       11
       11
       +
         sha256 = "00azhpll0xnb9nnkh7c3hbfk0fzmvh5cgdxlgx7jvaglrmsnvzw3";

     

       12
       12
       +
         isLibrary = true;

     

       13
       13
       +
         isExecutable = true;

     

       14
       14
       +
         buildDepends = [

     

       15
       15
       +
           aeson aesonPretty attoparsec filepath hexpat hsBibutils mtl pandoc

     

       16
       16
       +
           pandocTypes parsec rfc5051 split syb tagsoup temporary text time

     

       17
       17
       +
           vector yaml

     

       18
       18
       +
         ];

     

       19
       19
       +
         testDepends = [

     

       20
       20
       +
           aeson filepath pandoc pandocTypes temporary text yaml

     

       21
       21
       +
         ];

     

       22
       22
       +
         doCheck = false;

     

       23
       23
       +
         meta = {

     

       24
       24
       +
           description = "Supports using pandoc with citeproc";

     

       25
       25
       +
           license = self.stdenv.lib.licenses.bsd3;

     

       26
       26
       +
           platforms = self.ghc.meta.platforms;

     

       27
       27
       +
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       28
       28
       +
         };

     

       29
       29
       +
       })

pkgs/development/libraries/haskell/pandoc-citeproc/default.nix pkgs/development/libraries/haskell/pandoc-citeproc/0.6.nix

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "pango";

     

       9
       9
       -
         version = "0.13.0.2";

     

       10
       10
       -
         sha256 = "1f546k53j5ymb1321n31na0fpm69idx5l0nh9s75yallbij3gyfg";

     

       9
       9
       +
         version = "0.13.0.3";

     

       10
       10
       +
         sha256 = "0xvmv1r7lh727w1pag8myp069s4wnvgsqlr3c3ir1gyzxy5jq69f";

     

       11
       11
        
         buildDepends = [ cairo glib mtl text ];

     

       12
       12
        
         buildTools = [ gtk2hsBuildtools ];

     

       13
       13
        
         extraLibraries = [ libc pkgconfig ];

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "persistent-postgresql";

     

       10
       10
       -
         version = "2.1";

     

       11
       11
       -
         sha256 = "0458z9n61wn8g55cp8a9061qgc99i5yp3wmwmf3x4p4vfkl5kw9c";

     

       10
       10
       +
         version = "2.1.0.1";

     

       11
       11
       +
         sha256 = "0ndy8vbzxqcdx9hqmpmp9f7b8cd6lpgzzc8m7jlwzjz4agc51767";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           aeson blazeBuilder conduit monadControl monadLogger persistent

     

       14
       14
        
           postgresqlLibpq postgresqlSimple resourcet text time transformers

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       cabal.mkDerivation (self: {

     

       11
       11
        
         pname = "persistent";

     

       12
       12
       -
         version = "2.1";

     

       13
       13
       -
         sha256 = "0ybjjya8q4kwnq6lksahpm0g8wzxwzfqxqmkrw18vw4fb7kry58k";

     

       12
       12
       +
         version = "2.1.0.1";

     

       13
       13
       +
         sha256 = "0506w53shy0ck7vyncrhh5prp9jri8bbp2awzbkavfxiwzra1l83";

     

       14
       14
        
         buildDepends = [

     

       15
       15
        
           aeson attoparsec base64Bytestring blazeHtml blazeMarkup conduit

     

       16
       16
        
           exceptions fastLogger liftedBase monadControl monadLogger mtl

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "pipes-attoparsec";

     

       9
       9
       -
         version = "0.5.1";

     

       10
       10
       -
         sha256 = "0qvsvbcn211xp4c669cpljmnsqn9zk1rn94ya1dbq77l970s8xah";

     

       9
       9
       +
         version = "0.5.1.1";

     

       10
       10
       +
         sha256 = "1ns8s3p6jh4iya71z3j81cqnrfnr4n92kblwgkjlapb23dykl2qz";

     

       11
       11
        
         buildDepends = [ attoparsec pipes pipesParse text transformers ];

     

       12
       12
        
         testDepends = [

     

       13
       13
        
           attoparsec HUnit mmorph pipes pipesParse tasty tastyHunit text

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       cabal.mkDerivation (self: {

     

       11
       11
        
         pname = "rest-gen";

     

       12
       12
       -
         version = "0.16.0.2";

     

       13
       13
       -
         sha256 = "0sh3sgv02x49pr02yb9jsd694g27xifnclrcc6npkkbkcvy9m7y7";

     

       12
       12
       +
         version = "0.16.0.3";

     

       13
       13
       +
         sha256 = "1gl0dhl2dajlgms8f297x1763dqbrp9cszfq2qggzcdn896zxxgn";

     

       14
       14
        
         buildDepends = [

     

       15
       15
        
           aeson blazeHtml Cabal codeBuilder fclabels filepath hashable

     

       16
       16
        
           haskellSrcExts hslogger HStringTemplate hxt jsonSchema restCore

+5 -4

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

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "rethinkdb";

     

       10
       10
       -
         version = "1.15.0.0";

     

       11
       11
       -
         sha256 = "0zswbz73c8h7h31ppw5251l6spn6y5ha3hm9hb90j04hjg8g235i";

     

       10
       10
       +
         version = "1.15.1.0";

     

       11
       11
       +
         sha256 = "139a5xii9fkywr1fq7z37wvs732w6j06005z6r7ycr99swrzpgvq";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           aeson base64Bytestring binary dataDefault mtl network scientific

     

       14
       14
        
           text time unorderedContainers utf8String vector

     

       15
       15
        
         ];

     

       16
       16
        
         testDepends = [ doctest ];

     

       17
       17
       +
         jailbreak = true;

     

       18
       18
       +
         doCheck = false;

     

       17
       19
        
         meta = {

     

       18
       20
        
           homepage = "http://github.com/atnnn/haskell-rethinkdb";

     

       19
       19
       -
           description = "A driver for the RethinkDB database server";

     

       21
       21
       +
           description = "A driver for RethinkDB 1.15";

     

       20
       22
        
           license = self.stdenv.lib.licenses.asl20;

     

       21
       23
        
           platforms = self.ghc.meta.platforms;

     

       22
       22
       -
           broken = true;

     

       23
       24
        
         };

     

       24
       25
        
       })

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "sdl2";

     

       7
       7
       -
         version = "1.1.2";

     

       8
       8
       -
         sha256 = "1viy6f8iqbw264hmsvfqjf8b27h8klyybywd5976yin6ianbqm2a";

     

       7
       7
       +
         version = "1.1.3";

     

       8
       8
       +
         sha256 = "111kbairf50j8kkndcc54i0gsfaffnyla7zw49gbqlqs4kgxj6b5";

     

       9
       9
        
         extraLibraries = [ SDL2 ];

     

       10
       10
        
         pkgconfigDepends = [ SDL2 ];

     

       11
       11
        
         meta = {

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "shell-conduit";

     

       10
       10
       -
         version = "4.2";

     

       11
       11
       -
         sha256 = "1ac1imsz1ffm0ldi29ylprgs4zh0qhn52ka17zn8f9301hfx9vhc";

     

       10
       10
       +
         version = "4.3";

     

       11
       11
       +
         sha256 = "1f82ncdsi4w63r48aj7679hii0hkd46drdz3bdgwxqx2yynjmlj8";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           async conduit conduitExtra controlMonadLoop filepath monadControl

     

       14
       14
        
           monadsTf resourcet semigroups split text these transformers

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

···

       17
       17
        
           license = self.stdenv.lib.licenses.bsd3;

     

       18
       18
        
           platforms = self.ghc.meta.platforms;

     

       19
       19
        
           maintainers = with self.stdenv.lib.maintainers; [ ocharles ];

     

       20
       20
       +
           broken = true;

     

       20
       21
        
         };

     

       21
       22
        
       })

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "tasty-th";

     

       7
       7
       -
         version = "0.1.2";

     

       8
       8
       -
         sha256 = "1x3kixv0hnb7icigz2kfq959pivdc4jaaalvdgn8dlyqzkvfjzx4";

     

       7
       7
       +
         version = "0.1.3";

     

       8
       8
       +
         sha256 = "1fl5pagm9bdqvp7v54ilkr91m667rxw1jifwfdhrikr938aqrzx3";

     

       9
       9
        
         buildDepends = [ languageHaskellExtract tasty ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "http://github.com/bennofs/tasty-th";

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "template";

     

       7
       7
       -
         version = "0.2.0.9";

     

       8
       8
       -
         sha256 = "0i1xq6nj240gddbd8d5m42gzix16k81wqmirpy5a4fssnkpwjqnb";

     

       7
       7
       +
         version = "0.2.0.10";

     

       8
       8
       +
         sha256 = "10mcnhi2rdflmv79z0359nn5sylifvk9ih38xnjqqby6n4hs7mcg";

     

       9
       9
        
         buildDepends = [ mtl text ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           description = "Simple string substitution";

+2 -2

pkgs/development/libraries/haskell/th-lift-instances/default.nix

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "th-lift-instances";

     

       7
       7
       -
         version = "0.1.3";

     

       8
       8
       -
         sha256 = "0snqgcdkskwvrsw239j3xq84mwnf5x79kfsn495kprdc6yh3qdkx";

     

       7
       7
       +
         version = "0.1.4";

     

       8
       8
       +
         sha256 = "02sf7qn1rs33cdf1dl7vpwkhqzhmj8h3naw0ngh2kz05ymk2qng4";

     

       9
       9
        
         buildDepends = [ text thLift vector ];

     

       10
       10
        
         testDepends = [ doctest filepath QuickCheck text vector ];

     

       11
       11
        
         meta = {

+13 -13

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, asn1Encoding, asn1Types, byteable, cereal, cipherAes

     

       4
       4
       -
       , cipherDes, cipherRc4, cprngAes, cryptoCipherTypes, cryptohash

     

       5
       5
       -
       , cryptoNumbers, cryptoPubkey, cryptoPubkeyTypes, cryptoRandom

     

       6
       6
       -
       , dataDefaultClass, mtl, network, QuickCheck, testFramework

     

       7
       7
       -
       , testFrameworkQuickcheck2, time, x509, x509Store, x509Validation

     

       3
       3
       +
       { cabal, asn1Encoding, asn1Types, async, byteable, cereal

     

       4
       4
       +
       , cipherAes, cipherDes, cipherRc4, cprngAes, cryptoCipherTypes

     

       5
       5
       +
       , cryptohash, cryptoNumbers, cryptoPubkey, cryptoPubkeyTypes

     

       6
       6
       +
       , cryptoRandom, dataDefaultClass, hourglass, mtl, network

     

       7
       7
       +
       , QuickCheck, tasty, tastyQuickcheck, transformers, x509, x509Store

     

       8
       8
       +
       , x509Validation

     

       8
       9
        
       }:

     

       9
       10
        
       

     

       10
       11
        
       cabal.mkDerivation (self: {

     

       11
       12
        
         pname = "tls";

     

       12
       12
       -
         version = "1.2.9";

     

       13
       13
       -
         sha256 = "1cwhwxpsxx9x5hv2c66d3yvbs84lrgaxmaz18skidmhqhs4i0sjy";

     

       13
       13
       +
         version = "1.2.13";

     

       14
       14
       +
         sha256 = "1djjscmyn3wcnlzz1r0clz2nxa2y23rlyjk30xjsdp0m1sq0vdc3";

     

       14
       15
        
         buildDepends = [

     

       15
       15
       -
           asn1Encoding asn1Types byteable cereal cipherAes cipherDes

     

       16
       16
       +
           asn1Encoding asn1Types async byteable cereal cipherAes cipherDes

     

       16
       17
        
           cipherRc4 cryptoCipherTypes cryptohash cryptoNumbers cryptoPubkey

     

       17
       17
       -
           cryptoPubkeyTypes cryptoRandom dataDefaultClass mtl network x509

     

       18
       18
       -
           x509Store x509Validation

     

       18
       18
       +
           cryptoPubkeyTypes cryptoRandom dataDefaultClass mtl network

     

       19
       19
       +
           transformers x509 x509Store x509Validation

     

       19
       20
        
         ];

     

       20
       21
        
         testDepends = [

     

       21
       21
       -
           cereal cprngAes cryptoPubkey cryptoRandom dataDefaultClass mtl

     

       22
       22
       -
           QuickCheck testFramework testFrameworkQuickcheck2 time x509

     

       23
       23
       -
           x509Validation

     

       22
       22
       +
           cereal cprngAes cryptoPubkey cryptoRandom dataDefaultClass

     

       23
       23
       +
           hourglass mtl QuickCheck tasty tastyQuickcheck x509 x509Validation

     

       24
       24
        
         ];

     

       25
       25
        
         doCheck = false;

     

       26
       26
        
         meta = {

pkgs/development/libraries/haskell/vty-ui/default.nix

···

       19
       19
        
           description = "An interactive terminal user interface library for Vty";

     

       20
       20
        
           license = self.stdenv.lib.licenses.bsd3;

     

       21
       21
        
           platforms = self.ghc.meta.platforms;

     

       22
       22
       +
           broken = true;

     

       22
       23
        
         };

     

       23
       24
        
       })

-29

pkgs/development/libraries/haskell/vty/4.7.5.nix

···

       1
       1
       -
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
       -
       

     

       3
       3
       -
       { cabal, Cabal, deepseq, mtl, parallel, parsec, QuickCheck, random

     

       4
       4
       -
       , stringQq, terminfo, utf8String, vector

     

       5
       5
       -
       }:

     

       6
       6
       -
       

     

       7
       7
       -
       cabal.mkDerivation (self: {

     

       8
       8
       -
         pname = "vty";

     

       9
       9
       -
         version = "4.7.5";

     

       10
       10
       -
         sha256 = "0ahd5qjszfw1xbl5jxhzfw31mny8hp8clw9qciv15xn442prvvpr";

     

       11
       11
       -
         isLibrary = true;

     

       12
       12
       -
         isExecutable = true;

     

       13
       13
       -
         buildDepends = [

     

       14
       14
       -
           deepseq mtl parallel parsec stringQq terminfo utf8String vector

     

       15
       15
       -
         ];

     

       16
       16
       -
         testDepends = [

     

       17
       17
       -
           Cabal deepseq mtl parallel parsec QuickCheck random terminfo

     

       18
       18
       -
           utf8String vector

     

       19
       19
       -
         ];

     

       20
       20
       -
         jailbreak = true;

     

       21
       21
       -
         doCheck = false;

     

       22
       22
       -
         meta = {

     

       23
       23
       -
           homepage = "https://github.com/coreyoconnor/vty";

     

       24
       24
       -
           description = "A simple terminal UI library";

     

       25
       25
       -
           license = self.stdenv.lib.licenses.bsd3;

     

       26
       26
       -
           platforms = self.ghc.meta.platforms;

     

       27
       27
       -
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       28
       28
       -
         };

     

       29
       29
       -
       })

+2 -2

pkgs/development/libraries/haskell/vty/5.2.3.nix pkgs/development/libraries/haskell/vty/default.nix

···

       9
       9
        
       

     

       10
       10
        
       cabal.mkDerivation (self: {

     

       11
       11
        
         pname = "vty";

     

       12
       12
       -
         version = "5.2.3";

     

       13
       13
       -
         sha256 = "0afgysliv7bi3x46cj8bcmahfc1lz2niyfmvnzrf9brhxf7l9y76";

     

       12
       12
       +
         version = "5.2.4";

     

       13
       13
       +
         sha256 = "0dqp54sf6pl7magjhd91k87z50zi83x6w27kmyzp55112aiy7bf6";

     

       14
       14
        
         isLibrary = true;

     

       15
       15
        
         isExecutable = true;

     

       16
       16
        
         buildDepends = [

+2 -2

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

···

       10
       10
        
       

     

       11
       11
        
       cabal.mkDerivation (self: {

     

       12
       12
        
         pname = "wai-app-static";

     

       13
       13
       -
         version = "3.0.0.1";

     

       14
       14
       -
         sha256 = "1xqw7xvbq38m19337vpalnz5c5mvc57mfp53vqbah3lalxy9mqby";

     

       13
       13
       +
         version = "3.0.0.2";

     

       14
       14
       +
         sha256 = "1y8x8gb60330mxzp649xp8dhancimmraf2h7py76wjmjp5vc5cx4";

     

       15
       15
        
         isLibrary = true;

     

       16
       16
        
         isExecutable = true;

     

       17
       17
        
         buildDepends = [

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "webkit";

     

       9
       9
       -
         version = "0.13.0.2";

     

       10
       10
       -
         sha256 = "1dagfc5v5ihg7hm8vkymg1jyhxqhlxb8f4bnbmjcv4sffbm9q14f";

     

       9
       9
       +
         version = "0.13.0.3";

     

       10
       10
       +
         sha256 = "0l05cg6krafpcfszcka03x7gay8wg1fhd0gpbn2cchfshfkicgxc";

     

       11
       11
        
         buildDepends = [ cairo glib gtk mtl pango text ];

     

       12
       12
        
         buildTools = [ gtk2hsBuildtools ];

     

       13
       13
        
         pkgconfigDepends = [ webkit ];

+4 -4

pkgs/development/libraries/haskell/x509-store/default.nix

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
        
       { cabal, asn1Encoding, asn1Types, cryptoPubkeyTypes, filepath, mtl

     

       4
       4
       -
       , pem, time, x509

     

       4
       4
       +
       , pem, x509

     

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "x509-store";

     

       9
       9
       -
         version = "1.4.4";

     

       10
       10
       -
         sha256 = "0i3hfrddr0wpfl75a76a1j24az08z4x7ya8l5qcdk7c1lr2c2bw8";

     

       9
       9
       +
         version = "1.5.0";

     

       10
       10
       +
         sha256 = "1w9sqb007s4avjzvrdwq13a4c528h7h2lg3m8cl31syrgznc9ny5";

     

       11
       11
        
         buildDepends = [

     

       12
       12
       -
           asn1Encoding asn1Types cryptoPubkeyTypes filepath mtl pem time x509

     

       12
       12
       +
           asn1Encoding asn1Types cryptoPubkeyTypes filepath mtl pem x509

     

       13
       13
        
         ];

     

       14
       14
        
         meta = {

     

       15
       15
        
           homepage = "http://github.com/vincenthz/hs-certificate";

+4 -4

pkgs/development/libraries/haskell/x509-system/default.nix

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, filepath, mtl, pem, time, x509, x509Store }:

     

       3
       3
       +
       { cabal, filepath, mtl, pem, x509, x509Store }:

     

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "x509-system";

     

       7
       7
       -
         version = "1.4.6";

     

       8
       8
       -
         sha256 = "0h462dgc0jf88yfd4nx9xpqx5kfzc3z6ps8akw13pfy92xdxj28c";

     

       9
       9
       -
         buildDepends = [ filepath mtl pem time x509 x509Store ];

     

       7
       7
       +
         version = "1.5.0";

     

       8
       8
       +
         sha256 = "159zwg35nq42j1rl0p4x00hdf3iy48hd7kavz0rnpwd2p7ljamr3";

     

       9
       9
       +
         buildDepends = [ filepath mtl pem x509 x509Store ];

     

       10
       10
        
         meta = {

     

       11
       11
        
           homepage = "http://github.com/vincenthz/hs-certificate";

     

       12
       12
        
           description = "Handle per-operating-system X.509 accessors and storage";

+6 -6

pkgs/development/libraries/haskell/x509-validation/default.nix

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
        
       { cabal, asn1Encoding, asn1Types, byteable, cryptohash

     

       4
       4
       -
       , cryptoPubkey, cryptoPubkeyTypes, dataDefaultClass, filepath, mtl

     

       5
       5
       -
       , network, pem, time, x509, x509Store

     

       4
       4
       +
       , cryptoPubkey, cryptoPubkeyTypes, dataDefaultClass, filepath

     

       5
       5
       +
       , hourglass, mtl, network, pem, x509, x509Store

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "x509-validation";

     

       10
       10
       -
         version = "1.5.0";

     

       11
       11
       -
         sha256 = "1xarn00ipi77whly5yjlpqa0xd25lj0jf4xk8ylp4ba58hvcxqrn";

     

       10
       10
       +
         version = "1.5.1";

     

       11
       11
       +
         sha256 = "19cp187id9hdlzkr7sbv2sdxqxnpjv0db09hwf3zdqqqxr30mn6x";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           asn1Encoding asn1Types byteable cryptohash cryptoPubkey

     

       14
       14
       -
           cryptoPubkeyTypes dataDefaultClass filepath mtl network pem time

     

       15
       15
       -
           x509 x509Store

     

       14
       14
       +
           cryptoPubkeyTypes dataDefaultClass filepath hourglass mtl network

     

       15
       15
       +
           pem x509 x509Store

     

       16
       16
        
         ];

     

       17
       17
        
         meta = {

     

       18
       18
        
           homepage = "http://github.com/vincenthz/hs-certificate";

+6 -7

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
        
       { cabal, asn1Encoding, asn1Parse, asn1Types, cryptohash

     

       4
       4
       -
       , cryptoPubkeyTypes, filepath, HUnit, mtl, pem, QuickCheck

     

       5
       5
       -
       , testFramework, testFrameworkHunit, testFrameworkQuickcheck2, time

     

       4
       4
       +
       , cryptoPubkeyTypes, filepath, hourglass, mtl, pem, tasty

     

       5
       5
       +
       , tastyQuickcheck

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
        
       cabal.mkDerivation (self: {

     

       9
       9
        
         pname = "x509";

     

       10
       10
       -
         version = "1.4.13";

     

       11
       11
       -
         sha256 = "1cl2ygk38jh803aplsg68q6njzb0wcd1syb182amxqn8jlwh8a7c";

     

       10
       10
       +
         version = "1.5.0.1";

     

       11
       11
       +
         sha256 = "03gj4190f0ql1ghn2mri8901xdydhhnwijyfn8lmpjyn7pgpl3ba";

     

       12
       12
        
         buildDepends = [

     

       13
       13
        
           asn1Encoding asn1Parse asn1Types cryptohash cryptoPubkeyTypes

     

       14
       14
       -
           filepath mtl pem time

     

       14
       14
       +
           filepath hourglass mtl pem

     

       15
       15
        
         ];

     

       16
       16
        
         testDepends = [

     

       17
       17
       -
           asn1Types cryptoPubkeyTypes HUnit mtl QuickCheck testFramework

     

       18
       18
       -
           testFrameworkHunit testFrameworkQuickcheck2 time

     

       17
       17
       +
           asn1Types cryptoPubkeyTypes hourglass mtl tasty tastyQuickcheck

     

       19
       18
        
         ];

     

       20
       19
        
         meta = {

     

       21
       20
        
           homepage = "http://github.com/vincenthz/hs-certificate";

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "xdot";

     

       7
       7
       -
         version = "0.2.4.4";

     

       8
       8
       -
         sha256 = "1bv2n1pzn58kqf9k5qbyzlkddhx2v2c9gc50c7q7yd7wxxpml7gi";

     

       7
       7
       +
         version = "0.2.4.5";

     

       8
       8
       +
         sha256 = "0dv9y5i3707pnx4c0gf9y3zv6p02az4rvspd84hprfvnhd8qfdcp";

     

       9
       9
        
         isLibrary = true;

     

       10
       10
        
         isExecutable = true;

     

       11
       11
        
         buildDepends = [ cairo graphviz gtk mtl polyparse text ];

+6 -5

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

···

       1
       1
        
       # This file was auto-generated by cabal2nix. Please do NOT edit manually!

     

       2
       2
        
       

     

       3
       3
       -
       { cabal, cryptohash, persistent, pwstoreFast, text, yesodAuth

     

       4
       4
       -
       , yesodCore, yesodForm, yesodPersistent

     

       3
       3
       +
       { cabal, cryptohash, hspec, persistent, pwstoreFast, text

     

       4
       4
       +
       , yesodAuth, yesodCore, yesodForm, yesodPersistent

     

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "yesod-auth-hashdb";

     

       9
       9
       -
         version = "1.4.0";

     

       10
       10
       -
         sha256 = "0z6gfm1dk03ap2ra7b9wd2jcsnfazcpk6vxcsx94vmb3a9jqx22l";

     

       9
       9
       +
         version = "1.4.1";

     

       10
       10
       +
         sha256 = "11biiylg2366vymx37asr7ibw8migwnkf3nj6lx1i94ldvs9kfd4";

     

       11
       11
        
         buildDepends = [

     

       12
       12
        
           cryptohash persistent pwstoreFast text yesodAuth yesodCore

     

       13
       13
        
           yesodForm yesodPersistent

     

       14
       14
        
         ];

     

       15
       15
       +
         testDepends = [ hspec text ];

     

       15
       16
        
         meta = {

     

       16
       16
       -
           homepage = "http://www.yesodweb.com/";

     

       17
       17
       +
           homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";

     

       17
       18
        
           description = "Authentication plugin for Yesod";

     

       18
       19
        
           license = self.stdenv.lib.licenses.mit;

     

       19
       20
        
           platforms = self.ghc.meta.platforms;

+2 -2

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

···

       11
       11
        
       

     

       12
       12
        
       cabal.mkDerivation (self: {

     

       13
       13
        
         pname = "yesod-bin";

     

       14
       14
       -
         version = "1.4.0.1";

     

       15
       15
       -
         sha256 = "062jr3g32rsljscq7bq9bgwwfx7vijx3cmhakwcxw17yh5405ks5";

     

       14
       14
       +
         version = "1.4.0.4";

     

       15
       15
       +
         sha256 = "1f05y5nh218c2r7d67r3lpxkbf6f6irhy7mg8pvbgy9yz90k0j8b";

     

       16
       16
        
         isLibrary = false;

     

       17
       17
        
         isExecutable = true;

     

       18
       18
        
         buildDepends = [

+11 -10

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

···

       4
       4
        
       , caseInsensitive, cereal, clientsession, conduit, conduitExtra

     

       5
       5
        
       , cookie, dataDefault, deepseq, exceptions, fastLogger, hspec

     

       6
       6
        
       , httpTypes, HUnit, liftedBase, monadControl, monadLogger, mtl

     

       7
       7
       -
       , network, parsec, pathPieces, QuickCheck, random, resourcet, safe

     

       8
       8
       -
       , shakespeare, streamingCommons, text, time, transformers

     

       9
       9
       -
       , transformersBase, unixCompat, unorderedContainers, vector, wai

     

       10
       10
       -
       , waiExtra, waiLogger, warp

     

       7
       7
       +
       , mwcRandom, network, parsec, pathPieces, primitive, QuickCheck

     

       8
       8
       +
       , random, resourcet, safe, shakespeare, streamingCommons, text

     

       9
       9
       +
       , time, transformers, transformersBase, unixCompat

     

       10
       10
       +
       , unorderedContainers, vector, wai, waiExtra, waiLogger, warp

     

       11
       11
       +
       , word8

     

       11
       12
        
       }:

     

       12
       13
        
       

     

       13
       14
        
       cabal.mkDerivation (self: {

     

       14
       15
        
         pname = "yesod-core";

     

       15
       15
       -
         version = "1.4.2";

     

       16
       16
       -
         sha256 = "0qi1shmbsi8vkxzvyzqzgmdapnbfkkjvhkshkmr7rrdhkdbnkbxl";

     

       16
       16
       +
         version = "1.4.3";

     

       17
       17
       +
         sha256 = "1mglavffzvav4dzwqq70agz5rd4bdb66p40qa445fq1dxwbwcq6i";

     

       17
       18
        
         buildDepends = [

     

       18
       19
        
           aeson blazeBuilder blazeHtml blazeMarkup caseInsensitive cereal

     

       19
       20
        
           clientsession conduit conduitExtra cookie dataDefault deepseq

     

       20
       21
        
           exceptions fastLogger httpTypes liftedBase monadControl monadLogger

     

       21
       21
       -
           mtl parsec pathPieces random resourcet safe shakespeare text time

     

       22
       22
       -
           transformers transformersBase unixCompat unorderedContainers vector

     

       23
       23
       -
           wai waiExtra waiLogger warp

     

       22
       22
       +
           mtl mwcRandom parsec pathPieces primitive random resourcet safe

     

       23
       23
       +
           shakespeare text time transformers transformersBase unixCompat

     

       24
       24
       +
           unorderedContainers vector wai waiExtra waiLogger warp word8

     

       24
       25
        
         ];

     

       25
       26
        
         testDepends = [

     

       26
       27
        
           async blazeBuilder conduit conduitExtra hspec httpTypes HUnit

     

       27
       27
       -
           liftedBase network pathPieces QuickCheck random resourcet

     

       28
       28
       +
           liftedBase mwcRandom network pathPieces QuickCheck random resourcet

     

       28
       29
        
           shakespeare streamingCommons text transformers wai waiExtra

     

       29
       30
        
         ];

     

       30
       31
        
         jailbreak = true;

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       cabal.mkDerivation (self: {

     

       10
       10
        
         pname = "yesod-form";

     

       11
       11
       -
         version = "1.4.0.2";

     

       12
       12
       -
         sha256 = "1y2585pdph2vl42ig6fvzpyy1p3n4v1i1xqnlkb2cfsyssswh5d4";

     

       11
       11
       +
         version = "1.4.1";

     

       12
       12
       +
         sha256 = "034bgkr5fmfjbxwy6kkz36als51jyq0ksx8wknwxf7pr07zwbl3x";

     

       13
       13
        
         buildDepends = [

     

       14
       14
        
           aeson attoparsec blazeBuilder blazeHtml blazeMarkup byteable

     

       15
       15
        
           dataDefault emailValidate networkUri persistent resourcet

+20

pkgs/development/libraries/libinput/default.nix

···

       1
       1
       +
       { stdenv, fetchurl, pkgconfig, mtdev, udev, libevdev }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "libinput-0.6.0";

     

       5
       5
       +
       

     

       6
       6
       +
         src = fetchurl {

     

       7
       7
       +
           url = "http://www.freedesktop.org/software/libinput/${name}.tar.xz";

     

       8
       8
       +
           sha256 = "1g5za42f60vw87982vjh0n6r78qajj34l323p7623fbw3rvmbd9h";

     

       9
       9
       +
         };

     

       10
       10
       +
       

     

       11
       11
       +
         buildInputs = [ pkgconfig mtdev udev libevdev ];

     

       12
       12
       +
       

     

       13
       13
       +
         meta = with stdenv.lib; {

     

       14
       14
       +
           homepage = http://www.freedesktop.org/wiki/Software/libinput;

     

       15
       15
       +
           description = "handles input devices in Wayland compositors and to provide a generic X.Org input driver";

     

       16
       16
       +
           platforms = platforms.unix;

     

       17
       17
       +
           license = licenses.mit;

     

       18
       18
       +
           maintainers = with maintainers; [ wkennington ];

     

       19
       19
       +
         };

     

       20
       20
       +
       }

+1 -2

pkgs/development/libraries/libpcap/default.nix

···

       10
       10
        
         

     

       11
       11
        
         nativeBuildInputs = [ flex bison ];

     

       12
       12
        
         

     

       13
       13
       -
         # Apparently, 32 bit systems need this forced? Not verified if still needed.

     

       14
       14
       -
         configureFlags = stdenv.lib.optionals (stdenv.system == "i686-linux") "--with-pcap=linux";

     

       13
       13
       +
         configureFlags = stdenv.lib.optionals stdenv.isLinux "--with-pcap=linux";

     

       15
       14
        
       

     

       16
       15
        
         preInstall = ''mkdir -p $out/bin'';

     

       17
       16

+2 -2

pkgs/development/libraries/libqb/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec{

     

       4
       4
       -
         name = "libqb-0.16.0";

     

       4
       4
       +
         name = "libqb-0.17.1";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "https://fedorahosted.org/releases/q/u/quarterback/${name}.tar.xz";

     

       8
       8
       -
           sha256 = "0j3zl5g5nnx98jb16p89q8w61har3gbvnlnmma8yj31xngps3kdq";

     

       8
       8
       +
           sha256 = "0a9fy4hb6ixs875fbqw77dfj7519ixg27vg4yajyl87y7gw1a8bs";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         buildInputs = [ pkgconfig ];

+6 -7

pkgs/development/libraries/mtdev/default.nix

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "mtdev-1.1.2";

     

       4
       4
       +
         name = "mtdev-1.1.5";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "http://bitmath.org/code/mtdev/${name}.tar.bz2";

     

       8
       8
       -
           sha256 = "0c2sfxxymf20ylvblgmdmybqs0cydmphg9fq6fnp6flbl0fd33b9";

     

       8
       8
       +
           sha256 = "0zxs7shzgbalkvlaiibi25bd902rbmkv9n1lww6q8j3ri9qdaxv6";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
       -
         meta = {

     

       11
       11
       +
         meta = with stdenv.lib; {

     

       12
       12
        
           homepage = http://bitmath.org/code/mtdev/;

     

       13
       13
       -
       

     

       14
       13
        
           description = "Multitouch Protocol Translation Library";

     

       15
       15
       -
       

     

       16
       14
        
           longDescription = ''

     

       17
       15
        
             The mtdev is a stand-alone library which transforms all variants of

     

       18
       16
        
             kernel MT events to the slotted type B protocol. The events put into

     
···

       20
       18
        
             tracking, type A with contact tracking, or type B with contact tracking.

     

       21
       19
        
             See the kernel documentation for further details. 

     

       22
       20
        
           '';

     

       23
       23
       -
       

     

       24
       24
       -
           license = stdenv.lib.licenses.mit;

     

       21
       21
       +
           license = licenses.mit;

     

       22
       22
       +
           platforms = platforms.unix;

     

       23
       23
       +
           maintainers = with maintainers; [ wkennington ];

     

       25
       24
        
         };

     

       26
       25
        
       }

+1 -1

pkgs/development/libraries/pangomm/default.nix

···

       18
       18
        
         meta = with stdenv.lib; {

     

       19
       19
        
           description = "C++ interface to the Pango text rendering library";

     

       20
       20
        
           homepage    = http://www.pango.org/;

     

       21
       21
       -
           # TODO license     = with licenses; [ lgpl2 lgpl21 ];

     

       21
       21
       +
           license     = with licenses; [ lgpl2 lgpl21 ];

     

       22
       22
        
           maintainers = with maintainers; [ lovek323 raskin ];

     

       23
       23
        
           platforms   = platforms.unix;

     

       24
       24

+3 -3

pkgs/development/libraries/sqlite/default.nix

···

       3
       3
        
       assert readline != null -> ncurses != null;

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation {

     

       6
       6
       -
         name = "sqlite-3.8.4.3";

     

       6
       6
       +
         name = "sqlite-3.8.6";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
       -
           url = "http://www.sqlite.org/2014/sqlite-autoconf-3080403.tar.gz";

     

       10
       10
       -
           sha1 = "zd9nqg1fc41222hvzvmvzr92z80b3wvh";

     

       9
       9
       +
           url = "http://www.sqlite.org/2014/sqlite-autoconf-3080600.tar.gz";

     

       10
       10
       +
           sha1 = "c4b2911bc4a6e1dc2b411aa21d8c4f524113eb64";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         buildInputs = [ readline ncurses ];

+1 -1

pkgs/development/libraries/talloc/default.nix

···

       12
       12
        
         

     

       13
       13
        
         # https://bugzilla.samba.org/show_bug.cgi?id=7000

     

       14
       14
        
         postConfigure = if stdenv.isDarwin then ''

     

       15
       15
       -
           substituteInPlace "Makefile" --replace "SONAMEFLAG = #" "SONAMEFLAG = -install_name"

     

       15
       15
       +
           substituteInPlace "Makefile" --replace "SONAMEFLAG = #" "SONAMEFLAG = -Wl,-install_name,"

     

       16
       16
        
         '' else "";

     

       17
       17
        
       

     

       18
       18
        
         meta = {

+1 -1

pkgs/development/libraries/thrift/default.nix

···

       21
       21
        
         patches = [ ./yylex.patch ];

     

       22
       22
        
       

     

       23
       23
        
         # Workaround to make the python wrapper not drop this package:

     

       24
       24
       -
         # pythonFullBuildEnv.override { extraLibs = [ thrift ]; }

     

       24
       24
       +
         # pythonFull.buildEnv.override { extraLibs = [ thrift ]; }

     

       25
       25
        
         pythonPath = [];

     

       26
       26
        
       

     

       27
       27
        
         buildInputs = [

+6 -2

pkgs/development/libraries/tsocks/default.nix

···

       2
       2
        
       stdenv.mkDerivation rec {

     

       3
       3
        
         name = "tsocks-${version}";

     

       4
       4
        
         version = "1.8beta5";

     

       5
       5
       -
         

     

       5
       5
       +
       

     

       6
       6
        
         src = fetchurl {

     

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

     

       8
       8
        
           sha256 = "0ixkymiph771dcdzvssi9dr2pk1bzaw9zv85riv3xl40mzspx7c4";

     

       9
       9
        
         };

     

       10
       10
       +
       

     

       11
       11
       +
         patches = [ ./poll.patch ];

     

       10
       12
        
       

     

       11
       13
        
         preConfigure = ''

     

       12
       12
       -
             export configureFlags="$configureFlags --libdir=$out/lib"

     

       14
       14
       +
           sed -i -e "s,\\\/usr,"$(echo $out|sed -e "s,\\/,\\\\\\\/,g")",g" tsocks

     

       15
       15
       +
           substituteInPlace tsocks --replace /usr $out

     

       16
       16
       +
           export configureFlags="$configureFlags --libdir=$out/lib"

     

       13
       17
        
         '';

     

       14
       18
        
       

     

       15
       19
        
         meta = with stdenv.lib; {

+26

pkgs/development/libraries/tsocks/poll.patch

···

       1
       1
       +
       From Ingo Hadan <ingo.hadan@sdm.de> Fri, 02 Apr 2010 21:08:50 +0200

     

       2
       2
       +
       From: Julien Moutinho <julm+tsocks@autogeree.net>

     

       3
       3
       +
       Date: Fri, 26 Apr 2013 01:57:26 +0200

     

       4
       4
       +
       Subject: tsocks fails if socksified application uses poll(2) (e.g. subversion-1.5)

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
       diff --git a/tsocks.c b/tsocks.c

     

       8
       8
       +
       index 9cfdfff..470babd 100644

     

       9
       9
       +
       --- a/tsocks.c

     

       10
       10
       +
       +++ b/tsocks.c

     

       11
       11
       +
       @@ -657,10 +657,11 @@ int poll(POLL_SIGNATURE) {

     

       12
       12
       +
                     * be ready for writing), otherwise we'll just let the select loop

     

       13
       13
       +
                     * come around again (since we can't flag it for read, we don't know

     

       14
       14
       +
                     * if there is any data to be read and can't be bothered checking) */

     

       15
       15
       +
       -            if (conn->selectevents & WRITE) {

     

       16
       16
       +
       -               setevents |= POLLOUT; 

     

       17
       17
       +
       +            if (conn->selectevents & POLLOUT) {

     

       18
       18
       +
       +               ufds[i].revents |= POLLOUT; 

     

       19
       19
       +
                       nevents++;

     

       20
       20
       +
                    }

     

       21
       21
       +
       +            ufds[i].events = conn->selectevents;

     

       22
       22
       +
                 }

     

       23
       23
       +
              }

     

       24
       24
       +
           } while (nevents == 0);

     

       25
       25
       +
       

     

       26
       26
       +

+2 -2

pkgs/development/libraries/wayland/default.nix

···

       1
       1
        
       { stdenv, fetchurl, libffi, expat, pkgconfig, libxslt, docbook_xsl, doxygen }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "1.5.0"; in

     

       3
       3
       +
       let version = "1.6.0"; in

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "wayland-${version}";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "http://wayland.freedesktop.org/releases/${name}.tar.xz";

     

       10
       10
       -
           sha256 = "1da179livkkmfsds32yhh4zflxn9qs6av023702kx2w8mzly2s80";

     

       10
       10
       +
           sha256 = "0zzwlrmxil10g9rvdgha0y1d8z0x97g65g14kl2qrl2krwni1md7";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         buildInputs = [ pkgconfig libffi expat libxslt docbook_xsl doxygen ];

+18 -28

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

···

       1
       1
       -
       { stdenv, fetchurl, buildPythonPackage, pykickstart, pyparted, pyblock

     

       2
       2
       -
       , libselinux, cryptsetup, multipath_tools, lsof, utillinux

     

       3
       3
       -
       , useNixUdev ? true, udev ? null

     

       4
       4
       -
       # This is only used when useNixUdev is false

     

       5
       5
       -
       , udevSoMajor ? 1

     

       1
       1
       +
       { stdenv, fetchFromGitHub, buildPythonPackage, pykickstart, pyparted, pyblock

     

       2
       2
       +
       , pyudev, six, libselinux, cryptsetup, multipath_tools, lsof, utillinux

     

       6
       3
        
       }:

     

       7
       7
       -
       

     

       8
       8
       -
       assert useNixUdev -> udev != null;

     

       9
       4
        
       

     

       10
       5
        
       let

     

       11
       6
        
         pyenable = { enablePython = true; };

     
···

       13
       8
        
         cryptsetupWithPython = cryptsetup.override pyenable;

     

       14
       9
        
       in buildPythonPackage rec {

     

       15
       10
        
         name = "blivet-${version}";

     

       16
       16
       -
         version = "0.17-1";

     

       11
       11
       +
         version = "0.67";

     

       17
       12
        
       

     

       18
       18
       -
         src = fetchurl {

     

       19
       19
       -
           url = "https://git.fedorahosted.org/cgit/blivet.git/snapshot/"

     

       20
       20
       -
               + "${name}.tar.bz2";

     

       21
       21
       -
           sha256 = "1k3mws2q0ryb7422mml6idmaasz2i2v6ngyvg6d976dx090qnmci";

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "dwlehman";

     

       15
       15
       +
           repo = "blivet";

     

       16
       16
       +
           rev = name;

     

       17
       17
       +
           sha256 = "1gk94ghjrxfqnx53hph1j2s7qcv86fjz48is7l099q9c24rjv8ky";

     

       22
       18
        
         };

     

       23
       19
        
       

     

       24
       20
        
         postPatch = ''

     

       25
       25
       -
           sed -i -e 's|"multipath"|"${multipath_tools}/sbin/multipath"|' \

     

       26
       26
       -
             blivet/devicelibs/mpath.py blivet/devices.py

     

       21
       21
       +
           sed -i \

     

       22
       22
       +
             -e 's|"multipath"|"${multipath_tools}/sbin/multipath"|' \

     

       23
       23
       +
             -e '/^def set_friendly_names/a \    return False' \

     

       24
       24
       +
             blivet/devicelibs/mpath.py

     

       27
       25
        
           sed -i -e '/"wipefs"/ {

     

       28
       26
        
             s|wipefs|${utillinux}/sbin/wipefs|

     

       29
       27
        
             s/-f/--force/

     

       30
       28
        
           }' blivet/formats/__init__.py

     

       31
       29
        
           sed -i -e 's|"lsof"|"${lsof}/bin/lsof"|' blivet/formats/fs.py

     

       32
       30
        
           sed -i -r -e 's|"(u?mount)"|"${utillinux}/bin/\1"|' blivet/util.py

     

       33
       33
       -
           sed -i '/pvscan/s/, *"--cache"//' blivet/devicelibs/lvm.py

     

       34
       34
       -
         '' + (if useNixUdev then ''

     

       35
       35
       -
           sed -i -e '/find_library/,/find_library/ {

     

       36
       36
       -
             c libudev = "${udev}/lib/libudev.so.1"

     

       37
       37
       -
           }' blivet/pyudev.py

     

       38
       38
       -
         '' else ''

     

       39
       39
       -
           sed -i \

     

       40
       40
       -
             -e '/^somajor *=/s/=.*/= ${toString udevSoMajor}/p' \

     

       41
       41
       -
             -e 's|common =.*|& + ["/lib/x86_64-linux-gnu", "/lib/i686-linux-gnu"]|' \

     

       42
       42
       -
             blivet/pyudev.py

     

       43
       43
       -
         '');

     

       31
       31
       +
           sed -i -e '/pvscan/s/, *"--cache"//' blivet/devicelibs/lvm.py

     

       32
       32
       +
         '';

     

       44
       33
        
       

     

       45
       34
        
         propagatedBuildInputs = [

     

       46
       46
       -
           pykickstart pyparted pyblock selinuxWithPython cryptsetupWithPython

     

       47
       47
       -
         ] ++ stdenv.lib.optional useNixUdev udev;

     

       35
       35
       +
           pykickstart pyparted pyblock pyudev selinuxWithPython cryptsetupWithPython

     

       36
       36
       +
           six

     

       37
       37
       +
         ];

     

       48
       38
        
       

     

       49
       49
       -
         # tests are currently _heavily_ broken upstream

     

       39
       39
       +
         # Tests are in <nixos/tests/blivet.nix>.

     

       50
       40
        
         doCheck = false;

     

       51
       41
        
       

     

       52
       42
        
         meta = {

+1 -1

pkgs/development/python-modules/rhpl/builder.sh

···

       1
       1
        
       source $stdenv/setup

     

       2
       2
        
       

     

       3
       3
       -
       rpm2cpio $src | cpio -idv

     

       3
       3
       +
       rpmextract $src

     

       4
       4
        
       tar xfvj rhpl-*.tar.bz2

     

       5
       5
        
       rm rhpl-*.tar.bz2

     

       6
       6
        
       cd rhpl-*

+2 -2

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

···

       1
       1
       -
       {stdenv, fetchurl, rpm, cpio, python, wirelesstools, gettext}:

     

       1
       1
       +
       {stdenv, fetchurl, rpmextract, python, wirelesstools, gettext}:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation {

     

       4
       4
        
         name = "rhpl-0.218";

     
···

       12
       12
        
         

     

       13
       13
        
         builder = ./builder.sh;

     

       14
       14
        
         

     

       15
       15
       -
         buildInputs = [ rpm cpio python wirelesstools gettext ];

     

       15
       15
       +
         buildInputs = [ rpmextract python wirelesstools gettext ];

     

       16
       16
        
       }

+3 -4

pkgs/development/tools/haskell/cabal-db/default.nix

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "cabal-db";

     

       9
       9
       -
         version = "0.1.9";

     

       10
       10
       -
         sha256 = "19mw5ycc2y5wkn1h7wkdm2gb29pq2sh0n8z52dbxlkf0rwcgjbfq";

     

       9
       9
       +
         version = "0.1.10";

     

       10
       10
       +
         sha256 = "0j9xnf23zrpyrfkcx321rqbabzsm4208idpvfy7sdnnvw9a2k5xw";

     

       11
       11
        
         isLibrary = false;

     

       12
       12
        
         isExecutable = true;

     

       13
       13
        
         buildDepends = [

     
···

       15
       15
        
         ];

     

       16
       16
        
         meta = {

     

       17
       17
        
           homepage = "http://github.com/vincenthz/cabal-db";

     

       18
       18
       -
           description = "query tools for the local cabal database (revdeps, graph, info, search-by, license, bounds)";

     

       18
       18
       +
           description = "query tools for the local cabal database";

     

       19
       19
        
           license = self.stdenv.lib.licenses.bsd3;

     

       20
       20
        
           platforms = self.ghc.meta.platforms;

     

       21
       21
       -
           broken = true;

     

       22
       21
        
         };

     

       23
       22
        
       })

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "graphmod";

     

       7
       7
       -
         version = "1.2.5";

     

       8
       8
       -
         sha256 = "1rmrsfvajzrak7jlhwnvhrgszgyg1b6z5wp21k0d7pv2cbfdkp8s";

     

       7
       7
       +
         version = "1.2.6";

     

       8
       8
       +
         sha256 = "02p1x44ywv2mb4l2dsz9z3ybnvv4nns3882lqm3nc8sw2hkib8z3";

     

       9
       9
        
         isLibrary = false;

     

       10
       10
        
         isExecutable = true;

     

       11
       11
        
         buildDepends = [ dotgen filepath haskellLexer ];

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       cabal.mkDerivation (self: {

     

       8
       8
        
         pname = "hlint";

     

       9
       9
       -
         version = "1.9.9";

     

       10
       10
       -
         sha256 = "193ls1pfycdl8ifq09y2acbhy2hjb2p8f79gjn13ziaycgfz9ygr";

     

       9
       9
       +
         version = "1.9.10";

     

       10
       10
       +
         sha256 = "08pfc0mhqkhali0hjxpa26hr5ykfdmyldh0r04v1b42a1c60k1id";

     

       11
       11
        
         isLibrary = true;

     

       12
       12
        
         isExecutable = true;

     

       13
       13
        
         buildDepends = [

+2 -1

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

···

       16
       16
        
         sha256 = "012rmasdc167w6gl18ysr53737j4p4afk0qcsv81hif92vvg5j1c";

     

       17
       17
        
         isLibrary = true;

     

       18
       18
        
         isExecutable = true;

     

       19
       19
       -
         patches = [ (fetchpatch { url = "https://github.com/gibiansky/IHaskell/pull/288.patch"; sha256 = "022zdz4wnyra6cfa7mq0w2ycsb007cvppn2f1360nr3fa5s9wibg"; }) ];

     

       19
       19
       +
         patches = [ (fetchpatch { url = "https://github.com/gibiansky/IHaskell/pull/296.patch"; sha256 = "1h9gxq9l3j949prcwqkdkrc3q3sxai4b345hfp5hfi0mhfbysfn6"; }) ];

     

       20
       20
        
         prePatch = ''

     

       21
       21
        
           tar xvf profile/profile.tar -C profile

     

       22
       22
        
           sed -i -e '1iexe = "'$out'/bin/IHaskell".replace(" ", "\\ ")\' profile/ipython_config.py

     
···

       45
       45
        
           description = "A Haskell backend kernel for the IPython project";

     

       46
       46
        
           license = licenses.mit;

     

       47
       47
        
           platforms = self.ghc.meta.platforms;

     

       48
       48
       +
           hydraPlatforms = self.stdenv.lib.platforms.none;

     

       48
       49
        
           maintainers = with maintainers; [ edwtjo ];

     

       49
       50
        
         };

     

       50
       51
        
       })

+2 -4

pkgs/development/tools/haskell/ihaskell/wrapper.nix

···

       20
       20
        
             --set GHC_PACKAGE_PATH "\$GHC_PACKAGE_PATH:" # always end with : to include base packages

     

       21
       21
        
         '';

     

       22
       22
        
       

     

       23
       23
       -
         meta = {

     

       24
       24
       -
           description = ihaskell.meta.description;

     

       25
       25
       -
         };

     

       26
       26
       -
       }
     

       23
       23
       +
         inherit (ihaskell) meta;

     

       24
       24
       +
       }

+2 -2

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

···

       11
       11
        
       

     

       12
       12
        
       cabal.mkDerivation (self: {

     

       13
       13
        
         pname = "keter";

     

       14
       14
       -
         version = "1.3.4";

     

       15
       15
       -
         sha256 = "127sv155kgwz64adylfn2dmpnqh833pa53lnc8ahhwa63xwf9pzk";

     

       14
       14
       +
         version = "1.3.5";

     

       15
       15
       +
         sha256 = "0jbf9x50gy9qja6gazh0lgyffz46a3wps6hbxppqmcicjhwbpvr5";

     

       16
       16
        
         isLibrary = true;

     

       17
       17
        
         isExecutable = true;

     

       18
       18
        
         buildDepends = [

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       cabal.mkDerivation (self: {

     

       6
       6
        
         pname = "cpphs";

     

       7
       7
       -
         version = "1.18.5";

     

       8
       8
       -
         sha256 = "0bqfz0wkfnxvv711fgmhmh6rbwffgna1pfqbj7whb6crqji9w7g7";

     

       7
       7
       +
         version = "1.18.6";

     

       8
       8
       +
         sha256 = "0ds712zabigswf3cljzh7f2ys4rl1fj2cf76lbw856adm8514gxc";

     

       9
       9
        
         isLibrary = true;

     

       10
       10
        
         isExecutable = true;

     

       11
       11
        
         buildDepends = [ polyparse ];

+1 -1

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

···

       15
       15
        
           homepage = http://lttng.org/;

     

       16
       16
        
           # liblttvtraceread (ltt/ directory) is distributed under the GNU LGPL v2.1.

     

       17
       17
        
           # The rest of the LTTV package is distributed under the GNU GPL v2.

     

       18
       18
       -
           # TODO license = with licenses; [ gpl2 lgpl21 ];

     

       18
       18
       +
           license = with licenses; [ gpl2 lgpl21 ];

     

       19
       19
        
           platforms = platforms.linux;

     

       20
       20
        
           maintainers = [ maintainers.bjornfor ];

     

       21
       21
        
         };

pkgs/development/tools/quilt/default.nix

···

       29
       29
        
           '';

     

       30
       30
        
       

     

       31
       31
        
           license = "GPLv2+";

     

       32
       32
       +
           platforms = stdenv.lib.platforms.all;

     

       32
       33
        
         };

     

       33
       34
        
       }

+3 -1

pkgs/development/web/nodejs/default.nix

···

       10
       10
        
       

     

       11
       11
        
         # !!! Should we also do shared libuv?

     

       12
       12
        
         deps = {

     

       13
       13
       -
           inherit openssl zlib http-parser;

     

       13
       13
       +
           inherit openssl zlib;

     

       14
       14
        
           cares = c-ares;

     

       15
       15
        
       

     

       16
       16
        
           # disabled system v8 because v8 3.14 no longer receives security fixes

     

       17
       17
        
           # we fall back to nodejs' internal v8 copy which receives backports for now

     

       18
       18
        
           # inherit v8

     

       19
       19
       +
         } // stdenv.lib.optionalAttrs (!stdenv.isDarwin) {

     

       20
       20
       +
           inherit http-parser;

     

       19
       21
        
         };

     

       20
       22
        
       

     

       21
       23
        
         sharedConfigureFlags = name: [

+6 -5

pkgs/development/web/twitter-bootstrap/default.nix

···

       1
       1
       -
       { stdenv, fetchgit, lessc, closurecompiler }:

     

       1
       1
       +
       { stdenv, fetchFromGitHub, lessc, closurecompiler }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "twitter-bootstrap-${version}";

     

       5
       5
        
         version = "2.3.2";

     

       6
       6
        
       

     

       7
       7
       -
         src = fetchgit {

     

       8
       8
       -
           url = https://github.com/twitter/bootstrap.git;

     

       9
       9
       -
           rev = "refs/tags/v${version}";

     

       10
       10
       -
           sha256 = "093z4yxqhrr30vna67ksxz3bq146q2xr05hinh78pg2ls88k77la";

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "twitter";

     

       9
       9
       +
           repo = "bootstrap";

     

       10
       10
       +
           rev =  "v${version}";

     

       11
       11
       +
           sha256 = "0b4dsk9sqlkwwfgqqjlgi6p05qz2jssmmz4adm83f31sx70lgh4g";

     

       11
       12
        
         };  

     

       12
       13
        
       

     

       13
       14
        
         buildInputs = [ lessc closurecompiler ];

+3 -3

pkgs/games/chocolate-doom/default.nix

···

       1
       1
        
       { stdenv, autoconf, automake, pkgconfig, SDL, SDL_mixer, SDL_net, fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "chocolate-doom-2.0.0";

     

       4
       4
       +
         name = "chocolate-doom-2.1.0";

     

       5
       5
        
         src = fetchurl {

     

       6
       6
       -
           url = https://github.com/chocolate-doom/chocolate-doom/archive/chocolate-doom-2.0.0.tar.gz;

     

       7
       7
       -
           sha256 = "1n9lkx97h987bq8z586jgissdhs07xyfr0xfdk7m2wpw4yhw10k1";

     

       6
       6
       +
           url = "https://github.com/chocolate-doom/chocolate-doom/archive/${name}.tar.gz";

     

       7
       7
       +
           sha256 = "1qwnc5j3n99jk35c487mxsij04m4kpkqzkbrb8qwqlsnqllyh1s1";

     

       8
       8
        
         };

     

       9
       9
        
         buildInputs = [ autoconf automake pkgconfig SDL SDL_mixer SDL_net ];

     

       10
       10
        
         patchPhase = ''

-24

pkgs/games/chocolate-doom/master.nix

···

       1
       1
       -
       { stdenv, autoconf, automake, pkgconfig, SDL, SDL_mixer, SDL_net, git, fetchgit }:

     

       2
       2
       -
       

     

       3
       3
       -
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "chocolate-doom-20141008";

     

       5
       5
       -
         src = fetchgit {

     

       6
       6
       -
           url = git://github.com/fragglet/chocolate-doom.git;

     

       7
       7
       -
           rev = "63e1c884911f9e3382936f84a388e941b29343e6";

     

       8
       8
       -
           sha256 = "1855a70widf1ni7lrfvp3hwxs1fhg1v5l738ckai88xpbak8i14m";

     

       9
       9
       -
         };

     

       10
       10
       -
         buildInputs = [ autoconf automake pkgconfig SDL SDL_mixer SDL_net git ];

     

       11
       11
       -
         patchPhase = ''

     

       12
       12
       -
           sed -e 's#/games#/bin#g' -i src{,/setup}/Makefile.am

     

       13
       13
       -
           ./autogen.sh --prefix=$out

     

       14
       14
       -
         '';

     

       15
       15
       -
       

     

       16
       16
       -
         enableParallelBuilding = true;

     

       17
       17
       -
       

     

       18
       18
       -
         meta = {

     

       19
       19
       -
           homepage = http://chocolate-doom.org/;

     

       20
       20
       -
           description = "A Doom source port that accurately reproduces the experience of Doom as it was played in the 1990s";

     

       21
       21
       -
           license = stdenv.lib.licenses.gpl2Plus;

     

       22
       22
       -
           maintainers = with stdenv.lib.maintainers; [ MP2E ];

     

       23
       23
       -
         };

     

       24
       24
       -
       }

+2 -2

pkgs/misc/emulators/wine/unstable.nix

···

       7
       7
        
       assert stdenv.gcc.gcc != null;

     

       8
       8
        
       

     

       9
       9
        
       let

     

       10
       10
       -
           version = "1.7.28";

     

       10
       10
       +
           version = "1.7.29";

     

       11
       11
        
           name = "wine-${version}";

     

       12
       12
        
       

     

       13
       13
        
           src = fetchurl {

     

       14
       14
        
             url = "mirror://sourceforge/wine/${name}.tar.bz2";

     

       15
       15
       -
             sha256 = "04r3zk3dz2vzly2a4nqbcvppjs5iy3lq5ibx3wfrf877p5bz3hv7";

     

       15
       15
       +
             sha256 = "0qnyp1svzh2yyc3p34dg8hf21lwzxn4xkgpa3s0rfcak6l6ijj5f";

     

       16
       16
        
           };

     

       17
       17
        
       

     

       18
       18
        
           gecko = fetchurl {

+761 -366

pkgs/misc/vim-plugins/default.nix

···

       1
       1
       -
       { fetchurl, bash, stdenv, python, cmake, vim, perl, ruby, unzip, which, fetchgit, clang }:

     

       1
       1
       +
       { fetchurl, bash, stdenv, python, cmake, vim, perl, ruby, unzip, which, fetchgit, fetchzip, clang, zip }:

     

       2
       2
        
       

     

       3
       3
        
       /*

     

       4
       4
        
       About Vim and plugins

     
···

       18
       18
        
       of which files belong to what plugin. Now this problem is "fixed" by nix which

     

       19
       19
        
       assembles your profile for you.

     

       20
       20
        
       

     

       21
       21
       -
       

     

       22
       21
        
       Vim offers the :h rtp setting which works for most plugins. Thus adding adding

     

       23
       22
        
       this to your .vimrc should make most plugins work:

     

       24
       23
        
       

     

       25
       25
       -
         set rtp+=~/.nix-profile/vim-plugins/YouCompleteMe

     

       26
       26
       -
         " or for p in ["YouCompleteMe"] | exec 'set rtp+=~/.nix-profile/vim-plugins/'.p | endfor

     

       24
       24
       +
         set rtp+=~/.nix-profile/vim-plugins/youcompleteme

     

       25
       25
       +
         " or for p in ["youcompleteme"] | exec 'set rtp+=~/.nix-profile/vim-plugins/'.p | endfor

     

       27
       26
        
       

     

       28
       27
        
       Its what pathogen, vundle, vim-addon-manager (VAM) use.

     

       29
       28
        
       

     
···

       68
       67
        
       

     

       69
       68
        
       So which plugins to add here according to what Marc Weber thinks is best?

     

       70
       69
        
       Complicated plugins requiring dependencies, such as YouCompleteMe.

     

       71
       71
       -
       Then its best to symlink ~/.nix-profile/vim-plugins/YouCompleteMe to

     

       70
       70
       +
       Then its best to symlink ~/.nix-profile/vim-plugins/youcompleteme to

     

       72
       71
        
       ~/.vim/{vim-addons,bundle} or whatever plugin management solution you use.

     

       73
       72
        
       

     

       74
       73
        
       If you feel differently change the comments and proceed.

     
···

       83
       82
        
           }

     

       84
       83
        
         '';

     

       85
       84
        
       

     

       86
       86
       -
         # install a simple standard vim plugin

     

       87
       87
       -
         simpleDerivation = a@{name, src, path, buildPhase ? "", ...} : stdenv.mkDerivation (a // {

     

       85
       85
       +
         buildVimPlugin = a@{name, namePrefix ? "vimplugin-", src, buildPhase ? "", ...}: stdenv.mkDerivation (a // {

     

       86
       86
       +
           name = namePrefix + name;

     

       87
       87
       +
       

     

       88
       88
        
           inherit buildPhase;

     

       89
       89
        
       

     

       90
       90
       -
           installPhase = ''

     

       90
       90
       +
           installPhase = let path = (builtins.parseDrvName name).name; in ''

     

       91
       91
        
             target=$out/share/vim-plugins/${path}

     

       92
       92
        
             mkdir -p $out/share/vim-plugins

     

       93
       93
        
             cp -r . $target

     
···

       99
       99
        
       in rec

     

       100
       100
        
       

     

       101
       101
        
       {

     

       102
       102
       +
         a = buildVimPlugin {

     

       103
       103
       +
           name = "a-git-2010-11-06";

     

       104
       104
       +
           src = fetchgit {

     

       105
       105
       +
             url = "https://github.com/vim-scripts/a.vim.git";

     

       106
       106
       +
             rev = "2cbe946206ec622d9d8cf2c99317f204c4d41885";

     

       107
       107
       +
             sha256 = "ca0982873ed81e7f6545a6623b735104c574fe580d5f21b0aa3dc1557edac240";

     

       108
       108
       +
            };

     

       109
       109
       +
           meta = {

     

       110
       110
       +
             homepage = https://github.com/vim-scripts/a.vim; 

     

       111
       111
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       112
       112
       +
           };

     

       113
       113
       +
         };

     

       102
       114
        
       

     

       103
       103
       -
         vimAddonNix = {

     

       104
       104
       -
           # github.com/MarcWeber/vim-addon-nix provides some additional support for

     

       105
       105
       -
           # editing .nix files

     

       115
       115
       +
         alternative = a; # backwards compat, added 2014-10-21

     

       106
       116
        
       

     

       107
       107
       -
           # This is a placeholder, because I think you always should be using latest

     

       108
       108
       -
           # git version. It also depends on some additional plugins (see addon-info.json)

     

       117
       117
       +
         airline = buildVimPlugin {

     

       118
       118
       +
           name = "airline-git-2014-10-18";

     

       119
       119
       +
           src = fetchgit {

     

       120
       120
       +
             url = "https://github.com/bling/vim-airline.git";

     

       121
       121
       +
             rev = "616daceb735771ed27535abe8a6e4907320f1e82";

     

       122
       122
       +
             sha256 = "05ee7f6d58b14c35edda36183745e508bab19d2289b02af73f980062e51316e7";

     

       123
       123
       +
            };

     

       124
       124
       +
           meta = {

     

       125
       125
       +
             homepage = https://github.com/bling/vim-airline; 

     

       126
       126
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       127
       127
       +
           };

     

       109
       128
        
         };

     

       110
       129
        
       

     

       111
       111
       -
         YouCompleteMe = stdenv.mkDerivation {

     

       130
       130
       +
         align = buildVimPlugin {

     

       131
       131
       +
           name = "align-git-2012-08-07";

     

       112
       132
        
           src = fetchgit {

     

       113
       113
       -
             url = "https://github.com/Valloric/YouCompleteMe.git";

     

       114
       114
       -
             rev = "a2cae90f7ba1746bf1209edd6739f87d5914b375";

     

       115
       115
       -
             sha256 = "1yxrxskxnr2da5awm59ra4s9wg67rimcbazvln9bayg9saxs540d";

     

       133
       133
       +
             url = "https://github.com/vim-scripts/align.git";

     

       134
       134
       +
             rev = "787662fe90cd057942bc5b682fd70c87e1a9dd77";

     

       135
       135
       +
             sha256 = "f7b5764357370f03546556bd45558837f3790b0e86afadb63cd04d714a668a29";

     

       116
       136
        
            };

     

       137
       137
       +
           meta = {

     

       138
       138
       +
             homepage = https://github.com/vim-scripts/align; 

     

       139
       139
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       140
       140
       +
           };

     

       141
       141
       +
         };

     

       117
       142
        
       

     

       118
       118
       -
           name = "youcompleteme-20140929";  # commit date

     

       119
       119
       -
           buildInputs = [ python cmake clang.clang ];

     

       143
       143
       +
         calendar = buildVimPlugin {

     

       144
       144
       +
           name = "calendar-git-2014-10-19";

     

       145
       145
       +
           src = fetchgit {

     

       146
       146
       +
             url = "https://github.com/itchyny/calendar.vim.git";

     

       147
       147
       +
             rev = "44890a96d80bcd5fe62307e4bcb4d4085010e324";

     

       148
       148
       +
             sha256 = "55f38e3e0af0f95229c654420c332668f93ac941f044c0573c7f1b26030e9202";

     

       149
       149
       +
            };

     

       150
       150
       +
           meta = {

     

       151
       151
       +
             homepage = https://github.com/itchyny/calendar.vim; 

     

       152
       152
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       153
       153
       +
           };

     

       154
       154
       +
         };

     

       120
       155
        
       

     

       121
       121
       -
           configurePhase = ":";

     

       156
       156
       +
         coffee-script = buildVimPlugin {

     

       157
       157
       +
           name = "coffee-script-002";

     

       158
       158
       +
           src = fetchurl {

     

       159
       159
       +
             url = "https://github.com/vim-scripts/vim-coffee-script/archive/v002.tar.gz";

     

       160
       160
       +
             sha256 = "1xln6i6jbbihcyp5bsdylr2146y41hmp2xf7wi001g2ymj1zdsc0";

     

       161
       161
       +
           };

     

       162
       162
       +
         };

     

       122
       163
        
       

     

       123
       123
       -
           buildPhase = ''

     

       124
       124
       -
             patchShebangs .

     

       164
       164
       +
         coffeeScript = coffee-script; # backwards compat, added 2014-10-18

     

       125
       165
        
       

     

       126
       126
       -
             target=$out/share/vim-plugins/YouCompleteMe

     

       127
       127
       -
             mkdir -p $target

     

       128
       128
       -
             cp -a ./ $target

     

       129
       129
       -
       

     

       130
       130
       -
             mkdir $target/build

     

       131
       131
       -
             cd $target/build

     

       132
       132
       -
             cmake -G "Unix Makefiles" . $target/third_party/ycmd/cpp -DPYTHON_LIBRARIES:PATH=${python}/lib/libpython2.7.so -DPYTHON_INCLUDE_DIR:PATH=${python}/include/python2.7 -DUSE_CLANG_COMPLETER=ON -DUSE_SYSTEM_LIBCLANG=ON

     

       133
       133
       -
             make ycm_support_libs -j''${NIX_BUILD_CORES} -l''${NIX_BUILD_CORES}}

     

       134
       134
       -
             ${bash}/bin/bash $target/install.sh --clang-completer --system-libclang

     

       135
       135
       -
       

     

       136
       136
       -
             ${vimHelpTags}

     

       137
       137
       -
             vimHelpTags $target

     

       138
       138
       -
           '';

     

       139
       139
       -
       

     

       140
       140
       -
           # TODO: implement proper install phase rather than keeping everything in store

     

       141
       141
       -
           # TODO: support llvm based C completion, See README of git repository

     

       142
       142
       -
           installPhase = ":";

     

       143
       143
       -
       

     

       144
       144
       -
           path = "YouCompleteMe";

     

       145
       145
       -
       

     

       166
       166
       +
         colors-solarized = buildVimPlugin {

     

       167
       167
       +
           name = "colors-solarized-git-2011-05-09";

     

       168
       168
       +
           src = fetchgit {

     

       169
       169
       +
             url = "https://github.com/altercation/vim-colors-solarized.git";

     

       170
       170
       +
             rev = "528a59f26d12278698bb946f8fb82a63711eec21";

     

       171
       171
       +
             sha256 = "a1b2ef696eee94dafa76431c31ee260acdd13a7cf87939f27eca431d5aa5a315";

     

       172
       172
       +
            };

     

       146
       173
        
           meta = {

     

       147
       147
       -
             description = "fastest non utf-8 aware word and C completion engine for Vim";

     

       148
       148
       -
             homepage = http://github.com/Valloric/YouCompleteMe;

     

       149
       149
       -
             license = stdenv.lib.licenses.gpl3;

     

       150
       150
       -
             maintainers = [stdenv.lib.maintainers.marcweber];

     

       151
       151
       -
             platforms = stdenv.lib.platforms.linux;

     

       174
       174
       +
             homepage = https://github.com/altercation/vim-colors-solarized; 

     

       175
       175
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       152
       176
        
           };

     

       153
       177
        
         };

     

       154
       178
        
       

     

       155
       155
       -
         syntastic = simpleDerivation rec {

     

       156
       156
       -
           version = "3.4.0";

     

       157
       157
       -
           name    = "vim-syntastic-${version}";

     

       179
       179
       +
         colorsamplerpack = buildVimPlugin rec {

     

       180
       180
       +
           version = "2012.10.28";

     

       181
       181
       +
           name    = "colorsamplerpack-${version}";

     

       158
       182
        
       

     

       183
       183
       +
           setSourceRoot = "sourceRoot=.";

     

       159
       184
        
           src = fetchurl {

     

       160
       160
       -
             url    = "https://github.com/scrooloose/syntastic/archive/${version}.tar.gz";

     

       161
       161
       -
             sha256 = "0h8vfs6icpfwc41qx6n6rc1m35haxp2gaswg9fhcki2w2ikp6knb";

     

       185
       185
       +
             url    = "http://www.vim.org/scripts/download_script.php?src_id=18915";

     

       186
       186
       +
             name   = "colorsamplerpack.zip";

     

       187
       187
       +
             sha256 = "1wsrb3vpqn9fncnalfpvc8r92wk1mcskm4shb3s2h9x5dyihf2rd";

     

       162
       188
        
           };

     

       163
       189
        
       

     

       164
       164
       -
           path = "syntastic";

     

       165
       165
       -
         };

     

       166
       166
       -
       

     

       167
       167
       -
         coffeeScript = simpleDerivation {

     

       168
       168
       -
           name = "vim-coffee-script-v002";

     

       169
       169
       -
           src = fetchurl {

     

       170
       170
       -
             url = "https://github.com/vim-scripts/vim-coffee-script/archive/v002.tar.gz";

     

       171
       171
       -
             sha256 = "1xln6i6jbbihcyp5bsdylr2146y41hmp2xf7wi001g2ymj1zdsc0";

     

       172
       172
       -
           };

     

       173
       173
       -
           path = "vim-coffee-script";

     

       190
       190
       +
           buildInputs = [ unzip ];

     

       174
       191
        
         };

     

       175
       192
        
       

     

       176
       176
       -
         command_T = simpleDerivation rec {

     

       193
       193
       +
         command-t = buildVimPlugin rec {

     

       177
       194
        
           version = "1.8";

     

       178
       178
       -
           name = "vim-command-t-${version}";

     

       179
       179
       -
           src = fetchurl {

     

       195
       195
       +
           name = "command-t-${version}";

     

       196
       196
       +
           src = fetchzip {

     

       197
       197
       +
             inherit name;

     

       180
       198
        
             url    = "https://github.com/wincent/Command-T/archive/${version}.tar.gz";

     

       181
       181
       -
             sha256 = "ad8664292e6eee40fbe195d856d20d93a8630e8c0149317ad72cc39423630800";

     

       199
       199
       +
             sha256 = "186qz1smf7w91r68p724whg6d821f7ph6ks63l2vkhff8f9qqhrc";

     

       182
       200
        
           };

     

       183
       183
       -
           path = "Command-T";

     

       184
       201
        
           buildInputs = [ perl ruby ];

     

       185
       202
        
           buildPhase = ''

     

       186
       203
        
             pushd ruby/command-t

     
···

       190
       207
        
           '';

     

       191
       208
        
         };

     

       192
       209
        
       

     

       193
       193
       -
         eighties = simpleDerivation rec {

     

       210
       210
       +
         command_T = command-t; # backwards compat, added 2014-10-18

     

       211
       211
       +
       

     

       212
       212
       +
         commentary = buildVimPlugin {

     

       213
       213
       +
           name = "commentary-git-2014-06-27";

     

       214
       214
       +
           src = fetchgit {

     

       215
       215
       +
             url = "https://github.com/tpope/vim-commentary.git";

     

       216
       216
       +
             rev = "8b4df6ca0ba9cd117d97a8fd26b44b2439d5e3f1";

     

       217
       217
       +
             sha256 = "5496ed31706552957d4caa76669ecd04e9b2853cf7a7e40bd0164726b21fcca0";

     

       218
       218
       +
            };

     

       219
       219
       +
           meta = {

     

       220
       220
       +
             homepage = https://github.com/tpope/vim-commentary; 

     

       221
       221
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       222
       222
       +
           };

     

       223
       223
       +
         };

     

       224
       224
       +
       

     

       225
       225
       +
         ctrlp = buildVimPlugin rec {

     

       226
       226
       +
           version = "1.79";

     

       227
       227
       +
           name    = "ctrlp-${version}";

     

       228
       228
       +
       

     

       229
       229
       +
           setSourceRoot = "sourceRoot=.";

     

       230
       230
       +
           src = fetchurl {

     

       231
       231
       +
             url    = "http://www.vim.org/scripts/download_script.php?src_id=19448";

     

       232
       232
       +
             name   = "ctrlp_180.zip";

     

       233
       233
       +
             sha256 = "1x9im8g0g27mxc3c9k7v0jg5bb1dmnbjygmqif5bizab5g69n2mi";

     

       234
       234
       +
           };

     

       235
       235
       +
       

     

       236
       236
       +
           buildInputs = [ unzip ];

     

       237
       237
       +
         };

     

       238
       238
       +
       

     

       239
       239
       +
         easy-align = buildVimPlugin {

     

       240
       240
       +
           name = "easy-align-git-2014-10-03";

     

       241
       241
       +
           src = fetchgit {

     

       242
       242
       +
             url = "https://github.com/junegunn/vim-easy-align.git";

     

       243
       243
       +
             rev = "2595ebf9333f3598502276b29f78ad39965bc595";

     

       244
       244
       +
             sha256 = "1223b587c515169d4b735bf56f109f7bfc4f7c1327e76865f498309f7472ef78";

     

       245
       245
       +
            };

     

       246
       246
       +
           meta = {

     

       247
       247
       +
             homepage = https://github.com/junegunn/vim-easy-align; 

     

       248
       248
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       249
       249
       +
           };

     

       250
       250
       +
         };

     

       251
       251
       +
       

     

       252
       252
       +
         easymotion = buildVimPlugin {

     

       253
       253
       +
           name = "easymotion-git-2014-09-29";

     

       254
       254
       +
           src = fetchgit {

     

       255
       255
       +
             url = "https://github.com/lokaltog/vim-easymotion.git";

     

       256
       256
       +
             rev = "868cd71710a48e8ec8acffeabd1eebfb10812c77";

     

       257
       257
       +
             sha256 = "13c8b93c257fcbb0f6e0eb197700b4f8cbe4cf4846d29f1aba65f625202b9d77";

     

       258
       258
       +
            };

     

       259
       259
       +
           meta = {

     

       260
       260
       +
             homepage = https://github.com/lokaltog/vim-easymotion; 

     

       261
       261
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       262
       262
       +
           };

     

       263
       263
       +
         };

     

       264
       264
       +
       

     

       265
       265
       +
         eighties = buildVimPlugin rec {

     

       194
       266
        
           version = "1.0.4";

     

       195
       195
       -
           name = "vim-eighties-${version}";

     

       267
       267
       +
           name = "eighties-${version}";

     

       196
       268
        
           src = fetchurl {

     

       197
       269
        
             url    = "https://github.com/justincampbell/vim-eighties/archive/${version}.tar.gz";

     

       198
       270
        
             sha256 = "0cjd9hbg2qd7jjkvyi15f9ysp7m3aa2sg8nvbf80yb890rfkwaqr";

     

       199
       271
        
           };

     

       200
       200
       -
           path = "eighties";

     

       201
       272
        
           meta = with stdenv.lib; {

     

       202
       273
        
             description = "Automatically resizes your windows to 80 characters";

     

       203
       274
        
             homepage    = https://github.com/justincampbell/vim-eighties;

     
···

       207
       278
        
           };

     

       208
       279
        
         };

     

       209
       280
        
       

     

       210
       210
       -
         golang = simpleDerivation {

     

       211
       211
       -
           name = "vim-golang-20131127";

     

       281
       281
       +
         extradite = buildVimPlugin {

     

       282
       282
       +
           name = "extradite-git-2014-06-18";

     

       212
       283
        
           src = fetchgit {

     

       213
       213
       -
             url = "https://github.com/jnwhiteh/vim-golang.git";

     

       214
       214
       -
             rev = "832d64e5a813511ed52217aa24f0255c49671bab";

     

       215
       215
       -
             sha256 = "6858eb674be132477c5dc7f7d3cbe550371f90d1aba480547a614965412a7b3c";

     

       216
       216
       -
           };

     

       217
       217
       -
           path = "golang";

     

       218
       218
       -
           meta = with stdenv.lib; {

     

       219
       219
       -
             description = "Vim plugins for Go";

     

       220
       220
       -
             homepage    = https://github.com/jnwhiteh/vim-golang;

     

       221
       221
       -
             license     = licenses.publicDomain;

     

       222
       222
       -
             maintainers = with maintainers; [ lovek323 ];

     

       223
       223
       -
             platforms   = platforms.unix;

     

       284
       284
       +
             url = "https://github.com/int3/vim-extradite.git";

     

       285
       285
       +
             rev = "af4f3a51b6b654d655121b93c0cd9d8fe9a0c85d";

     

       286
       286
       +
             sha256 = "d1d29cfbc654134be383747f2cd6b14b7a87de75f997af6a041f14d7ef61ade6";

     

       287
       287
       +
            };

     

       288
       288
       +
           meta = {

     

       289
       289
       +
             homepage = https://github.com/int3/vim-extradite; 

     

       290
       290
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       224
       291
        
           };

     

       225
       292
        
         };

     

       226
       293
        
       

     

       227
       227
       -
         ipython = simpleDerivation {

     

       228
       228
       -
           name = "vim-ipython-ff8f88f3fe518851a91dc88aaa5a75f8f352a960";

     

       229
       229
       -
           src = fetchurl {

     

       230
       230
       -
             url    = "https://github.com/ivanov/vim-ipython/archive/ff8f88f3fe518851a91dc88aaa5a75f8f352a960.tar.gz";

     

       231
       231
       -
             sha256 = "0hlx526dm8amrvh41kwnmgvvdzs6sh5yc5sfq4nk1zjkfcp1ah5j";

     

       232
       232
       -
           };

     

       233
       233
       -
           path = "ipython";

     

       234
       234
       -
           meta = with stdenv.lib; {

     

       235
       235
       -
             description = "A two-way integration between vim and iPython";

     

       236
       236
       -
             homepage    = https://github.com/ivanov/vim-ipython;

     

       237
       237
       -
             repositories.git = https://github.com/ivanov/vim-ipython.git;

     

       238
       238
       -
             license     = licenses.publicDomain;

     

       239
       239
       -
             maintainers = with maintainers; [ lovek323 ];

     

       240
       240
       -
             platforms   = platforms.unix;

     

       294
       294
       +
         fugitive = buildVimPlugin {

     

       295
       295
       +
           name = "fugitive-git-2014-09-02";

     

       296
       296
       +
           src = fetchgit {

     

       297
       297
       +
             url = "https://github.com/tpope/vim-fugitive.git";

     

       298
       298
       +
             rev = "0374322ba5d85ae44dd9dc44ef31ca015a59097e";

     

       299
       299
       +
             sha256 = "3bb09693726c4f9fc1695bc8b40c45d64a6a0f1d9a4243b4a79add841013ad6c";

     

       300
       300
       +
            };

     

       301
       301
       +
           meta = {

     

       302
       302
       +
             homepage = https://github.com/tpope/vim-fugitive; 

     

       303
       303
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       241
       304
        
           };

     

       242
       305
        
         };

     

       243
       306
        
       

     

       244
       244
       -
         taglist = simpleDerivation {

     

       245
       245
       -
           name = "vim-taglist-4.6";

     

       246
       246
       -
           meta = with stdenv.lib; {

     

       247
       247
       -
             description = "Source code browser plugin";

     

       248
       248
       -
             homepage    = "http://www.vim.org/scripts/script.php?script_id=273";

     

       249
       249
       -
             license     = licenses.gpl3;

     

       250
       250
       -
             maintainers = with maintainers; [ lovek323 ];

     

       251
       251
       -
             platforms   = platforms.unix;

     

       307
       307
       +
         ghcmod-vim = buildVimPlugin {

     

       308
       308
       +
           name = "ghcmod-vim-git-2014-10-19";

     

       309
       309
       +
           src = fetchgit {

     

       310
       310
       +
             url = "https://github.com/eagletmt/ghcmod-vim.git";

     

       311
       311
       +
             rev = "d5c6c7f3c85608b5b76dc3e7e001f60b86c32cb9";

     

       312
       312
       +
             sha256 = "ab56d470ea18da3fae021e22bba14460505e61a94f8bf707778dff5eec51cd6d";

     

       313
       313
       +
            };

     

       314
       314
       +
           meta = {

     

       315
       315
       +
             homepage = https://github.com/eagletmt/ghcmod-vim; 

     

       316
       316
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       252
       317
        
           };

     

       253
       253
       -
           src = fetchurl {

     

       254
       254
       -
             url    = "http://www.vim.org/scripts/download_script.php?src_id=19574";

     

       255
       255
       -
             name   = "taglist_46.zip";

     

       256
       256
       -
             sha256 = "18cbv462vwg7vip2p99qlahm99hswav96cj4ki227kyi05q2lkjj";

     

       318
       318
       +
         };

     

       319
       319
       +
       

     

       320
       320
       +
         gist-vim = buildVimPlugin {

     

       321
       321
       +
           name = "gist-vim-git-2014-10-19";

     

       322
       322
       +
           src = fetchgit {

     

       323
       323
       +
             url = "https://github.com/mattn/gist-vim.git";

     

       324
       324
       +
             rev = "9265aaa3fb3f090a292c3fb883eab4cea9d2a722";

     

       325
       325
       +
             sha256 = "2a1b6c589a60af7acd68f7686d1cbadc60a1da8a407b02d96f86ddfe8bc70c18";

     

       326
       326
       +
            };

     

       327
       327
       +
           buildInputs = [ zip ];

     

       328
       328
       +
           meta = {

     

       329
       329
       +
             homepage = https://github.com/mattn/gist-vim; 

     

       330
       330
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       257
       331
        
           };

     

       258
       258
       -
           setSourceRoot = ''

     

       259
       259
       -
             export sourceRoot=taglist

     

       260
       260
       -
             mkdir taglist

     

       261
       261
       -
             mv doc taglist

     

       262
       262
       -
             mv plugin taglist

     

       263
       263
       -
           '';

     

       264
       264
       -
           buildInputs = [ unzip ];

     

       265
       265
       -
           path = "taglist";

     

       266
       332
        
         };

     

       267
       333
        
       

     

       268
       268
       -
         tagbar = simpleDerivation rec {

     

       269
       269
       -
           version = "2.6.1";

     

       270
       270
       -
           name    = "vim-tagbar-${version}";

     

       334
       334
       +
         gitgutter = buildVimPlugin {

     

       335
       335
       +
           name = "gitgutter-git-2014-10-17";

     

       336
       336
       +
           src = fetchgit {

     

       337
       337
       +
             url = "https://github.com/airblade/vim-gitgutter.git";

     

       338
       338
       +
             rev = "39f011909620e0c7ae555efdace20c3963ac88af";

     

       339
       339
       +
             sha256 = "585c367c8cf72d7ef511b3beca3d1eae1d68bbd61b9a8d4dc7aea6e0caa4813a";

     

       340
       340
       +
            };

     

       341
       341
       +
           meta = {

     

       342
       342
       +
             homepage = https://github.com/airblade/vim-gitgutter; 

     

       343
       343
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       344
       344
       +
           };

     

       345
       345
       +
         };

     

       271
       346
        
       

     

       272
       272
       -
           meta = with stdenv.lib; {

     

       273
       273
       -
             description = "A vim plugin for browsing the tags of source code files";

     

       274
       274
       -
             homepage    = https://github.com/majutsushi/tagbar;

     

       275
       275
       -
             license     = licenses.gpl3;

     

       276
       276
       -
             maintainers = with maintainers; [ lovek323 ];

     

       277
       277
       -
             platforms   = platforms.unix;

     

       347
       347
       +
         golang = buildVimPlugin {

     

       348
       348
       +
           name = "golang-git-2014-08-06";

     

       349
       349
       +
           src = fetchgit {

     

       350
       350
       +
             url = "https://github.com/jnwhiteh/vim-golang.git";

     

       351
       351
       +
             rev = "e6d0c6a72a66af2674b96233c4747661e0f47a8c";

     

       352
       352
       +
             sha256 = "1231a2eff780dbff4f885fcb4f656f7dd70597e1037ca800470de03bf0c5e7af";

     

       353
       353
       +
            };

     

       354
       354
       +
           meta = {

     

       355
       355
       +
             homepage = https://github.com/jnwhiteh/vim-golang; 

     

       356
       356
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       278
       357
        
           };

     

       358
       358
       +
         };

     

       279
       359
        
       

     

       280
       280
       -
           src = fetchurl {

     

       281
       281
       -
             url    = "https://github.com/majutsushi/tagbar/archive/v${version}.tar.gz";

     

       282
       282
       -
             sha256 = "c061a7e0a45a166f4558b31e6c47b9fd701f5fa1319527b65a268ea054dea5fb";

     

       360
       360
       +
         gundo = buildVimPlugin {

     

       361
       361
       +
           name = "gundo-git-2013-08-11";

     

       362
       362
       +
           src = fetchgit {

     

       363
       363
       +
             url = "https://github.com/vim-scripts/gundo.git";

     

       364
       364
       +
             rev = "f443470b96364c24a775629418a6b2562ec9173e";

     

       365
       365
       +
             sha256 = "b7a949167e59c936d6eae0d23635b87491b2cd2f46a197683b171d30165a90f9";

     

       366
       366
       +
            };

     

       367
       367
       +
           meta = {

     

       368
       368
       +
             homepage = https://github.com/vim-scripts/gundo; 

     

       369
       369
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       283
       370
        
           };

     

       371
       371
       +
         };

     

       284
       372
        
       

     

       285
       285
       -
           path = "tagbar";

     

       373
       373
       +
         hardtime = buildVimPlugin {

     

       374
       374
       +
           name = "hardtime-git-2014-10-21";

     

       375
       375
       +
           src = fetchgit {

     

       376
       376
       +
             url = "https://github.com/takac/vim-hardtime.git";

     

       377
       377
       +
             rev = "b401c72528d1c23e4cc9bc9585fda4361d0199bf";

     

       378
       378
       +
             sha256 = "65e4bda7531076147fc46f496c8e56c740d1fcf8fe85c18cb2d2070d0c3803cd";

     

       379
       379
       +
            };

     

       380
       380
       +
           meta = {

     

       381
       381
       +
             homepage = https://github.com/takac/vim-hardtime; 

     

       382
       382
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       383
       383
       +
           };

     

       286
       384
        
         };

     

       287
       385
        
       

     

       288
       288
       -
         xdebug = simpleDerivation {

     

       289
       289
       -
           name = "vim-xdebug-a4980fa65f7f159780593ee37c178281691ba2c4";

     

       290
       290
       -
           src = fetchurl {

     

       291
       291
       -
             url = "https://github.com/joonty/vim-xdebug/archive/a4980fa65f7f159780593ee37c178281691ba2c4.tar.gz";

     

       292
       292
       -
             sha256 = "1348gzp0zhc2wifvs5vmf92m9y8ik8ldnvy7bawsxahy8hmhiksk";

     

       386
       386
       +
         haskellconceal = buildVimPlugin {

     

       387
       387
       +
           name = "haskellconceal-git-2014-08-07";

     

       388
       388
       +
           src = fetchgit {

     

       389
       389
       +
             url = "https://github.com/twinside/vim-haskellconceal.git";

     

       390
       390
       +
             rev = "1d85e8f10b675d38ec117368ec8032f486c27f98";

     

       391
       391
       +
             sha256 = "8ae762939ea435333031a094f3c63e6edd534ac849f0008fa0440440f1f2f633";

     

       392
       392
       +
            };

     

       393
       393
       +
           meta = {

     

       394
       394
       +
             homepage = https://github.com/twinside/vim-haskellconceal; 

     

       395
       395
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       293
       396
        
           };

     

       294
       294
       -
           path = "xdebug";

     

       295
       295
       -
           postInstall = false;

     

       296
       397
        
         };

     

       297
       398
        
       

     

       298
       298
       -
         vimshell = simpleDerivation rec {

     

       299
       299
       -
           version = "9.2";

     

       300
       300
       -
           name = "vimshell-${version}";

     

       399
       399
       +
         haskellConceal = haskellconceal; # backwards compat, added 2014-10-18

     

       301
       400
        
       

     

       302
       302
       -
           meta = with stdenv.lib; {

     

       303
       303
       -
             description = "An extreme shell that doesn't depend on external shells and is written completely in Vim script";

     

       304
       304
       -
             homepage    = https://github.com/Shougo/vimshell.vim;

     

       305
       305
       -
             repositories.git = https://github.com/Shougo/vimshell.vim.git;

     

       306
       306
       -
             license     = licenses.gpl3;

     

       307
       307
       -
             maintainers = with maintainers; [ lovek323 ];

     

       308
       308
       -
             platforms   = platforms.unix;

     

       401
       401
       +
         hasksyn = buildVimPlugin {

     

       402
       402
       +
           name = "hasksyn-git-2014-09-03";

     

       403
       403
       +
           src = fetchgit {

     

       404
       404
       +
             url = "https://github.com/travitch/hasksyn.git";

     

       405
       405
       +
             rev = "c434040bf13a17ca20a551223021b3ace7e453b9";

     

       406
       406
       +
             sha256 = "b1a735928aeca7011b83133959d59b9c95ab8535fd00ce9968fae4c3b1381931";

     

       407
       407
       +
            };

     

       408
       408
       +
           meta = {

     

       409
       409
       +
             homepage = https://github.com/travitch/hasksyn; 

     

       410
       410
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       309
       411
        
           };

     

       412
       412
       +
         };

     

       310
       413
        
       

     

       311
       311
       -
           src = fetchurl {

     

       312
       312
       -
             url    = "https://github.com/Shougo/vimshell.vim/archive/ver.${version}.tar.gz";

     

       313
       313
       -
             sha256 = "1pbwxdhpv6pr09b6hwkgy7grpmpwlqpsgsawl38r40q6yib8zb4a";

     

       414
       414
       +
         hdevtools = buildVimPlugin {

     

       415
       415
       +
           name = "hdevtools-git-2012-12-29";

     

       416
       416
       +
           src = fetchgit {

     

       417
       417
       +
             url = "https://github.com/bitc/vim-hdevtools.git";

     

       418
       418
       +
             rev = "474947c52ff9c93dd36f3c49de90bd9a78f0baa1";

     

       419
       419
       +
             sha256 = "bf5f096b665c51ce611c6c1bfddc3267c4b2f94af84b04482b07272a6a5a92f3";

     

       420
       420
       +
            };

     

       421
       421
       +
           meta = {

     

       422
       422
       +
             homepage = https://github.com/bitc/vim-hdevtools; 

     

       423
       423
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       314
       424
        
           };

     

       425
       425
       +
         };

     

       315
       426
        
       

     

       316
       316
       -
           buildInputs = [ vimproc ];

     

       427
       427
       +
         hier = buildVimPlugin {

     

       428
       428
       +
           name = "hier-git-2011-08-27";

     

       429
       429
       +
           src = fetchgit {

     

       430
       430
       +
             url = "https://github.com/jceb/vim-hier.git";

     

       431
       431
       +
             rev = "0b8c365263551a67404ebd7e528c55e17c1d3de7";

     

       432
       432
       +
             sha256 = "f62836545abfe379f9c5410da28409947407cd282ef784b2db89aed0756a1785";

     

       433
       433
       +
            };

     

       434
       434
       +
           buildInputs = [ vim ];

     

       435
       435
       +
           meta = {

     

       436
       436
       +
             homepage = https://github.com/jceb/vim-hier; 

     

       437
       437
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       438
       438
       +
           };

     

       439
       439
       +
         };

     

       317
       440
        
       

     

       318
       318
       -
           preBuild = ''

     

       319
       319
       -
             sed -ie '1 i\

     

       320
       320
       -
             set runtimepath+=${vimproc}/share/vim-plugins/vimproc\

     

       321
       321
       -
             ' autoload/vimshell.vim

     

       322
       322
       -
           '';

     

       323
       441
        
       

     

       324
       324
       -
           path = "vimshell";

     

       442
       442
       +
         hoogle = buildVimPlugin {

     

       443
       443
       +
           name = "hoogle-git-2013-11-26";

     

       444
       444
       +
           src = fetchgit {

     

       445
       445
       +
             url = "https://github.com/twinside/vim-hoogle.git";

     

       446
       446
       +
             rev = "81f28318b0d4174984c33df99db7752891c5c4e9";

     

       447
       447
       +
             sha256 = "0f96f3badb6218cac87d0f7027ff032ecc74f08ad3ada542898278ce11cbd5a0";

     

       448
       448
       +
            };

     

       449
       449
       +
           meta = {

     

       450
       450
       +
             homepage = https://github.com/twinside/vim-hoogle; 

     

       451
       451
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       452
       452
       +
           };

     

       325
       453
        
         };

     

       326
       454
        
       

     

       327
       327
       -
         vimproc = simpleDerivation rec {

     

       328
       328
       -
           version = "21a79bf4edca3ae97555df3fc729d208c7e19b9c";

     

       329
       329
       -
           name    = "vimproc-${version}";

     

       455
       455
       +
         idris-vim = buildVimPlugin {

     

       456
       456
       +
           name = "idris-vim-git-2014-10-14";

     

       457
       457
       +
           src = fetchgit {

     

       458
       458
       +
             url = "https://github.com/idris-hackers/idris-vim.git";

     

       459
       459
       +
             rev = "78730e511cae0a067f79da1168466601553f619b";

     

       460
       460
       +
             sha256 = "47638b25fa53203e053e27ec6f135fd63ae640edbe37e62d7450a8c434a4cc6b";

     

       461
       461
       +
            };

     

       462
       462
       +
           meta = {

     

       463
       463
       +
             homepage = https://github.com/idris-hackers/idris-vim; 

     

       464
       464
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       465
       465
       +
           };

     

       466
       466
       +
         };

     

       330
       467
        
       

     

       331
       331
       -
           meta = with stdenv.lib; {

     

       332
       332
       -
             description = "An asynchronous execution library for Vim";

     

       333
       333
       -
             homepage    = https://github.com/Shougo/vimproc.vim;

     

       334
       334
       -
             repositories.git = https://github.com/Shougo/vimproc.vim.git;

     

       335
       335
       -
             license     = licenses.gpl3;

     

       336
       336
       -
             maintainers = with maintainers; [ lovek323 ];

     

       337
       337
       -
             platforms   = platforms.unix;

     

       468
       468
       +
         ipython = buildVimPlugin {

     

       469
       469
       +
           name = "ipython-git-2014-07-17";

     

       470
       470
       +
           src = fetchgit {

     

       471
       471
       +
             url = "https://github.com/ivanov/vim-ipython.git";

     

       472
       472
       +
             rev = "9ce4f201ce26e9f01d56a6040ddf9255aab27272";

     

       473
       473
       +
             sha256 = "444dede544f9b519143ecc3a6cdfef0c4c32043fc3cd69f92fdcd86c1010e824";

     

       474
       474
       +
            };

     

       475
       475
       +
           meta = {

     

       476
       476
       +
             homepage = https://github.com/ivanov/vim-ipython; 

     

       477
       477
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       338
       478
        
           };

     

       479
       479
       +
         };

     

       339
       480
        
       

     

       481
       481
       +
         latex-box = buildVimPlugin {

     

       482
       482
       +
           name = "latex-box-git-2014-10-05";

     

       340
       483
        
           src = fetchgit {

     

       341
       341
       -
             url = "https://github.com/Shougo/vimproc.vim.git";

     

       342
       342
       -
             rev = "${version}";

     

       343
       343
       -
             sha256 = "16mlrhmd1hq4rgg7bl9gajhb4nmn1x8jxfaxfwiy2bm1phgljgq0";

     

       484
       484
       +
             url = "https://github.com/latex-box-team/latex-box.git";

     

       485
       485
       +
             rev = "3e000fb161bdf6efe7aef517aef276554aeabb65";

     

       486
       486
       +
             sha256 = "462803aceec5904943074e11888482ef6c49c8a5e26d6728ebcb2c4f5dbbb6a4";

     

       344
       487
        
            };

     

       488
       488
       +
           meta = {

     

       489
       489
       +
             homepage = https://github.com/latex-box-team/latex-box; 

     

       490
       490
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       491
       491
       +
           };

     

       492
       492
       +
         };

     

       345
       493
        
       

     

       346
       346
       -
           buildInputs = [ which ];

     

       494
       494
       +
         latex-live-preview = buildVimPlugin {

     

       495
       495
       +
           name = "latex-live-preview-git-2013-11-25";

     

       496
       496
       +
           src = fetchgit {

     

       497
       497
       +
             url = "https://github.com/xuhdev/vim-latex-live-preview.git";

     

       498
       498
       +
             rev = "18625ceca4de5984f3df50cdd0202fc13eb9e37c";

     

       499
       499
       +
             sha256 = "261852d3830189a50176f997a4c6b4ec7e25893c5b7842a3eb57eb7771158722";

     

       500
       500
       +
            };

     

       501
       501
       +
           meta = {

     

       502
       502
       +
             homepage = https://github.com/xuhdev/vim-latex-live-preview; 

     

       503
       503
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       504
       504
       +
           };

     

       505
       505
       +
         };

     

       347
       506
        
       

     

       348
       348
       -
           buildPhase = ''

     

       349
       349
       -
             sed -i 's/vimproc_mac\.so/vimproc_unix\.so/' autoload/vimproc.vim

     

       350
       350
       -
             make -f make_unix.mak

     

       351
       351
       -
           '';

     

       507
       507
       +
         lushtags = buildVimPlugin {

     

       508
       508
       +
           name = "lushtags-git-2013-12-27";

     

       509
       509
       +
           src = fetchgit {

     

       510
       510
       +
             url = "https://github.com/bitc/lushtags.git";

     

       511
       511
       +
             rev = "429fab3b748ae04ee5de0cbf75d947f15441e798";

     

       512
       512
       +
             sha256 = "5170019fbe64b15be30a0ba82e6b01364d115ccad6ef690a6df86f73af22a0a7";

     

       513
       513
       +
            };

     

       514
       514
       +
           meta = {

     

       515
       515
       +
             homepage = https://github.com/bitc/lushtags; 

     

       516
       516
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       517
       517
       +
           };

     

       518
       518
       +
         };

     

       352
       519
        
       

     

       353
       353
       -
           path = "vimproc";

     

       520
       520
       +
         neco-ghc = buildVimPlugin {

     

       521
       521
       +
           name = "neco-ghc-git-2014-10-17";

     

       522
       522
       +
           src = fetchgit {

     

       523
       523
       +
             url = "https://github.com/eagletmt/neco-ghc.git";

     

       524
       524
       +
             rev = "fffdf57dcb312f874a43a202157b5efecfe3d9de";

     

       525
       525
       +
             sha256 = "464b24e3151ebaf0e95c25f09cb047e2542d5dd9100087e538d0a5e46bd0e638";

     

       526
       526
       +
            };

     

       527
       527
       +
           meta = {

     

       528
       528
       +
             homepage = https://github.com/eagletmt/neco-ghc; 

     

       529
       529
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       530
       530
       +
           };

     

       354
       531
        
         };

     

       355
       532
        
       

     

       356
       356
       -
         colorsamplerpack = simpleDerivation rec {

     

       357
       357
       -
           version = "2012.10.28";

     

       358
       358
       -
           name    = "vim-colorsamplerpack-${version}";

     

       533
       533
       +
         necoGhc = neco-ghc; # backwards compat, added 2014-10-18

     

       359
       534
        
       

     

       360
       360
       -
           setSourceRoot = "sourceRoot=.";

     

       361
       361
       -
           src = fetchurl {

     

       362
       362
       -
             url    = "http://www.vim.org/scripts/download_script.php?src_id=18915";

     

       363
       363
       -
             name   = "colorsamplerpack.zip";

     

       364
       364
       -
             sha256 = "1wsrb3vpqn9fncnalfpvc8r92wk1mcskm4shb3s2h9x5dyihf2rd";

     

       535
       535
       +
         nerdcommenter = buildVimPlugin {

     

       536
       536
       +
           name = "nerdcommenter-git-2014-07-08";

     

       537
       537
       +
           src = fetchgit {

     

       538
       538
       +
             url = "https://github.com/scrooloose/nerdcommenter.git";

     

       539
       539
       +
             rev = "6549cfde45339bd4f711504196ff3e8b766ef5e6";

     

       540
       540
       +
             sha256 = "ef270ae5617237d68b3d618068e758af8ffd8d3ba27a3799149f7a106cfd178e";

     

       541
       541
       +
            };

     

       542
       542
       +
           meta = {

     

       543
       543
       +
             homepage = https://github.com/scrooloose/nerdcommenter; 

     

       544
       544
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       365
       545
        
           };

     

       546
       546
       +
         };

     

       366
       547
        
       

     

       367
       367
       -
           buildInputs = [ unzip ];

     

       548
       548
       +
         nerdtree = buildVimPlugin {

     

       549
       549
       +
           name = "nerdtree-git-2014-08-06";

     

       550
       550
       +
           src = fetchgit {

     

       551
       551
       +
             url = "https://github.com/scrooloose/nerdtree.git";

     

       552
       552
       +
             rev = "4f1e6ecb057fc0bac189171c1430d71ef25f6bb1";

     

       553
       553
       +
             sha256 = "67ff2e7b9a7f39e58e9e334b1b79343a4c11aae10a657ab4fece289d8fe59300";

     

       554
       554
       +
            };

     

       555
       555
       +
           meta = {

     

       556
       556
       +
             homepage = https://github.com/scrooloose/nerdtree; 

     

       557
       557
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       558
       558
       +
           };

     

       559
       559
       +
         };

     

       368
       560
        
       

     

       369
       369
       -
           path = "colorsamplerpack";

     

       561
       561
       +
         pathogen = buildVimPlugin {

     

       562
       562
       +
           name = "pathogen-git-2014-07-19";

     

       563
       563
       +
           src = fetchgit {

     

       564
       564
       +
             url = "https://github.com/tpope/vim-pathogen.git";

     

       565
       565
       +
             rev = "91e6378908721d20514bbe5d18d292a0a15faf0c";

     

       566
       566
       +
             sha256 = "24c1897d6b58576b2189c90050a7f8ede72a51343c752e9d030e833dbe5cac6f";

     

       567
       567
       +
            };

     

       568
       568
       +
           meta = {

     

       569
       569
       +
             homepage = https://github.com/tpope/vim-pathogen; 

     

       570
       570
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       571
       571
       +
           };

     

       370
       572
        
         };

     

       371
       573
        
       

     

       372
       372
       -
         yankring = simpleDerivation rec {

     

       373
       373
       -
           version = "18.0";

     

       374
       374
       -
           name    = "vim-yankring-${version}";

     

       574
       574
       +
         quickfixstatus = buildVimPlugin {

     

       575
       575
       +
           name = "quickfixstatus-git-2011-09-02";

     

       576
       576
       +
           src = fetchgit {

     

       577
       577
       +
             url = "https://github.com/dannyob/quickfixstatus.git";

     

       578
       578
       +
             rev = "fd3875b914fc51bbefefa8c4995588c088163053";

     

       579
       579
       +
             sha256 = "7b6831d5da1c23d95f3158c67e4376d32c2f62ab2e30d02d3f3e14dcfd867d9b";

     

       580
       580
       +
            };

     

       581
       581
       +
           meta = {

     

       582
       582
       +
             homepage = https://github.com/dannyob/quickfixstatus; 

     

       583
       583
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       584
       584
       +
           };

     

       585
       585
       +
         };

     

       375
       586
        
       

     

       376
       376
       -
           setSourceRoot = "sourceRoot=.";

     

       377
       377
       -
           src = fetchurl {

     

       378
       378
       -
             url    = "http://www.vim.org/scripts/download_script.php?src_id=20842";

     

       379
       379
       -
             name   = "yankring_180.zip";

     

       380
       380
       -
             sha256 = "0bsq4pxagy12jqxzs7gcf25k5ahwif13ayb9k8clyhm0jjdkf0la";

     

       587
       587
       +
         quickrun = buildVimPlugin {

     

       588
       588
       +
           name = "quickrun-git-2014-10-08";

     

       589
       589
       +
           src = fetchgit {

     

       590
       590
       +
             url = "https://github.com/thinca/vim-quickrun.git";

     

       591
       591
       +
             rev = "ae97cef42ae142306e9431dce9ab97c4353e5254";

     

       592
       592
       +
             sha256 = "3219fadb3732c895c82b8bcff1d6e86f0917cd5ac7bf34180c27bb3f75ed1787";

     

       593
       593
       +
            };

     

       594
       594
       +
           meta = {

     

       595
       595
       +
             homepage = https://github.com/thinca/vim-quickrun; 

     

       596
       596
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       381
       597
        
           };

     

       598
       598
       +
         };

     

       382
       599
        
       

     

       383
       383
       -
           buildInputs = [ unzip ];

     

       384
       600
        
       

     

       385
       385
       -
           path = "yankring";

     

       601
       601
       +
         rainbow_parentheses = buildVimPlugin {

     

       602
       602
       +
           name = "rainbow_parentheses-git-2013-03-04";

     

       603
       603
       +
           src = fetchgit {

     

       604
       604
       +
             url = "https://github.com/kien/rainbow_parentheses.vim.git";

     

       605
       605
       +
             rev = "eb8baa5428bde10ecc1cb14eed1d6e16f5f24695";

     

       606
       606
       +
             sha256 = "47975a426d06f41811882691d8a51f32bc72f590477ed52b298660486b2488e3";

     

       607
       607
       +
            };

     

       608
       608
       +
           meta = {

     

       609
       609
       +
             homepage = https://github.com/kien/rainbow_parentheses.vim; 

     

       610
       610
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       611
       611
       +
           };

     

       386
       612
        
         };

     

       387
       613
        
       

     

       388
       388
       -
         ctrlp = simpleDerivation rec {

     

       389
       389
       -
           version = "1.79";

     

       390
       390
       -
           name    = "vim-ctrlp-${version}";

     

       614
       614
       +
         rust = buildVimPlugin {

     

       615
       615
       +
           name = "rust-git-2014-10-15";

     

       616
       616
       +
           src = fetchgit {

     

       617
       617
       +
             url = "https://github.com/wting/rust.vim.git";

     

       618
       618
       +
             rev = "aaeb7b51f1b188fb1edc29c3a3824053b3e5e265";

     

       619
       619
       +
             sha256 = "be858b1e2cb0b37091a3d79a51e264b3101229b007cfc16bcd28c740f3823c01";

     

       620
       620
       +
            };

     

       621
       621
       +
           meta = {

     

       622
       622
       +
             homepage = https://github.com/wting/rust.vim; 

     

       623
       623
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       624
       624
       +
           };

     

       625
       625
       +
         };

     

       391
       626
        
       

     

       392
       392
       -
           setSourceRoot = "sourceRoot=.";

     

       393
       393
       -
           src = fetchurl {

     

       394
       394
       -
             url    = "http://www.vim.org/scripts/download_script.php?src_id=19448";

     

       395
       395
       -
             name   = "ctrlp_180.zip";

     

       396
       396
       -
             sha256 = "1x9im8g0g27mxc3c9k7v0jg5bb1dmnbjygmqif5bizab5g69n2mi";

     

       627
       627
       +
         shabadou = buildVimPlugin {

     

       628
       628
       +
           name = "shabadou-git-2014-07-27";

     

       629
       629
       +
           src = fetchgit {

     

       630
       630
       +
             url = "https://github.com/osyo-manga/shabadou.vim.git";

     

       631
       631
       +
             rev = "c5af30bb0c028d53cfd89e00cab636c844034a9a";

     

       632
       632
       +
             sha256 = "392efa8a5e725219e478b571d9a30ddba88d47662467ed3123a168e8b55c4de6";

     

       633
       633
       +
            };

     

       634
       634
       +
           meta = {

     

       635
       635
       +
             homepage = https://github.com/osyo-manga/shabadou.vim; 

     

       636
       636
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       397
       637
        
           };

     

       638
       638
       +
         };

     

       398
       639
        
       

     

       399
       399
       -
           buildInputs = [ unzip ];

     

       400
       400
       -
       

     

       401
       401
       -
           path = "ctrlp";

     

       640
       640
       +
         stylish-haskell = buildVimPlugin {

     

       641
       641
       +
           name = "stylish-haskell-git-2014-07-14";

     

       642
       642
       +
           src = fetchgit {

     

       643
       643
       +
             url = "https://github.com/nbouscal/vim-stylish-haskell.git";

     

       644
       644
       +
             rev = "453fd203aee3d7305ea8e4088ff53bd1f5933d75";

     

       645
       645
       +
             sha256 = "c0e5010e1e8e56b179ce500387afb569f051c45b37ce92feb4350f293df96a8c";

     

       646
       646
       +
            };

     

       647
       647
       +
           meta = {

     

       648
       648
       +
             homepage = https://github.com/nbouscal/vim-stylish-haskell; 

     

       649
       649
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       650
       650
       +
           };

     

       402
       651
        
         };

     

       403
       652
        
       

     

       404
       404
       -
         alternate = stdenv.mkDerivation rec {

     

       405
       405
       -
           version = "2.18";

     

       406
       406
       -
           name    = "vim-a-${version}";

     

       653
       653
       +
         stylishHaskell = stylish-haskell; # backwards compat, added 2014-10-18

     

       407
       654
        
       

     

       408
       408
       -
           src = fetchurl {

     

       409
       409
       -
             url    = "http://www.vim.org/scripts/download_script.php?src_id=7218";

     

       410
       410
       -
             name   = "a.vim";

     

       411
       411
       -
             sha256 = "1q22vfkv60sshp9yj3mmfc8azavgzz7rpmaf72iznzq4wccy6gac";

     

       655
       655
       +
         supertab = buildVimPlugin {

     

       656
       656
       +
           name = "supertab-git-2014-10-17";

     

       657
       657
       +
           src = fetchgit {

     

       658
       658
       +
             url = "https://github.com/ervandew/supertab.git";

     

       659
       659
       +
             rev = "fd4e0d06c2b1d9bff2eef1d15e7895b3b4da7cd7";

     

       660
       660
       +
             sha256 = "5919521b95519d4baa8ed146c340ca739fa7f31dfd305c74ca0ace324ba93d74";

     

       661
       661
       +
            };

     

       662
       662
       +
           buildInputs = [ vim ];

     

       663
       663
       +
           meta = {

     

       664
       664
       +
             homepage = https://github.com/ervandew/supertab; 

     

       665
       665
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       412
       666
        
           };

     

       413
       413
       -
           unpackPhase = ":";

     

       414
       414
       -
           installPhase = ''

     

       415
       415
       -
             mkdir -p $out/share/vim-plugins/vim-a

     

       416
       416
       -
             cp ${src} $out/share/vim-plugins/vim-a/a.vim

     

       417
       417
       -
           '';

     

       418
       667
        
         };

     

       419
       668
        
       

     

       420
       420
       -
         vundle = simpleDerivation {

     

       421
       421
       -
           name = "vundle-vim-git-0b28e334";

     

       669
       669
       +
         surround = buildVimPlugin {

     

       670
       670
       +
           name = "surround-git-2014-07-26";

     

       422
       671
        
           src = fetchgit {

     

       423
       423
       -
             url = "https://github.com/gmarik/Vundle.vim.git";

     

       424
       424
       -
             rev = "0b28e334e65b6628b0a61c412fcb45204a2f2bab";

     

       425
       425
       -
             sha256 = "9681d471d1391626cb9ad22b2b469003d9980cd23c5c3a8d34666376447e6204";

     

       672
       672
       +
             url = "https://github.com/tpope/vim-surround.git";

     

       673
       673
       +
             rev = "fa433e0b7330753688f715f3be5d10dc480f20e5";

     

       674
       674
       +
             sha256 = "5f01daf72d23fc065f4e4e8eac734275474f32bfa276a9d90ce0d20dfe24058d";

     

       426
       675
        
            };

     

       427
       427
       -
           path = "vundle";

     

       676
       676
       +
           meta = {

     

       677
       677
       +
             homepage = https://github.com/tpope/vim-surround; 

     

       678
       678
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       679
       679
       +
           };

     

       428
       680
        
         };

     

       429
       681
        
       

     

       430
       430
       -
         tslime = simpleDerivation {

     

       431
       431
       -
           name = "tslime-vim-git-e801a32b";

     

       682
       682
       +
         signature = buildVimPlugin {

     

       683
       683
       +
           name = "signature-git-2014-10-17";

     

       432
       684
        
           src = fetchgit {

     

       433
       433
       -
             url = "https://github.com/jgdavey/tslime.vim.git";

     

       434
       434
       -
             rev = "e801a32b27d83cb5d91afbf7c3d71bb6220f32bd";

     

       435
       435
       -
             sha256 = "47fb7165c1dcc444285cdff6fa89bbd4ace82ca79ec14ba0da6091c5f78d1251";

     

       685
       685
       +
             url = "https://github.com/kshenoy/vim-signature.git";

     

       686
       686
       +
             rev = "f012d6f4d288ef6006f61b06f5240bc461a1f89e";

     

       687
       687
       +
             sha256 = "bef5254e343758d609856c745fe9d83639546f3af4ca50542429c1cb91ab577a";

     

       436
       688
        
            };

     

       437
       437
       -
           path = "tslime";

     

       689
       689
       +
           meta = {

     

       690
       690
       +
             homepage = https://github.com/kshenoy/vim-signature; 

     

       691
       691
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       692
       692
       +
           };

     

       438
       693
        
         };

     

       439
       694
        
       

     

       440
       440
       -
         supertab = simpleDerivation {

     

       441
       441
       -
           name = "supertab-git-23db5585";

     

       695
       695
       +
         syntastic = buildVimPlugin {

     

       696
       696
       +
           name = "syntastic-git-2014-10-17";

     

       442
       697
        
           src = fetchgit {

     

       443
       443
       -
             url = "https://github.com/ervandew/supertab.git";

     

       444
       444
       -
             rev = "23db558596d4a73e4afa8fbedcde23b95bf72251";

     

       445
       445
       -
             sha256 = "21fa675969f4cfd2686ab3b63cba632fa55d62481e61d36193403bea9c02ebde";

     

       698
       698
       +
             url = "https://github.com/scrooloose/syntastic.git";

     

       699
       699
       +
             rev = "77c125170aa6b8c553d58f876021b0cedd8ac820";

     

       700
       700
       +
             sha256 = "ec9b1e22134cb16d07bef842be26b4f1f74a9f8b9a0afd9ab771ff79935920af";

     

       446
       701
        
            };

     

       447
       447
       -
           path = "supertab";

     

       448
       448
       -
           buildInputs = [ vim ];

     

       702
       702
       +
           meta = {

     

       703
       703
       +
             homepage = https://github.com/scrooloose/syntastic; 

     

       704
       704
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       705
       705
       +
           };

     

       449
       706
        
         };

     

       450
       707
        
       

     

       451
       451
       -
         fugitive = simpleDerivation {

     

       452
       452
       -
           name = "vim-fugitive-git-90ee6fb5";

     

       708
       708
       +
         table-mode = buildVimPlugin {

     

       709
       709
       +
           name = "table-mode-git-2014-09-17";

     

       453
       710
        
           src = fetchgit {

     

       454
       454
       -
             url = "https://github.com/tpope/vim-fugitive.git";

     

       455
       455
       -
             rev = "90ee6fb5d255d14d9f12f2469f92ee50149f5b44";

     

       456
       456
       -
             sha256 = "0297512f7fee62af601a99a68617591ecb2e244475ff0d79ebee9c7e6eff2eaf";

     

       711
       711
       +
             url = "https://github.com/dhruvasagar/vim-table-mode.git";

     

       712
       712
       +
             rev = "ef0eef0f35f2ca172907f6d696dc8859acd8a0da";

     

       713
       713
       +
             sha256 = "0377059972580f621f1bb4b35738e0e00d386b23d839115e8c5fa8fd3acbc98d";

     

       457
       714
        
            };

     

       458
       458
       -
           path = "fugitive";

     

       715
       715
       +
           meta = {

     

       716
       716
       +
             homepage = https://github.com/dhruvasagar/vim-table-mode; 

     

       717
       717
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       718
       718
       +
           };

     

       459
       719
        
         };

     

       460
       720
        
       

     

       461
       461
       -
         extradite = simpleDerivation {

     

       462
       462
       -
           name = "vim-extradite-git-af4f3a51";

     

       721
       721
       +
         tabmerge = buildVimPlugin {

     

       722
       722
       +
           name = "tabmerge-git-2010-10-17";

     

       463
       723
        
           src = fetchgit {

     

       464
       464
       -
             url = "https://github.com/int3/vim-extradite.git";

     

       465
       465
       -
             rev = "af4f3a51b6b654d655121b93c0cd9d8fe9a0c85d";

     

       466
       466
       -
             sha256 = "d1d29cfbc654134be383747f2cd6b14b7a87de75f997af6a041f14d7ef61ade6";

     

       724
       724
       +
             url = "https://github.com/vim-scripts/tabmerge.git";

     

       725
       725
       +
             rev = "074e5f06f26e7108a0570071a0f938a821768c06";

     

       726
       726
       +
             sha256 = "b84501b0fc5cd51bbb58f12f4c2b3a7c97b03fe2a76446b56a2c111bd4f7335f";

     

       467
       727
        
            };

     

       468
       468
       -
           path = "extradite";

     

       728
       728
       +
           meta = {

     

       729
       729
       +
             homepage = https://github.com/vim-scripts/tabmerge; 

     

       730
       730
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       731
       731
       +
           };

     

       469
       732
        
         };

     

       470
       733
        
       

     

       471
       471
       -
         nerdtree = simpleDerivation {

     

       472
       472
       -
           name = "nerdtree-git-4f1e6ecb";

     

       734
       734
       +
         tabular = buildVimPlugin {

     

       735
       735
       +
           name = "tabular-git-2013-05-16";

     

       473
       736
        
           src = fetchgit {

     

       474
       474
       -
             url = "https://github.com/scrooloose/nerdtree.git";

     

       475
       475
       -
             rev = "4f1e6ecb057fc0bac189171c1430d71ef25f6bb1";

     

       476
       476
       -
             sha256 = "67ff2e7b9a7f39e58e9e334b1b79343a4c11aae10a657ab4fece289d8fe59300";

     

       737
       737
       +
             url = "https://github.com/godlygeek/tabular.git";

     

       738
       738
       +
             rev = "60f25648814f0695eeb6c1040d97adca93c4e0bb";

     

       739
       739
       +
             sha256 = "28c860ad621587f2c3213fae47d1a3997746527c17d51e9ab94c209eb7bfeb0f";

     

       477
       740
        
            };

     

       478
       478
       -
           path = "nerdtree";

     

       741
       741
       +
           meta = {

     

       742
       742
       +
             homepage = https://github.com/godlygeek/tabular; 

     

       743
       743
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       744
       744
       +
           };

     

       479
       745
        
         };

     

       480
       746
        
       

     

       481
       481
       -
         airline = simpleDerivation {

     

       482
       482
       -
           name = "vim-airline-git-2114e702";

     

       747
       747
       +
         tagbar = buildVimPlugin {

     

       748
       748
       +
           name = "tagbar-git-2014-10-14";

     

       483
       749
        
           src = fetchgit {

     

       484
       484
       -
             url = "https://github.com/bling/vim-airline.git";

     

       485
       485
       -
             rev = "2114e7025188a941e5c63b1f942d576adb98d8a4";

     

       486
       486
       -
             sha256 = "b6fc4d0545f8b7e107c5f80b94cf536a2b1fdd55d9f2484a29a007911e96130f";

     

       750
       750
       +
             url = "https://github.com/majutsushi/tagbar.git";

     

       751
       751
       +
             rev = "64e935fe5812d3b7022aba1dee63ec9f7456b02f";

     

       752
       752
       +
             sha256 = "2a66b86328e395bd594c8673a6420307a32468e4040dafe2b877ad4afcf6b7f9";

     

       487
       753
        
            };

     

       488
       488
       -
           path = "airline";

     

       754
       754
       +
           meta = {

     

       755
       755
       +
             homepage = https://github.com/majutsushi/tagbar; 

     

       756
       756
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       757
       757
       +
           };

     

       489
       758
        
         };

     

       490
       759
        
       

     

       491
       491
       -
         ultisnips = simpleDerivation {

     

       492
       492
       -
           name = "ultisnips-git-279d6e63";

     

       760
       760
       +
         taglist = buildVimPlugin {

     

       761
       761
       +
           name = "taglist-4.6";

     

       762
       762
       +
           meta = with stdenv.lib; {

     

       763
       763
       +
             description = "Source code browser plugin";

     

       764
       764
       +
             homepage    = "http://www.vim.org/scripts/script.php?script_id=273";

     

       765
       765
       +
             license     = licenses.gpl3;

     

       766
       766
       +
             maintainers = with maintainers; [ lovek323 ];

     

       767
       767
       +
             platforms   = platforms.unix;

     

       768
       768
       +
           };

     

       769
       769
       +
           src = fetchurl {

     

       770
       770
       +
             url    = "http://www.vim.org/scripts/download_script.php?src_id=19574";

     

       771
       771
       +
             name   = "taglist_46.zip";

     

       772
       772
       +
             sha256 = "18cbv462vwg7vip2p99qlahm99hswav96cj4ki227kyi05q2lkjj";

     

       773
       773
       +
           };

     

       774
       774
       +
           setSourceRoot = ''

     

       775
       775
       +
             export sourceRoot=taglist

     

       776
       776
       +
             mkdir taglist

     

       777
       777
       +
             mv doc taglist

     

       778
       778
       +
             mv plugin taglist

     

       779
       779
       +
           '';

     

       780
       780
       +
           buildInputs = [ unzip ];

     

       781
       781
       +
         };

     

       782
       782
       +
       

     

       783
       783
       +
         thumbnail = buildVimPlugin {

     

       784
       784
       +
           name = "thumbnail-git-2014-07-24";

     

       493
       785
        
           src = fetchgit {

     

       494
       494
       -
             url = "https://github.com/SirVer/ultisnips.git";

     

       495
       495
       -
             rev = "279d6e63c9a8dbaa20ffc43c3c5f057dfc8f1121";

     

       496
       496
       -
             sha256 = "f8d93849ef2bce798aa599ba860694ced37d12450010a48dd6bd3004bc52b503";

     

       786
       786
       +
             url = "https://github.com/itchyny/thumbnail.vim.git";

     

       787
       787
       +
             rev = "e59a1791862ed470510a58456cc001226e177a39";

     

       788
       788
       +
             sha256 = "f36d915804e36b5f2dcea7db481da97ec60d0c90df87599a5d5499e649d97f66";

     

       497
       789
        
            };

     

       498
       498
       -
           path = "ultisnips";

     

       790
       790
       +
           meta = {

     

       791
       791
       +
             homepage = https://github.com/itchyny/thumbnail.vim; 

     

       792
       792
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       793
       793
       +
           };

     

       499
       794
        
         };

     

       500
       795
        
       

     

       501
       501
       -
         align = simpleDerivation {

     

       502
       502
       -
           name = "align-git-787662fe";

     

       796
       796
       +
         tmux-navigator = buildVimPlugin {

     

       797
       797
       +
           name = "tmux-navigator-git-2014-09-09";

     

       503
       798
        
           src = fetchgit {

     

       504
       504
       -
             url = "https://github.com/vim-scripts/Align.git";

     

       505
       505
       -
             rev = "787662fe90cd057942bc5b682fd70c87e1a9dd77";

     

       506
       506
       -
             sha256 = "f7b5764357370f03546556bd45558837f3790b0e86afadb63cd04d714a668a29";

     

       799
       799
       +
             url = "https://github.com/christoomey/vim-tmux-navigator.git";

     

       800
       800
       +
             rev = "195cdf087fea7beaf6274d0a655d157dfab3130c";

     

       801
       801
       +
             sha256 = "4235c2bfb64a9094b854cdd7303a64bbb994717f24704911c4b358b2373dfaa9";

     

       507
       802
        
            };

     

       508
       508
       -
           path = "align";

     

       803
       803
       +
           meta = {

     

       804
       804
       +
             homepage = https://github.com/christoomey/vim-tmux-navigator; 

     

       805
       805
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       806
       806
       +
           };

     

       509
       807
        
         };

     

       510
       808
        
       

     

       511
       511
       -
         gundo = simpleDerivation {

     

       512
       512
       -
           name = "gundo-git-f443470b";

     

       809
       809
       +
         tmuxNavigator = tmux-navigator; # backwards compat, added 2014-10-18

     

       810
       810
       +
       

     

       811
       811
       +
         tslime = buildVimPlugin {

     

       812
       812
       +
           name = "tslime-git-2014-06-12";

     

       513
       813
        
           src = fetchgit {

     

       514
       514
       -
             url = "https://github.com/vim-scripts/Gundo.git";

     

       515
       515
       -
             rev = "f443470b96364c24a775629418a6b2562ec9173e";

     

       516
       516
       -
             sha256 = "b7a949167e59c936d6eae0d23635b87491b2cd2f46a197683b171d30165a90f9";

     

       814
       814
       +
             url = "https://github.com/jgdavey/tslime.vim.git";

     

       815
       815
       +
             rev = "e801a32b27d83cb5d91afbf7c3d71bb6220f32bd";

     

       816
       816
       +
             sha256 = "47fb7165c1dcc444285cdff6fa89bbd4ace82ca79ec14ba0da6091c5f78d1251";

     

       517
       817
        
            };

     

       518
       518
       -
           path = "gundo";

     

       818
       818
       +
           meta = {

     

       819
       819
       +
             homepage = https://github.com/jgdavey/tslime.vim; 

     

       820
       820
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       821
       821
       +
           };

     

       519
       822
        
         };

     

       520
       823
        
       

     

       521
       521
       -
         commentary = simpleDerivation {

     

       522
       522
       -
           name = "vim-commentary-git-8b4df6ca";

     

       824
       824
       +
         ultisnips = buildVimPlugin {

     

       825
       825
       +
           name = "ultisnips-git-2014-10-11";

     

       523
       826
        
           src = fetchgit {

     

       524
       524
       -
             url = "https://github.com/tpope/vim-commentary.git";

     

       525
       525
       -
             rev = "8b4df6ca0ba9cd117d97a8fd26b44b2439d5e3f1";

     

       526
       526
       -
             sha256 = "5496ed31706552957d4caa76669ecd04e9b2853cf7a7e40bd0164726b21fcca0";

     

       827
       827
       +
             url = "https://github.com/sirver/ultisnips.git";

     

       828
       828
       +
             rev = "1ad970379edaec1a386bab5ff26c385b9e89a0ff";

     

       829
       829
       +
             sha256 = "5d6858a153d79f596513d01d4ed9cd6dcff853e2c42c4b4546d38bd15423af98";

     

       527
       830
        
            };

     

       528
       528
       -
           path = "commentary";

     

       831
       831
       +
           meta = {

     

       832
       832
       +
             homepage = https://github.com/sirver/ultisnips; 

     

       833
       833
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       834
       834
       +
           };

     

       529
       835
        
         };

     

       530
       836
        
       

     

       531
       531
       -
         tabular = simpleDerivation {

     

       532
       532
       -
           name = "tabular-git-60f25648";

     

       837
       837
       +
         undotree = buildVimPlugin {

     

       838
       838
       +
           name = "undotree-git-2014-09-17";

     

       533
       839
        
           src = fetchgit {

     

       534
       534
       -
             url = "https://github.com/godlygeek/tabular.git";

     

       535
       535
       -
             rev = "60f25648814f0695eeb6c1040d97adca93c4e0bb";

     

       536
       536
       -
             sha256 = "28c860ad621587f2c3213fae47d1a3997746527c17d51e9ab94c209eb7bfeb0f";

     

       840
       840
       +
             url = "https://github.com/mbbill/undotree.git";

     

       841
       841
       +
             rev = "14655d87774b1f35b5bd23c6de64f535d90ed48d";

     

       842
       842
       +
             sha256 = "ad55b88db051f57d0c7ddc226a7b7778daab58fa67dc8ac1d78432c0e7d38520";

     

       537
       843
        
            };

     

       538
       538
       -
           path = "tabular";

     

       844
       844
       +
           meta = {

     

       845
       845
       +
             homepage = https://github.com/mbbill/undotree; 

     

       846
       846
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       847
       847
       +
           };

     

       539
       848
        
         };

     

       540
       849
        
       

     

       541
       541
       -
         vim2hs = simpleDerivation {

     

       542
       542
       -
           name = "vim2hs-git-f2afd557";

     

       850
       850
       +
         vim2hs = buildVimPlugin {

     

       851
       851
       +
           name = "vim2hs-git-2014-04-16";

     

       543
       852
        
           src = fetchgit {

     

       544
       853
        
             url = "https://github.com/dag/vim2hs.git";

     

       545
       854
        
             rev = "f2afd55704bfe0a2d66e6b270d247e9b8a7b1664";

     

       546
       855
        
             sha256 = "485fc58595bb4e50f2239bec5a4cbb0d8f5662aa3f744e42c110cd1d66b7e5b0";

     

       547
       856
        
            };

     

       548
       548
       -
           path = "vim2hs";

     

       857
       857
       +
           meta = {

     

       858
       858
       +
             homepage = https://github.com/dag/vim2hs; 

     

       859
       859
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       860
       860
       +
           };

     

       549
       861
        
         };

     

       550
       862
        
       

     

       551
       551
       -
         hasksyn = simpleDerivation {

     

       552
       552
       -
           name = "hasksyn-git-175cd460";

     

       863
       863
       +
         vimoutliner = buildVimPlugin {

     

       864
       864
       +
           name = "vimoutliner-git-2014-10-20";

     

       553
       865
        
           src = fetchgit {

     

       554
       554
       -
             url = "https://github.com/travitch/hasksyn.git";

     

       555
       555
       -
             rev = "175cd4605afa5d9b9c75758112c8159fd118c631";

     

       556
       556
       -
             sha256 = "3488e38d1f45a9a3363da62c1c946591621151a0a9cdaedd22b3fe8f666bbdb9";

     

       866
       866
       +
             url = "https://github.com/vimoutliner/vimoutliner.git";

     

       867
       867
       +
             rev = "4e924d9e42b6955a696e087d22795f5fe0e6c857";

     

       868
       868
       +
             sha256 = "6a9a27526c51202fb15374b40c5a759df0e10977dbe3045dabef0439c3e62c72";

     

       557
       869
        
            };

     

       558
       558
       -
           path = "hasksyn";

     

       870
       870
       +
           meta = {

     

       871
       871
       +
             homepage = https://github.com/vimoutliner/vimoutliner; 

     

       872
       872
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       873
       873
       +
           };

     

       559
       874
        
         };

     

       560
       875
        
       

     

       561
       561
       -
         haskellConceal = simpleDerivation {

     

       562
       562
       -
           name = "vim-haskellConceal-git-73a8d712";

     

       876
       876
       +
         vimproc = buildVimPlugin {

     

       877
       877
       +
           name = "vimproc-git-2014-10-03";

     

       563
       878
        
           src = fetchgit {

     

       564
       564
       -
             url = "https://github.com/begriffs/vim-haskellConceal.git";

     

       565
       565
       -
             rev = "73a8d712d3342b2ffdc087b12924f1cf81053860";

     

       566
       566
       -
             sha256 = "be60ca030e2d39e972a8c71c0ab3b75b893589d26d5dd78a20cd6779f1f5cfa8";

     

       879
       879
       +
             url = "https://github.com/shougo/vimproc.vim.git";

     

       880
       880
       +
             rev = "3e055023dfab4f5a4dfa05a834f9d0cb7294a82e";

     

       881
       881
       +
             sha256 = "63c2786897e8315eed2473822879b7ceb847e6021695a861892d7b9ab15a69fb";

     

       567
       882
        
            };

     

       568
       568
       -
           path = "haskellConceal";

     

       569
       569
       -
         };

     

       883
       883
       +
           buildInputs = [ which ];

     

       884
       884
       +
       

     

       885
       885
       +
           buildPhase = ''

     

       886
       886
       +
             sed -i 's/vimproc_mac\.so/vimproc_unix\.so/' autoload/vimproc.vim

     

       887
       887
       +
             make -f make_unix.mak

     

       888
       888
       +
           '';

     

       570
       889
        
       

     

       571
       571
       -
         ghcmod = simpleDerivation {

     

       572
       572
       -
           name = "ghcmod-vim-git-0c4e9428";

     

       573
       573
       -
           src = fetchgit {

     

       574
       574
       -
             url = "https://github.com/eagletmt/ghcmod-vim.git";

     

       575
       575
       -
             rev = "0c4e94281e57c475752e799adc261f7d5e4ab124";

     

       576
       576
       -
             sha256 = "f6a085f7b8198747fae3fff0bc38e4d030e5c97aaeb84958fbf96fa658bbe862";

     

       577
       577
       -
            };

     

       578
       578
       -
           patches = [ (fetchurl { url = "https://github.com/eagletmt/ghcmod-vim/pull/57.diff"; md5 = "cafbb9f725afbba26b52b6c3344ee89a"; }) ];

     

       579
       579
       -
           path = "ghcmod";

     

       890
       890
       +
           meta = {

     

       891
       891
       +
             homepage = https://github.com/shougo/vimproc.vim; 

     

       892
       892
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       893
       893
       +
           };

     

       580
       894
        
         };

     

       581
       895
        
       

     

       582
       582
       -
         necoGhc = simpleDerivation {

     

       583
       583
       -
           name = "neco-ghc-git-0311f31b";

     

       584
       584
       -
           src = fetchgit {

     

       585
       585
       -
             url = "https://github.com/eagletmt/neco-ghc.git";

     

       586
       586
       -
             rev = "0311f31b3acaccec5b651ae7089d627a3a49239b";

     

       587
       587
       -
             sha256 = "302f29f54c56e9cee647745a8355aeafe323c4efe2f3593d5e4f586acc1c06a5";

     

       588
       588
       -
            };

     

       589
       589
       -
           path = "neco-ghc";

     

       896
       896
       +
         vimshell = buildVimPlugin rec {

     

       897
       897
       +
           version = "9.2";

     

       898
       898
       +
           name = "vimshell-${version}";

     

       899
       899
       +
       

     

       900
       900
       +
           meta = with stdenv.lib; {

     

       901
       901
       +
             description = "An extreme shell that doesn't depend on external shells and is written completely in Vim script";

     

       902
       902
       +
             homepage    = https://github.com/Shougo/vimshell.vim;

     

       903
       903
       +
             repositories.git = https://github.com/Shougo/vimshell.vim.git;

     

       904
       904
       +
             license     = licenses.gpl3;

     

       905
       905
       +
             maintainers = with maintainers; [ lovek323 ];

     

       906
       906
       +
             platforms   = platforms.unix;

     

       907
       907
       +
           };

     

       908
       908
       +
       

     

       909
       909
       +
           src = fetchurl {

     

       910
       910
       +
             url    = "https://github.com/Shougo/vimshell.vim/archive/ver.${version}.tar.gz";

     

       911
       911
       +
             sha256 = "1pbwxdhpv6pr09b6hwkgy7grpmpwlqpsgsawl38r40q6yib8zb4a";

     

       912
       912
       +
           };

     

       913
       913
       +
       

     

       914
       914
       +
           buildInputs = [ vimproc ];

     

       915
       915
       +
       

     

       916
       916
       +
           preBuild = ''

     

       917
       917
       +
             sed -ie '1 i\

     

       918
       918
       +
             set runtimepath+=${vimproc}/share/vim-plugins/vimproc\

     

       919
       919
       +
             ' autoload/vimshell.vim

     

       920
       920
       +
           '';

     

       590
       921
        
         };

     

       591
       922
        
       

     

       592
       592
       -
         hoogle = simpleDerivation {

     

       593
       593
       -
           name = "vim-hoogle-git-81f28318";

     

       923
       923
       +
         vundle = buildVimPlugin {

     

       924
       924
       +
           name = "vundle-git-2014-07-18";

     

       594
       925
        
           src = fetchgit {

     

       595
       595
       -
             url = "https://github.com/Twinside/vim-hoogle.git";

     

       596
       596
       -
             rev = "81f28318b0d4174984c33df99db7752891c5c4e9";

     

       597
       597
       -
             sha256 = "0f96f3badb6218cac87d0f7027ff032ecc74f08ad3ada542898278ce11cbd5a0";

     

       926
       926
       +
             url = "https://github.com/gmarik/vundle.vim.git";

     

       927
       927
       +
             rev = "0b28e334e65b6628b0a61c412fcb45204a2f2bab";

     

       928
       928
       +
             sha256 = "9681d471d1391626cb9ad22b2b469003d9980cd23c5c3a8d34666376447e6204";

     

       598
       929
        
            };

     

       599
       599
       -
           path = "hoogle";

     

       930
       930
       +
           meta = {

     

       931
       931
       +
             homepage = https://github.com/gmarik/vundle.vim; 

     

       932
       932
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       933
       933
       +
           };

     

       600
       934
        
         };

     

       601
       935
        
       

     

       602
       602
       -
         hdevtools = simpleDerivation {

     

       603
       603
       -
           name = "vim-hdevtools-git-474947c5";

     

       936
       936
       +
         watchdogs = buildVimPlugin {

     

       937
       937
       +
           name = "watchdogs-git-2014-10-18";

     

       604
       938
        
           src = fetchgit {

     

       605
       605
       -
             url = "https://github.com/bitc/vim-hdevtools.git";

     

       606
       606
       -
             rev = "474947c52ff9c93dd36f3c49de90bd9a78f0baa1";

     

       607
       607
       -
             sha256 = "bf5f096b665c51ce611c6c1bfddc3267c4b2f94af84b04482b07272a6a5a92f3";

     

       939
       939
       +
             url = "https://github.com/osyo-manga/vim-watchdogs.git";

     

       940
       940
       +
             rev = "ad222796eb88b44954340c19c39938046af26e05";

     

       941
       941
       +
             sha256 = "4c621ac2834864cf0c46f776029837913e1ba0c725a12d7cb24bf92e04ed1279";

     

       608
       942
        
            };

     

       609
       609
       -
           path = "hdevtools";

     

       943
       943
       +
           meta = {

     

       944
       944
       +
             homepage = https://github.com/osyo-manga/vim-watchdogs; 

     

       945
       945
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       946
       946
       +
           };

     

       610
       947
        
         };

     

       611
       948
        
       

     

       612
       612
       -
         stylishHaskell = simpleDerivation {

     

       613
       613
       -
           name = "vim-stylish-haskell-git-453fd203";

     

       949
       949
       +
         webapi-vim = buildVimPlugin {

     

       950
       950
       +
           name = "webapi-vim-git-2014-10-19";

     

       614
       951
        
           src = fetchgit {

     

       615
       615
       -
             url = "https://github.com/nbouscal/vim-stylish-haskell.git";

     

       616
       616
       -
             rev = "453fd203aee3d7305ea8e4088ff53bd1f5933d75";

     

       617
       617
       -
             sha256 = "c0e5010e1e8e56b179ce500387afb569f051c45b37ce92feb4350f293df96a8c";

     

       952
       952
       +
             url = "https://github.com/mattn/webapi-vim.git";

     

       953
       953
       +
             rev = "99e11199838ccbeb7213cbc30698200170d355c9";

     

       954
       954
       +
             sha256 = "599e282ef45bf6587c34579ab08d4e4a1f2cb54589e1e386c75d701880c90b9e";

     

       618
       955
        
            };

     

       619
       619
       -
           path = "stylish-haskell";

     

       956
       956
       +
           buildInputs = [ zip ];

     

       957
       957
       +
           meta = {

     

       958
       958
       +
             homepage = https://github.com/mattn/webapi-vim; 

     

       959
       959
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       960
       960
       +
           };

     

       620
       961
        
         };

     

       621
       962
        
       

     

       622
       622
       -
         wombat256 = simpleDerivation {

     

       623
       623
       -
           name = "wombat256-vim-git-8734ba45";

     

       963
       963
       +
         wombat256 = buildVimPlugin {

     

       964
       964
       +
           name = "wombat256-git-2010-10-17";

     

       624
       965
        
           src = fetchgit {

     

       625
       966
        
             url = "https://github.com/vim-scripts/wombat256.vim.git";

     

       626
       967
        
             rev = "8734ba45dcf5e38c4d2686b35c94f9fcb30427e2";

     

       627
       968
        
             sha256 = "2feb7d57ab0a9f2ea44ccd606e540db64ab3285956398a50ecc562d7b8dbcd05";

     

       628
       969
        
            };

     

       629
       629
       -
           path = "wombat256";

     

       970
       970
       +
           meta = {

     

       971
       971
       +
             homepage = https://github.com/vim-scripts/wombat256.vim; 

     

       972
       972
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       973
       973
       +
           };

     

       630
       974
        
         };

     

       631
       975
        
       

     

       632
       632
       -
         tmuxNavigator = simpleDerivation {

     

       633
       633
       -
           name = "vim-tmux-navigator-git-3de98bfc";

     

       976
       976
       +
         xdebug = buildVimPlugin {

     

       977
       977
       +
           name = "xdebug-git-2012-08-15";

     

       634
       978
        
           src = fetchgit {

     

       635
       635
       -
             url = "https://github.com/christoomey/vim-tmux-navigator.git";

     

       636
       636
       -
             rev = "3de98bfcee1289ce8edc6daf9a18f243180c7168";

     

       637
       637
       -
             sha256 = "3843f92e0a21fe5ccf613f8a561abd06c822b2ee98bd82c98937548144e4e8df";

     

       979
       979
       +
             url = "https://github.com/joonty/vim-xdebug.git";

     

       980
       980
       +
             rev = "a4980fa65f7f159780593ee37c178281691ba2c4";

     

       981
       981
       +
             sha256 = "1ccb0e63eaf68548feb1c37b09c07c84b6bea9b350c4257549f091aa414601e2";

     

       638
       982
        
            };

     

       639
       639
       -
           path = "tmux-navigator";

     

       983
       983
       +
           postInstall = false;

     

       984
       984
       +
           meta = {

     

       985
       985
       +
             homepage = https://github.com/joonty/vim-xdebug; 

     

       986
       986
       +
             maintainers = [ stdenv.lib.maintainers.jagajaga ];

     

       987
       987
       +
           };

     

       640
       988
        
         };

     

       641
       989
        
       

     

       642
       642
       -
         pathogen = simpleDerivation {

     

       643
       643
       -
           name = "vim-pathogen-git-3de98bfc";

     

       644
       644
       -
           src = fetchgit {

     

       645
       645
       -
             url = "https://github.com/tpope/vim-pathogen.git";

     

       646
       646
       -
             rev = "91e6378908721d20514bbe5d18d292a0a15faf0c";

     

       647
       647
       -
             sha256 = "24c1897d6b58576b2189c90050a7f8ede72a51343c752e9d030e833dbe5cac6f";

     

       648
       648
       -
            };

     

       649
       649
       -
           path = "pathogen";

     

       990
       990
       +
         yankring = buildVimPlugin rec {

     

       991
       991
       +
           version = "18.0";

     

       992
       992
       +
           name    = "yankring-${version}";

     

       993
       993
       +
       

     

       994
       994
       +
           setSourceRoot = "sourceRoot=.";

     

       995
       995
       +
           src = fetchurl {

     

       996
       996
       +
             url    = "http://www.vim.org/scripts/download_script.php?src_id=20842";

     

       997
       997
       +
             name   = "yankring_180.zip";

     

       998
       998
       +
             sha256 = "0bsq4pxagy12jqxzs7gcf25k5ahwif13ayb9k8clyhm0jjdkf0la";

     

       999
       999
       +
           };

     

       1000
       1000
       +
       

     

       1001
       1001
       +
           buildInputs = [ unzip ];

     

       1002
       1002
       +
         };

     

       1003
       1003
       +
       

     

       1004
       1004
       +
         vim-addon-nix = {

     

       1005
       1005
       +
           # github.com/MarcWeber/vim-addon-nix provides some additional support for

     

       1006
       1006
       +
           # editing .nix files

     

       1007
       1007
       +
       

     

       1008
       1008
       +
           # This is a placeholder, because I think you always should be using latest

     

       1009
       1009
       +
           # git version. It also depends on some additional plugins (see addon-info.json)

     

       650
       1010
        
         };

     

       651
       1011
        
       

     

       652
       652
       -
         vimoutliner = simpleDerivation {

     

       653
       653
       -
           name = "vimoutliner-git-dce383e7";

     

       1012
       1012
       +
         youcompleteme = stdenv.mkDerivation {

     

       654
       1013
        
           src = fetchgit {

     

       655
       655
       -
             url = "https://github.com/vimoutliner/vimoutliner";

     

       656
       656
       -
             rev = "2fc82976683c8770bece157ae3ada55251b6ddeb";

     

       657
       657
       -
             sha256 = "dce383e7842c42bcfa8e7c3329fa426cb0fb05786d40a733da705c03aabd196b";

     

       1014
       1014
       +
             url = "https://github.com/Valloric/YouCompleteMe.git";

     

       1015
       1015
       +
             rev = "87b42c689391b69968950ae99c3aaacf2e14c329";

     

       1016
       1016
       +
             sha256 = "1f3pywv8bsqyyakvyarg7z9m73gmvp1lfbfp2f2jj73jmmlzb2kv";

     

       658
       1017
        
            };

     

       659
       659
       -
           path = "vimoutliner";

     

       1018
       1018
       +
       

     

       1019
       1019
       +
           name = "vimplugin-youcompleteme-2014-10-06";

     

       1020
       1020
       +
       

     

       1021
       1021
       +
           buildInputs = [ python cmake clang.clang ];

     

       1022
       1022
       +
       

     

       1023
       1023
       +
           configurePhase = ":";

     

       1024
       1024
       +
       

     

       1025
       1025
       +
           buildPhase = ''

     

       1026
       1026
       +
             patchShebangs .

     

       1027
       1027
       +
       

     

       1028
       1028
       +
             target=$out/share/vim-plugins/youcompleteme

     

       1029
       1029
       +
             mkdir -p $target

     

       1030
       1030
       +
             cp -a ./ $target

     

       1031
       1031
       +
       

     

       1032
       1032
       +
             mkdir $target/build

     

       1033
       1033
       +
             cd $target/build

     

       1034
       1034
       +
             cmake -G "Unix Makefiles" . $target/third_party/ycmd/cpp -DPYTHON_LIBRARIES:PATH=${python}/lib/libpython2.7.so -DPYTHON_INCLUDE_DIR:PATH=${python}/include/python2.7 -DUSE_CLANG_COMPLETER=ON -DUSE_SYSTEM_LIBCLANG=ON

     

       1035
       1035
       +
             make ycm_support_libs -j''${NIX_BUILD_CORES} -l''${NIX_BUILD_CORES}}

     

       1036
       1036
       +
             ${bash}/bin/bash $target/install.sh --clang-completer --system-libclang

     

       1037
       1037
       +
       

     

       1038
       1038
       +
             ${vimHelpTags}

     

       1039
       1039
       +
             vimHelpTags $target

     

       1040
       1040
       +
           '';

     

       1041
       1041
       +
       

     

       1042
       1042
       +
           # TODO: implement proper install phase rather than keeping everything in store

     

       1043
       1043
       +
           # TODO: support llvm based C completion, See README of git repository

     

       1044
       1044
       +
           installPhase = ":";

     

       1045
       1045
       +
       

     

       1046
       1046
       +
           meta = {

     

       1047
       1047
       +
             description = "fastest non utf-8 aware word and C completion engine for Vim";

     

       1048
       1048
       +
             homepage = http://github.com/Valloric/YouCompleteMe;

     

       1049
       1049
       +
             license = stdenv.lib.licenses.gpl3;

     

       1050
       1050
       +
             maintainers = [stdenv.lib.maintainers.marcweber];

     

       1051
       1051
       +
             platforms = stdenv.lib.platforms.linux;

     

       1052
       1052
       +
           };

     

       660
       1053
        
         };

     

       1054
       1054
       +
       

     

       1055
       1055
       +
         YouCompleteMe = youcompleteme; # backwards compat, added 2014-10-18

     

       661
       1056
        
       

     

       662
       1057
        
       }

+1 -1

pkgs/os-specific/darwin/otool/default.nix

···

       24
       24
        
         meta = with stdenv.lib; {

     

       25
       25
        
           description = "Object file displaying tool";

     

       26
       26
        
           homepage    = https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/otool.1.html;

     

       27
       27
       -
           # TODO license     = with licenses; [ apsl20 gpl2Plus ];

     

       27
       27
       +
           license     = with licenses; [ apsl20 gpl2Plus ];

     

       28
       28
        
           maintainers = with maintainers; [ lovek323 ];

     

       29
       29
        
           platforms   = platforms.darwin;

     

       30
       30

+1 -1

pkgs/os-specific/linux/ati-drivers/builder.sh

···

       264
       264
        
           cp $BIN/* $out/bin

     

       265
       265
        
           for prog in $BIN/*; do

     

       266
       266
        
             patchelf --set-interpreter $(echo $glibc/lib/ld-linux*.so.2) $out/bin/$(basename $prog)

     

       267
       267
       -
             wrapProgram $out/bin/$(basename $prog) --prefix LD_LIBRARY_PATH : $out/lib:$LD_LIBRARY_PATH

     

       267
       267
       +
             wrapProgram $out/bin/$(basename $prog) --prefix LD_LIBRARY_PATH : $out/lib:$gcc/lib:$qt4/lib:$LD_LIBRARY_PATH

     

       268
       268
        
           done

     

       269
       269
        
         }

     

       270
       270

+4 -2

pkgs/os-specific/linux/ati-drivers/default.nix

···

       3
       3
        
       , libXxf86vm, xf86vidmodeproto # for fglrx_gamma

     

       4
       4
        
       , xorg, makeWrapper, glibc, patchelf

     

       5
       5
        
       , unzip

     

       6
       6
       +
       , qt4 # for amdcccle

     

       6
       7
        
       , # Whether to build the libraries only (i.e. not the kernel module or

     

       7
       8
        
         # driver utils). Used to support 32-bit binaries on 64-bit

     

       8
       9
        
         # Linux.

     
···

       53
       54
        
             patchelf

     

       54
       55
        
             unzip

     

       55
       56
        
             mesa

     

       57
       57
       +
             qt4

     

       56
       58
        
           ];

     

       57
       59
        
       

     

       58
       60
        
         inherit libsOnly;

     
···

       74
       76
        
         # appear in /run/opengl-driver/lib which get's added to LD_LIBRARY_PATH

     

       75
       77
        
         extraDRIlibs = [ xorg.libXext ];

     

       76
       78
        
       

     

       77
       77
       -
         inherit mesa; # only required to build examples

     

       79
       79
       +
         inherit mesa qt4; # only required to build examples and amdcccle

     

       78
       80
        
       

     

       79
       81
        
         meta = with stdenv.lib; {

     

       80
       82
        
           description = "ATI drivers";

     

       81
       83
        
           homepage = http://support.amd.com/us/gpudownload/Pages/index.aspx;

     

       82
       84
        
           license = licenses.unfree;

     

       83
       83
       -
           maintainers = with maintainers; [marcweber offline];

     

       85
       85
       +
           maintainers = with maintainers; [ marcweber offline jgeerds ];

     

       84
       86
        
           platforms = platforms.linux;

     

       85
       87
        
           hydraPlatforms = [];

     

       86
       88
        
         };

+23 -20

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

···

       1
       1
       -
       { fetchurl, stdenv, flex, bison, db, iptables, pkgconfig }:

     

       1
       1
       +
       { fetchgit, stdenv, flex, bison, db, iptables, pkgconfig }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "iproute2-3.16.0";

     

       4
       4
       +
         name = "iproute2-3.17.0";

     

       5
       5
        
       

     

       6
       6
       -
         src = fetchurl {

     

       7
       7
       -
           url = "mirror://kernel/linux/utils/net/iproute2/${name}.tar.xz";

     

       8
       8
       -
           sha256 = "0ybv29m88lccpfrh2dgiqash4c3gfvwwpx9kakvnc8c71rn8l2hz";

     

       6
       6
       +
         src = fetchgit {

     

       7
       7
       +
           url = "git://git.kernel.org/pub/scm/linux/kernel/git/shemminger/iproute2.git";

     

       8
       8
       +
           rev = "refs/tags/v3.17.0";

     

       9
       9
       +
           sha256 = "113ayyy7cjxn0bf67fh4is4z0jysgif016kv7ig0jp6r68xp2spa";

     

       9
       10
        
         };

     

       10
       11
        
       

     

       11
       11
       -
         patch = [

     

       12
       12
       -
           ./vpnc.patch

     

       13
       13
       -
           ./device-checking.patch # Remove after 3.16.0

     

       14
       14
       -
         ];

     

       12
       12
       +
         patch = [ ./vpnc.patch ];

     

       15
       13
        
       

     

       16
       16
       -
         preConfigure =

     

       17
       17
       -
           ''

     

       18
       18
       -
             patchShebangs ./configure

     

       19
       19
       -
             sed -e '/ARPDDIR/d' -i Makefile

     

       20
       20
       -
           '';

     

       14
       14
       +
         preConfigure = ''

     

       15
       15
       +
           patchShebangs ./configure

     

       16
       16
       +
           sed -e '/ARPDDIR/d' -i Makefile

     

       17
       17
       +
         '';

     

       21
       18
        
       

     

       22
       22
       -
         makeFlags = "DESTDIR= LIBDIR=$(out)/lib SBINDIR=$(out)/sbin"

     

       23
       23
       -
           + " CONFDIR=$(out)/etc DOCDIR=$(out)/share/doc/${name}"

     

       24
       24
       -
           + " MANDIR=$(out)/share/man";

     

       19
       19
       +
         makeFlags = [

     

       20
       20
       +
           "DESTDIR="

     

       21
       21
       +
           "LIBDIR=$(out)/lib"

     

       22
       22
       +
           "SBINDIR=$(out)/sbin"

     

       23
       23
       +
           "CONFDIR=$(out)/etc"

     

       24
       24
       +
           "DOCDIR=$(out)/share/doc/${name}"

     

       25
       25
       +
           "MANDIR=$(out)/share/man"

     

       26
       26
       +
         ];

     

       25
       27
        
       

     

       26
       28
        
         buildInputs = [ db iptables ];

     

       27
       29
        
         nativeBuildInputs = [ bison flex pkgconfig ];

     
···

       31
       33
        
         # Get rid of useless TeX/SGML docs.

     

       32
       34
        
         postInstall = "rm -rf $out/share/doc";

     

       33
       35
        
       

     

       34
       34
       -
         meta = {

     

       36
       36
       +
         meta = with stdenv.lib; {

     

       35
       37
        
           homepage = http://www.linuxfoundation.org/collaborate/workgroups/networking/iproute2;

     

       36
       38
        
           description = "A collection of utilities for controlling TCP/IP networking and traffic control in Linux";

     

       37
       37
       -
           platforms = stdenv.lib.platforms.linux;

     

       38
       38
       -
           maintainers = [ stdenv.lib.maintainers.eelco ];

     

       39
       39
       +
           platforms = platforms.linux;

     

       40
       40
       +
           license = licenses.gpl2;

     

       41
       41
       +
           maintainers = with maintainers; [ eelco wkennington ];

     

       39
       42
        
         };

     

       40
       43
        
       }

-32

pkgs/os-specific/linux/iproute/device-checking.patch

···

       1
       1
       -
       From f1b66ff83a0babbe99fef81b3a960d7a4ce8dbc6 Mon Sep 17 00:00:00 2001

     

       2
       2
       -
       From: vadimk <vadim4j@gmail.com>

     

       3
       3
       -
       Date: Sat, 30 Aug 2014 15:06:00 +0300

     

       4
       4
       -
       Subject: ip link: Remove unnecessary device checking

     

       5
       5
       -
       

     

       6
       6
       -
       The real checking is performed later in iplink_modify(..) func which

     

       7
       7
       -
       checks device existence if NLM_F_CREATE flag is set.

     

       8
       8
       -
       

     

       9
       9
       -
       Also it fixes the case when impossible to add veth link which was

     

       10
       10
       -
       caused by 9a02651a87 (ip: check for missing dev arg when doing VF rate)

     

       11
       11
       -
       because these devices are not exist yet.

     

       12
       12
       -
       

     

       13
       13
       -
       Signed-off-by: Vadim Kochan <vadim4j@gmail.com>

     

       14
       14
       -
       Acked-by: Oliver Hartkopp <socketcan@hartkopp.net>

     

       15
       15
       -
       Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

     

       16
       16
       -
       

     

       17
       17
       -
       diff --git a/ip/iplink.c b/ip/iplink.c

     

       18
       18
       -
       index 1a907d9..ea06871 100644

     

       19
       19
       -
       --- a/ip/iplink.c

     

       20
       20
       -
       +++ b/ip/iplink.c

     

       21
       21
       -
       @@ -593,8 +593,6 @@ int iplink_parse(int argc, char **argv, struct iplink_req *req,

     

       22
       22
       -
        				duparg2("dev", *argv);

     

       23
       23
       -
        			*dev = *argv;

     

       24
       24
       -
        			dev_index = ll_name_to_index(*dev);

     

       25
       25
       -
       -			if (dev_index == 0)

     

       26
       26
       -
       -				invarg("Unknown device", *argv);

     

       27
       27
       -
        		}

     

       28
       28
       -
        		argc--; argv++;

     

       29
       29
       -
        	}

     

       30
       30
       -
       -- 

     

       31
       31
       -
       cgit v0.10.1

     

       32
       32
       -

+8 -2

pkgs/os-specific/linux/kernel/common-config.nix

···

       332
       332
        
         TRANSPARENT_HUGEPAGE_ALWAYS? n

     

       333
       333
        
         TRANSPARENT_HUGEPAGE_MADVISE? y

     

       334
       334
        
       

     

       335
       335
       -
         # zram support (e.g for in-memory compressed swap)

     

       335
       335
       +
         # zram support (e.g for in-memory compressed swap).

     

       336
       336
        
         ${optionalString (versionAtLeast version "3.4") ''

     

       337
       337
        
           ZSMALLOC y

     

       338
       338
        
         ''}

     

       339
       339
        
         ZRAM m

     

       340
       340
       -
         

     

       340
       340
       +
       

     

       341
       341
        
         ${optionalString (versionAtLeast version "3.17") "NFC? n"}

     

       342
       342
       +
       

     

       343
       343
       +
         # Enable firmware loading via udev. Only needed for non-declarative

     

       344
       344
       +
         # firmware in /root/test-firmware.

     

       345
       345
       +
         ${optionalString (versionAtLeast version "3.17") ''

     

       346
       346
       +
           FW_LOADER_USER_HELPER_FALLBACK y

     

       347
       347
       +
         ''}

     

       342
       348
        
       

     

       343
       349
        
         ${kernelPlatform.kernelExtraConfig or ""}

     

       344
       350
        
         ${extraConfig}

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.10.56";

     

       4
       4
       +
         version = "3.10.58";

     

       5
       5
        
         extraMeta.branch = "3.10";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "02q0rda1dsapfi2d3nz398fhlk0gvr2q6mj6jcck2izcxzqhsz9a";

     

       9
       9
       +
           sha256 = "06wn2ghqjcna517dmqj4yx5c5vl1mnn610xs5wdsyv2ikpr5mzfz";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         features.iwlwifi = true;

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.12.29";

     

       4
       4
       +
         version = "3.12.30";

     

       5
       5
        
         extraMeta.branch = "3.12";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "1ckzd9s64iahlnv7wh687m827f94q8hw0s4h8s69ijhay6igqqzm";

     

       9
       9
       +
           sha256 = "101lcf83y93pwz96glr93gnkkrx4xvwkxrjr1l45didrwnkim514";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         features.iwlwifi = true;

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.14.20";

     

       4
       4
       +
         version = "3.14.22";

     

       5
       5
        
         extraMeta.branch = "3.14";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "090i8drjwhxawn7jfg9mrmvqik13j58v0hb272b457k48qyc070y";

     

       9
       9
       +
           sha256 = "115hcaxavgqz549y0ly5ijf7cwc0z549wlwwjlm27i0z3fjcg83p";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         features.iwlwifi = true;

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.16.4";

     

       4
       4
       +
         version = "3.16.6";

     

       5
       5
        
         extraMeta.branch = "3.16";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "0x8jh9j7kdfbxcf3f69p28j5dwjjdxf92sjnlhk3mp016yv02i99";

     

       9
       9
       +
           sha256 = "1wh662krzgcgkhymqrjn8rasv92zsz0nmlwii85h8cwrszzxrs9i";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         features.iwlwifi = true;

+2 -3

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.17";

     

       5
       5
       -
         modDirVersion = "3.17.0";

     

       4
       4
       +
         version = "3.17.1";

     

       6
       5
        
         extraMeta.branch = "3.17";

     

       7
       6
        
       

     

       8
       7
        
         src = fetchurl {

     

       9
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       10
       10
       -
           sha256 = "0lb2yyh3j932789jq4gxx9xshgy6rfdnl3lm8yr43kaz7k4kw5gm";

     

       9
       9
       +
           sha256 = "1hhxsb4gsaj2mlmshivild7ayagam8f3xfl27n4652b1z4n0171c";

     

       11
       10
        
         };

     

       12
       11
        
       

     

       13
       12
        
         features.iwlwifi = true;

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.2.62";

     

       4
       4
       +
         version = "3.2.63";

     

       5
       5
        
         extraMeta.branch = "3.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "1yrmar14p5y9xaj9df388xwjmwz8fnsxnid6rkxxk7dni5di8nqf";

     

       9
       9
       +
           sha256 = "0fxfk1dppmgv5pwy7jjyih03i9rz5acp0pww4g5sy2d59rzfpbn8";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         # We don't provide these patches if grsecurity is enabled, because

+2 -2

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

···

       1
       1
        
       { stdenv, fetchurl, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       import ./generic.nix (args // rec {

     

       4
       4
       -
         version = "3.4.103";

     

       4
       4
       +
         version = "3.4.104";

     

       5
       5
        
         extraMeta.branch = "3.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "1ldga9l7dydwv5zvl3xgk8833cjv73yasyy2qmgimkbs03s8q4ig";

     

       9
       9
       +
           sha256 = "0xf2w4lccws2pps89hmh7ry8n43wr9p65yvdajba4qfxxy5jvx4b";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         kernelPatches = args.kernelPatches ++

+6 -6

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

···

       60
       60
        
         };

     

       61
       61
        
       

     

       62
       62
        
         grsecurity_stable = grsecPatch

     

       63
       63
       -
           { kversion  = "3.14.20";

     

       64
       64
       -
             revision  = "201410062037";

     

       63
       63
       +
           { kversion  = "3.14.22";

     

       64
       64
       +
             revision  = "201410192047";

     

       65
       65
        
             branch    = "stable";

     

       66
       66
       -
             sha256    = "0vs5s7xlnsrs5w59vhi57xhsnx3fryqfpvdgsfg2rxqnc1a5b3sp";

     

       66
       66
       +
             sha256    = "0f6mdc0m89idlygm75x3z01rqacla4r26cgz1ai1c6sm5vp9yvw1";

     

       67
       67
        
           };

     

       68
       68
        
       

     

       69
       69
        
         grsecurity_unstable = grsecPatch

     

       70
       70
       -
           { kversion  = "3.16.4";

     

       71
       71
       -
             revision  = "201410062041";

     

       70
       70
       +
           { kversion  = "3.17.1";

     

       71
       71
       +
             revision  = "201410192051";

     

       72
       72
        
             branch    = "test";

     

       73
       73
       -
             sha256    = "17g993gwjbj10gp2in534ycsv5hwggi5hrbqrsar1lm95m3d6pbc";

     

       73
       73
       +
             sha256    = "1ny8h6dd5mijg7lwi7zwqc6x5n5wkv19avl1d5qx8g2fs6qxbg0m";

     

       74
       74
        
           };

     

       75
       75
        
       

     

       76
       76
        
         grsec_fix_path =

+7 -8

pkgs/os-specific/linux/lttng-modules/default.nix

···

       1
       1
       -
       { stdenv, fetchgit, kernel }:

     

       1
       1
       +
       { stdenv, fetchurl, kernel }:

     

       2
       2
        
       

     

       3
       3
        
       assert stdenv.lib.versionAtLeast kernel.version "3.4";  # fails on 3.2

     

       4
       4
       +
       assert builtins.substring 0 4 kernel.version != "3.12";

     

       4
       5
        
       

     

       5
       6
        
       stdenv.mkDerivation rec {

     

       6
       7
        
         pname = "lttng-modules-${version}";

     

       7
       8
        
         name = "${pname}-${kernel.version}";

     

       8
       8
       -
         # Support for linux 3.16 and 3.17 was added just after the 2.5.0 release

     

       9
       9
       -
         version = "2.5.0-58-gbf2ba31"; # "git describe bf2ba318fff"

     

       9
       9
       +
         version = "2.6.0-rc1"; # "git describe bf2ba318fff"

     

       10
       10
        
       

     

       11
       11
       -
         src = fetchgit {

     

       12
       12
       -
           url = "https://github.com/lttng/lttng-modules.git";

     

       13
       13
       -
           sha256 = "0x70xp463g208rdz5b9b0wdwr2v8px1bwa589knvp4j7zi8d2gj9";

     

       14
       14
       -
           rev = "bf2ba318fff";

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "https://github.com/lttng/lttng-modules/archive/v${version}.tar.gz";

     

       13
       13
       +
           sha256 = "01gha02ybbzr86v6s6bqn649jiw5k89kb363b9s1iv8igrdlzhl1";

     

       15
       14
        
         };

     

       16
       15
        
       

     

       17
       16
        
         preConfigure = ''

     
···

       26
       25
        
         meta = with stdenv.lib; {

     

       27
       26
        
           description = "Linux kernel modules for LTTng tracing";

     

       28
       27
        
           homepage = http://lttng.org/;

     

       29
       29
       -
           # TODO license = with licenses; [ lgpl21 gpl2 mit ];

     

       28
       28
       +
           license = with licenses; [ lgpl21 gpl2 mit ];

     

       30
       29
        
           platforms = platforms.linux;

     

       31
       30
        
           maintainers = [ maintainers.bjornfor ];

     

       32
       31
        
         };

+2 -2

pkgs/os-specific/linux/pax-utils/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "pax-utils-${version}";

     

       5
       5
       -
         version = "0.8.1";

     

       5
       5
       +
         version = "0.9.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://dev.gentoo.org/~vapier/dist/${name}.tar.xz";

     

       9
       9
       -
           sha256 = "1fgm70s52x48dxjihs0rcwmpfsi2dxbjzcilxy9fzg0i39dz4kw4";

     

       9
       9
       +
           sha256 = "034b365il58bd01ld8r5493x7qkxbxzavmgwm916r0rgjpvclg34";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         makeFlags = [

pkgs/os-specific/linux/procps-ng/default.nix

···

       18
       18
        
           CC = stdenv.cross.config + "-gcc";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
       +
         # Too red

     

       22
       22
       +
         configureFlags = [ "--disable-modern-top" ];

     

       23
       23
       +
       

     

       21
       24
        
         meta = {

     

       22
       25
        
           homepage = http://sourceforge.net/projects/procps-ng/;

     

       23
       26
        
           description = "Utilities that give information about processes using the /proc filesystem";

+2 -2

pkgs/servers/monitoring/zabbix/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
       -
         version = "1.8.20";

     

       5
       5
       +
         version = "1.8.21";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://sourceforge/zabbix/zabbix-${version}.tar.gz";

     

       9
       9
       -
           sha256 = "0psdvzg5c3yhdqqmy5m1b0j3nrvcshjywhl56igy0j8vj16zxi86";

     

       9
       9
       +
           sha256 = "1ssqi31blkl1lyv9vjrsrrn494grdng187s8xwfv79adk2w94paw";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         preConfigure =

+11 -8

pkgs/servers/mpd/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, pkgconfig, glib, systemd

     

       1
       1
       +
       { stdenv, fetchurl, pkgconfig, glib, systemd, boost

     

       2
       2
        
       , alsaSupport ? true, alsaLib

     

       3
       3
        
       , flacSupport ? true, flac

     

       4
       4
        
       , vorbisSupport ? true, libvorbis

     
···

       18
       18
        
       , mpg123Support ? true, mpg123

     

       19
       19
        
       , aacSupport ? true, faad2

     

       20
       20
        
       , pulseaudioSupport ? true, pulseaudio

     

       21
       21
       +
       , icuSupport ? true, icu

     

       21
       22
        
       }:

     

       22
       23
        
       

     

       23
       24
        
       let

     

       24
       24
       -
       

     

       25
       25
        
         opt = stdenv.lib.optional;

     

       26
       26
       -
       

     

       27
       26
        
         mkFlag = c: f: if c then "--enable-${f}" else "--disable-${f}";

     

       27
       27
       +
         major = "0.19";

     

       28
       28
       +
         minor = "1";

     

       28
       29
        
       

     

       29
       30
        
       in stdenv.mkDerivation rec {

     

       30
       30
       -
         name = "mpd-0.18.16";

     

       31
       31
       +
         name = "mpd-${major}.${minor}";

     

       31
       32
        
         src = fetchurl {

     

       32
       32
       -
           url    = "http://www.musicpd.org/download/mpd/0.18/${name}.tar.gz";

     

       33
       33
       -
           sha256 = "0xpmc70ccp0s2s10vsi4hkijiv497dy42a7g225y77axp5ncf364";

     

       33
       33
       +
           url    = "http://www.musicpd.org/download/mpd/${major}/${name}.tar.gz";

     

       34
       34
       +
           sha256 = "08a8wgr1kp86nnf9xbc71l9py1plslp10xw0ah344imkwyfg0nj8";

     

       34
       35
        
         };

     

       35
       36
        
       

     

       36
       36
       -
         buildInputs = [ pkgconfig glib ]

     

       37
       37
       +
         buildInputs = [ pkgconfig glib boost ]

     

       37
       38
        
           ++ opt stdenv.isLinux systemd

     

       38
       39
        
           ++ opt (stdenv.isLinux && alsaSupport) alsaLib

     

       39
       40
        
           ++ opt flacSupport flac

     
···

       55
       56
        
           ++ opt mpg123Support mpg123

     

       56
       57
        
           ++ opt aacSupport faad2

     

       57
       58
        
           ++ opt zipSupport zziplib

     

       58
       58
       -
           ++ opt pulseaudioSupport pulseaudio;

     

       59
       59
       +
           ++ opt pulseaudioSupport pulseaudio

     

       60
       60
       +
           ++ opt icuSupport icu;

     

       59
       61
        
       

     

       60
       62
        
         configureFlags =

     

       61
       63
        
           [ (mkFlag (!stdenv.isDarwin && alsaSupport) "alsa")

     
···

       79
       81
        
             (mkFlag aacSupport "aac")

     

       80
       82
        
             (mkFlag pulseaudioSupport "pulse")

     

       81
       83
        
             (mkFlag stdenv.isDarwin "osx")

     

       84
       84
       +
             (mkFlag icuSupport "icu")

     

       82
       85
        
             "--enable-debug"

     

       83
       86
        
           ]

     

       84
       87
        
           ++ opt stdenv.isLinux

+2 -2

pkgs/servers/sql/oracle-xe/default.nix

···

       1
       1
       -
       { stdenv, makeWrapper, requireFile, patchelf, rpm, cpio, libaio }:

     

       1
       1
       +
       { stdenv, makeWrapper, requireFile, patchelf, rpmextract, libaio }:

     

       2
       2
        
       

     

       3
       3
        
       assert stdenv.system == "x86_64-linux";

     

       4
       4
        
       

     
···

       20
       20
        
       

     

       21
       21
        
         unpackCmd = ''

     

       22
       22
        
           (mkdir -p "${name}" && cd "${name}" &&

     

       23
       23
       -
             ${rpm}/bin/rpm2cpio "$curSrc" | ${cpio}/bin/cpio -id)

     

       23
       23
       +
             ${rpmextract}/bin/rpmextract "$curSrc")

     

       24
       24
        
         '';

     

       25
       25
        
       

     

       26
       26
        
         buildPhase = let

+4 -4

pkgs/tools/X11/xdotool/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, libX11, perl, libXtst, xextproto, libXi }:

     

       1
       1
       +
       { stdenv, fetchurl, libX11, perl, libXtst, xextproto, libXi, libXinerama }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.20101012.3049"; in

     

       3
       3
       +
       let version = "2.20110530.1"; in

     

       4
       4
        
       stdenv.mkDerivation {

     

       5
       5
        
         name = "xdotool-${version}";

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "http://semicomplete.googlecode.com/files/xdotool-${version}.tar.gz";

     

       8
       8
       -
           sha256 = "0amkb1zvdk0gj7va3rjw9arbyj8pgprkdik05yl6rghq21q076ls";

     

       8
       8
       +
           sha256 = "0rxggg1cy7nnkwidx8x2w3c5f3pk6dh2b6q0q7hp069r3n5jrd77";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
       -
         buildInputs = [ libX11 perl libXtst xextproto libXi ];

     

       11
       11
       +
         buildInputs = [ libX11 perl libXtst xextproto libXi libXinerama ];

     

       12
       12
        
       

     

       13
       13
        
         configurePhase = ''

     

       14
       14
        
           export makeFlags="PREFIX=$out";

+21

pkgs/tools/archivers/rpmextract/default.nix

···

       1
       1
       +
       { stdenv, fetchurl, rpm, cpio, substituteAll }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "rpmextract";

     

       5
       5
       +
       

     

       6
       6
       +
         buildCommand = ''

     

       7
       7
       +
           install -Dm755 $script $out/bin/rpmextract

     

       8
       8
       +
         '';

     

       9
       9
       +
           

     

       10
       10
       +
         script = substituteAll {

     

       11
       11
       +
           src = ./rpmextract.sh;

     

       12
       12
       +
           inherit rpm cpio;

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with stdenv.lib; {

     

       16
       16
       +
           description = "Script to extract RPM archives";

     

       17
       17
       +
           platforms = platforms.all;

     

       18
       18
       +
           license = licenses.gpl2;

     

       19
       19
       +
           maintainers = maintainers.abbradar;

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+10

pkgs/tools/archivers/rpmextract/rpmextract.sh

···

       1
       1
       +
       #!/bin/sh -e

     

       2
       2
       +
       

     

       3
       3
       +
       if [ "$1" = "" ]; then

     

       4
       4
       +
         echo "usage: rpmextract package_name..." 1>&2

     

       5
       5
       +
         exit 1

     

       6
       6
       +
       fi

     

       7
       7
       +
       

     

       8
       8
       +
       for i in "$@"; do

     

       9
       9
       +
         @rpm@/bin/rpm2cpio "$i" | @cpio@/bin/cpio -idv

     

       10
       10
       +
       done

+3 -3

pkgs/tools/audio/gvolicon/default.nix

···

       4
       4
        
         name = "gvolicon";

     

       5
       5
        
         src = fetchgit {

     

       6
       6
        
           url = "https://github.com/Unia/gvolicon";

     

       7
       7
       -
           rev = "26343415de836e0b05aa0b480c0c69cc2ed9e419";

     

       8
       8
       -
           sha256 = "68858840a45b5f74803e85116c6219f805d6d944c00354662889549910856cdd";

     

       7
       7
       +
           rev = "c04cafb88124e1e5edc61dd52f76bf13381d5167";

     

       8
       8
       +
           sha256 = "31cf770dca0d216e3108b258b4c150cbeb3b127002d53fd6ddddfcf9e3e293aa";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         buildInputs = [ pkgconfig makeWrapper alsaLib gnome3.gtk ];

     
···

       24
       24
        
           license = stdenv.lib.licenses.gpl3Plus;

     

       25
       25
        
           maintainers = [ stdenv.lib.maintainers.bennofs ];

     

       26
       26
        
         };

     

       27
       27
       -
       }
     

       27
       27
       +
       }

+54

pkgs/tools/filesystems/nixpart/0.4/blivet.nix

···

       1
       1
       +
       { stdenv, fetchurl, buildPythonPackage, pykickstart, pyparted, pyblock

     

       2
       2
       +
       , libselinux, cryptsetup, multipath_tools, lsof, utillinux

     

       3
       3
       +
       , useNixUdev ? true, udev ? null

     

       4
       4
       +
       # This is only used when useNixUdev is false

     

       5
       5
       +
       , udevSoMajor ? 1

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       assert useNixUdev -> udev != null;

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         name = "blivet-${version}";

     

       12
       12
       +
         version = "0.17-1";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchurl {

     

       15
       15
       +
           url = "https://git.fedorahosted.org/cgit/blivet.git/snapshot/"

     

       16
       16
       +
               + "${name}.tar.bz2";

     

       17
       17
       +
           sha256 = "1k3mws2q0ryb7422mml6idmaasz2i2v6ngyvg6d976dx090qnmci";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         postPatch = ''

     

       21
       21
       +
           sed -i -e 's|"multipath"|"${multipath_tools}/sbin/multipath"|' \

     

       22
       22
       +
             blivet/devicelibs/mpath.py blivet/devices.py

     

       23
       23
       +
           sed -i -e '/"wipefs"/ {

     

       24
       24
       +
             s|wipefs|${utillinux}/sbin/wipefs|

     

       25
       25
       +
             s/-f/--force/

     

       26
       26
       +
           }' blivet/formats/__init__.py

     

       27
       27
       +
           sed -i -e 's|"lsof"|"${lsof}/bin/lsof"|' blivet/formats/fs.py

     

       28
       28
       +
           sed -i -r -e 's|"(u?mount)"|"${utillinux}/bin/\1"|' blivet/util.py

     

       29
       29
       +
           sed -i '/pvscan/s/, *"--cache"//' blivet/devicelibs/lvm.py

     

       30
       30
       +
         '' + (if useNixUdev then ''

     

       31
       31
       +
           sed -i -e '/find_library/,/find_library/ {

     

       32
       32
       +
             c libudev = "${udev}/lib/libudev.so.1"

     

       33
       33
       +
           }' blivet/pyudev.py

     

       34
       34
       +
         '' else ''

     

       35
       35
       +
           sed -i \

     

       36
       36
       +
             -e '/^somajor *=/s/=.*/= ${toString udevSoMajor}/p' \

     

       37
       37
       +
             -e 's|common =.*|& + ["/lib/x86_64-linux-gnu", "/lib/i686-linux-gnu"]|' \

     

       38
       38
       +
             blivet/pyudev.py

     

       39
       39
       +
         '');

     

       40
       40
       +
       

     

       41
       41
       +
         propagatedBuildInputs = [

     

       42
       42
       +
           pykickstart pyparted pyblock libselinux cryptsetup

     

       43
       43
       +
         ] ++ stdenv.lib.optional useNixUdev udev;

     

       44
       44
       +
       

     

       45
       45
       +
         # tests are currently _heavily_ broken upstream

     

       46
       46
       +
         doCheck = false;

     

       47
       47
       +
       

     

       48
       48
       +
         meta = {

     

       49
       49
       +
           homepage = "https://fedoraproject.org/wiki/Blivet";

     

       50
       50
       +
           description = "Module for management of a system's storage configuration";

     

       51
       51
       +
           license = [ "GPLv2+" "LGPLv2.1+" ];

     

       52
       52
       +
           platforms = stdenv.lib.platforms.linux;

     

       53
       53
       +
         };

     

       54
       54
       +
       }

+28

pkgs/tools/filesystems/nixpart/0.4/cryptsetup.nix

···

       1
       1
       +
       { stdenv, fetchurl, devicemapper, libgcrypt, libuuid, pkgconfig, popt

     

       2
       2
       +
       , enablePython ? true, python ? null

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       assert enablePython -> python != null;

     

       6
       6
       +
       

     

       7
       7
       +
       stdenv.mkDerivation rec {

     

       8
       8
       +
         name = "cryptsetup-1.6.3";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "http://cryptsetup.googlecode.com/files/${name}.tar.bz2";

     

       12
       12
       +
           sha256 = "1n1qk5chyjspbiianrdb55fhb4wl0vfyqz2br05vfb24v4qlgbx2";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         configureFlags = [ "--enable-cryptsetup-reencrypt" ]

     

       16
       16
       +
                       ++ stdenv.lib.optional enablePython "--enable-python";

     

       17
       17
       +
       

     

       18
       18
       +
         buildInputs = [ devicemapper libgcrypt libuuid pkgconfig popt ]

     

       19
       19
       +
                    ++ stdenv.lib.optional enablePython python;

     

       20
       20
       +
       

     

       21
       21
       +
         meta = {

     

       22
       22
       +
           homepage = http://code.google.com/p/cryptsetup/;

     

       23
       23
       +
           description = "LUKS for dm-crypt";

     

       24
       24
       +
           license = stdenv.lib.licenses.gpl2;

     

       25
       25
       +
           maintainers = with stdenv.lib.maintainers; [ viric chaoflow ];

     

       26
       26
       +
           platforms = with stdenv.lib.platforms; linux;

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+76

pkgs/tools/filesystems/nixpart/0.4/default.nix

···

       1
       1
       +
       { stdenv, fetchurl, python, buildPythonPackage

     

       2
       2
       +
       # Propagated to blivet

     

       3
       3
       +
       , useNixUdev ? true, udevSoMajor ? null

     

       4
       4
       +
       # Propagated dependencies

     

       5
       5
       +
       , pkgs, urlgrabber

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       let

     

       9
       9
       +
         blivet = import ./blivet.nix {

     

       10
       10
       +
           inherit stdenv fetchurl buildPythonPackage;

     

       11
       11
       +
           inherit pykickstart pyparted pyblock cryptsetup multipath_tools;

     

       12
       12
       +
           inherit useNixUdev udevSoMajor;

     

       13
       13
       +
           inherit (pkgs) lsof utillinux udev;

     

       14
       14
       +
           libselinux = pkgs.libselinux.override { enablePython = true; };

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         cryptsetup = import ./cryptsetup.nix {

     

       18
       18
       +
           inherit stdenv fetchurl python;

     

       19
       19
       +
           inherit (pkgs) pkgconfig libgcrypt libuuid popt;

     

       20
       20
       +
           devicemapper = lvm2;

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         dmraid = import ./dmraid.nix {

     

       24
       24
       +
           inherit stdenv fetchurl;

     

       25
       25
       +
           devicemapper = lvm2;

     

       26
       26
       +
         };

     

       27
       27
       +
       

     

       28
       28
       +
         lvm2 = import ./lvm2.nix {

     

       29
       29
       +
           inherit stdenv fetchurl;

     

       30
       30
       +
           inherit (pkgs) pkgconfig utillinux udev coreutils;

     

       31
       31
       +
         };

     

       32
       32
       +
       

     

       33
       33
       +
         multipath_tools = import ./multipath-tools.nix {

     

       34
       34
       +
           inherit stdenv fetchurl lvm2;

     

       35
       35
       +
           inherit (pkgs) readline udev libaio gzip;

     

       36
       36
       +
         };

     

       37
       37
       +
       

     

       38
       38
       +
         parted = import ./parted.nix {

     

       39
       39
       +
           inherit stdenv fetchurl;

     

       40
       40
       +
           inherit (pkgs) utillinux readline libuuid gettext check;

     

       41
       41
       +
           devicemapper = lvm2;

     

       42
       42
       +
         };

     

       43
       43
       +
       

     

       44
       44
       +
         pyblock = import ./pyblock.nix {

     

       45
       45
       +
           inherit stdenv fetchurl python lvm2 dmraid;

     

       46
       46
       +
         };

     

       47
       47
       +
       

     

       48
       48
       +
         pykickstart = import ./pykickstart.nix {

     

       49
       49
       +
           inherit stdenv fetchurl python buildPythonPackage urlgrabber;

     

       50
       50
       +
         };

     

       51
       51
       +
       

     

       52
       52
       +
         pyparted = import ./pyparted.nix {

     

       53
       53
       +
           inherit stdenv fetchurl python buildPythonPackage parted;

     

       54
       54
       +
           inherit (pkgs) pkgconfig e2fsprogs;

     

       55
       55
       +
         };

     

       56
       56
       +
       

     

       57
       57
       +
       in buildPythonPackage rec {

     

       58
       58
       +
         name = "nixpart-${version}";

     

       59
       59
       +
         version = "0.4.1";

     

       60
       60
       +
       

     

       61
       61
       +
         src = fetchurl {

     

       62
       62
       +
           url = "https://github.com/aszlig/nixpart/archive/v${version}.tar.gz";

     

       63
       63
       +
           sha256 = "0avwd8p47xy9cydlbjxk8pj8q75zyl68gw2w6fnkk78dcb1a3swp";

     

       64
       64
       +
         };

     

       65
       65
       +
       

     

       66
       66
       +
         propagatedBuildInputs = [ blivet ];

     

       67
       67
       +
       

     

       68
       68
       +
         doCheck = false;

     

       69
       69
       +
       

     

       70
       70
       +
         meta = {

     

       71
       71
       +
           description = "NixOS storage manager/partitioner";

     

       72
       72
       +
           license = stdenv.lib.licenses.gpl2Plus;

     

       73
       73
       +
           maintainers = [ stdenv.lib.maintainers.aszlig ];

     

       74
       74
       +
           platforms = stdenv.lib.platforms.linux;

     

       75
       75
       +
         };

     

       76
       76
       +
       }

+26

pkgs/tools/filesystems/nixpart/0.4/dmraid.nix

···

       1
       1
       +
       { stdenv, fetchurl, devicemapper }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "dmraid-1.0.0.rc15";

     

       5
       5
       +
       

     

       6
       6
       +
         src = fetchurl {

     

       7
       7
       +
           url = "http://people.redhat.com/~heinzm/sw/dmraid/src/old/${name}.tar.bz2";

     

       8
       8
       +
           sha256 = "01bcaq0sc329ghgj7f182xws7jgjpdc41bvris8fsiprnxc7511h";

     

       9
       9
       +
         };

     

       10
       10
       +
       

     

       11
       11
       +
         preConfigure = "cd */";

     

       12
       12
       +
       

     

       13
       13
       +
         buildInputs = [ devicemapper ];

     

       14
       14
       +
       

     

       15
       15
       +
         meta = {

     

       16
       16
       +
           description = "Old-style RAID configuration utility";

     

       17
       17
       +
           longDescritipn = ''

     

       18
       18
       +
             Old RAID configuration utility (still under development, though).

     

       19
       19
       +
             It is fully compatible with modern kernels and mdadm recognizes

     

       20
       20
       +
             its volumes. May be needed for rescuing an older system or nuking

     

       21
       21
       +
             the metadata when reformatting.

     

       22
       22
       +
           '';

     

       23
       23
       +
           maintainers = [ stdenv.lib.maintainers.raskin ];

     

       24
       24
       +
           platforms = stdenv.lib.platforms.linux;

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+58

pkgs/tools/filesystems/nixpart/0.4/lvm2.nix

···

       1
       1
       +
       { stdenv, fetchurl, pkgconfig, udev, utillinux, coreutils }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         v = "2.02.106";

     

       5
       5
       +
       in

     

       6
       6
       +
       

     

       7
       7
       +
       stdenv.mkDerivation {

     

       8
       8
       +
         name = "lvm2-${v}";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "ftp://sources.redhat.com/pub/lvm2/releases/LVM2.${v}.tgz";

     

       12
       12
       +
           sha256 = "0nr833bl0q4zq52drjxmmpf7bs6kqxwa5kahwwxm9411khkxz0vc";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         configureFlags =

     

       16
       16
       +
           "--disable-readline --enable-udev_rules --enable-udev_sync --enable-pkgconfig --enable-applib";

     

       17
       17
       +
       

     

       18
       18
       +
         buildInputs = [ pkgconfig udev ];

     

       19
       19
       +
       

     

       20
       20
       +
         preConfigure =

     

       21
       21
       +
           ''

     

       22
       22
       +
             substituteInPlace scripts/lvmdump.sh \

     

       23
       23
       +
               --replace /usr/bin/tr ${coreutils}/bin/tr

     

       24
       24
       +
             substituteInPlace scripts/lvm2_activation_generator_systemd_red_hat.c \

     

       25
       25
       +
               --replace /usr/sbin/lvm $out/sbin/lvm \

     

       26
       26
       +
               --replace /usr/bin/udevadm ${udev}/bin/udevadm

     

       27
       27
       +
       

     

       28
       28
       +
             sed -i /DEFAULT_SYS_DIR/d Makefile.in

     

       29
       29
       +
             sed -i /DEFAULT_PROFILE_DIR/d conf/Makefile.in

     

       30
       30
       +
           '';

     

       31
       31
       +
       

     

       32
       32
       +
         enableParallelBuilding = true;

     

       33
       33
       +
       

     

       34
       34
       +
         #patches = [ ./purity.patch ];

     

       35
       35
       +
       

     

       36
       36
       +
         # To prevent make install from failing.

     

       37
       37
       +
         preInstall = "installFlags=\"OWNER= GROUP= confdir=$out/etc\"";

     

       38
       38
       +
       

     

       39
       39
       +
         # Install systemd stuff.

     

       40
       40
       +
         #installTargets = "install install_systemd_generators install_systemd_units install_tmpfiles_configuration";

     

       41
       41
       +
       

     

       42
       42
       +
         postInstall =

     

       43
       43
       +
           ''

     

       44
       44
       +
             substituteInPlace $out/lib/udev/rules.d/13-dm-disk.rules \

     

       45
       45
       +
               --replace $out/sbin/blkid ${utillinux}/sbin/blkid

     

       46
       46
       +
       

     

       47
       47
       +
             # Systemd stuff

     

       48
       48
       +
             mkdir -p $out/etc/systemd/system $out/lib/systemd/system-generators

     

       49
       49
       +
             cp scripts/blk_availability_systemd_red_hat.service $out/etc/systemd/system

     

       50
       50
       +
             cp scripts/lvm2_activation_generator_systemd_red_hat $out/lib/systemd/system-generators

     

       51
       51
       +
           '';

     

       52
       52
       +
       

     

       53
       53
       +
         meta = {

     

       54
       54
       +
           homepage = http://sourceware.org/lvm2/;

     

       55
       55
       +
           descriptions = "Tools to support Logical Volume Management (LVM) on Linux";

     

       56
       56
       +
           platforms = stdenv.lib.platforms.linux;

     

       57
       57
       +
         };

     

       58
       58
       +
       }

+34

pkgs/tools/filesystems/nixpart/0.4/multipath-tools.nix

···

       1
       1
       +
       { stdenv, fetchurl, lvm2, libaio, gzip, readline, udev }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "multipath-tools-0.4.9";

     

       5
       5
       +
       

     

       6
       6
       +
         src = fetchurl {

     

       7
       7
       +
           url = "http://christophe.varoqui.free.fr/multipath-tools/${name}.tar.bz2";

     

       8
       8
       +
           sha256 = "04n7kazp1zrlqfza32phmqla0xkcq4zwn176qff5ida4a60whi4d";

     

       9
       9
       +
         };

     

       10
       10
       +
       

     

       11
       11
       +
         sourceRoot = ".";

     

       12
       12
       +
       

     

       13
       13
       +
         buildInputs = [ lvm2 libaio readline ];

     

       14
       14
       +
       

     

       15
       15
       +
         preBuild =

     

       16
       16
       +
           ''

     

       17
       17
       +
             makeFlagsArray=(GZIP="${gzip}/bin/gzip -9 -c" prefix=$out mandir=$out/share/man/man8 man5dir=$out/share/man/man5 LIB=lib)

     

       18
       18
       +
             

     

       19
       19
       +
             substituteInPlace multipath/Makefile --replace /etc $out/etc

     

       20
       20
       +
             substituteInPlace kpartx/Makefile --replace /etc $out/etc

     

       21
       21
       +
             

     

       22
       22
       +
             substituteInPlace kpartx/kpartx.rules --replace /sbin/kpartx $out/sbin/kpartx

     

       23
       23
       +
             substituteInPlace kpartx/kpartx_id --replace /sbin/dmsetup ${lvm2}/sbin/dmsetup

     

       24
       24
       +
       

     

       25
       25
       +
             substituteInPlace libmultipath/defaults.h --replace /lib/udev/scsi_id ${udev}/lib/udev/scsi_id

     

       26
       26
       +
             substituteInPlace libmultipath/hwtable.c --replace /lib/udev/scsi_id ${udev}/lib/udev/scsi_id

     

       27
       27
       +
           '';

     

       28
       28
       +
       

     

       29
       29
       +
         meta = {

     

       30
       30
       +
           description = "Tools for the Linux multipathing driver";

     

       31
       31
       +
           homepage = http://christophe.varoqui.free.fr/;

     

       32
       32
       +
           platforms = stdenv.lib.platforms.linux;

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+57

pkgs/tools/filesystems/nixpart/0.4/parted.nix

···

       1
       1
       +
       { stdenv, fetchurl, devicemapper, libuuid, gettext, readline

     

       2
       2
       +
       , utillinux, check, enableStatic ? false, hurd ? null }:

     

       3
       3
       +
       

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       5
       5
       +
         name = "parted-3.1";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchurl {

     

       8
       8
       +
           url = "mirror://gnu/parted/${name}.tar.xz";

     

       9
       9
       +
           sha256 = "05fa4m1bky9d13hqv91jlnngzlyn7y4rnnyq6d86w0dg3vww372y";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         buildInputs = [ libuuid ]

     

       13
       13
       +
           ++ stdenv.lib.optional (readline != null) readline

     

       14
       14
       +
           ++ stdenv.lib.optional (gettext != null) gettext

     

       15
       15
       +
           ++ stdenv.lib.optional (devicemapper != null) devicemapper

     

       16
       16
       +
           ++ stdenv.lib.optional (hurd != null) hurd

     

       17
       17
       +
           ++ stdenv.lib.optional doCheck check;

     

       18
       18
       +
       

     

       19
       19
       +
         configureFlags =

     

       20
       20
       +
              (if (readline != null)

     

       21
       21
       +
               then [ "--with-readline" ]

     

       22
       22
       +
               else [ "--without-readline" ])

     

       23
       23
       +
           ++ stdenv.lib.optional (devicemapper == null) "--disable-device-mapper"

     

       24
       24
       +
           ++ stdenv.lib.optional enableStatic "--enable-static";

     

       25
       25
       +
       

     

       26
       26
       +
         doCheck = true;

     

       27
       27
       +
       

     

       28
       28
       +
         preCheck =

     

       29
       29
       +
           stdenv.lib.optionalString doCheck

     

       30
       30
       +
             # The `t0400-loop-clobber-infloop.sh' test wants `mkswap'.

     

       31
       31
       +
             "export PATH=\"${utillinux}/sbin:$PATH\"";

     

       32
       32
       +
       

     

       33
       33
       +
         meta = {

     

       34
       34
       +
           description = "Create, destroy, resize, check, and copy partitions";

     

       35
       35
       +
       

     

       36
       36
       +
           longDescription = ''

     

       37
       37
       +
             GNU Parted is an industrial-strength package for creating, destroying,

     

       38
       38
       +
             resizing, checking and copying partitions, and the file systems on

     

       39
       39
       +
             them.  This is useful for creating space for new operating systems,

     

       40
       40
       +
             reorganising disk usage, copying data on hard disks and disk imaging.

     

       41
       41
       +
       

     

       42
       42
       +
             It contains a library, libparted, and a command-line frontend, parted,

     

       43
       43
       +
             which also serves as a sample implementation and script backend.

     

       44
       44
       +
           '';

     

       45
       45
       +
       

     

       46
       46
       +
           homepage = http://www.gnu.org/software/parted/;

     

       47
       47
       +
           license = stdenv.lib.licenses.gpl3Plus;

     

       48
       48
       +
       

     

       49
       49
       +
           maintainers = [

     

       50
       50
       +
             # Add your name here!

     

       51
       51
       +
             stdenv.lib.maintainers.ludo

     

       52
       52
       +
           ];

     

       53
       53
       +
       

     

       54
       54
       +
           # GNU Parted requires libuuid, which is part of util-linux-ng.

     

       55
       55
       +
           platforms = stdenv.lib.platforms.linux;

     

       56
       56
       +
         };

     

       57
       57
       +
       }

+29

pkgs/tools/filesystems/nixpart/0.4/pyblock.nix

···

       1
       1
       +
       { stdenv, fetchurl, python, lvm2, dmraid }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "pyblock-${version}";

     

       5
       5
       +
         version = "0.53";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchurl rec {

     

       8
       8
       +
           url = "http://pkgs.fedoraproject.org/repo/pkgs/python-pyblock/"

     

       9
       9
       +
               + "${name}.tar.bz2/${md5}/${name}.tar.bz2";

     

       10
       10
       +
           md5 = "f6d33a8362dee358517d0a9e2ebdd044";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         postPatch = ''

     

       14
       14
       +
           sed -i -e 's|/usr/include/python|${python}/include/python|' \

     

       15
       15
       +
                  -e 's/-Werror *//' -e 's|/usr/|'"$out"'/|' Makefile

     

       16
       16
       +
         '';

     

       17
       17
       +
       

     

       18
       18
       +
         buildInputs = [ python lvm2 dmraid ];

     

       19
       19
       +
       

     

       20
       20
       +
         makeFlags = [

     

       21
       21
       +
           "USESELINUX=0"

     

       22
       22
       +
           "SITELIB=$(out)/lib/${python.libPrefix}/site-packages"

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = {

     

       26
       26
       +
           description = "Interface for working with block devices";

     

       27
       27
       +
           license = stdenv.lib.licenses.gpl2Plus;

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+30

pkgs/tools/filesystems/nixpart/0.4/pykickstart.nix

···

       1
       1
       +
       { stdenv, python, buildPythonPackage, fetchurl, urlgrabber }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildPythonPackage rec {

     

       4
       4
       +
         name = "pykickstart-${version}";

     

       5
       5
       +
         version = "1.99.39";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchurl rec {

     

       8
       8
       +
           url = "http://pkgs.fedoraproject.org/repo/pkgs/pykickstart/"

     

       9
       9
       +
               + "${name}.tar.gz/${md5}/${name}.tar.gz";

     

       10
       10
       +
           md5 = "d249f60aa89b1b4facd63f776925116d";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         postPatch = ''

     

       14
       14
       +
           sed -i -e "s/for tst in tstList/for tst in sorted(tstList, \

     

       15
       15
       +
                      key=lambda m: m.__name__)/" tests/baseclass.py

     

       16
       16
       +
         '';

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedBuildInputs = [ urlgrabber ];

     

       19
       19
       +
       

     

       20
       20
       +
         checkPhase = ''

     

       21
       21
       +
           export PYTHONPATH="$PYTHONPATH:."

     

       22
       22
       +
           ${python}/bin/${python.executable} tests/baseclass.py -vv

     

       23
       23
       +
         '';

     

       24
       24
       +
       

     

       25
       25
       +
         meta = {

     

       26
       26
       +
           homepage = "http://fedoraproject.org/wiki/Pykickstart";

     

       27
       27
       +
           description = "Read and write Fedora kickstart files";

     

       28
       28
       +
           license = stdenv.lib.licenses.gpl2Plus;

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+42

pkgs/tools/filesystems/nixpart/0.4/pyparted.nix

···

       1
       1
       +
       { stdenv, fetchurl, pkgconfig, python, buildPythonPackage, parted, e2fsprogs }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildPythonPackage rec {

     

       4
       4
       +
         name = "pyparted-${version}";

     

       5
       5
       +
         version = "3.10";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchurl {

     

       8
       8
       +
           url = "https://fedorahosted.org/releases/p/y/pyparted/${name}.tar.gz";

     

       9
       9
       +
           sha256 = "17wq4invmv1nfazaksf59ymqyvgv3i8h4q03ry2az0s9lldyg3dv";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         postPatch = ''

     

       13
       13
       +
           sed -i -e 's|/sbin/mke2fs|${e2fsprogs}&|' tests/baseclass.py

     

       14
       14
       +
           sed -i -e '

     

       15
       15
       +
             s|e\.path\.startswith("/tmp/temp-device-")|"temp-device-" in e.path|

     

       16
       16
       +
           ' tests/test__ped_ped.py

     

       17
       17
       +
         '' + stdenv.lib.optionalString stdenv.isi686 ''

     

       18
       18
       +
           # remove some integers in this test case which overflow on 32bit systems

     

       19
       19
       +
           sed -i -r -e '/class *UnitGetSizeTestCase/,/^$/{/[0-9]{11}/d}' \

     

       20
       20
       +
             tests/test__ped_ped.py

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         preConfigure = ''

     

       24
       24
       +
           PATH="${parted}/sbin:$PATH"

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         buildInputs = [ pkgconfig ];

     

       28
       28
       +
       

     

       29
       29
       +
         propagatedBuildInputs = [ parted ];

     

       30
       30
       +
       

     

       31
       31
       +
         checkPhase = ''

     

       32
       32
       +
           patchShebangs Makefile

     

       33
       33
       +
           make test PYTHON=${python.executable}

     

       34
       34
       +
         '';

     

       35
       35
       +
       

     

       36
       36
       +
         meta = {

     

       37
       37
       +
           homepage = "https://fedorahosted.org/pyparted/";

     

       38
       38
       +
           description = "Python interface for libparted";

     

       39
       39
       +
           license = stdenv.lib.licenses.gpl2Plus;

     

       40
       40
       +
           platforms = stdenv.lib.platforms.linux;

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+5 -13

pkgs/tools/filesystems/nixpart/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, buildPythonPackage, blivet

     

       2
       2
       -
       # Propagated to blivet

     

       3
       3
       -
       , useNixUdev ? null, udevSoMajor ? null

     

       4
       4
       -
       }:

     

       1
       1
       +
       { stdenv, fetchurl, buildPythonPackage, blivet }:

     

       5
       2
        
       

     

       6
       6
       -
       let

     

       7
       7
       -
         blivetOverrides = stdenv.lib.filterAttrs (k: v: v != null) {

     

       8
       8
       -
           inherit useNixUdev udevSoMajor;

     

       9
       9
       -
         };

     

       10
       10
       -
       in buildPythonPackage rec {

     

       3
       3
       +
       buildPythonPackage rec {

     

       11
       4
        
         name = "nixpart-${version}";

     

       12
       12
       -
         version = "0.4.1";

     

       5
       5
       +
         version = "1.0.0";

     

       13
       6
        
       

     

       14
       7
        
         src = fetchurl {

     

       15
       8
        
           url = "https://github.com/aszlig/nixpart/archive/v${version}.tar.gz";

     

       16
       9
        
           sha256 = "0avwd8p47xy9cydlbjxk8pj8q75zyl68gw2w6fnkk78dcb1a3swp";

     

       17
       10
        
         };

     

       18
       11
        
       

     

       19
       19
       -
         propagatedBuildInputs = [ (blivet.override blivetOverrides) ];

     

       20
       20
       -
       

     

       21
       21
       -
         doCheck = false;

     

       12
       12
       +
         propagatedBuildInputs = [ blivet ];

     

       22
       13
        
       

     

       23
       14
        
         meta = {

     

       24
       15
        
           description = "NixOS storage manager/partitioner";

     

       25
       16
        
           license = stdenv.lib.licenses.gpl2Plus;

     

       26
       17
        
           maintainers = [ stdenv.lib.maintainers.aszlig ];

     

       27
       18
        
           platforms = stdenv.lib.platforms.linux;

     

       19
       19
       +
           broken = true;

     

       28
       20
        
         };

     

       29
       21
        
       }

+8 -6

pkgs/tools/filesystems/squashfs/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, zlib, xz }:

     

       1
       1
       +
       { stdenv, fetchgit, zlib, xz }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "squashfs-4.3";

     

       4
       4
       +
         name = "squashfs-4.4dev";

     

       5
       5
        
       

     

       6
       6
       -
         src = fetchurl {

     

       7
       7
       -
           url = mirror://sourceforge/squashfs/squashfs4.3.tar.gz;

     

       8
       8
       -
           sha256 = "1xpklm0y43nd9i6jw43y2xh5zvlmj9ar2rvknh0bh7kv8c95aq0d";

     

       6
       6
       +
         src = fetchgit {

     

       7
       7
       +
           url = https://github.com/plougher/squashfs-tools.git;

     

       8
       8
       +
           sha256 = "059pa2shdysr3zfmwrhq28s12zbi5nyzbpzyaf5lmspgfh1493ks";

     

       9
       9
       +
           rev = "9c1db6d13a51a2e009f0027ef336ce03624eac0d";

     

       9
       10
        
         };

     

       10
       11
        
       

     

       11
       12
        
         buildInputs = [ zlib xz ];

     

       12
       13
        
       

     

       13
       14
        
         preBuild = "cd squashfs-tools";

     

       14
       14
       -
       

     

       15
       15
       +
         

     

       15
       16
        
         NIX_LDFLAGS = "-lgcc_s"; # for pthread_cancel

     

       16
       17
        
       

     

       17
       18
        
         installFlags = "INSTALL_DIR=\${out}/bin";

     
···

       21
       22
        
         meta = {

     

       22
       23
        
           homepage = http://squashfs.sourceforge.net/;

     

       23
       24
        
           description = "Tool for creating and unpacking squashfs filesystems";

     

       25
       25
       +
           platforms = stdenv.lib.platforms.linux;

     

       24
       26
        
         };

     

       25
       27
        
       }

+2 -2

pkgs/tools/filesystems/yandex-disk/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, writeText, zlib, rpm, cpio, patchelf, which }:

     

       1
       1
       +
       { stdenv, fetchurl, writeText, zlib, rpmextract, patchelf, which }:

     

       2
       2
        
       

     

       3
       3
        
       assert stdenv.isLinux;

     

       4
       4
        
       

     
···

       31
       31
        
       

     

       32
       32
        
           mkdir -pv unpacked

     

       33
       33
        
           cd unpacked

     

       34
       34
       -
           ${rpm}/bin/rpm2cpio $src | ${cpio}/bin/cpio -imd

     

       34
       34
       +
           ${rpmextract}/bin/rpmextract $src

     

       35
       35
        
       

     

       36
       36
        
           cp -r -t $out/bin usr/bin/*

     

       37
       37
        
           cp -r -t $out/share usr/share/*

+3 -3

pkgs/tools/misc/megacli/default.nix

···

       1
       1
       -
       { stdenv, rpm, cpio, ncurses, patchelf, makeWrapper, requireFile, unzip }:

     

       1
       1
       +
       { stdenv, rpmextract, ncurses, patchelf, makeWrapper, requireFile, unzip }:

     

       2
       2
        
       

     

       3
       3
        
       assert stdenv.system == "x86_64-linux";

     

       4
       4
        
       

     
···

       12
       12
        
             sha256 = "11jzvh25mlygflazd37gi05xv67im4rgq7sbs5nwgw3gxdh4xfjj";

     

       13
       13
        
           };

     

       14
       14
        
       

     

       15
       15
       -
         buildInputs = [rpm cpio ncurses unzip makeWrapper];

     

       15
       15
       +
         buildInputs = [rpmextract ncurses unzip makeWrapper];

     

       16
       16
        
         libPath =

     

       17
       17
        
           stdenv.lib.makeLibraryPath

     

       18
       18
        
              [ stdenv.gcc.gcc stdenv.gcc.libc ncurses ];

     
···

       21
       21
        
           mkdir -p $out/bin

     

       22
       22
        
           cd $out

     

       23
       23
        
           unzip ${src}

     

       24
       24
       -
           rpm2cpio linux/MegaCli-8.07.07-1.noarch.rpm | cpio -idmv

     

       24
       24
       +
           rpmextract linux/MegaCli-8.07.07-1.noarch.rpm

     

       25
       25
        
           ${patchelf}/bin/patchelf --interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" --set-rpath ${libPath}:$out/opt/lsi/3rdpartylibs/x86_64:$out/opt/lsi/3rdpartylibs:${stdenv.gcc.gcc}/lib64:${stdenv.gcc.gcc}/lib opt/MegaRAID/MegaCli/MegaCli64

     

       26
       26
        
           wrapProgram $out/opt/MegaRAID/MegaCli/MegaCli64 --set LD_LIBRARY_PATH $out/opt/lsi/3rdpartylibs/x86_64

     

       27
       27
        
           ln -s $out/opt/MegaRAID/MegaCli/MegaCli64 $out/bin/MegaCli64

+10 -4

pkgs/tools/misc/parted/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, devicemapper, libuuid, gettext, readline

     

       1
       1
       +
       { stdenv, fetchurl, devicemapper, libuuid, gettext, readline, perl, python

     

       2
       2
        
       , utillinux, check, enableStatic ? false, hurd ? null }:

     

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
       -
         name = "parted-3.1";

     

       5
       5
       +
         name = "parted-3.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://gnu/parted/${name}.tar.xz";

     

       9
       9
       -
           sha256 = "05fa4m1bky9d13hqv91jlnngzlyn7y4rnnyq6d86w0dg3vww372y";

     

       9
       9
       +
           sha256 = "1r3qpg3bhz37mgvp9chsaa3k0csby3vayfvz8ggsqz194af5i2w5";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       +
         patches = stdenv.lib.optional doCheck ./gpt-unicode-test-fix.patch;

     

       13
       13
       +
       

     

       14
       14
       +
         postPatch = stdenv.lib.optionalString doCheck ''

     

       15
       15
       +
           patchShebangs tests

     

       16
       16
       +
         '';

     

       17
       17
       +
       

     

       12
       18
        
         buildInputs = [ libuuid ]

     

       13
       19
        
           ++ stdenv.lib.optional (readline != null) readline

     

       14
       20
        
           ++ stdenv.lib.optional (gettext != null) gettext

     

       15
       21
        
           ++ stdenv.lib.optional (devicemapper != null) devicemapper

     

       16
       22
        
           ++ stdenv.lib.optional (hurd != null) hurd

     

       17
       17
       -
           ++ stdenv.lib.optional doCheck check;

     

       23
       23
       +
           ++ stdenv.lib.optionals doCheck [ check perl python ];

     

       18
       24
        
       

     

       19
       25
        
         configureFlags =

     

       20
       26
        
              (if (readline != null)

+38

pkgs/tools/misc/parted/gpt-unicode-test-fix.patch

···

       1
       1
       +
       From Ludo's suggestion at:

     

       2
       2
       +
       

     

       3
       3
       +
         http://debbugs.gnu.org/cgi/bugreport.cgi?msg=8;bug=18258

     

       4
       4
       +
       

     

       5
       5
       +
       diff --git a/tests/.t0251-gpt-unicode.sh.swp b/tests/.t0251-gpt-unicode.sh.swp

     

       6
       6
       +
       deleted file mode 100644

     

       7
       7
       +
       index b41c337..0000000

     

       8
       8
       +
       Binary files a/tests/.t0251-gpt-unicode.sh.swp and /dev/null differ

     

       9
       9
       +
       diff --git a/tests/t0251-gpt-unicode.sh b/tests/t0251-gpt-unicode.sh

     

       10
       10
       +
       index c845950..fa63a72 100755

     

       11
       11
       +
       --- a/tests/t0251-gpt-unicode.sh

     

       12
       12
       +
       +++ b/tests/t0251-gpt-unicode.sh

     

       13
       13
       +
       @@ -22,7 +22,24 @@ dev=loop-file

     

       14
       14
       +
        # create zeroed device

     

       15
       15
       +
        truncate -s 10m $dev || fail=1

     

       16
       16
       +
        

     

       17
       17
       +
       -export LC_ALL=C.UTF-8

     

       18
       18
       +
       +found_locale=no

     

       19
       19
       +
       +for locale in en_US de_DE fr_FR es_ES

     

       20
       20
       +
       +do

     

       21
       21
       +
       +  LC_ALL="$locale.UTF-8"

     

       22
       22
       +
       +  export LC_ALL

     

       23
       23
       +
       +

     

       24
       24
       +
       +  # In a UTF-8 locale, the string below prints as 4 characters.

     

       25
       25
       +
       +  if [ `printf 'foo\341\264\244' | wc -m` -eq 4 ]; then

     

       26
       26
       +
       +    found_locale=yes

     

       27
       27
       +
       +    break

     

       28
       28
       +
       +  fi

     

       29
       29
       +
       +done

     

       30
       30
       +
       +

     

       31
       31
       +
       +if [ "$found_locale" != "yes" ]; then

     

       32
       32
       +
       +  echo "no valid UTF-8 locale found; skipping" >&2

     

       33
       33
       +
       +  exit 77

     

       34
       34
       +
       +fi

     

       35
       35
       +
       +

     

       36
       36
       +
        # create gpt label with named partition

     

       37
       37
       +
        part_name=$(printf 'foo\341\264\244')

     

       38
       38
       +
        parted -s $dev mklabel gpt mkpart primary ext2 1MiB 2MiB name 1 $part_name > empty 2>&1 || fail=1

+97

pkgs/tools/misc/pipelight/default.nix

···

       1
       1
       +
       { stdenv, fetchurl, fetchgit, autoconf, automake, wineUnstable, perl, xlibs

     

       2
       2
       +
         , gnupg, gcc48_multi, mesa, curl, bash, cacert, cabextract, utillinux, attr

     

       3
       3
       +
         }:

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         wine_patches_version = "1.7.28";

     

       7
       7
       +
         wine_hash = "04r3zk3dz2vzly2a4nqbcvppjs5iy3lq5ibx3wfrf877p5bz3hv7";

     

       8
       8
       +
       

     

       9
       9
       +
         wine_patches = fetchgit {

     

       10
       10
       +
           url = "git://github.com/compholio/wine-compholio.git";

     

       11
       11
       +
           rev = "refs/tags/v${wine_patches_version}";

     

       12
       12
       +
           sha256 = "17f1wmxbx6ly1ws4p528ijf9b4yvmnmap5k7npw9icvkyaky5xi9";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         wine_custom =

     

       16
       16
       +
           stdenv.lib.overrideDerivation wineUnstable (args: rec {

     

       17
       17
       +
             name = "wine-${wine_patches_version}";

     

       18
       18
       +
             version = "${wine_patches_version}";

     

       19
       19
       +
             src = null;

     

       20
       20
       +
             srcs = [

     

       21
       21
       +
       	      (fetchurl {

     

       22
       22
       +
                       url = "mirror://sourceforge/wine/${name}.tar.bz2";

     

       23
       23
       +
                       sha256 = wine_hash;

     

       24
       24
       +
       	      })

     

       25
       25
       +
       	      wine_patches ];

     

       26
       26
       +
             sourceRoot = "./${name}";

     

       27
       27
       +
             buildInputs = args.buildInputs ++ [ 

     

       28
       28
       +
               autoconf perl utillinux automake attr 

     

       29
       29
       +
             ];

     

       30
       30
       +
             nativeBuildInputs = args.nativeBuildInputs ++ [ 

     

       31
       31
       +
               autoconf perl utillinux automake attr 

     

       32
       32
       +
             ];

     

       33
       33
       +
             postPatch = ''

     

       34
       34
       +
               export wineDir=$(pwd)

     

       35
       35
       +
               patchShebangs $wineDir/tools/

     

       36
       36
       +
       	chmod u+w $wineDir/../git-export/debian/tools/

     

       37
       37
       +
               patchShebangs $wineDir/../git-export/debian/tools/

     

       38
       38
       +
               chmod -R +rwx ../git-export/

     

       39
       39
       +
               make -C ../git-export/patches DESTDIR=$wineDir install

     

       40
       40
       +
             '';

     

       41
       41
       +
           });

     

       42
       42
       +
       

     

       43
       43
       +
         mozillaPluginPath = "/lib/mozilla/plugins";

     

       44
       44
       +
       

     

       45
       45
       +
       

     

       46
       46
       +
       in stdenv.mkDerivation rec {

     

       47
       47
       +
       

     

       48
       48
       +
         version = "0.2.7.2";

     

       49
       49
       +
       

     

       50
       50
       +
         name = "pipelight-${version}";

     

       51
       51
       +
       

     

       52
       52
       +
         src = fetchurl {

     

       53
       53
       +
           url = "https://bitbucket.org/mmueller2012/pipelight/get/v${version}.tar.gz";

     

       54
       54
       +
           sha256 = "02132151091f1f62d7409a537649efc86deb0eb4a323fd66907fc22947e2cfbd";

     

       55
       55
       +
         };

     

       56
       56
       +
       

     

       57
       57
       +
         buildInputs = [ wine_custom xlibs.libX11 gcc48_multi mesa curl ];

     

       58
       58
       +
         propagatedbuildInputs = [ curl cabextract ];

     

       59
       59
       +
       

     

       60
       60
       +
         patches = [ ./pipelight.patch ];

     

       61
       61
       +
       

     

       62
       62
       +
         configurePhase = ''

     

       63
       63
       +
           patchShebangs . 

     

       64
       64
       +
           ./configure \

     

       65
       65
       +
             --prefix=$out \

     

       66
       66
       +
             --moz-plugin-path=$out/${mozillaPluginPath} \

     

       67
       67
       +
             --wine-path=${wine_custom} \

     

       68
       68
       +
             --gpg-exec=${gnupg}/bin/gpg2 \

     

       69
       69
       +
             --bash-interp=${bash}/bin/bash \

     

       70
       70
       +
             --downloader=${curl}/bin/curl

     

       71
       71
       +
             $configureFlags

     

       72
       72
       +
         '';

     

       73
       73
       +
       

     

       74
       74
       +
         passthru = {

     

       75
       75
       +
           mozillaPlugin = mozillaPluginPath;

     

       76
       76
       +
           wine = wine_custom;

     

       77
       77
       +
         };

     

       78
       78
       +
       

     

       79
       79
       +
         postInstall = ''

     

       80
       80
       +
           $out/bin/pipelight-plugin --create-mozilla-plugins

     

       81
       81
       +
         '';

     

       82
       82
       +
       

     

       83
       83
       +
         preFixup = ''

     

       84
       84
       +
           substituteInPlace $out/share/pipelight/install-dependency \

     

       85
       85
       +
             --replace cabextract ${cabextract}/bin/cabextract

     

       86
       86
       +
         '';

     

       87
       87
       +
       

     

       88
       88
       +
         enableParallelBuilding = true;

     

       89
       89
       +
       

     

       90
       90
       +
         meta = {

     

       91
       91
       +
           homepage = "http://pipelight.net/";

     

       92
       92
       +
           licenses = with stdenv.lib.licenses; [ mpl11 gpl2 lgpl21 ];

     

       93
       93
       +
           description = "A wrapper for using Windows plugins in Linux browsers";

     

       94
       94
       +
           maintainers = with stdenv.lib.maintainers; [skeidel];

     

       95
       95
       +
           platforms = with stdenv.lib.platforms; linux;

     

       96
       96
       +
         };

     

       97
       97
       +
       }

+149

pkgs/tools/misc/pipelight/pipelight.patch

···

       1
       1
       +
       diff -urN pipelight.old/bin/pipelight-plugin.in pipelight.new/bin/pipelight-plugin.in

     

       2
       2
       +
       --- pipelight.old/bin/pipelight-plugin.in	2014-07-19 22:53:02.000000000 +0200

     

       3
       3
       +
       +++ pipelight.new/bin/pipelight-plugin.in	2014-07-27 00:02:39.275834030 +0200

     

       4
       4
       +
       @@ -92,7 +92,7 @@

     

       5
       5
       +
       	PLUGIN_PATH=$(realpath "$PLUGIN_PATH")

     

       6
       6
       +
       

     

       7
       7
       +
       	# Global installation

     

       8
       8
       +
       -	if [ $(/usr/bin/id -u) -eq 0 ]; then

     

       9
       9
       +
       +	if [ $(id -u) -eq 0 ]; then

     

       10
       10
       +
       		INSTALLDIR="$PLUGIN_PATH"

     

       11
       11
       +
       

     

       12
       12
       +
       	# Use environment variable (only if it doesn't point to the global directory)

     

       13
       13
       +
       @@ -594,7 +594,7 @@

     

       14
       14
       +
       	fi

     

       15
       15
       +
       

     

       16
       16
       +
       	# Ensure the signature is valid, extract the content

     

       17
       17
       +
       -	if ! @@GPG@@ --batch --no-default-keyring --keyring "$PIPELIGHT_SHARE_PATH/sig-install-dependency.gpg" --decrypt "$tmpfile" > "$decfile"; then

     

       18
       18
       +
       +	if ! @@GPG@@ --homedir /tmp --batch --no-default-keyring --keyring "$PIPELIGHT_SHARE_PATH/sig-install-dependency.gpg" --decrypt "$tmpfile" > "$decfile"; then

     

       19
       19
       +
       		rm "$tmpfile"

     

       20
       20
       +
       		rm "$decfile"

     

       21
       21
       +
       		echo ""

     

       22
       22
       +
       @@ -630,24 +630,10 @@

     

       23
       23
       +
       	return 0

     

       24
       24
       +
        }

     

       25
       25
       +
       

     

       26
       26
       +
       -# Use fetch on FreeBSD if wget is not available

     

       27
       27
       +
       -if command -v wget >/dev/null 2>&1; then

     

       28
       28
       +
       -	download_file()

     

       29
       29
       +
       -	{

     

       30
       30
       +
       -		wget -O "$1" "$2"

     

       31
       31
       +
       -	}

     

       32
       32
       +
       -elif command -v fetch >/dev/null 2>&1; then

     

       33
       33
       +
       -	download_file()

     

       34
       34
       +
       -	{

     

       35
       35
       +
       -		fetch -o "$1" "$2"

     

       36
       36
       +
       -	}

     

       37
       37
       +
       -else

     

       38
       38
       +
       -	download_file()

     

       39
       39
       +
       -	{

     

       40
       40
       +
       -		echo "ERROR: Could neither find wget nor fetch. Unable to download file!" >&2

     

       41
       41
       +
       -		return 1

     

       42
       42
       +
       -	}

     

       43
       43
       +
       -fi

     

       44
       44
       +
       +download_file()

     

       45
       45
       +
       +{

     

       46
       46
       +
       +	curl --cacert /etc/ssl/certs/ca-bundle.crt -o "$1" "$2"

     

       47
       47
       +
       +}

     

       48
       48
       +
       

     

       49
       49
       +
        # Use shasum instead of sha256sum on MacOS / *BSD

     

       50
       50
       +
        if ! command -v sha256sum >/dev/null 2>&1 && command -v shasum >/dev/null 2>&1; then

     

       51
       51
       +
       diff -urN pipelight.old/configure pipelight.new/configure

     

       52
       52
       +
       --- pipelight.old/configure	2014-07-19 22:53:02.000000000 +0200

     

       53
       53
       +
       +++ pipelight.new/configure	2014-07-26 23:52:13.690881447 +0200

     

       54
       54
       +
       @@ -66,12 +66,8 @@

     

       55
       55
       +
        datadir=""

     

       56
       56
       +
        libdir=""

     

       57
       57
       +
        mandir=""

     

       58
       58
       +
       -bash_interp="$(which bash)"

     

       59
       59
       +
       -if which gpg &> /dev/null; then

     

       60
       60
       +
       -	gpg_exec="$(which gpg)"

     

       61
       61
       +
       -else

     

       62
       62
       +
       -	gpg_exec="/usr/bin/gpg"

     

       63
       63
       +
       -fi

     

       64
       64
       +
       +bash_interp=bash

     

       65
       65
       +
       +gpg_exec=gpg2

     

       66
       66
       +
        moz_plugin_path=""

     

       67
       67
       +
        gcc_runtime_dlls=""

     

       68
       68
       +
        so_mode="0644"

     

       69
       69
       +
       diff -urN pipelight.old/Makefile pipelight.new/Makefile

     

       70
       70
       +
       --- pipelight.old/Makefile	2014-07-19 22:53:02.000000000 +0200

     

       71
       71
       +
       +++ pipelight.new/Makefile	2014-07-26 23:25:22.020707765 +0200

     

       72
       72
       +
       @@ -29,7 +29,7 @@

     

       73
       73
       +
       			-e 's|@@BINDIR@@|$(bindir)|g' \

     

       74
       74
       +
       			-e 's|@@DATADIR@@|$(datadir)|g' \

     

       75
       75
       +
       			-e 's|@@GCC_RUNTIME_DLLS@@|$(gcc_runtime_dlls)|g' \

     

       76
       76
       +
       -			-e 's|@@GPG@@|$(gpgexec)|g' \

     

       77
       77
       +
       +			-e 's|@@GPG@@|$(gpg_exec)|g' \

     

       78
       78
       +
       			-e 's|@@LIBDIR@@|$(libdir)|g' \

     

       79
       79
       +
       			-e 's|@@MANDIR@@|$(mandir)|g' \

     

       80
       80
       +
       			-e 's|@@MOZ_PLUGIN_PATH@@|$(moz_plugin_path)|g' \

     

       81
       81
       +
       @@ -69,12 +69,12 @@

     

       82
       82
       +
       

     

       83
       83
       +
        .PHONY: prebuilt32

     

       84
       84
       +
        prebuilt32: config.make pluginloader-$(git_commit).tar.gz pluginloader-$(git_commit).tar.gz.sig

     

       85
       85
       +
       -	$(gpgexec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"

     

       86
       86
       +
       +	$(gpg_exec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"

     

       87
       87
       +
       	tar -xvf "pluginloader-$(git_commit).tar.gz" src/windows/pluginloader.exe src/winecheck/winecheck.exe

     

       88
       88
       +
       

     

       89
       89
       +
        .PHONY: prebuilt64

     

       90
       90
       +
        prebuilt64: config.make pluginloader-$(git_commit).tar.gz pluginloader-$(git_commit).tar.gz.sig

     

       91
       91
       +
       -	$(gpgexec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"

     

       92
       92
       +
       +	$(gpg_exec) --batch --no-default-keyring --keyring "share/sig-pluginloader.gpg" --verify "pluginloader-$(git_commit).tar.gz.sig"

     

       93
       93
       +
       	tar -xvf "pluginloader-$(git_commit).tar.gz" src/windows/pluginloader64.exe src/winecheck/winecheck64.exe

     

       94
       94
       +
       

     

       95
       95
       +
        .PHONY: pluginloader32

     

       96
       96
       +
       diff -urN pipelight.old/share/install-dependency pipelight.new/share/install-dependency

     

       97
       97
       +
       --- pipelight.old/share/install-dependency	2014-07-19 22:53:02.000000000 +0200

     

       98
       98
       +
       +++ pipelight.new/share/install-dependency	2014-07-26 23:26:18.431938546 +0200

     

       99
       99
       +
       @@ -734,42 +734,14 @@

     

       100
       100
       +
       	return 0

     

       101
       101
       +
        }

     

       102
       102
       +
       

     

       103
       103
       +
       -# Use fetch on FreeBSD if wget is not available

     

       104
       104
       +
       -if command -v wget >/dev/null 2>&1; then

     

       105
       105
       +
       -	download_file()

     

       106
       106
       +
       -	{

     

       107
       107
       +
       -		wget -O "$1" "$2"

     

       108
       108
       +
       -	}

     

       109
       109
       +
       -	get_download_size()

     

       110
       110
       +
       -	{

     

       111
       111
       +
       -		local filesize="$(wget -O- "$1" --spider --server-response 2>&1 | sed -ne '/Content-Length/{s/.*: //;p}')"

     

       112
       112
       +
       -		local re='^[0-9]+$'

     

       113
       113
       +
       -		if [[ "$filesize" -ne "0" ]] && [[ "$filesize" =~ $re ]]; then

     

       114
       114
       +
       -			echo "$(($filesize/(1024*1024)))"

     

       115
       115
       +
       -		else

     

       116
       116
       +
       -			echo "N/A"

     

       117
       117
       +
       -		fi

     

       118
       118
       +
       -	}

     

       119
       119
       +
       -elif command -v fetch >/dev/null 2>&1; then

     

       120
       120
       +
       -	download_file()

     

       121
       121
       +
       -	{

     

       122
       122
       +
       -		fetch -o "$1" "$2"

     

       123
       123
       +
       -	}

     

       124
       124
       +
       -	get_download_size()

     

       125
       125
       +
       -	{

     

       126
       126
       +
       -		echo "N/A"

     

       127
       127
       +
       -	}

     

       128
       128
       +
       -else

     

       129
       129
       +
       -	download_file()

     

       130
       130
       +
       -	{

     

       131
       131
       +
       -		echo "ERROR: Could neither find wget nor fetch. Unable to download file!" >&2

     

       132
       132
       +
       -		return 1

     

       133
       133
       +
       -	}

     

       134
       134
       +
       -	get_download_size()

     

       135
       135
       +
       -	{

     

       136
       136
       +
       -		echo "N/A"

     

       137
       137
       +
       -	}

     

       138
       138
       +
       -fi

     

       139
       139
       +
       +download_file()

     

       140
       140
       +
       +{

     

       141
       141
       +
       +	curl --cacert /etc/ssl/certs/ca-bundle.crt -o "$1" "$2"

     

       142
       142
       +
       +}

     

       143
       143
       +
       +get_download_size()

     

       144
       144
       +
       +{

     

       145
       145
       +
       +	echo "N/A"

     

       146
       146
       +
       +}

     

       147
       147
       +
       

     

       148
       148
       +
        # Use shasum instead of sha256sum on MacOS / *BSD

     

       149
       149
       +
        if ! command -v sha256sum >/dev/null 2>&1 && command -v shasum >/dev/null 2>&1; then

+3 -4

pkgs/tools/misc/tmux/default.nix

···

       1
       1
       -
       {stdenv, fetchurl, ncurses, libevent, pkgconfig, makeWrapper}:

     

       1
       1
       +
       {stdenv, fetchurl, ncurses, libevent, pkgconfig}:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "tmux";

     
···

       12
       12
        
       

     

       13
       13
        
         nativeBuildInputs = [ pkgconfig ];

     

       14
       14
        
       

     

       15
       15
       -
         buildInputs = [ ncurses libevent makeWrapper ];

     

       15
       15
       +
         buildInputs = [ ncurses libevent ];

     

       16
       16
        
       

     

       17
       17
        
         postInstall =

     

       18
       18
        
           ''

     

       19
       19
        
             mkdir -p $out/etc/bash_completion.d

     

       20
       20
        
             cp -v examples/bash_completion_tmux.sh $out/etc/bash_completion.d/tmux

     

       21
       21
       -
             wrapProgram $out/bin/tmux --prefix TERMINFO : $out/share/terminfo

     

       22
       21
        
           '';

     

       23
       22
        
       

     

       24
       23
        
         meta = {

     
···

       36
       35
        
                 * Interactive menus to select windows, sessions or clients.

     

       37
       36
        
                 * Change the current window by searching for text in the target.

     

       38
       37
        
                 * Terminal locking, manually or after a timeout.

     

       39
       39
       -
                 * A clean, easily extended, BSD-licensed codebase, under active development. 

     

       38
       38
       +
                 * A clean, easily extended, BSD-licensed codebase, under active development.

     

       40
       39
        
             '';

     

       41
       40
        
       

     

       42
       41
        
           license = stdenv.lib.licenses.bsd3;

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

···

       26
       26
        
           homepage = "http://rg3.github.com/youtube-dl/";

     

       27
       27
        
           repositories.git = https://github.com/rg3/youtube-dl.git;

     

       28
       28
        
           description = "Command-line tool to download videos from YouTube.com and other sites";

     

       29
       29
       +
           license = stdenv.lib.licenses.unlicense;

     

       29
       30
        
       

     

       30
       31
        
           platforms = with stdenv.lib.platforms; linux ++ darwin;

     

       31
       32
        
           maintainers = with stdenv.lib.maintainers; [ bluescreen303 simons phreedom ];

+4 -1

pkgs/tools/networking/cadaver/default.nix

···

       1
       1
       -
       { stdenv, fetchurl }:

     

       1
       1
       +
       { stdenv, fetchurl, openssl }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "cadaver-0.23.3";

     
···

       7
       7
        
           url = "http://www.webdav.org/cadaver/${name}.tar.gz";

     

       8
       8
        
           sha256 = "1jizq69ifrjbjvz5y79wh1ny94gsdby4gdxwjad4bfih6a5fck7x";

     

       9
       9
        
         };

     

       10
       10
       +
       

     

       11
       11
       +
         buildInputs = [openssl];

     

       12
       12
       +
         configureFlags = ["--with-ssl"];

     

       10
       13
        
       

     

       11
       14
        
         meta = with stdenv.lib; {

     

       12
       15
        
           description = "A command-line WebDAV client for Unix";

+14 -13

pkgs/tools/networking/cjdns/default.nix

···

       1
       1
       -
       { stdenv, fetchgit, nodejs, which, python27 }:

     

       1
       1
       +
       { stdenv, fetchFromGitHub, nodejs, which, python27 }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         date = "20140922";

     

       5
       5
       -
         rev = "5ebca772b0582173127e8c1e61ee235c5ab3fb50";

     

       4
       4
       +
         date = "20140928";

     

       5
       5
       +
         rev = "e2b673698e471dbc82b4e9dbc04cb9e16f1f06a6";

     

       6
       6
        
       in

     

       7
       7
        
       stdenv.mkDerivation {

     

       8
       8
        
         name = "cjdns-${date}-${stdenv.lib.strings.substring 0 7 rev}";

     

       9
       9
        
       

     

       10
       10
       -
         src = fetchgit {

     

       11
       11
       -
           url = "https://github.com/cjdelisle/cjdns.git";

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "cjdelisle";

     

       12
       12
       +
           repo = "cjdns";

     

       12
       13
        
           inherit rev;

     

       13
       13
       -
           sha256 = "04abf73f4aede12c35b70ae09a367b3d6352a63f818185f788ed13356d06197a";

     

       14
       14
       +
           sha256 = "0ql51845rni6678dda03zr18ary7xlqcs3khva9x80x815h1sy8v";

     

       14
       15
        
         };

     

       15
       16
        
       

     

       16
       16
       -
         buildInputs = [ which python27 nodejs];

     

       17
       17
       +
         patches = [ ./rfc5952.patch ];

     

       17
       18
        
       

     

       18
       18
       -
         patches = [ ./makekey.patch ];

     

       19
       19
       +
         buildInputs = [ which python27 nodejs];

     

       19
       20
        
       

     

       20
       21
        
         buildPhase = "bash do";

     

       21
       21
       -
         installPhase = "installBin cjdroute makekey";

     

       22
       22
       +
         installPhase = "installBin cjdroute makekeys privatetopublic publictoip6";

     

       22
       23
        
       

     

       23
       23
       -
         meta = {

     

       24
       24
       +
         meta = with stdenv.lib; {

     

       24
       25
        
           homepage = https://github.com/cjdelisle/cjdns;

     

       25
       26
        
           description = "Encrypted networking for regular people";

     

       26
       26
       -
           license = stdenv.lib.licenses.gpl3;

     

       27
       27
       -
           maintainers = with stdenv.lib.maintainers; [ viric emery ];

     

       28
       28
       -
           platforms = stdenv.lib.platforms.linux;

     

       27
       27
       +
           license = licenses.gpl3;

     

       28
       28
       +
           maintainers = with maintainers; [ viric emery ];

     

       29
       29
       +
           platforms = platforms.unix;

     

       29
       30
        
         };

     

       30
       31
        
       }

-64

pkgs/tools/networking/cjdns/makekey.patch

···

       1
       1
       -
       diff --git a/contrib/c/makekey.c b/contrib/c/makekey.c

     

       2
       2
       -
       new file mode 100644

     

       3
       3
       -
       index 0000000..c7184e5

     

       4
       4
       -
       --- /dev/null

     

       5
       5
       -
       +++ b/contrib/c/makekey.c

     

       6
       6
       -
       @@ -0,0 +1,46 @@

     

       7
       7
       -
       +/* vim: set expandtab ts=4 sw=4: */

     

       8
       8
       -
       +/*

     

       9
       9
       -
       + * You may redistribute this program and/or modify it under the terms of

     

       10
       10
       -
       + * the GNU General Public License as published by the Free Software Foundation,

     

       11
       11
       -
       + * either version 3 of the License, or (at your option) any later version.

     

       12
       12
       -
       + *

     

       13
       13
       -
       + * This program is distributed in the hope that it will be useful,

     

       14
       14
       -
       + * but WITHOUT ANY WARRANTY; without even the implied warranty of

     

       15
       15
       -
       + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     

       16
       16
       -
       + * GNU General Public License for more details.

     

       17
       17
       -
       + *

     

       18
       18
       -
       + * You should have received a copy of the GNU General Public License

     

       19
       19
       -
       + * along with this program.  If not, see <http://www.gnu.org/licenses/>.

     

       20
       20
       -
       + */

     

       21
       21
       -
       +#include "crypto/random/Random.h"

     

       22
       22
       -
       +#include "memory/MallocAllocator.h"

     

       23
       23
       -
       +#include "crypto/AddressCalc.h"

     

       24
       24
       -
       +#include "util/AddrTools.h"

     

       25
       25
       -
       +#include "util/Hex.h"

     

       26
       26
       -
       +

     

       27
       27
       -
       +#include "crypto_scalarmult_curve25519.h"

     

       28
       28
       -
       +

     

       29
       29
       -
       +#include <stdio.h>

     

       30
       30
       -
       +

     

       31
       31
       -
       +int main(int argc, char** argv)

     

       32
       32
       -
       +{

     

       33
       33
       -
       +    struct Allocator* alloc = MallocAllocator_new(1<<22);

     

       34
       34
       -
       +    struct Random* rand = Random_new(alloc, NULL, NULL);

     

       35
       35
       -
       +

     

       36
       36
       -
       +    uint8_t privateKey[32];

     

       37
       37
       -
       +    uint8_t publicKey[32];

     

       38
       38
       -
       +    uint8_t ip[16];

     

       39
       39
       -
       +    uint8_t hexPrivateKey[65];

     

       40
       40
       -
       +

     

       41
       41
       -
       +    for (;;) {

     

       42
       42
       -
       +        Random_bytes(rand, privateKey, 32);

     

       43
       43
       -
       +        crypto_scalarmult_curve25519_base(publicKey, privateKey);

     

       44
       44
       -
       +        if (AddressCalc_addressForPublicKey(ip, publicKey)) {

     

       45
       45
       -
       +            Hex_encode(hexPrivateKey, 65, privateKey, 32);

     

       46
       46
       -
       +            printf(hexPrivateKey);

     

       47
       47
       -
       +            return 0;

     

       48
       48
       -
       +        }

     

       49
       49
       -
       +    }

     

       50
       50
       -
       +    return 0;

     

       51
       51
       -
       +}

     

       52
       52
       -
       +

     

       53
       53
       -
       diff --git a/node_build/make.js b/node_build/make.js

     

       54
       54
       -
       index 5e51645..11465e3 100644

     

       55
       55
       -
       --- a/node_build/make.js

     

       56
       56
       -
       +++ b/node_build/make.js

     

       57
       57
       -
       @@ -339,6 +339,7 @@ Builder.configure({

     

       58
       58
       -
            builder.buildExecutable('contrib/c/privatetopublic.c');

     

       59
       59
       -
            builder.buildExecutable('contrib/c/sybilsim.c');

     

       60
       60
       -
            builder.buildExecutable('contrib/c/makekeys.c');

     

       61
       61
       -
       +    builder.buildExecutable('contrib/c/makekey.c');

     

       62
       62
       -
        

     

       63
       63
       -
            builder.buildExecutable('crypto/random/randombytes.c');

     

       64
       64
       -

+286

pkgs/tools/networking/cjdns/rfc5952.patch

···

       1
       1
       +
       diff --git a/admin/angel/cjdroute2.c b/admin/angel/cjdroute2.c

     

       2
       2
       +
       index dfce6c6..77954a7 100644

     

       3
       3
       +
       --- a/admin/angel/cjdroute2.c

     

       4
       4
       +
       +++ b/admin/angel/cjdroute2.c

     

       5
       5
       +
       @@ -80,7 +80,7 @@ static int genAddress(uint8_t addressOut[40],

     

       6
       6
       +
                if (AddressCalc_addressForPublicKey(address.ip6.bytes, address.key)) {

     

       7
       7
       +
                    Hex_encode(privateKeyHexOut, 65, privateKey, 32);

     

       8
       8
       +
                    Base32_encode(publicKeyBase32Out, 53, address.key, 32);

     

       9
       9
       +
       -            Address_printIp(addressOut, &address);

     

       10
       10
       +
       +            Address_printShortIp(addressOut, &address);

     

       11
       11
       +
                    return 0;

     

       12
       12
       +
                }

     

       13
       13
       +
            }

     

       14
       14
       +
       diff --git a/contrib/c/makekeys.c b/contrib/c/makekeys.c

     

       15
       15
       +
       index 3727fff..29582f1 100644

     

       16
       16
       +
       --- a/contrib/c/makekeys.c

     

       17
       17
       +
       +++ b/contrib/c/makekeys.c

     

       18
       18
       +
       @@ -41,7 +41,7 @@ int main(int argc, char** argv)

     

       19
       19
       +
                if (AddressCalc_addressForPublicKey(ip, publicKey)) {

     

       20
       20
       +
                    Hex_encode(hexPrivateKey, 65, privateKey, 32);

     

       21
       21
       +
                    Base32_encode(publicKeyBase32, 53, publicKey, 32);

     

       22
       22
       +
       -            AddrTools_printIp(printedIp, ip);

     

       23
       23
       +
       +            AddrTools_printShortIp(printedIp, ip);

     

       24
       24
       +
                    printf("%s %s %s.k\n", hexPrivateKey, printedIp, publicKeyBase32);

     

       25
       25
       +
                }

     

       26
       26
       +
            }

     

       27
       27
       +
       diff --git a/contrib/c/privatetopublic.c b/contrib/c/privatetopublic.c

     

       28
       28
       +
       index 7f5f967..dc98f1c 100644

     

       29
       29
       +
       --- a/contrib/c/privatetopublic.c

     

       30
       30
       +
       +++ b/contrib/c/privatetopublic.c

     

       31
       31
       +
       @@ -73,7 +73,7 @@ int main(int argc, char** argv)

     

       32
       32
       +
            AddressCalc_addressForPublicKey(address.ip6.bytes, address.key);

     

       33
       33
       +
            if (address.ip6.bytes[0] == 0xFC) {

     

       34
       34
       +
                Base32_encode(publicKeyBase32Out, 53, address.key, 32);

     

       35
       35
       +
       -        Address_printIp(addressOut, &address);

     

       36
       36
       +
       +        Address_printShortIp(addressOut, &address);

     

       37
       37
       +
                printf(    "Input privkey: %s\n"

     

       38
       38
       +
                    "Matching pubkey: %s.k\n"

     

       39
       39
       +
                    "Resulting address: %s\n"

     

       40
       40
       +
       diff --git a/contrib/c/publictoip6.c b/contrib/c/publictoip6.c

     

       41
       41
       +
       index fc92f7e..99afc4c 100644

     

       42
       42
       +
       --- a/contrib/c/publictoip6.c

     

       43
       43
       +
       +++ b/contrib/c/publictoip6.c

     

       44
       44
       +
       @@ -48,7 +48,7 @@ int main(int argc, char** argv)

     

       45
       45
       +
            }

     

       46
       46
       +
        

     

       47
       47
       +
            uint8_t output[40] = {0};

     

       48
       48
       +
       -    AddrTools_printIp(output, ip6Bytes);

     

       49
       49
       +
       +    AddrTools_printShortIp(output, ip6Bytes);

     

       50
       50
       +
            printf("%s\n", output);

     

       51
       51
       +
            return 0;

     

       52
       52
       +
        }

     

       53
       53
       +
       diff --git a/dht/Address.c b/dht/Address.c

     

       54
       54
       +
       index e4c2dba..ba77cad 100644

     

       55
       55
       +
       --- a/dht/Address.c

     

       56
       56
       +
       +++ b/dht/Address.c

     

       57
       57
       +
       @@ -102,6 +102,12 @@ void Address_printIp(uint8_t output[40], struct Address* addr)

     

       58
       58
       +
            AddrTools_printIp(output, addr->ip6.bytes);

     

       59
       59
       +
        }

     

       60
       60
       +
        

     

       61
       61
       +
       +void Address_printShortIp(uint8_t output[40], struct Address* addr)

     

       62
       62
       +
       +{

     

       63
       63
       +
       +    Address_getPrefix(addr);

     

       64
       64
       +
       +    AddrTools_printShortIp(output, addr->ip6.bytes);

     

       65
       65
       +
       +}

     

       66
       66
       +
       +

     

       67
       67
       +
        void Address_print(uint8_t output[60], struct Address* addr)

     

       68
       68
       +
        {

     

       69
       69
       +
            Address_printIp(output, addr);

     

       70
       70
       +
       diff --git a/dht/Address.h b/dht/Address.h

     

       71
       71
       +
       index 43c6f05..f200b40 100644

     

       72
       72
       +
       --- a/dht/Address.h

     

       73
       73
       +
       +++ b/dht/Address.h

     

       74
       74
       +
       @@ -94,6 +94,8 @@ void Address_forKey(struct Address* out, const uint8_t key[Address_KEY_SIZE]);

     

       75
       75
       +
        

     

       76
       76
       +
        void Address_printIp(uint8_t output[40], struct Address* addr);

     

       77
       77
       +
        

     

       78
       78
       +
       +void Address_printShortIp(uint8_t output[40], struct Address* addr);

     

       79
       79
       +
       +

     

       80
       80
       +
        void Address_print(uint8_t output[60], struct Address* addr);

     

       81
       81
       +
        

     

       82
       82
       +
        String* Address_toString(struct Address* addr, struct Allocator* alloc);

     

       83
       83
       +
       diff --git a/net/Ducttape.c b/net/Ducttape.c

     

       84
       84
       +
       index 84597d0..1813f3f 100644

     

       85
       85
       +
       --- a/net/Ducttape.c

     

       86
       86
       +
       +++ b/net/Ducttape.c

     

       87
       87
       +
       @@ -227,7 +227,7 @@ static inline bool isRouterTraffic(struct Message* message, struct Headers_IP6He

     

       88
       88
       +
        #define debugHandles(logger, session, message, ...) \

     

       89
       89
       +
            do {                                                                               \

     

       90
       90
       +
                uint8_t ip[40];                                                                \

     

       91
       91
       +
       -        AddrTools_printIp(ip, session->ip6);                                           \

     

       92
       92
       +
       +        AddrTools_printIp(ip, session->ip6);                                      \

     

       93
       93
       +
                Log_debug(logger, "ver[%u] send[%d] recv[%u] ip[%s] " message,                 \

     

       94
       94
       +
                          session->version,                                                    \

     

       95
       95
       +
                          Endian_hostToBigEndian32(session->sendHandle_be),                    \

     

       96
       96
       +
       @@ -271,10 +271,10 @@ static inline uint8_t incomingForMe(struct Message* message,

     

       97
       97
       +
            if (Bits_memcmp(addr.ip6.bytes, dtHeader->ip6Header->sourceAddr, 16)) {

     

       98
       98
       +
                #ifdef Log_DEBUG

     

       99
       99
       +
                    uint8_t keyAddr[40];

     

       100
       100
       +
       -            Address_printIp(keyAddr, &addr);

     

       101
       101
       +
       +            Address_printShortIp(keyAddr, &addr);

     

       102
       102
       +
                    Bits_memcpyConst(addr.ip6.bytes, dtHeader->ip6Header->sourceAddr, 16);

     

       103
       103
       +
                    uint8_t srcAddr[40];

     

       104
       104
       +
       -            Address_printIp(srcAddr, &addr);

     

       105
       105
       +
       +            Address_printShortIp(srcAddr, &addr);

     

       106
       106
       +
                    Log_debug(context->logger,

     

       107
       107
       +
                               "DROP packet because source address is not same as key.\n"

     

       108
       108
       +
                               "    %s source addr\n"

     

       109
       109
       +
       @@ -292,7 +292,7 @@ static inline uint8_t incomingForMe(struct Message* message,

     

       110
       110
       +
                if (Checksum_udpIp6(dtHeader->ip6Header->sourceAddr, (uint8_t*)uh, message->length)) {

     

       111
       111
       +
                    #ifdef Log_DEBUG

     

       112
       112
       +
                        uint8_t keyAddr[40];

     

       113
       113
       +
       -                Address_printIp(keyAddr, &addr);

     

       114
       114
       +
       +                Address_printShortIp(keyAddr, &addr);

     

       115
       115
       +
                        Log_debug(context->logger,

     

       116
       116
       +
                                  "DROP Router packet with incorrect checksum, from [%s]", keyAddr);

     

       117
       117
       +
                    #endif

     

       118
       118
       +
       @@ -708,7 +708,7 @@ static inline int core(struct Message* message,

     

       119
       119
       +
                            struct Address destination;

     

       120
       120
       +
                            Bits_memcpyConst(destination.ip6.bytes, ip6Header->destinationAddr, 16);

     

       121
       121
       +
                            uint8_t ipAddr[40];

     

       122
       122
       +
       -                    Address_printIp(ipAddr, &destination);

     

       123
       123
       +
       +                    Address_printShortIp(ipAddr, &destination);

     

       124
       124
       +
                            Log_debug(context->logger, "Forwarding data to %s via %s\n", ipAddr, nhAddr);

     

       125
       125
       +
                        #endif */

     

       126
       126
       +
                    } else {

     

       127
       127
       +
       @@ -723,7 +723,7 @@ static inline int core(struct Message* message,

     

       128
       128
       +
                struct Address destination;

     

       129
       129
       +
                Bits_memcpyConst(destination.ip6.bytes, ip6Header->destinationAddr, 16);

     

       130
       130
       +
                uint8_t ipAddr[40];

     

       131
       131
       +
       -        Address_printIp(ipAddr, &destination);

     

       132
       132
       +
       +        Address_printShortIp(ipAddr, &destination);

     

       133
       133
       +
                Log_info(context->logger, "DROP message because this node is the closest known "

     

       134
       134
       +
                                           "node to the destination %s.", ipAddr);

     

       135
       135
       +
            #endif

     

       136
       136
       +
       diff --git a/test/printIp_test.c b/test/printIp_test.c

     

       137
       137
       +
       new file mode 100644

     

       138
       138
       +
       index 0000000..75d7427

     

       139
       139
       +
       --- /dev/null

     

       140
       140
       +
       +++ b/test/printIp_test.c

     

       141
       141
       +
       @@ -0,0 +1,54 @@

     

       142
       142
       +
       +/* vim: set expandtab ts=4 sw=4: */

     

       143
       143
       +
       +/*

     

       144
       144
       +
       + * You may redistribute this program and/or modify it under the terms of

     

       145
       145
       +
       + * the GNU General Public License as published by the Free Software Foundation,

     

       146
       146
       +
       + * either version 3 of the License, or (at your option) any later version.

     

       147
       147
       +
       + *

     

       148
       148
       +
       + * This program is distributed in the hope that it will be useful,

     

       149
       149
       +
       + * but WITHOUT ANY WARRANTY; without even the implied warranty of

     

       150
       150
       +
       + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     

       151
       151
       +
       + * GNU General Public License for more details.

     

       152
       152
       +
       + *

     

       153
       153
       +
       + * You should have received a copy of the GNU General Public License

     

       154
       154
       +
       + * along with this program.  If not, see <http://www.gnu.org/licenses/>.

     

       155
       155
       +
       + */

     

       156
       156
       +
       +

     

       157
       157
       +
       +#include "crypto/random/Random.h"

     

       158
       158
       +
       +#include "memory/MallocAllocator.h"

     

       159
       159
       +
       +#include "util/AddrTools.h"

     

       160
       160
       +
       +#include "util/Assert.h"

     

       161
       161
       +
       +

     

       162
       162
       +
       +#include <stdio.h>

     

       163
       163
       +
       +

     

       164
       164
       +
       +int main()

     

       165
       165
       +
       +{

     

       166
       166
       +
       +    struct Allocator* alloc = MallocAllocator_new(1<<22);

     

       167
       167
       +
       +    struct Random* rand = Random_new(alloc, NULL, NULL);

     

       168
       168
       +
       +

     

       169
       169
       +
       +    uint8_t ip[16];

     

       170
       170
       +
       +    uint8_t printedIp[40];

     

       171
       171
       +
       +    uint8_t printedShortIp[40];

     

       172
       172
       +
       +    uint8_t ipFromFull[16];

     

       173
       173
       +
       +    uint8_t ipFromShort[16];

     

       174
       174
       +
       +

     

       175
       175
       +
       +    for (int i = 0; i < 1024; ++i) {

     

       176
       176
       +
       +        Random_bytes(rand, ip, 16);

     

       177
       177
       +
       +

     

       178
       178
       +
       +        for (int j = 0; j < 16; j++) {

     

       179
       179
       +
       +            // make the random result have lots of zeros since that's what we're looking for.

     

       180
       180
       +
       +            ip[j] = (ip[j] % 2) ? 0 : ip[j];

     

       181
       181
       +
       +        }

     

       182
       182
       +
       +

     

       183
       183
       +
       +        AddrTools_printIp(printedIp, ip);

     

       184
       184
       +
       +        AddrTools_printShortIp(printedShortIp, ip);

     

       185
       185
       +
       +        //printf("%s\n%s\n\n", printedIp, printedShortIp);

     

       186
       186
       +
       +

     

       187
       187
       +
       +        AddrTools_parseIp(ipFromFull, printedIp);

     

       188
       188
       +
       +        AddrTools_parseIp(ipFromShort, printedShortIp);

     

       189
       189
       +
       +

     

       190
       190
       +
       +        Assert_true(0 == Bits_memcmp(ip, ipFromFull, 16));

     

       191
       191
       +
       +        Assert_true(0 == Bits_memcmp(ipFromFull, ipFromShort, 16));

     

       192
       192
       +
       +    }

     

       193
       193
       +
       +

     

       194
       194
       +
       +    return 0;

     

       195
       195
       +
       +}

     

       196
       196
       +
       diff --git a/util/AddrTools.h b/util/AddrTools.h

     

       197
       197
       +
       index 858ced4..d59544d 100644

     

       198
       198
       +
       --- a/util/AddrTools.h

     

       199
       199
       +
       +++ b/util/AddrTools.h

     

       200
       200
       +
       @@ -143,6 +143,44 @@ static inline void AddrTools_printIp(uint8_t output[40], const uint8_t binIp[16]

     

       201
       201
       +
            output[39] = '\0';

     

       202
       202
       +
        }

     

       203
       203
       +
        

     

       204
       204
       +
       +static inline void AddrTools_printShortIp(uint8_t output[40], const uint8_t binIp[16])

     

       205
       205
       +
       +{

     

       206
       206
       +
       +    /* The chances of hitting :0:0: and breaking

     

       207
       207
       +
       +     * RFC5952 are 1 in (1 / (2^16))^2 * 6.

     

       208
       208
       +
       +     * E. Siler

     

       209
       209
       +
       +     */

     

       210
       210
       +
       +

     

       211
       211
       +
       +    char *p = output;

     

       212
       212
       +
       +    int i = 0;

     

       213
       213
       +
       +    for (; i < 16;) {

     

       214
       214
       +
       +        if ((size_t)p != (size_t)output) {

     

       215
       215
       +
       +            *p++= ':';

     

       216
       216
       +
       +        }

     

       217
       217
       +
       +

     

       218
       218
       +
       +        if (binIp[i] > 0x0F) {

     

       219
       219
       +
       +            Hex_encode(p, 2, &binIp[i++], 1);

     

       220
       220
       +
       +            p += 2;

     

       221
       221
       +
       +        } else if (binIp[i] > 0x00) {

     

       222
       222
       +
       +            *p++ = Hex_encodeLowNibble(binIp[i++]);

     

       223
       223
       +
       +        } else {

     

       224
       224
       +
       +            ++i;

     

       225
       225
       +
       +            if (binIp[i] > 0x0F) {

     

       226
       226
       +
       +                Hex_encode(p, 2, &binIp[i++], 1);

     

       227
       227
       +
       +                p += 2;

     

       228
       228
       +
       +            } else {

     

       229
       229
       +
       +                *p++ = Hex_encodeLowNibble(binIp[i++]);

     

       230
       230
       +
       +            }

     

       231
       231
       +
       +            continue;

     

       232
       232
       +
       +        }

     

       233
       233
       +
       +        Hex_encode(p, 2, &binIp[i++], 1);

     

       234
       234
       +
       +        p += 2;

     

       235
       235
       +
       +    }

     

       236
       236
       +
       +    *p = '\0';

     

       237
       237
       +
       +

     

       238
       238
       +
       +    Assert_true((size_t)p <= ((size_t)output + 40));

     

       239
       239
       +
       +    Assert_true(i <= 16);

     

       240
       240
       +
       +}

     

       241
       241
       +
       +

     

       242
       242
       +
        /**

     

       243
       243
       +
         * Parse out an address.

     

       244
       244
       +
         *

     

       245
       245
       +
       diff --git a/util/Hex.c b/util/Hex.c

     

       246
       246
       +
       index e3e3c4d..b9bce57 100644

     

       247
       247
       +
       --- a/util/Hex.c

     

       248
       248
       +
       +++ b/util/Hex.c

     

       249
       249
       +
       @@ -29,6 +29,8 @@ static const uint8_t numForAscii[] =

     

       250
       250
       +
            99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,

     

       251
       251
       +
        };

     

       252
       252
       +
        

     

       253
       253
       +
       +static const char* hexEntities = "0123456789abcdef";

     

       254
       254
       +
       +

     

       255
       255
       +
        int Hex_encode(uint8_t* output,

     

       256
       256
       +
                       const uint32_t outputLength,

     

       257
       257
       +
                       const uint8_t* in,

     

       258
       258
       +
       @@ -40,8 +42,6 @@ int Hex_encode(uint8_t* output,

     

       259
       259
       +
                output[inputLength * 2] = '\0';

     

       260
       260
       +
            }

     

       261
       261
       +
        

     

       262
       262
       +
       -    static const char* hexEntities = "0123456789abcdef";

     

       263
       263
       +
       -

     

       264
       264
       +
            for (uint32_t i = 0; i < inputLength; i++) {

     

       265
       265
       +
                output[i * 2] = hexEntities[in[i] >> 4];

     

       266
       266
       +
                output[i * 2 + 1] = hexEntities[in[i] & 15];

     

       267
       267
       +
       @@ -88,3 +88,8 @@ int Hex_decode(uint8_t* output,

     

       268
       268
       +
        

     

       269
       269
       +
            return length / 2;

     

       270
       270
       +
        }

     

       271
       271
       +
       +

     

       272
       272
       +
       +uint8_t Hex_encodeLowNibble(const uint8_t nibble)

     

       273
       273
       +
       +{

     

       274
       274
       +
       +    return hexEntities[nibble & 15];

     

       275
       275
       +
       +}

     

       276
       276
       +
       diff --git a/util/Hex.h b/util/Hex.h

     

       277
       277
       +
       index 4570c3e..a12e402 100644

     

       278
       278
       +
       --- a/util/Hex.h

     

       279
       279
       +
       +++ b/util/Hex.h

     

       280
       280
       +
       @@ -41,4 +41,6 @@ bool Hex_isHexEntity(const uint8_t character);

     

       281
       281
       +
        

     

       282
       282
       +
        int Hex_decodeByte(const uint8_t highNibble, const uint8_t lowNibble);

     

       283
       283
       +
        

     

       284
       284
       +
       +uint8_t Hex_encodeLowNibble(const uint8_t nibble);

     

       285
       285
       +
       +

     

       286
       286
       +
        #endif

+2 -2

pkgs/tools/networking/dhcpcd/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, udev }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "dhcpcd-6.4.7";

     

       4
       4
       +
         name = "dhcpcd-6.5.1";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "http://roy.marples.name/downloads/dhcpcd/${name}.tar.bz2";

     

       8
       8
       -
           sha256 = "11z14nxk91g232zk4j17b822b7lvrzaa9kaxz0n6nhvihsb8025v";

     

       8
       8
       +
           sha256 = "0y0falxxlahr2i630ydraq4ldr7d5mg8ar0s5np5ddl76w58dlrp";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         patches = [ /* ./lxc_ro_promote_secondaries.patch */ ];

+1 -3

pkgs/tools/networking/p2p/tahoe-lafs/default.nix

···

       66
       66
        
           '';

     

       67
       67
        
       

     

       68
       68
        
           homepage = http://allmydata.org/;

     

       69
       69
       -
       

     

       70
       70
       -
           # TODO license = [ lib.licenses.gpl2Plus /* or */ "TGPPLv1+" ];

     

       71
       71
       -
       

     

       69
       69
       +
           license = [ lib.licenses.gpl2Plus /* or */ "TGPPLv1+" ];

     

       72
       70
        
           maintainers = [ lib.maintainers.simons  ];

     

       73
       71
        
           platforms = lib.platforms.gnu;  # arbitrary choice

     

       74
       72
        
         };

+2 -2

pkgs/tools/networking/radvd/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, libdaemon, bison, flex, check }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "radvd-2.7";

     

       4
       4
       +
         name = "radvd-2.8";

     

       5
       5
        
         

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "http://www.litech.org/radvd/dist/${name}.tar.xz";

     

       8
       8
       -
           sha256 = "09rzw96cjkzywadxmhbhaw52ahawzjp3pv7pblcsnb0mrwaawny0";

     

       8
       8
       +
           sha256 = "1y8d8k457apc5wrzc80sdkbvwynvvax31z5rh9ca9bsd0jr4240a";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         buildInputs = [ pkgconfig libdaemon bison flex check ];

+3 -3

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

···

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       stdenv.mkDerivation rec {

     

       8
       8
       -
         name = "nix-1.8pre3843_3f8576";

     

       8
       8
       +
         name = "nix-1.8pre3861_bca6d35";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
       -
           url = "http://hydra.nixos.org/build/15588665/download/4/${name}.tar.xz";

     

       12
       12
       -
           sha256 = "23befe1b5ecff38cc1088b98f221893f87d47e3335b381090ce13e9dd6c6eb87";

     

       11
       11
       +
           url = http://hydra.nixos.org/build/15940830/download/4/nix-1.8pre3861_bca6d35.tar.xz;

     

       12
       12
       +
           sha256 = "f2c5d2669c69a23fc8510d08beb48210da72cb4ec8fe334eff476b93f76d744f";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ perl pkgconfig ];

+34

pkgs/tools/system/safe-rm/default.nix

···

       1
       1
       +
       { stdenv, fetchgit, perl, coreutils }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "safe-rm-${version}";

     

       5
       5
       +
         version = "0.11";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchgit {

     

       8
       8
       +
           url = "https://gitorious.org/safe-rm/mainline.git";

     

       9
       9
       +
           rev = "refs/tags/${name}";

     

       10
       10
       +
           sha256 = "1csnqq22pfbg9dwhv13x60jih0gn07bn5rwg2nhi0dsslzk4l496";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         propagatedBuildInputs = [ perl coreutils ];

     

       14
       14
       +
       

     

       15
       15
       +
         postFixup = ''

     

       16
       16
       +
           sed -e 's@/bin/rm@${coreutils}/bin/rm@' -i $out/bin/safe-rm

     

       17
       17
       +
         '';

     

       18
       18
       +
       

     

       19
       19
       +
         installPhase = ''

     

       20
       20
       +
           mkdir -p $out/bin

     

       21
       21
       +
           cp safe-rm $out/bin

     

       22
       22
       +
       

     

       23
       23
       +
           mkdir -p $out/share/man/man1

     

       24
       24
       +
           pod2man safe-rm > $out/share/man/man1/safe-rm.1

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with stdenv.lib; {

     

       28
       28
       +
           description = "Tool intended to prevent the accidental deletion of important files.";

     

       29
       29
       +
           homepage = https://launchpad.net/safe-rm;

     

       30
       30
       +
           license = licenses.gpl3;

     

       31
       31
       +
           platforms = platforms.all;

     

       32
       32
       +
           maintainers = [ maintainers.koral ];

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+83 -28

pkgs/top-level/all-packages.nix

···

       401
       401
        
           inherit stdenv;

     

       402
       402
        
         };

     

       403
       403
        
       

     

       404
       404
       +
         substituteAllFiles = import ../build-support/substitute-files/substitute-all-files.nix {

     

       405
       405
       +
           inherit stdenv;

     

       406
       406
       +
         };

     

       407
       407
       +
       

     

       404
       408
        
         replaceDependency = import ../build-support/replace-dependency.nix {

     

       405
       409
        
           inherit runCommand nix lib;

     

       406
       410
        
         };

     
···

       617
       621
        
       

     

       618
       622
        
         bitbucket-cli = pythonPackages.bitbucket-cli;

     

       619
       623
        
       

     

       624
       624
       +
         blink = callPackage ../applications/networking/instant-messengers/blink { };

     

       625
       625
       +
       

     

       620
       626
        
         blockdiag = pythonPackages.blockdiag;

     

       621
       627
        
       

     

       622
       628
        
         bmon = callPackage ../tools/misc/bmon { };

     
···

       805
       811
        
         chkrootkit = callPackage ../tools/security/chkrootkit { };

     

       806
       812
        
       

     

       807
       813
        
         chocolateDoom = callPackage ../games/chocolate-doom { };

     

       808
       808
       -
         # master is here because chocolateDoom v2.0 has broken netplay

     

       809
       809
       -
         chocolateDoomMaster = callPackage ../games/chocolate-doom/master.nix { };

     

       810
       814
        
       

     

       811
       815
        
         chrony = callPackage ../tools/networking/chrony { };

     

       812
       816
        
       

     
···

       1477
       1481
        
       

     

       1478
       1482
        
         jwhois = callPackage ../tools/networking/jwhois { };

     

       1479
       1483
        
       

     

       1484
       1484
       +
         k2pdfopt = callPackage ../applications/misc/k2pdfopt { };

     

       1485
       1485
       +
       

     

       1480
       1486
        
         kazam = callPackage ../applications/video/kazam { };

     

       1481
       1487
        
       

     

       1482
       1488
        
         kalibrate-rtl = callPackage ../tools/misc/kalibrate-rtl { };

     
···

       1866
       1872
        
         openobex = callPackage ../tools/bluetooth/openobex { };

     

       1867
       1873
        
       

     

       1868
       1874
        
         openopc = callPackage ../tools/misc/openopc {

     

       1869
       1869
       -
           pythonFull = python27FullBuildEnv.override {

     

       1875
       1875
       +
           pythonFull = python27.buildEnv.override {

     

       1870
       1876
        
             extraLibs = [ python27Packages.pyro3 ];

     

       1871
       1877
        
           };

     

       1872
       1878
        
         };

     
···

       2043
       2049
        
         prey-bash-client = callPackage ../tools/security/prey { };

     

       2044
       2050
        
       

     

       2045
       2051
        
         projectm = callPackage ../applications/audio/projectm { };

     

       2052
       2052
       +
       

     

       2053
       2053
       +
         proot = callPackage ../tools/system/proot { };

     

       2046
       2054
        
       

     

       2047
       2055
        
         proxychains = callPackage ../tools/networking/proxychains { };

     

       2048
       2056
        
       

     
···

       2160
       2168
        
       

     

       2161
       2169
        
         rpm = callPackage ../tools/package-management/rpm { };

     

       2162
       2170
        
       

     

       2171
       2171
       +
         rpmextract = callPackage ../tools/archivers/rpmextract { };

     

       2172
       2172
       +
       

     

       2163
       2173
        
         rrdtool = callPackage ../tools/misc/rrdtool { };

     

       2164
       2174
        
       

     

       2165
       2175
        
         rtorrent = callPackage ../tools/networking/p2p/rtorrent { };

     
···

       2193
       2203
        
         sablotron = callPackage ../tools/text/xml/sablotron { };

     

       2194
       2204
        
       

     

       2195
       2205
        
         safecopy = callPackage ../tools/system/safecopy { };

     

       2206
       2206
       +
       

     

       2207
       2207
       +
         safe-rm = callPackage ../tools/system/safe-rm { };

     

       2196
       2208
        
       

     

       2197
       2209
        
         salut_a_toi = callPackage ../applications/networking/instant-messengers/salut-a-toi {};

     

       2198
       2210
        
       

     
···

       3318
       3330
        
           llvm = llvm_34;

     

       3319
       3331
        
           openblas = openblas_0_2_10;

     

       3320
       3332
        
         };

     

       3321
       3321
       -
         julia = julia030;

     

       3333
       3333
       +
         julia031 = let

     

       3334
       3334
       +
           liblapack = liblapack_3_5_0.override {shared = true;};

     

       3335
       3335
       +
         in callPackage ../development/compilers/julia/0.3.1.nix {

     

       3336
       3336
       +
           inherit liblapack;

     

       3337
       3337
       +
           suitesparse = suitesparse.override {

     

       3338
       3338
       +
             inherit liblapack;

     

       3339
       3339
       +
           };

     

       3340
       3340
       +
           llvm = llvm_34;

     

       3341
       3341
       +
           openblas = openblas_0_2_10;

     

       3342
       3342
       +
         };

     

       3343
       3343
       +
         julia = julia031;

     

       3322
       3344
        
       

     

       3323
       3345
        
         lazarus = builderDefsPackage (import ../development/compilers/fpc/lazarus.nix) {

     

       3324
       3346
        
           inherit makeWrapper gtk glib pango atk gdk_pixbuf;

     
···

       3645
       3667
        
       

     

       3646
       3668
        
         roadsend = callPackage ../development/compilers/roadsend { };

     

       3647
       3669
        
       

     

       3648
       3648
       -
         rustc       = callPackage ../development/compilers/rustc/0.11.nix {};

     

       3670
       3670
       +
         rustc       = callPackage ../development/compilers/rustc/0.12.nix {};

     

       3649
       3671
        
         rustcMaster = callPackage ../development/compilers/rustc/head.nix {};

     

       3650
       3672
        
       

     

       3651
       3673
        
         rust = rustc;

     
···

       3760
       3782
        
         clisp = callPackage ../development/interpreters/clisp { };

     

       3761
       3783
        
       

     

       3762
       3784
        
         # compatibility issues in 2.47 - at list 2.44.1 is known good

     

       3763
       3763
       -
         # for sbcl bootstrap

     

       3785
       3785
       +
         # for sbcl bootstrap.

     

       3786
       3786
       +
         # SBCL page recommends 2.33.2, though. Not sure when was it last tested

     

       3764
       3787
        
         clisp_2_44_1 = callPackage ../development/interpreters/clisp/2.44.1.nix {

     

       3765
       3788
        
           libsigsegv = libsigsegv_25;

     

       3766
       3789
        
         };

     
···

       3927
       3950
        
         python2Packages = python27Packages;

     

       3928
       3951
        
         python3Packages = python34Packages;

     

       3929
       3952
        
       

     

       3930
       3930
       -
         python26 = callPackage ../development/interpreters/python/2.6 { db = db47; };

     

       3931
       3931
       -
         python27 = callPackage ../development/interpreters/python/2.7 { };

     

       3932
       3932
       -
         python32 = callPackage ../development/interpreters/python/3.2 { };

     

       3933
       3933
       -
         python33 = callPackage ../development/interpreters/python/3.3 { };

     

       3934
       3934
       -
         python34 = hiPrio (callPackage ../development/interpreters/python/3.4 { });

     

       3935
       3935
       -
       

     

       3936
       3936
       -
         pypy = callPackage ../development/interpreters/pypy/2.4 { };

     

       3953
       3953
       +
         python26 = callPackage ../development/interpreters/python/2.6 {

     

       3954
       3954
       +
           db = db47;

     

       3955
       3955
       +
           self = python26;

     

       3956
       3956
       +
         };

     

       3957
       3957
       +
         python27 = callPackage ../development/interpreters/python/2.7 {

     

       3958
       3958
       +
           self = python27;

     

       3959
       3959
       +
         };

     

       3960
       3960
       +
         python32 = callPackage ../development/interpreters/python/3.2 {

     

       3961
       3961
       +
           self = python32;

     

       3962
       3962
       +
         };

     

       3963
       3963
       +
         python33 = callPackage ../development/interpreters/python/3.3 {

     

       3964
       3964
       +
           self = python33;

     

       3965
       3965
       +
         };

     

       3966
       3966
       +
         python34 = hiPrio (callPackage ../development/interpreters/python/3.4 {

     

       3967
       3967
       +
           self = python34;

     

       3968
       3968
       +
         });

     

       3969
       3969
       +
         pypy = callPackage ../development/interpreters/pypy/2.4 {

     

       3970
       3970
       +
           self = pypy;

     

       3971
       3971
       +
         };

     

       3937
       3972
        
       

     

       3938
       3973
        
         pythonFull = python2Full;

     

       3939
       3974
        
         python2Full = python27Full;

     

       3940
       3975
        
         python26Full = python26.override {

     

       3941
       3976
        
           includeModules = true;

     

       3977
       3977
       +
           self = python26Full;

     

       3942
       3978
        
         };

     

       3943
       3979
        
         python27Full = python27.override {

     

       3944
       3980
        
           includeModules = true;

     

       3945
       3945
       -
         };

     

       3946
       3946
       -
         python26FullBuildEnv = callPackage ../development/interpreters/python/wrapper.nix {

     

       3947
       3947
       -
           python = python26Full;

     

       3948
       3948
       -
           inherit (python26Packages) recursivePthLoader;

     

       3949
       3949
       -
         };

     

       3950
       3950
       -
         python27FullBuildEnv = callPackage ../development/interpreters/python/wrapper.nix {

     

       3951
       3951
       -
           python = python27Full;

     

       3952
       3952
       -
           inherit (python27Packages) recursivePthLoader;

     

       3981
       3981
       +
           self = python27Full;

     

       3953
       3982
        
         };

     

       3954
       3954
       -
         pythonFullBuildEnv = python2FullBuildEnv;

     

       3955
       3955
       -
         python2FullBuildEnv = python27FullBuildEnv;

     

       3956
       3983
        
       

     

       3957
       3984
        
         python2nix = callPackage ../tools/package-management/python2nix { };

     

       3958
       3985
        
       

     
···

       4039
       4066
        
         tcl = callPackage ../development/interpreters/tcl { };

     

       4040
       4067
        
       

     

       4041
       4068
        
         xulrunner = callPackage ../development/interpreters/xulrunner {

     

       4069
       4069
       +
           stdenv = if stdenv.isLinux then useGoldLinker stdenv else stdenv;

     

       4042
       4070
        
           inherit (gnome) libIDL;

     

       4043
       4071
        
           inherit (pythonPackages) pysqlite;

     

       4044
       4072
        
         };

     
···

       5722
       5750
        
           inherit (gnome) gtkdoc;

     

       5723
       5751
        
         };

     

       5724
       5752
        
       

     

       5753
       5753
       +
         libinput = callPackage ../development/libraries/libinput { };

     

       5754
       5754
       +
       

     

       5725
       5755
        
         libiptcdata = callPackage ../development/libraries/libiptcdata { };

     

       5726
       5756
        
       

     

       5727
       5757
        
         libjpeg_original = callPackage ../development/libraries/libjpeg { };

     
···

       6323
       6353
        
       

     

       6324
       6354
        
         physfs = callPackage ../development/libraries/physfs { };

     

       6325
       6355
        
       

     

       6356
       6356
       +
         pipelight = callPackage ../tools/misc/pipelight { };

     

       6357
       6357
       +
       

     

       6326
       6358
        
         pkcs11helper = callPackage ../development/libraries/pkcs11helper { };

     

       6327
       6359
        
       

     

       6328
       6360
        
         plib = callPackage ../development/libraries/plib { };

     
···

       8012
       8044
        
             stdenv = stdenv_32bit;

     

       8013
       8045
        
             inherit (gnome) libIDL;

     

       8014
       8046
        
             enableExtensionPack = config.virtualbox.enableExtensionPack or false;

     

       8047
       8047
       +
             pulseSupport = config.pulseaudio or false;

     

       8015
       8048
        
           };

     

       8016
       8049
        
       

     

       8017
       8050
        
           virtualboxGuestAdditions = callPackage ../applications/virtualization/virtualbox/guest-additions { };

     
···

       8970
       9003
        
           libXaw = xlibs.libXaw;

     

       8971
       9004
        
           Xaw3d = null;

     

       8972
       9005
        
           gconf = null;

     

       8973
       8973
       -
           librsvg = null;

     

       8974
       9006
        
           alsaLib = null;

     

       8975
       9007
        
           imagemagick = null;

     

       8976
       9008
        
         };

     
···

       9031
       9063
        
           graphvizDot = callPackage ../applications/editors/emacs-modes/graphviz-dot { };

     

       9032
       9064
        
       

     

       9033
       9065
        
           gist = callPackage ../applications/editors/emacs-modes/gist { };

     

       9066
       9066
       +
       

     

       9067
       9067
       +
           gitModes = callPackage ../applications/editors/emacs-modes/git-modes { };

     

       9034
       9068
        
       

     

       9035
       9069
        
           haskellMode = callPackage ../applications/editors/emacs-modes/haskell { };

     

       9036
       9070
        
       

     
···

       9110
       9144
        
           stratego = callPackage ../applications/editors/emacs-modes/stratego { };

     

       9111
       9145
        
       

     

       9112
       9146
        
           structuredHaskellMode = callPackage ../applications/editors/emacs-modes/structured-haskell-mode {

     

       9113
       9113
       -
             inherit (haskellPackages) cabal haskellSrcExts;

     

       9147
       9147
       +
             inherit (haskellPackages) cabal ;

     

       9148
       9148
       +
             haskellSrcExts = haskellPackages.haskellSrcExts_1_15_0_1;

     

       9114
       9149
        
           };

     

       9115
       9150
        
       

     

       9116
       9151
        
           sunriseCommander = callPackage ../applications/editors/emacs-modes/sunrise-commander { };

     
···

       9257
       9292
        
         firefox13Wrapper = wrapFirefox { browser = firefox13Pkgs.firefox; };

     

       9258
       9293
        
       

     

       9259
       9294
        
         firefox = callPackage ../applications/networking/browsers/firefox {

     

       9295
       9295
       +
           stdenv = if stdenv.isLinux then useGoldLinker stdenv else stdenv;

     

       9260
       9296
        
           inherit (gnome) libIDL;

     

       9261
       9297
        
           inherit (pythonPackages) pysqlite;

     

       9262
       9298
        
         };

     
···

       9832
       9868
        
       

     

       9833
       9869
        
         ncmpcpp = callPackage ../applications/audio/ncmpcpp { };

     

       9834
       9870
        
       

     

       9871
       9871
       +
         ncmpcppBeta = callPackage ../applications/audio/ncmpcpp/beta.nix { };

     

       9872
       9872
       +
       

     

       9835
       9873
        
         normalize = callPackage ../applications/audio/normalize { };

     

       9836
       9874
        
       

     

       9837
       9875
        
         mplayer = callPackage ../applications/video/mplayer {

     
···

       10243
       10281
        
                                           })

     

       10244
       10282
        
                                        );

     

       10245
       10283
        
       

     

       10246
       10246
       -
         sxiv = callPackage ../applications/graphics/sxiv { };

     

       10284
       10284
       +
         sxiv = callPackage ../applications/graphics/sxiv {

     

       10285
       10285
       +
           giflib = giflib_5_0;

     

       10286
       10286
       +
         };

     

       10247
       10287
        
       

     

       10248
       10288
        
         bittorrentSync = callPackage ../applications/networking/bittorrentsync { };

     

       10249
       10289
        
       

     
···

       10508
       10548
        
       

     

       10509
       10549
        
         vim = callPackage ../applications/editors/vim { };

     

       10510
       10550
        
       

     

       10511
       10511
       -
         macvim = callPackage ../applications/editors/vim/macvim.nix { };

     

       10551
       10551
       +
         macvim = callPackage ../applications/editors/vim/macvim.nix { stdenv = clangStdenv; };

     

       10512
       10552
        
       

     

       10513
       10553
        
         vimHugeX = vim_configurable;

     

       10514
       10554
        
       

     
···

       10530
       10570
        
         };

     

       10531
       10571
        
       

     

       10532
       10572
        
         vimNox = lowPrio (vim_configurable.override { source = "vim-nox"; });

     

       10573
       10573
       +
       

     

       10574
       10574
       +
         qpdfview = callPackage ../applications/misc/qpdfview {};

     

       10533
       10575
        
       

     

       10534
       10576
        
         qvim = lowPrio (callPackage ../applications/editors/vim/qvim.nix {

     

       10535
       10577
        
           inherit (pkgs) fetchgit stdenv ncurses pkgconfig gettext

     
···

       10594
       10636
        
       

     

       10595
       10637
        
         weechatDevel = lowPrio (callPackage ../applications/networking/irc/weechat/devel.nix { });

     

       10596
       10638
        
       

     

       10597
       10597
       -
         weston = callPackage ../applications/window-managers/weston { };

     

       10639
       10639
       +
         westonLite = callPackage ../applications/window-managers/weston {

     

       10640
       10640
       +
           pango = null;

     

       10641
       10641
       +
           freerdp = null;

     

       10642
       10642
       +
           libunwind = null;

     

       10643
       10643
       +
           vaapi = null;

     

       10644
       10644
       +
           libva = null;

     

       10645
       10645
       +
           libwebp = null;

     

       10646
       10646
       +
         };

     

       10647
       10647
       +
       

     

       10648
       10648
       +
         weston = callPackage ../applications/window-managers/weston {

     

       10649
       10649
       +
           freerdp = freerdpUnstable;

     

       10650
       10650
       +
         };

     

       10598
       10651
        
       

     

       10599
       10652
        
         windowmaker = callPackage ../applications/window-managers/windowmaker { };

     

       10600
       10653
        
       

     
···

       11629
       11682
        
           coqExtLib = callPackage ../development/coq-modules/coq-ext-lib {};

     

       11630
       11683
        
       

     

       11631
       11684
        
           domains = callPackage ../development/coq-modules/domains {};

     

       11685
       11685
       +
       

     

       11686
       11686
       +
           flocq = callPackage ../development/coq-modules/flocq {};

     

       11632
       11687
        
       

     

       11633
       11688
        
           heq = callPackage ../development/coq-modules/heq {};

     

       11634
       11689

+1 -2

pkgs/top-level/haskell-defaults.nix

···

       24
       24
        
           cabalInstall_1_20_0_3 = super.cabalInstall_1_20_0_3.override { Cabal = self.Cabal_1_20_0_2; };

     

       25
       25
        
           codex = super.codex.override { hackageDb = super.hackageDb.override { Cabal = self.Cabal_1_20_0_2; }; };

     

       26
       26
        
           MonadRandom = self.MonadRandom_0_1_13; # requires transformers >= 0.4.x

     

       27
       27
       -
           mtl = self.mtl_2_1_2;

     

       27
       27
       +
           mtl = self.mtl_2_1_3_1;

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         ghc763Prefs = self : super : ghc783Prefs self super // {

     
···

       47
       47
        
               vectorBinaryInstances = self.vectorBinaryInstances.override { binary = self.binary_0_7_2_2; };

     

       48
       48
        
             };

     

       49
       49
        
           };

     

       50
       50
       -
           Elm = super.Elm.override { pandoc = self.pandoc.override { zipArchive = self.zipArchive.override { binary = self.binary_0_7_2_2; }; }; };

     

       51
       50
        
           gloss = null;                       # requires base >= 4.7

     

       52
       51
        
           haddock = self.haddock_2_13_2;

     

       53
       52
        
           modularArithmetic = null;           # requires base >= 4.7

+46 -25

pkgs/top-level/haskell-packages.nix

···

       143
       143
        
       

     

       144
       144
        
         aeson_0_7_0_4 = callPackage ../development/libraries/haskell/aeson/0.7.0.4.nix { blazeBuilder = null; };

     

       145
       145
        
         aeson_0_7_0_6 = callPackage ../development/libraries/haskell/aeson/0.7.0.6.nix { blazeBuilder = null; };

     

       146
       146
       -
         aeson_0_8_0_1 = callPackage ../development/libraries/haskell/aeson/0.8.0.1.nix { blazeBuilder = null; };

     

       147
       147
       -
         aeson = self.aeson_0_8_0_1;

     

       146
       146
       +
         aeson_0_8_0_2 = callPackage ../development/libraries/haskell/aeson/0.8.0.2.nix { blazeBuilder = null; };

     

       147
       147
       +
         aeson = self.aeson_0_8_0_2;

     

       148
       148
        
       

     

       149
       149
        
         aesonPretty = callPackage ../development/libraries/haskell/aeson-pretty {};

     

       150
       150
        
       

     
···

       396
       396
        
       

     

       397
       397
        
         charset = callPackage ../development/libraries/haskell/charset {};

     

       398
       398
        
       

     

       399
       399
       +
         charsetdetectAe = callPackage ../development/libraries/haskell/charsetdetect-ae {};

     

       400
       400
       +
       

     

       399
       401
        
         Chart = callPackage ../development/libraries/haskell/Chart {};

     

       400
       402
        
         ChartCairo = callPackage ../development/libraries/haskell/Chart-cairo {};

     

       401
       403
        
         ChartDiagrams = callPackage ../development/libraries/haskell/Chart-diagrams {};

     
···

       615
       617
        
       

     

       616
       618
        
         dbus = callPackage ../development/libraries/haskell/dbus {};

     

       617
       619
        
       

     

       620
       620
       +
         Decimal = callPackage ../development/libraries/haskell/Decimal {};

     

       621
       621
       +
       

     

       618
       622
        
         deepseq_1_1_0_0 = callPackage ../development/libraries/haskell/deepseq/1.1.0.0.nix {};

     

       619
       623
        
         deepseq_1_1_0_2 = callPackage ../development/libraries/haskell/deepseq/1.1.0.2.nix {};

     

       620
       624
        
         deepseq_1_2_0_1 = callPackage ../development/libraries/haskell/deepseq/1.2.0.1.nix {};

     
···

       788
       792
        
       

     

       789
       793
        
         executablePath = callPackage ../development/libraries/haskell/executable-path {};

     

       790
       794
        
       

     

       791
       791
       -
         Extra = callPackage ../development/libraries/haskell/Extra {};

     

       795
       795
       +
         Extra = callPackage ../development/libraries/haskell/Extra-lib {};

     

       792
       796
        
       

     

       793
       797
        
         fay = callPackage ../development/libraries/haskell/fay {};

     

       794
       798
        
       

     
···

       813
       817
        
         extensibleExceptions_0_1_1_3 = callPackage ../development/libraries/haskell/extensible-exceptions/0.1.1.3.nix {};

     

       814
       818
        
         extensibleExceptions_0_1_1_4 = callPackage ../development/libraries/haskell/extensible-exceptions/0.1.1.4.nix {};

     

       815
       819
        
         extensibleExceptions = self.extensibleExceptions_0_1_1_4;

     

       820
       820
       +
       

     

       821
       821
       +
         extra = callPackage ../development/libraries/haskell/extra {};

     

       816
       822
        
       

     

       817
       823
        
         failure = callPackage ../development/libraries/haskell/failure {};

     

       818
       824
        
       

     
···

       1041
       1047
        
       

     

       1042
       1048
        
         groupoids = callPackage ../development/libraries/haskell/groupoids {};

     

       1043
       1049
        
       

     

       1044
       1044
       -
         hakyll = callPackage ../development/libraries/haskell/hakyll {};

     

       1050
       1050
       +
         hakyll = callPackage ../development/libraries/haskell/hakyll {

     

       1051
       1051
       +
           pandocCiteproc = self.pandocCiteproc_0_4;

     

       1052
       1052
       +
         };

     

       1045
       1053
        
       

     

       1046
       1054
        
         hamlet = callPackage ../development/libraries/haskell/hamlet {};

     

       1047
       1055
        
       

     
···

       1202
       1210
        
       

     

       1203
       1211
        
         hi = callPackage ../development/libraries/haskell/hi {};

     

       1204
       1212
        
       

     

       1205
       1205
       -
         hindent = callPackage ../development/libraries/haskell/hindent {};

     

       1213
       1213
       +
         hindent = callPackage ../development/libraries/haskell/hindent {

     

       1214
       1214
       +
           haskellSrcExts = self.haskellSrcExts_1_15_0_1;

     

       1215
       1215
       +
         };

     

       1206
       1216
        
       

     

       1207
       1217
        
         hint = callPackage ../development/libraries/haskell/hint {};

     

       1208
       1218
        
       

     
···

       1242
       1252
        
       

     

       1243
       1253
        
         hoodleTypes = callPackage ../development/libraries/haskell/hoodle-types {};

     

       1244
       1254
        
       

     

       1245
       1245
       -
         hoogle = callPackage ../development/libraries/haskell/hoogle {};

     

       1255
       1255
       +
         hoogle_4_2_34 = callPackage ../development/libraries/haskell/hoogle/4.2.34.nix { haskellSrcExts = self.haskellSrcExts_1_15_0_1; };

     

       1256
       1256
       +
         hoogle_4_2_36 = callPackage ../development/libraries/haskell/hoogle/4.2.36.nix {};

     

       1257
       1257
       +
         hoogle = self.hoogle_4_2_36;

     

       1258
       1258
       +
       

     

       1246
       1259
        
         hoogleLocal = callPackage ../development/libraries/haskell/hoogle/local.nix {};

     

       1247
       1260
        
       

     

       1248
       1261
        
         hopenssl = callPackage ../development/libraries/haskell/hopenssl {};

     
···

       1296
       1309
        
         hspecExpectationsLens = callPackage ../development/libraries/haskell/hspec-expectations-lens {};

     

       1297
       1310
        
       

     

       1298
       1311
        
         hspecMeta = callPackage ../development/libraries/haskell/hspec-meta {};

     

       1312
       1312
       +
       

     

       1313
       1313
       +
         hspecCheckers = callPackage ../development/libraries/haskell/hspec-checkers {};

     

       1299
       1314
        
       

     

       1300
       1315
        
         hstatsd = callPackage ../development/libraries/haskell/hstatsd {};

     

       1301
       1316
        
       

     
···

       1466
       1481
        
       

     

       1467
       1482
        
         languageHaskellExtract = callPackage ../development/libraries/haskell/language-haskell-extract {};

     

       1468
       1483
        
       

     

       1469
       1469
       -
         lambdabot = callPackage ../development/libraries/haskell/lambdabot {};

     

       1484
       1484
       +
         lambdabot = callPackage ../development/libraries/haskell/lambdabot {

     

       1485
       1485
       +
           haskellSrcExts = self.haskellSrcExts_1_15_0_1;

     

       1486
       1486
       +
           hoogle = self.hoogle_4_2_34.override {

     

       1487
       1487
       +
             haskellSrcExts = self.haskellSrcExts_1_15_0_1;

     

       1488
       1488
       +
           };

     

       1489
       1489
       +
         };

     

       1470
       1490
        
       

     

       1471
       1491
        
         lambdabotWrapper = callPackage ../development/libraries/haskell/lambdabot/wrapper.nix {

     

       1472
       1492
        
           mueval = self.muevalWrapper.override {

     
···

       1698
       1718
        
         mtl_2_0_1_0 = callPackage ../development/libraries/haskell/mtl/2.0.1.0.nix {};

     

       1699
       1719
        
         mtl_2_1_1 = callPackage ../development/libraries/haskell/mtl/2.1.1.nix {};

     

       1700
       1720
        
         mtl_2_1_2 = callPackage ../development/libraries/haskell/mtl/2.1.2.nix {};

     

       1721
       1721
       +
         mtl_2_1_3_1 = callPackage ../development/libraries/haskell/mtl/2.1.3.1.nix {};

     

       1701
       1722
        
         mtl_2_2_1 = callPackage ../development/libraries/haskell/mtl/2.2.1.nix {};

     

       1702
       1723
        
         mtl = null; # tightly coupled with 'transformers' which is a core package

     

       1703
       1724
        
       

     
···

       1843
       1864
        
       

     

       1844
       1865
        
         pandoc = callPackage ../development/libraries/haskell/pandoc {};

     

       1845
       1866
        
       

     

       1846
       1846
       -
         pandocCiteproc = callPackage ../development/libraries/haskell/pandoc-citeproc {};

     

       1867
       1867
       +
         pandocCiteproc_0_4 = callPackage ../development/libraries/haskell/pandoc-citeproc/0.4.nix {};

     

       1868
       1868
       +
         pandocCiteproc_0_5 = callPackage ../development/libraries/haskell/pandoc-citeproc/0.5.nix {};

     

       1869
       1869
       +
         pandocCiteproc_0_6 = callPackage ../development/libraries/haskell/pandoc-citeproc/0.6.nix {};

     

       1870
       1870
       +
         pandocCiteproc = self.pandocCiteproc_0_6;

     

       1847
       1871
        
       

     

       1848
       1872
        
         pandocTypes = callPackage ../development/libraries/haskell/pandoc-types {};

     

       1849
       1873
        
       

     
···

       2753
       2777
        
       

     

       2754
       2778
        
         void = callPackage ../development/libraries/haskell/void {};

     

       2755
       2779
        
       

     

       2756
       2756
       -
         vty_4_7_5 = callPackage ../development/libraries/haskell/vty/4.7.5.nix {};

     

       2757
       2757
       -
         vty_5_2_3 = callPackage ../development/libraries/haskell/vty/5.2.3.nix {};

     

       2758
       2758
       -
         vty = self.vty_5_2_3;

     

       2780
       2780
       +
         vty = callPackage ../development/libraries/haskell/vty {};

     

       2759
       2781
        
       

     

       2760
       2760
       -
         vtyUi = callPackage ../development/libraries/haskell/vty-ui {

     

       2761
       2761
       -
           vty = self.vty_4_7_5;

     

       2762
       2762
       -
         };

     

       2782
       2782
       +
         vtyUi = callPackage ../development/libraries/haskell/vty-ui {};

     

       2763
       2783
        
       

     

       2764
       2784
        
         wai = callPackage ../development/libraries/haskell/wai {};

     

       2765
       2785
        
       

     
···

       3092
       3112
        
       

     

       3093
       3113
        
         wordTrie = callPackage ../development/libraries/haskell/word-trie {};

     

       3094
       3114
        
       

     

       3095
       3095
       -
         # You should prefer ‘yiCustom’ over ‘yi’ unless you never plan to

     

       3096
       3096
       -
         # use any external libraries in your config.

     

       3115
       3115
       +
         # This is an unwrapped version of Yi, it will not behave well (no

     

       3116
       3116
       +
         # M-x or reload). Use ‘yiCustom’ instead.

     

       3097
       3117
        
         yi = callPackage ../applications/editors/yi/yi.nix { };

     

       3098
       3118
        
       

     

       3099
       3119
        
         yiContrib = callPackage ../development/libraries/haskell/yi-contrib {};

     

       3100
       3120
        
       

     

       3101
       3121
        
         yiCustom = callPackage ../applications/editors/yi/yi-custom.nix {

     

       3102
       3102
       -
           extraPackages = [];

     

       3122
       3122
       +
           extraPackages = pkgs: [];

     

       3103
       3123
        
         };

     

       3104
       3124
        
       

     

       3105
       3125
        
         yiLanguage = callPackage ../development/libraries/haskell/yi-language {};

     
···

       3125
       3145
        
       

     

       3126
       3146
        
             buildCommand = ''

     

       3127
       3147
        
             export HOME="$TMPDIR"

     

       3128
       3128
       -
             ${nativePkgs.haskellPackages.cabal2nix}/bin/cabal2nix ${src + "/${name}.cabal"} --sha256=FILTERME \

     

       3129
       3129
       -
                 | grep -v FILTERME | sed \

     

       3130
       3130
       -
                   -e 's/licenses.proprietary/licenses.unfree/' \

     

       3131
       3131
       -
                   -e 's/{ cabal/{ cabal, cabalInstall, cabalDrvArgs ? {}, src/' \

     

       3132
       3132
       -
                   -e 's/cabal.mkDerivation (self: {/cabal.mkDerivation (self: cabalDrvArgs \/\/ {/' \

     

       3133
       3133
       -
                   -e 's/buildDepends = \[/buildDepends = \[ cabalInstall/' \

     

       3134
       3134
       -
                   -e 's/pname = \([^\n]*\)/pname = \1\n  inherit src;\n/'  > $out

     

       3148
       3148
       +
             ${nativePkgs.haskellPackages.cabal2nix}/bin/cabal2nix ${src} \

     

       3149
       3149
       +
                 | sed -e 's/licenses.proprietary/licenses.unfree/' > $out

     

       3135
       3150
        
             '';

     

       3136
       3151
        
       

     

       3137
       3152
        
           } // pkgs.lib.optionalAttrs nativePkgs.stdenv.isLinux {

     

       3138
       3153
        
             LANG = "en_US.UTF-8";

     

       3139
       3154
        
             LOCALE_ARCHIVE = "${nativePkgs.glibcLocales}/lib/locale/locale-archive";

     

       3140
       3155
        
           });

     

       3141
       3141
       -
         in callPackage cabalExpr ({ inherit src cabalDrvArgs; } // args);

     

       3156
       3156
       +
         in callPackage cabalExpr {

     

       3157
       3157
       +
           cabal = self.cabal.override {

     

       3158
       3158
       +
             extension = eself: esuper: {

     

       3159
       3159
       +
               buildDepends = [ self.cabalInstall ] ++ esuper.buildDepends;

     

       3160
       3160
       +
             } // cabalDrvArgs;

     

       3161
       3161
       +
           };

     

       3162
       3162
       +
         };

     

       3142
       3163
        
       

     

       3143
       3164
        
         buildLocalCabal = src: name: self.buildLocalCabalWithArgs { inherit src name; };

     

       3144
       3165

+1243 -798

pkgs/top-level/node-packages-generated.nix

···

       157
       157
        
           ];

     

       158
       158
        
           passthru.names = [ "accepts" ];

     

       159
       159
        
         };

     

       160
       160
       -
         by-spec."accepts"."~1.1.0" =

     

       161
       161
       -
           self.by-version."accepts"."1.1.1";

     

       162
       162
       -
         by-version."accepts"."1.1.1" = lib.makeOverridable self.buildNodePackage {

     

       163
       163
       -
           name = "accepts-1.1.1";

     

       160
       160
       +
         by-spec."accepts"."~1.1.2" =

     

       161
       161
       +
           self.by-version."accepts"."1.1.2";

     

       162
       162
       +
         by-version."accepts"."1.1.2" = lib.makeOverridable self.buildNodePackage {

     

       163
       163
       +
           name = "accepts-1.1.2";

     

       164
       164
        
           bin = false;

     

       165
       165
        
           src = [

     

       166
       166
        
             (fetchurl {

     

       167
       167
       -
               url = "http://registry.npmjs.org/accepts/-/accepts-1.1.1.tgz";

     

       168
       168
       -
               name = "accepts-1.1.1.tgz";

     

       169
       169
       -
               sha1 = "3b40bf6abc3fe3bc004534f4672ae1efd0063a96";

     

       167
       167
       +
               url = "http://registry.npmjs.org/accepts/-/accepts-1.1.2.tgz";

     

       168
       168
       +
               name = "accepts-1.1.2.tgz";

     

       169
       169
       +
               sha1 = "8469a0a0a215b50cb0d156d351662f8978b00876";

     

       170
       170
        
             })

     

       171
       171
        
           ];

     

       172
       172
        
           buildInputs =

     

       173
       173
        
             (self.nativeDeps."accepts" or []);

     

       174
       174
        
           deps = {

     

       175
       175
        
             "mime-types-2.0.2" = self.by-version."mime-types"."2.0.2";

     

       176
       176
       -
             "negotiator-0.4.8" = self.by-version."negotiator"."0.4.8";

     

       176
       176
       +
             "negotiator-0.4.9" = self.by-version."negotiator"."0.4.9";

     

       177
       177
        
           };

     

       178
       178
        
           peerDependencies = [

     

       179
       179
        
           ];

     
···

       490
       490
        
             "glob-3.2.11" = self.by-version."glob"."3.2.11";

     

       491
       491
        
             "lazystream-0.1.0" = self.by-version."lazystream"."0.1.0";

     

       492
       492
        
             "lodash-2.4.1" = self.by-version."lodash"."2.4.1";

     

       493
       493
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       493
       493
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       494
       494
        
             "tar-stream-0.4.7" = self.by-version."tar-stream"."0.4.7";

     

       495
       495
        
             "zip-stream-0.4.1" = self.by-version."zip-stream"."0.4.1";

     

       496
       496
        
           };

     
···

       498
       498
        
           ];

     

       499
       499
        
           passthru.names = [ "archiver" ];

     

       500
       500
        
         };

     

       501
       501
       -
         by-spec."archy"."0" =

     

       501
       501
       +
         by-spec."archy"."0.0.2" =

     

       502
       502
        
           self.by-version."archy"."0.0.2";

     

       503
       503
        
         by-version."archy"."0.0.2" = lib.makeOverridable self.buildNodePackage {

     

       504
       504
        
           name = "archy-0.0.2";

     
···

       518
       518
        
           ];

     

       519
       519
        
           passthru.names = [ "archy" ];

     

       520
       520
        
         };

     

       521
       521
       -
         by-spec."archy"."0.0.2" =

     

       522
       522
       -
           self.by-version."archy"."0.0.2";

     

       523
       521
        
         by-spec."archy"."^0.0.2" =

     

       524
       522
        
           self.by-version."archy"."0.0.2";

     

       523
       523
       +
         by-spec."archy"."~1.0.0" =

     

       524
       524
       +
           self.by-version."archy"."1.0.0";

     

       525
       525
       +
         by-version."archy"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     

       526
       526
       +
           name = "archy-1.0.0";

     

       527
       527
       +
           bin = false;

     

       528
       528
       +
           src = [

     

       529
       529
       +
             (fetchurl {

     

       530
       530
       +
               url = "http://registry.npmjs.org/archy/-/archy-1.0.0.tgz";

     

       531
       531
       +
               name = "archy-1.0.0.tgz";

     

       532
       532
       +
               sha1 = "f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40";

     

       533
       533
       +
             })

     

       534
       534
       +
           ];

     

       535
       535
       +
           buildInputs =

     

       536
       536
       +
             (self.nativeDeps."archy" or []);

     

       537
       537
       +
           deps = {

     

       538
       538
       +
           };

     

       539
       539
       +
           peerDependencies = [

     

       540
       540
       +
           ];

     

       541
       541
       +
           passthru.names = [ "archy" ];

     

       542
       542
       +
         };

     

       525
       543
        
         by-spec."argparse"."0.1.15" =

     

       526
       544
        
           self.by-version."argparse"."0.1.15";

     

       527
       545
        
         by-version."argparse"."0.1.15" = lib.makeOverridable self.buildNodePackage {

     
···

       626
       644
        
           ];

     

       627
       645
        
           passthru.names = [ "asap" ];

     

       628
       646
        
         };

     

       647
       647
       +
         by-spec."asap"."~1.0.0" =

     

       648
       648
       +
           self.by-version."asap"."1.0.0";

     

       629
       649
        
         by-spec."ascii-json"."~0.2" =

     

       630
       650
        
           self.by-version."ascii-json"."0.2.0";

     

       631
       651
        
         by-version."ascii-json"."0.2.0" = lib.makeOverridable self.buildNodePackage {

     
···

       936
       956
        
           passthru.names = [ "async-some" ];

     

       937
       957
        
         };

     

       938
       958
        
         by-spec."aws-sdk"."*" =

     

       939
       939
       -
           self.by-version."aws-sdk"."2.0.18";

     

       940
       940
       -
         by-version."aws-sdk"."2.0.18" = lib.makeOverridable self.buildNodePackage {

     

       941
       941
       -
           name = "aws-sdk-2.0.18";

     

       959
       959
       +
           self.by-version."aws-sdk"."2.0.21";

     

       960
       960
       +
         by-version."aws-sdk"."2.0.21" = lib.makeOverridable self.buildNodePackage {

     

       961
       961
       +
           name = "aws-sdk-2.0.21";

     

       942
       962
        
           bin = false;

     

       943
       963
        
           src = [

     

       944
       964
        
             (fetchurl {

     

       945
       945
       -
               url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.18.tgz";

     

       946
       946
       -
               name = "aws-sdk-2.0.18.tgz";

     

       947
       947
       -
               sha1 = "aea83ffff08de9dd167f785d04b463025078c790";

     

       965
       965
       +
               url = "http://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.21.tgz";

     

       966
       966
       +
               name = "aws-sdk-2.0.21.tgz";

     

       967
       967
       +
               sha1 = "aece051188e5d4a13f2432eb1d00f9dd9a81ef54";

     

       948
       968
        
             })

     

       949
       969
        
           ];

     

       950
       970
        
           buildInputs =

     

       951
       971
        
             (self.nativeDeps."aws-sdk" or []);

     

       952
       972
        
           deps = {

     

       953
       953
       -
             "aws-sdk-apis-3.1.9" = self.by-version."aws-sdk-apis"."3.1.9";

     

       954
       973
        
             "xml2js-0.2.6" = self.by-version."xml2js"."0.2.6";

     

       955
       974
        
             "xmlbuilder-0.4.2" = self.by-version."xmlbuilder"."0.4.2";

     

       956
       975
        
           };

     
···

       958
       977
        
           ];

     

       959
       978
        
           passthru.names = [ "aws-sdk" ];

     

       960
       979
        
         };

     

       961
       961
       -
         "aws-sdk" = self.by-version."aws-sdk"."2.0.18";

     

       980
       980
       +
         "aws-sdk" = self.by-version."aws-sdk"."2.0.21";

     

       962
       981
        
         by-spec."aws-sdk".">=1.2.0 <2" =

     

       963
       982
        
           self.by-version."aws-sdk"."1.18.0";

     

       964
       983
        
         by-version."aws-sdk"."1.18.0" = lib.makeOverridable self.buildNodePackage {

     
···

       981
       1000
        
           ];

     

       982
       1001
        
           passthru.names = [ "aws-sdk" ];

     

       983
       1002
        
         };

     

       984
       984
       -
         by-spec."aws-sdk-apis".">=3.1.0 <4.0.0" =

     

       985
       985
       -
           self.by-version."aws-sdk-apis"."3.1.9";

     

       986
       986
       -
         by-version."aws-sdk-apis"."3.1.9" = lib.makeOverridable self.buildNodePackage {

     

       987
       987
       -
           name = "aws-sdk-apis-3.1.9";

     

       988
       988
       -
           bin = false;

     

       989
       989
       -
           src = [

     

       990
       990
       -
             (fetchurl {

     

       991
       991
       -
               url = "http://registry.npmjs.org/aws-sdk-apis/-/aws-sdk-apis-3.1.9.tgz";

     

       992
       992
       -
               name = "aws-sdk-apis-3.1.9.tgz";

     

       993
       993
       -
               sha1 = "abd017548bb9eab0472d3c729d512aba3fc16a67";

     

       994
       994
       -
             })

     

       995
       995
       -
           ];

     

       996
       996
       -
           buildInputs =

     

       997
       997
       -
             (self.nativeDeps."aws-sdk-apis" or []);

     

       998
       998
       -
           deps = {

     

       999
       999
       -
           };

     

       1000
       1000
       -
           peerDependencies = [

     

       1001
       1001
       -
           ];

     

       1002
       1002
       -
           passthru.names = [ "aws-sdk-apis" ];

     

       1003
       1003
       -
         };

     

       1004
       1003
        
         by-spec."aws-sign"."~0.2.0" =

     

       1005
       1004
        
           self.by-version."aws-sign"."0.2.0";

     

       1006
       1005
        
         by-version."aws-sign"."0.2.0" = lib.makeOverridable self.buildNodePackage {

     
···

       1389
       1388
        
           buildInputs =

     

       1390
       1389
        
             (self.nativeDeps."bl" or []);

     

       1391
       1390
        
           deps = {

     

       1392
       1392
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       1391
       1391
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       1393
       1392
        
           };

     

       1394
       1393
        
           peerDependencies = [

     

       1395
       1394
        
           ];

     
···

       1421
       1420
        
         by-spec."block-stream"."0.0.7" =

     

       1422
       1421
        
           self.by-version."block-stream"."0.0.7";

     

       1423
       1422
        
         by-spec."bluebird".">= 1.2.1" =

     

       1424
       1424
       -
           self.by-version."bluebird"."2.3.5";

     

       1425
       1425
       -
         by-version."bluebird"."2.3.5" = lib.makeOverridable self.buildNodePackage {

     

       1426
       1426
       -
           name = "bluebird-2.3.5";

     

       1423
       1423
       +
           self.by-version."bluebird"."2.3.6";

     

       1424
       1424
       +
         by-version."bluebird"."2.3.6" = lib.makeOverridable self.buildNodePackage {

     

       1425
       1425
       +
           name = "bluebird-2.3.6";

     

       1427
       1426
        
           bin = false;

     

       1428
       1427
        
           src = [

     

       1429
       1428
        
             (fetchurl {

     

       1430
       1430
       -
               url = "http://registry.npmjs.org/bluebird/-/bluebird-2.3.5.tgz";

     

       1431
       1431
       -
               name = "bluebird-2.3.5.tgz";

     

       1432
       1432
       -
               sha1 = "551366d041fdd09030109c2cab990ec444bf78b6";

     

       1429
       1429
       +
               url = "http://registry.npmjs.org/bluebird/-/bluebird-2.3.6.tgz";

     

       1430
       1430
       +
               name = "bluebird-2.3.6.tgz";

     

       1431
       1431
       +
               sha1 = "aa090a29c1bfbc01089609358f4b1c37683515f9";

     

       1433
       1432
        
             })

     

       1434
       1433
        
           ];

     

       1435
       1434
        
           buildInputs =

     
···

       1488
       1487
        
           ];

     

       1489
       1488
        
           passthru.names = [ "body-parser" ];

     

       1490
       1489
        
         };

     

       1491
       1491
       -
         by-spec."body-parser"."~1.8.4" =

     

       1492
       1492
       -
           self.by-version."body-parser"."1.8.4";

     

       1493
       1493
       -
         by-version."body-parser"."1.8.4" = lib.makeOverridable self.buildNodePackage {

     

       1494
       1494
       -
           name = "body-parser-1.8.4";

     

       1490
       1490
       +
         by-spec."body-parser"."~1.9.0" =

     

       1491
       1491
       +
           self.by-version."body-parser"."1.9.0";

     

       1492
       1492
       +
         by-version."body-parser"."1.9.0" = lib.makeOverridable self.buildNodePackage {

     

       1493
       1493
       +
           name = "body-parser-1.9.0";

     

       1495
       1494
        
           bin = false;

     

       1496
       1495
        
           src = [

     

       1497
       1496
        
             (fetchurl {

     

       1498
       1498
       -
               url = "http://registry.npmjs.org/body-parser/-/body-parser-1.8.4.tgz";

     

       1499
       1499
       -
               name = "body-parser-1.8.4.tgz";

     

       1500
       1500
       -
               sha1 = "d497e04bc13b3f9a8bd8c70bb0cdc16f2e028898";

     

       1497
       1497
       +
               url = "http://registry.npmjs.org/body-parser/-/body-parser-1.9.0.tgz";

     

       1498
       1498
       +
               name = "body-parser-1.9.0.tgz";

     

       1499
       1499
       +
               sha1 = "95d72943b1a4f67f56bbac9e0dcc837b68703605";

     

       1501
       1500
        
             })

     

       1502
       1501
        
           ];

     

       1503
       1502
        
           buildInputs =

     

       1504
       1503
        
             (self.nativeDeps."body-parser" or []);

     

       1505
       1504
        
           deps = {

     

       1506
       1505
        
             "bytes-1.0.0" = self.by-version."bytes"."1.0.0";

     

       1507
       1507
       -
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       1506
       1506
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       1508
       1507
        
             "iconv-lite-0.4.4" = self.by-version."iconv-lite"."0.4.4";

     

       1509
       1508
        
             "media-typer-0.3.0" = self.by-version."media-typer"."0.3.0";

     

       1510
       1509
        
             "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";

     
···

       1587
       1586
        
             "fstream-1.0.2" = self.by-version."fstream"."1.0.2";

     

       1588
       1587
        
             "fstream-ignore-1.0.1" = self.by-version."fstream-ignore"."1.0.1";

     

       1589
       1588
        
             "glob-4.0.6" = self.by-version."glob"."4.0.6";

     

       1590
       1590
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       1589
       1589
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       1591
       1590
        
             "handlebars-2.0.0" = self.by-version."handlebars"."2.0.0";

     

       1592
       1591
        
             "inquirer-0.7.1" = self.by-version."inquirer"."0.7.1";

     

       1593
       1592
        
             "insight-0.4.3" = self.by-version."insight"."0.4.3";

     
···

       1952
       1951
        
             (self.nativeDeps."browserchannel" or []);

     

       1953
       1952
        
           deps = {

     

       1954
       1953
        
             "hat-0.0.3" = self.by-version."hat"."0.0.3";

     

       1955
       1955
       -
             "connect-2.26.4" = self.by-version."connect"."2.26.4";

     

       1954
       1954
       +
             "connect-2.27.0" = self.by-version."connect"."2.27.0";

     

       1956
       1955
        
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       1957
       1956
        
             "ascii-json-0.2.0" = self.by-version."ascii-json"."0.2.0";

     

       1958
       1957
        
           };

     
···

       1962
       1961
        
         };

     

       1963
       1962
        
         "browserchannel" = self.by-version."browserchannel"."2.0.0";

     

       1964
       1963
        
         by-spec."browserify"."*" =

     

       1965
       1965
       -
           self.by-version."browserify"."6.0.2";

     

       1966
       1966
       -
         by-version."browserify"."6.0.2" = lib.makeOverridable self.buildNodePackage {

     

       1967
       1967
       -
           name = "browserify-6.0.2";

     

       1964
       1964
       +
           self.by-version."browserify"."6.1.0";

     

       1965
       1965
       +
         by-version."browserify"."6.1.0" = lib.makeOverridable self.buildNodePackage {

     

       1966
       1966
       +
           name = "browserify-6.1.0";

     

       1968
       1967
        
           bin = true;

     

       1969
       1968
        
           src = [

     

       1970
       1969
        
             (fetchurl {

     

       1971
       1971
       -
               url = "http://registry.npmjs.org/browserify/-/browserify-6.0.2.tgz";

     

       1972
       1972
       -
               name = "browserify-6.0.2.tgz";

     

       1973
       1973
       -
               sha1 = "d6dd7a9f9e909f2e84163e544a9d1f358ddd9d58";

     

       1970
       1970
       +
               url = "http://registry.npmjs.org/browserify/-/browserify-6.1.0.tgz";

     

       1971
       1971
       +
               name = "browserify-6.1.0.tgz";

     

       1972
       1972
       +
               sha1 = "8da16d98a0be638b5e53d1cd560f7f344d238cdb";

     

       1974
       1973
        
             })

     

       1975
       1974
        
           ];

     

       1976
       1975
        
           buildInputs =

     
···

       1987
       1986
        
             "concat-stream-1.4.6" = self.by-version."concat-stream"."1.4.6";

     

       1988
       1987
        
             "console-browserify-1.1.0" = self.by-version."console-browserify"."1.1.0";

     

       1989
       1988
        
             "constants-browserify-0.0.1" = self.by-version."constants-browserify"."0.0.1";

     

       1990
       1990
       -
             "crypto-browserify-3.2.6" = self.by-version."crypto-browserify"."3.2.6";

     

       1989
       1989
       +
             "crypto-browserify-3.2.8" = self.by-version."crypto-browserify"."3.2.8";

     

       1991
       1990
        
             "deep-equal-0.2.1" = self.by-version."deep-equal"."0.2.1";

     

       1992
       1991
        
             "defined-0.0.0" = self.by-version."defined"."0.0.0";

     

       1993
       1992
        
             "deps-sort-1.3.5" = self.by-version."deps-sort"."1.3.5";

     

       1994
       1994
       -
             "domain-browser-1.1.2" = self.by-version."domain-browser"."1.1.2";

     

       1993
       1993
       +
             "domain-browser-1.1.3" = self.by-version."domain-browser"."1.1.3";

     

       1995
       1994
        
             "duplexer2-0.0.2" = self.by-version."duplexer2"."0.0.2";

     

       1996
       1995
        
             "events-1.0.2" = self.by-version."events"."1.0.2";

     

       1997
       1996
        
             "glob-4.0.6" = self.by-version."glob"."4.0.6";

     
···

       2007
       2006
        
             "path-browserify-0.0.0" = self.by-version."path-browserify"."0.0.0";

     

       2008
       2007
        
             "process-0.8.0" = self.by-version."process"."0.8.0";

     

       2009
       2008
        
             "punycode-1.2.4" = self.by-version."punycode"."1.2.4";

     

       2010
       2010
       -
             "querystring-es3-0.2.1-0" = self.by-version."querystring-es3"."0.2.1-0";

     

       2009
       2009
       +
             "querystring-es3-0.2.1" = self.by-version."querystring-es3"."0.2.1";

     

       2011
       2010
        
             "readable-stream-1.1.13" = self.by-version."readable-stream"."1.1.13";

     

       2012
       2011
        
             "resolve-0.7.4" = self.by-version."resolve"."0.7.4";

     

       2013
       2012
        
             "shallow-copy-0.0.1" = self.by-version."shallow-copy"."0.0.1";

     
···

       2030
       2029
        
           ];

     

       2031
       2030
        
           passthru.names = [ "browserify" ];

     

       2032
       2031
        
         };

     

       2033
       2033
       -
         "browserify" = self.by-version."browserify"."6.0.2";

     

       2032
       2032
       +
         "browserify" = self.by-version."browserify"."6.1.0";

     

       2034
       2033
        
         by-spec."browserify-zlib"."^0.1.4" =

     

       2035
       2034
        
           self.by-version."browserify-zlib"."0.1.4";

     

       2036
       2035
        
         by-version."browserify-zlib"."0.1.4" = lib.makeOverridable self.buildNodePackage {

     
···

       2693
       2692
        
         by-spec."chmodr"."~0.1.0" =

     

       2694
       2693
        
           self.by-version."chmodr"."0.1.0";

     

       2695
       2694
        
         by-spec."chokidar".">=0.8.2" =

     

       2696
       2696
       -
           self.by-version."chokidar"."0.9.0";

     

       2697
       2697
       -
         by-version."chokidar"."0.9.0" = lib.makeOverridable self.buildNodePackage {

     

       2698
       2698
       -
           name = "chokidar-0.9.0";

     

       2695
       2695
       +
           self.by-version."chokidar"."0.10.1";

     

       2696
       2696
       +
         by-version."chokidar"."0.10.1" = lib.makeOverridable self.buildNodePackage {

     

       2697
       2697
       +
           name = "chokidar-0.10.1";

     

       2699
       2698
        
           bin = false;

     

       2700
       2699
        
           src = [

     

       2701
       2700
        
             (fetchurl {

     

       2702
       2702
       -
               url = "http://registry.npmjs.org/chokidar/-/chokidar-0.9.0.tgz";

     

       2703
       2703
       -
               name = "chokidar-0.9.0.tgz";

     

       2704
       2704
       -
               sha1 = "c1ae41561dbdb89dd5fac615453d20b48a946c2f";

     

       2701
       2701
       +
               url = "http://registry.npmjs.org/chokidar/-/chokidar-0.10.1.tgz";

     

       2702
       2702
       +
               name = "chokidar-0.10.1.tgz";

     

       2703
       2703
       +
               sha1 = "ec2b4e9910c75a2b2e09ff5fdf283029b73af199";

     

       2705
       2704
        
             })

     

       2706
       2705
        
           ];

     

       2707
       2706
        
           buildInputs =

     

       2708
       2707
        
             (self.nativeDeps."chokidar" or []);

     

       2709
       2708
        
           deps = {

     

       2710
       2709
        
             "fsevents-0.3.0" = self.by-version."fsevents"."0.3.0";

     

       2711
       2711
       -
             "recursive-readdir-0.0.2" = self.by-version."recursive-readdir"."0.0.2";

     

       2710
       2710
       +
             "readdirp-1.1.0" = self.by-version."readdirp"."1.1.0";

     

       2712
       2711
        
           };

     

       2713
       2712
        
           peerDependencies = [

     

       2714
       2713
        
           ];

     
···

       2758
       2757
        
         by-spec."clean-css"."~2.2.0" =

     

       2759
       2758
        
           self.by-version."clean-css"."2.2.16";

     

       2760
       2759
        
         by-spec."cli"."0.6.x" =

     

       2761
       2761
       -
           self.by-version."cli"."0.6.4";

     

       2762
       2762
       -
         by-version."cli"."0.6.4" = lib.makeOverridable self.buildNodePackage {

     

       2763
       2763
       -
           name = "cli-0.6.4";

     

       2760
       2760
       +
           self.by-version."cli"."0.6.5";

     

       2761
       2761
       +
         by-version."cli"."0.6.5" = lib.makeOverridable self.buildNodePackage {

     

       2762
       2762
       +
           name = "cli-0.6.5";

     

       2764
       2763
        
           bin = false;

     

       2765
       2764
        
           src = [

     

       2766
       2765
        
             (fetchurl {

     

       2767
       2767
       -
               url = "http://registry.npmjs.org/cli/-/cli-0.6.4.tgz";

     

       2768
       2768
       -
               name = "cli-0.6.4.tgz";

     

       2769
       2769
       -
               sha1 = "105c4e9b29ecdbc1ee0c8e418276f62d8351f88e";

     

       2766
       2766
       +
               url = "http://registry.npmjs.org/cli/-/cli-0.6.5.tgz";

     

       2767
       2767
       +
               name = "cli-0.6.5.tgz";

     

       2768
       2768
       +
               sha1 = "f4edda12dfa8d56d726b43b0b558e089b0d2a85c";

     

       2770
       2769
        
             })

     

       2771
       2770
        
           ];

     

       2772
       2771
        
           buildInputs =

     
···

       2796
       2795
        
           deps = {

     

       2797
       2796
        
             "d-0.1.1" = self.by-version."d"."0.1.1";

     

       2798
       2797
        
             "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";

     

       2799
       2799
       -
             "memoizee-0.3.7" = self.by-version."memoizee"."0.3.7";

     

       2798
       2798
       +
             "memoizee-0.3.8" = self.by-version."memoizee"."0.3.8";

     

       2800
       2799
        
             "timers-ext-0.1.0" = self.by-version."timers-ext"."0.1.0";

     

       2801
       2800
        
           };

     

       2802
       2801
        
           peerDependencies = [

     
···

       2843
       2842
        
           deps = {

     

       2844
       2843
        
             "colors-0.6.2" = self.by-version."colors"."0.6.2";

     

       2845
       2844
        
             "eyes-0.1.8" = self.by-version."eyes"."0.1.8";

     

       2846
       2846
       -
             "winston-0.8.0" = self.by-version."winston"."0.8.0";

     

       2845
       2845
       +
             "winston-0.8.1" = self.by-version."winston"."0.8.1";

     

       2847
       2846
        
           };

     

       2848
       2847
        
           peerDependencies = [

     

       2849
       2848
        
           ];

     
···

       2966
       2965
        
           buildInputs =

     

       2967
       2966
        
             (self.nativeDeps."cmd-shim" or []);

     

       2968
       2967
        
           deps = {

     

       2969
       2969
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       2968
       2968
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       2970
       2969
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       2971
       2970
        
           };

     

       2972
       2971
        
           peerDependencies = [

     
···

       3111
       3110
        
           passthru.names = [ "collections" ];

     

       3112
       3111
        
         };

     

       3113
       3112
        
         by-spec."color"."~0.7.1" =

     

       3114
       3114
       -
           self.by-version."color"."0.7.1";

     

       3115
       3115
       -
         by-version."color"."0.7.1" = lib.makeOverridable self.buildNodePackage {

     

       3116
       3116
       -
           name = "color-0.7.1";

     

       3113
       3113
       +
           self.by-version."color"."0.7.3";

     

       3114
       3114
       +
         by-version."color"."0.7.3" = lib.makeOverridable self.buildNodePackage {

     

       3115
       3115
       +
           name = "color-0.7.3";

     

       3117
       3116
        
           bin = false;

     

       3118
       3117
        
           src = [

     

       3119
       3118
        
             (fetchurl {

     

       3120
       3120
       -
               url = "http://registry.npmjs.org/color/-/color-0.7.1.tgz";

     

       3121
       3121
       -
               name = "color-0.7.1.tgz";

     

       3122
       3122
       -
               sha1 = "a2676f19c6ccb708b7586dc98b5c6e37dc9a199c";

     

       3119
       3119
       +
               url = "http://registry.npmjs.org/color/-/color-0.7.3.tgz";

     

       3120
       3120
       +
               name = "color-0.7.3.tgz";

     

       3121
       3121
       +
               sha1 = "ab3ae4bc6cb8cfadb5d749c40f34aea088104f89";

     

       3123
       3122
        
             })

     

       3124
       3123
        
           ];

     

       3125
       3124
        
           buildInputs =

     

       3126
       3125
        
             (self.nativeDeps."color" or []);

     

       3127
       3126
        
           deps = {

     

       3128
       3128
       -
             "color-convert-0.5.0" = self.by-version."color-convert"."0.5.0";

     

       3127
       3127
       +
             "color-convert-0.5.2" = self.by-version."color-convert"."0.5.2";

     

       3129
       3128
        
             "color-string-0.2.1" = self.by-version."color-string"."0.2.1";

     

       3130
       3129
        
           };

     

       3131
       3130
        
           peerDependencies = [

     
···

       3133
       3132
        
           passthru.names = [ "color" ];

     

       3134
       3133
        
         };

     

       3135
       3134
        
         by-spec."color-convert"."0.5.x" =

     

       3136
       3136
       -
           self.by-version."color-convert"."0.5.0";

     

       3137
       3137
       -
         by-version."color-convert"."0.5.0" = lib.makeOverridable self.buildNodePackage {

     

       3138
       3138
       -
           name = "color-convert-0.5.0";

     

       3135
       3135
       +
           self.by-version."color-convert"."0.5.2";

     

       3136
       3136
       +
         by-version."color-convert"."0.5.2" = lib.makeOverridable self.buildNodePackage {

     

       3137
       3137
       +
           name = "color-convert-0.5.2";

     

       3139
       3138
        
           bin = false;

     

       3140
       3139
        
           src = [

     

       3141
       3140
        
             (fetchurl {

     

       3142
       3142
       -
               url = "http://registry.npmjs.org/color-convert/-/color-convert-0.5.0.tgz";

     

       3143
       3143
       -
               name = "color-convert-0.5.0.tgz";

     

       3144
       3144
       -
               sha1 = "4032cab2128c81670c7b394d77b6783f49caaaf7";

     

       3141
       3141
       +
               url = "http://registry.npmjs.org/color-convert/-/color-convert-0.5.2.tgz";

     

       3142
       3142
       +
               name = "color-convert-0.5.2.tgz";

     

       3143
       3143
       +
               sha1 = "febd9efc33674df3374ff8eeaec3bc56c79a9b35";

     

       3145
       3144
        
             })

     

       3146
       3145
        
           ];

     

       3147
       3146
        
           buildInputs =

     
···

       3167
       3166
        
           buildInputs =

     

       3168
       3167
        
             (self.nativeDeps."color-string" or []);

     

       3169
       3168
        
           deps = {

     

       3170
       3170
       -
             "color-convert-0.5.0" = self.by-version."color-convert"."0.5.0";

     

       3169
       3169
       +
             "color-convert-0.5.2" = self.by-version."color-convert"."0.5.2";

     

       3171
       3170
        
           };

     

       3172
       3171
        
           peerDependencies = [

     

       3173
       3172
        
           ];

     
···

       3405
       3404
        
           ];

     

       3406
       3405
        
           passthru.names = [ "commander" ];

     

       3407
       3406
        
         };

     

       3408
       3408
       -
         by-spec."commander"."2.x" =

     

       3407
       3407
       +
         by-spec."commander"."2.3.0" =

     

       3409
       3408
        
           self.by-version."commander"."2.3.0";

     

       3410
       3409
        
         by-version."commander"."2.3.0" = lib.makeOverridable self.buildNodePackage {

     

       3411
       3410
        
           name = "commander-2.3.0";

     
···

       3415
       3414
        
               url = "http://registry.npmjs.org/commander/-/commander-2.3.0.tgz";

     

       3416
       3415
        
               name = "commander-2.3.0.tgz";

     

       3417
       3416
        
               sha1 = "fd430e889832ec353b9acd1de217c11cb3eef873";

     

       3417
       3417
       +
             })

     

       3418
       3418
       +
           ];

     

       3419
       3419
       +
           buildInputs =

     

       3420
       3420
       +
             (self.nativeDeps."commander" or []);

     

       3421
       3421
       +
           deps = {

     

       3422
       3422
       +
           };

     

       3423
       3423
       +
           peerDependencies = [

     

       3424
       3424
       +
           ];

     

       3425
       3425
       +
           passthru.names = [ "commander" ];

     

       3426
       3426
       +
         };

     

       3427
       3427
       +
         by-spec."commander"."2.x" =

     

       3428
       3428
       +
           self.by-version."commander"."2.4.0";

     

       3429
       3429
       +
         by-version."commander"."2.4.0" = lib.makeOverridable self.buildNodePackage {

     

       3430
       3430
       +
           name = "commander-2.4.0";

     

       3431
       3431
       +
           bin = false;

     

       3432
       3432
       +
           src = [

     

       3433
       3433
       +
             (fetchurl {

     

       3434
       3434
       +
               url = "http://registry.npmjs.org/commander/-/commander-2.4.0.tgz";

     

       3435
       3435
       +
               name = "commander-2.4.0.tgz";

     

       3436
       3436
       +
               sha1 = "fad884ce8f09509b10a5ec931332cb97786e2fd6";

     

       3418
       3437
        
             })

     

       3419
       3438
        
           ];

     

       3420
       3439
        
           buildInputs =

     
···

       3486
       3505
        
           deps = {

     

       3487
       3506
        
             "buffer-crc32-0.2.3" = self.by-version."buffer-crc32"."0.2.3";

     

       3488
       3507
        
             "crc32-stream-0.3.1" = self.by-version."crc32-stream"."0.3.1";

     

       3489
       3489
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       3508
       3508
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       3490
       3509
        
           };

     

       3491
       3510
        
           peerDependencies = [

     

       3492
       3511
        
           ];

     

       3493
       3512
        
           passthru.names = [ "compress-commons" ];

     

       3494
       3513
        
         };

     

       3495
       3495
       -
         by-spec."compressible"."~2.0.0" =

     

       3514
       3514
       +
         by-spec."compressible"."~2.0.1" =

     

       3496
       3515
        
           self.by-version."compressible"."2.0.1";

     

       3497
       3516
        
         by-version."compressible"."2.0.1" = lib.makeOverridable self.buildNodePackage {

     

       3498
       3517
        
           name = "compressible-2.0.1";

     
···

       3507
       3526
        
           buildInputs =

     

       3508
       3527
        
             (self.nativeDeps."compressible" or []);

     

       3509
       3528
        
           deps = {

     

       3510
       3510
       -
             "mime-db-1.1.0" = self.by-version."mime-db"."1.1.0";

     

       3529
       3529
       +
             "mime-db-1.1.1" = self.by-version."mime-db"."1.1.1";

     

       3511
       3530
        
           };

     

       3512
       3531
        
           peerDependencies = [

     

       3513
       3532
        
           ];

     

       3514
       3533
        
           passthru.names = [ "compressible" ];

     

       3515
       3534
        
         };

     

       3516
       3516
       -
         by-spec."compression"."~1.1.0" =

     

       3517
       3517
       -
           self.by-version."compression"."1.1.0";

     

       3518
       3518
       -
         by-version."compression"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     

       3519
       3519
       -
           name = "compression-1.1.0";

     

       3535
       3535
       +
         by-spec."compression"."~1.2.0" =

     

       3536
       3536
       +
           self.by-version."compression"."1.2.0";

     

       3537
       3537
       +
         by-version."compression"."1.2.0" = lib.makeOverridable self.buildNodePackage {

     

       3538
       3538
       +
           name = "compression-1.2.0";

     

       3520
       3539
        
           bin = false;

     

       3521
       3540
        
           src = [

     

       3522
       3541
        
             (fetchurl {

     

       3523
       3523
       -
               url = "http://registry.npmjs.org/compression/-/compression-1.1.0.tgz";

     

       3524
       3524
       -
               name = "compression-1.1.0.tgz";

     

       3525
       3525
       -
               sha1 = "58243eded272fc531d7c744d8e8daa7cc0b99215";

     

       3542
       3542
       +
               url = "http://registry.npmjs.org/compression/-/compression-1.2.0.tgz";

     

       3543
       3543
       +
               name = "compression-1.2.0.tgz";

     

       3544
       3544
       +
               sha1 = "c6951ca9ad90588ada7617da693c6bbbe8736866";

     

       3526
       3545
        
             })

     

       3527
       3546
        
           ];

     

       3528
       3547
        
           buildInputs =

     

       3529
       3548
        
             (self.nativeDeps."compression" or []);

     

       3530
       3549
        
           deps = {

     

       3531
       3531
       -
             "accepts-1.1.1" = self.by-version."accepts"."1.1.1";

     

       3550
       3550
       +
             "accepts-1.1.2" = self.by-version."accepts"."1.1.2";

     

       3532
       3551
        
             "bytes-1.0.0" = self.by-version."bytes"."1.0.0";

     

       3533
       3552
        
             "compressible-2.0.1" = self.by-version."compressible"."2.0.1";

     

       3534
       3534
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3553
       3553
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3535
       3554
        
             "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";

     

       3536
       3555
        
             "vary-1.0.0" = self.by-version."vary"."1.0.0";

     

       3537
       3556
        
           };

     
···

       3628
       3647
        
           buildInputs =

     

       3629
       3648
        
             (self.nativeDeps."configstore" or []);

     

       3630
       3649
        
           deps = {

     

       3631
       3631
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       3650
       3650
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       3632
       3651
        
             "js-yaml-3.0.2" = self.by-version."js-yaml"."3.0.2";

     

       3633
       3652
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       3634
       3653
        
             "object-assign-0.3.1" = self.by-version."object-assign"."0.3.1";

     
···

       3688
       3707
        
             "fresh-0.2.0" = self.by-version."fresh"."0.2.0";

     

       3689
       3708
        
             "pause-0.0.1" = self.by-version."pause"."0.0.1";

     

       3690
       3709
        
             "uid2-0.0.3" = self.by-version."uid2"."0.0.3";

     

       3691
       3691
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3710
       3710
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3692
       3711
        
             "methods-0.0.1" = self.by-version."methods"."0.0.1";

     

       3693
       3712
        
             "raw-body-0.0.3" = self.by-version."raw-body"."0.0.3";

     

       3694
       3713
        
             "negotiator-0.3.0" = self.by-version."negotiator"."0.3.0";

     
···

       3698
       3717
        
           ];

     

       3699
       3718
        
           passthru.names = [ "connect" ];

     

       3700
       3719
        
         };

     

       3701
       3701
       -
         by-spec."connect"."2.26.4" =

     

       3702
       3702
       -
           self.by-version."connect"."2.26.4";

     

       3703
       3703
       -
         by-version."connect"."2.26.4" = lib.makeOverridable self.buildNodePackage {

     

       3704
       3704
       -
           name = "connect-2.26.4";

     

       3720
       3720
       +
         by-spec."connect"."2.27.0" =

     

       3721
       3721
       +
           self.by-version."connect"."2.27.0";

     

       3722
       3722
       +
         by-version."connect"."2.27.0" = lib.makeOverridable self.buildNodePackage {

     

       3723
       3723
       +
           name = "connect-2.27.0";

     

       3705
       3724
        
           bin = false;

     

       3706
       3725
        
           src = [

     

       3707
       3726
        
             (fetchurl {

     

       3708
       3708
       -
               url = "http://registry.npmjs.org/connect/-/connect-2.26.4.tgz";

     

       3709
       3709
       -
               name = "connect-2.26.4.tgz";

     

       3710
       3710
       -
               sha1 = "1ad3477cb90e590f1778ac17b51475af376bece0";

     

       3727
       3727
       +
               url = "http://registry.npmjs.org/connect/-/connect-2.27.0.tgz";

     

       3728
       3728
       +
               name = "connect-2.27.0.tgz";

     

       3729
       3729
       +
               sha1 = "04a2922c7cbe12455c9466f93bd719c37c433dfa";

     

       3711
       3730
        
             })

     

       3712
       3731
        
           ];

     

       3713
       3732
        
           buildInputs =

     

       3714
       3733
        
             (self.nativeDeps."connect" or []);

     

       3715
       3734
        
           deps = {

     

       3716
       3735
        
             "basic-auth-connect-1.0.0" = self.by-version."basic-auth-connect"."1.0.0";

     

       3717
       3717
       -
             "body-parser-1.8.4" = self.by-version."body-parser"."1.8.4";

     

       3736
       3736
       +
             "body-parser-1.9.0" = self.by-version."body-parser"."1.9.0";

     

       3718
       3737
        
             "bytes-1.0.0" = self.by-version."bytes"."1.0.0";

     

       3719
       3738
        
             "cookie-0.1.2" = self.by-version."cookie"."0.1.2";

     

       3720
       3739
        
             "cookie-parser-1.3.3" = self.by-version."cookie-parser"."1.3.3";

     

       3721
       3740
        
             "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";

     

       3722
       3722
       -
             "compression-1.1.0" = self.by-version."compression"."1.1.0";

     

       3723
       3723
       -
             "connect-timeout-1.3.0" = self.by-version."connect-timeout"."1.3.0";

     

       3724
       3724
       -
             "csurf-1.6.1" = self.by-version."csurf"."1.6.1";

     

       3725
       3725
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3726
       3726
       -
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       3727
       3727
       -
             "errorhandler-1.2.0" = self.by-version."errorhandler"."1.2.0";

     

       3728
       3728
       -
             "express-session-1.8.2" = self.by-version."express-session"."1.8.2";

     

       3729
       3729
       -
             "finalhandler-0.2.0" = self.by-version."finalhandler"."0.2.0";

     

       3741
       3741
       +
             "compression-1.2.0" = self.by-version."compression"."1.2.0";

     

       3742
       3742
       +
             "connect-timeout-1.4.0" = self.by-version."connect-timeout"."1.4.0";

     

       3743
       3743
       +
             "csurf-1.6.2" = self.by-version."csurf"."1.6.2";

     

       3744
       3744
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3745
       3745
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       3746
       3746
       +
             "errorhandler-1.2.2" = self.by-version."errorhandler"."1.2.2";

     

       3747
       3747
       +
             "express-session-1.9.0" = self.by-version."express-session"."1.9.0";

     

       3748
       3748
       +
             "finalhandler-0.3.1" = self.by-version."finalhandler"."0.3.1";

     

       3730
       3749
        
             "fresh-0.2.4" = self.by-version."fresh"."0.2.4";

     

       3750
       3750
       +
             "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";

     

       3731
       3751
        
             "media-typer-0.3.0" = self.by-version."media-typer"."0.3.0";

     

       3732
       3732
       -
             "method-override-2.2.0" = self.by-version."method-override"."2.2.0";

     

       3733
       3733
       -
             "morgan-1.3.2" = self.by-version."morgan"."1.3.2";

     

       3752
       3752
       +
             "method-override-2.3.0" = self.by-version."method-override"."2.3.0";

     

       3753
       3753
       +
             "morgan-1.4.0" = self.by-version."morgan"."1.4.0";

     

       3734
       3754
        
             "multiparty-3.3.2" = self.by-version."multiparty"."3.3.2";

     

       3735
       3755
        
             "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";

     

       3736
       3756
        
             "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";

     

       3737
       3757
        
             "qs-2.2.4" = self.by-version."qs"."2.2.4";

     

       3738
       3738
       -
             "response-time-2.0.1" = self.by-version."response-time"."2.0.1";

     

       3739
       3739
       -
             "serve-favicon-2.1.5" = self.by-version."serve-favicon"."2.1.5";

     

       3740
       3740
       -
             "serve-index-1.2.1" = self.by-version."serve-index"."1.2.1";

     

       3741
       3741
       -
             "serve-static-1.6.3" = self.by-version."serve-static"."1.6.3";

     

       3758
       3758
       +
             "response-time-2.2.0" = self.by-version."response-time"."2.2.0";

     

       3759
       3759
       +
             "serve-favicon-2.1.6" = self.by-version."serve-favicon"."2.1.6";

     

       3760
       3760
       +
             "serve-index-1.5.0" = self.by-version."serve-index"."1.5.0";

     

       3761
       3761
       +
             "serve-static-1.7.0" = self.by-version."serve-static"."1.7.0";

     

       3742
       3762
        
             "type-is-1.5.2" = self.by-version."type-is"."1.5.2";

     

       3763
       3763
       +
             "utils-merge-1.0.0" = self.by-version."utils-merge"."1.0.0";

     

       3743
       3764
        
             "vhost-3.0.0" = self.by-version."vhost"."3.0.0";

     

       3744
       3765
        
             "pause-0.0.1" = self.by-version."pause"."0.0.1";

     

       3745
       3766
        
           };

     
···

       3769
       3790
        
             "bytes-0.1.0" = self.by-version."bytes"."0.1.0";

     

       3770
       3791
        
             "send-0.0.3" = self.by-version."send"."0.0.3";

     

       3771
       3792
        
             "fresh-0.1.0" = self.by-version."fresh"."0.1.0";

     

       3772
       3772
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3793
       3793
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3773
       3794
        
           };

     

       3774
       3795
        
           peerDependencies = [

     

       3775
       3796
        
           ];

     
···

       3799
       3820
        
             "bytes-0.2.0" = self.by-version."bytes"."0.2.0";

     

       3800
       3821
        
             "fresh-0.1.0" = self.by-version."fresh"."0.1.0";

     

       3801
       3822
        
             "pause-0.0.1" = self.by-version."pause"."0.0.1";

     

       3802
       3802
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3823
       3823
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3803
       3824
        
           };

     

       3804
       3825
        
           peerDependencies = [

     

       3805
       3826
        
           ];

     
···

       3829
       3850
        
             "bytes-0.2.0" = self.by-version."bytes"."0.2.0";

     

       3830
       3851
        
             "fresh-0.1.0" = self.by-version."fresh"."0.1.0";

     

       3831
       3852
        
             "pause-0.0.1" = self.by-version."pause"."0.0.1";

     

       3832
       3832
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3853
       3853
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3833
       3854
        
           };

     

       3834
       3855
        
           peerDependencies = [

     

       3835
       3856
        
           ];

     

       3836
       3857
        
           passthru.names = [ "connect" ];

     

       3837
       3858
        
         };

     

       3838
       3859
        
         by-spec."connect"."~2" =

     

       3839
       3839
       -
           self.by-version."connect"."2.26.4";

     

       3860
       3860
       +
           self.by-version."connect"."2.27.0";

     

       3840
       3861
        
         by-spec."connect"."~2.12.0" =

     

       3841
       3862
        
           self.by-version."connect"."2.12.0";

     

       3842
       3863
        
         by-version."connect"."2.12.0" = lib.makeOverridable self.buildNodePackage {

     
···

       3957
       3978
        
           passthru.names = [ "connect-mongo" ];

     

       3958
       3979
        
         };

     

       3959
       3980
        
         "connect-mongo" = self.by-version."connect-mongo"."0.4.1";

     

       3960
       3960
       -
         by-spec."connect-timeout"."~1.3.0" =

     

       3961
       3961
       -
           self.by-version."connect-timeout"."1.3.0";

     

       3962
       3962
       -
         by-version."connect-timeout"."1.3.0" = lib.makeOverridable self.buildNodePackage {

     

       3963
       3963
       -
           name = "connect-timeout-1.3.0";

     

       3981
       3981
       +
         by-spec."connect-timeout"."~1.4.0" =

     

       3982
       3982
       +
           self.by-version."connect-timeout"."1.4.0";

     

       3983
       3983
       +
         by-version."connect-timeout"."1.4.0" = lib.makeOverridable self.buildNodePackage {

     

       3984
       3984
       +
           name = "connect-timeout-1.4.0";

     

       3964
       3985
        
           bin = false;

     

       3965
       3986
        
           src = [

     

       3966
       3987
        
             (fetchurl {

     

       3967
       3967
       -
               url = "http://registry.npmjs.org/connect-timeout/-/connect-timeout-1.3.0.tgz";

     

       3968
       3968
       -
               name = "connect-timeout-1.3.0.tgz";

     

       3969
       3969
       -
               sha1 = "d9d1d2df2900d490ed54190809f37e6b4508a1ec";

     

       3988
       3988
       +
               url = "http://registry.npmjs.org/connect-timeout/-/connect-timeout-1.4.0.tgz";

     

       3989
       3989
       +
               name = "connect-timeout-1.4.0.tgz";

     

       3990
       3990
       +
               sha1 = "b8003ea155abd18bbdd8a19c91e5284ddc2e465e";

     

       3970
       3991
        
             })

     

       3971
       3992
        
           ];

     

       3972
       3993
        
           buildInputs =

     

       3973
       3994
        
             (self.nativeDeps."connect-timeout" or []);

     

       3974
       3995
        
           deps = {

     

       3975
       3975
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       3996
       3996
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       3997
       3997
       +
             "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";

     

       3976
       3998
        
             "ms-0.6.2" = self.by-version."ms"."0.6.2";

     

       3977
       3999
        
             "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";

     

       3978
       4000
        
           };

     
···

       4087
       4109
        
           ];

     

       4088
       4110
        
           passthru.names = [ "constants-browserify" ];

     

       4089
       4111
        
         };

     

       4112
       4112
       +
         by-spec."content-disposition"."0.5.0" =

     

       4113
       4113
       +
           self.by-version."content-disposition"."0.5.0";

     

       4114
       4114
       +
         by-version."content-disposition"."0.5.0" = lib.makeOverridable self.buildNodePackage {

     

       4115
       4115
       +
           name = "content-disposition-0.5.0";

     

       4116
       4116
       +
           bin = false;

     

       4117
       4117
       +
           src = [

     

       4118
       4118
       +
             (fetchurl {

     

       4119
       4119
       +
               url = "http://registry.npmjs.org/content-disposition/-/content-disposition-0.5.0.tgz";

     

       4120
       4120
       +
               name = "content-disposition-0.5.0.tgz";

     

       4121
       4121
       +
               sha1 = "4284fe6ae0630874639e44e80a418c2934135e9e";

     

       4122
       4122
       +
             })

     

       4123
       4123
       +
           ];

     

       4124
       4124
       +
           buildInputs =

     

       4125
       4125
       +
             (self.nativeDeps."content-disposition" or []);

     

       4126
       4126
       +
           deps = {

     

       4127
       4127
       +
           };

     

       4128
       4128
       +
           peerDependencies = [

     

       4129
       4129
       +
           ];

     

       4130
       4130
       +
           passthru.names = [ "content-disposition" ];

     

       4131
       4131
       +
         };

     

       4090
       4132
        
         by-spec."convert-source-map"."~0.3.0" =

     

       4091
       4133
        
           self.by-version."convert-source-map"."0.3.5";

     

       4092
       4134
        
         by-version."convert-source-map"."0.3.5" = lib.makeOverridable self.buildNodePackage {

     
···

       4533
       4575
        
           buildInputs =

     

       4534
       4576
        
             (self.nativeDeps."crc32-stream" or []);

     

       4535
       4577
        
           deps = {

     

       4536
       4536
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       4578
       4578
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       4537
       4579
        
             "buffer-crc32-0.2.3" = self.by-version."buffer-crc32"."0.2.3";

     

       4538
       4580
        
           };

     

       4539
       4581
        
           peerDependencies = [

     
···

       4624
       4666
        
           passthru.names = [ "crypto" ];

     

       4625
       4667
        
         };

     

       4626
       4668
        
         by-spec."crypto-browserify"."^3.0.0" =

     

       4627
       4627
       -
           self.by-version."crypto-browserify"."3.2.6";

     

       4628
       4628
       -
         by-version."crypto-browserify"."3.2.6" = lib.makeOverridable self.buildNodePackage {

     

       4629
       4629
       -
           name = "crypto-browserify-3.2.6";

     

       4669
       4669
       +
           self.by-version."crypto-browserify"."3.2.8";

     

       4670
       4670
       +
         by-version."crypto-browserify"."3.2.8" = lib.makeOverridable self.buildNodePackage {

     

       4671
       4671
       +
           name = "crypto-browserify-3.2.8";

     

       4630
       4672
        
           bin = false;

     

       4631
       4673
        
           src = [

     

       4632
       4674
        
             (fetchurl {

     

       4633
       4633
       -
               url = "http://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.2.6.tgz";

     

       4634
       4634
       -
               name = "crypto-browserify-3.2.6.tgz";

     

       4635
       4635
       -
               sha1 = "e65a44893ad85138dbf0eaf515675adfd917cdb4";

     

       4675
       4675
       +
               url = "http://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.2.8.tgz";

     

       4676
       4676
       +
               name = "crypto-browserify-3.2.8.tgz";

     

       4677
       4677
       +
               sha1 = "b9b11dbe6d9651dd882a01e6cc467df718ecf189";

     

       4636
       4678
        
             })

     

       4637
       4679
        
           ];

     

       4638
       4680
        
           buildInputs =

     
···

       4772
       4814
        
           ];

     

       4773
       4815
        
           passthru.names = [ "css-stringify" ];

     

       4774
       4816
        
         };

     

       4775
       4775
       -
         by-spec."csurf"."~1.6.1" =

     

       4776
       4776
       -
           self.by-version."csurf"."1.6.1";

     

       4777
       4777
       -
         by-version."csurf"."1.6.1" = lib.makeOverridable self.buildNodePackage {

     

       4778
       4778
       -
           name = "csurf-1.6.1";

     

       4817
       4817
       +
         by-spec."csurf"."~1.6.2" =

     

       4818
       4818
       +
           self.by-version."csurf"."1.6.2";

     

       4819
       4819
       +
         by-version."csurf"."1.6.2" = lib.makeOverridable self.buildNodePackage {

     

       4820
       4820
       +
           name = "csurf-1.6.2";

     

       4779
       4821
        
           bin = false;

     

       4780
       4822
        
           src = [

     

       4781
       4823
        
             (fetchurl {

     

       4782
       4782
       -
               url = "http://registry.npmjs.org/csurf/-/csurf-1.6.1.tgz";

     

       4783
       4783
       -
               name = "csurf-1.6.1.tgz";

     

       4784
       4784
       -
               sha1 = "78da376f016bcaa48275d553d133585e478f4054";

     

       4824
       4824
       +
               url = "http://registry.npmjs.org/csurf/-/csurf-1.6.2.tgz";

     

       4825
       4825
       +
               name = "csurf-1.6.2.tgz";

     

       4826
       4826
       +
               sha1 = "e732b7478b4bef654337fd8bb363d0422a71d9f1";

     

       4785
       4827
        
             })

     

       4786
       4828
        
           ];

     

       4787
       4829
        
           buildInputs =

     
···

       4790
       4832
        
             "cookie-0.1.2" = self.by-version."cookie"."0.1.2";

     

       4791
       4833
        
             "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";

     

       4792
       4834
        
             "csrf-2.0.1" = self.by-version."csrf"."2.0.1";

     

       4835
       4835
       +
             "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";

     

       4793
       4836
        
           };

     

       4794
       4837
        
           peerDependencies = [

     

       4795
       4838
        
           ];

     
···

       4981
       5024
        
         by-spec."dateformat"."~1.0.6" =

     

       4982
       5025
        
           self.by-version."dateformat"."1.0.8";

     

       4983
       5026
        
         by-spec."debug"."*" =

     

       4984
       4984
       -
           self.by-version."debug"."2.0.0";

     

       4985
       4985
       -
         by-version."debug"."2.0.0" = lib.makeOverridable self.buildNodePackage {

     

       4986
       4986
       -
           name = "debug-2.0.0";

     

       5027
       5027
       +
           self.by-version."debug"."2.1.0";

     

       5028
       5028
       +
         by-version."debug"."2.1.0" = lib.makeOverridable self.buildNodePackage {

     

       5029
       5029
       +
           name = "debug-2.1.0";

     

       4987
       5030
        
           bin = false;

     

       4988
       5031
        
           src = [

     

       4989
       5032
        
             (fetchurl {

     

       4990
       4990
       -
               url = "http://registry.npmjs.org/debug/-/debug-2.0.0.tgz";

     

       4991
       4991
       -
               name = "debug-2.0.0.tgz";

     

       4992
       4992
       -
               sha1 = "89bd9df6732b51256bc6705342bba02ed12131ef";

     

       5033
       5033
       +
               url = "http://registry.npmjs.org/debug/-/debug-2.1.0.tgz";

     

       5034
       5034
       +
               name = "debug-2.1.0.tgz";

     

       5035
       5035
       +
               sha1 = "33ab915659d8c2cc8a41443d94d6ebd37697ed21";

     

       4993
       5036
        
             })

     

       4994
       5037
        
           ];

     

       4995
       5038
        
           buildInputs =

     
···

       5062
       5105
        
           ];

     

       5063
       5106
        
           passthru.names = [ "debug" ];

     

       5064
       5107
        
         };

     

       5108
       5108
       +
         by-spec."debug"."2.0.0" =

     

       5109
       5109
       +
           self.by-version."debug"."2.0.0";

     

       5110
       5110
       +
         by-version."debug"."2.0.0" = lib.makeOverridable self.buildNodePackage {

     

       5111
       5111
       +
           name = "debug-2.0.0";

     

       5112
       5112
       +
           bin = false;

     

       5113
       5113
       +
           src = [

     

       5114
       5114
       +
             (fetchurl {

     

       5115
       5115
       +
               url = "http://registry.npmjs.org/debug/-/debug-2.0.0.tgz";

     

       5116
       5116
       +
               name = "debug-2.0.0.tgz";

     

       5117
       5117
       +
               sha1 = "89bd9df6732b51256bc6705342bba02ed12131ef";

     

       5118
       5118
       +
             })

     

       5119
       5119
       +
           ];

     

       5120
       5120
       +
           buildInputs =

     

       5121
       5121
       +
             (self.nativeDeps."debug" or []);

     

       5122
       5122
       +
           deps = {

     

       5123
       5123
       +
             "ms-0.6.2" = self.by-version."ms"."0.6.2";

     

       5124
       5124
       +
           };

     

       5125
       5125
       +
           peerDependencies = [

     

       5126
       5126
       +
           ];

     

       5127
       5127
       +
           passthru.names = [ "debug" ];

     

       5128
       5128
       +
         };

     

       5065
       5129
        
         by-spec."debug".">= 0.7.3 < 1" =

     

       5066
       5130
        
           self.by-version."debug"."0.8.1";

     

       5067
       5131
        
         by-version."debug"."0.8.1" = lib.makeOverridable self.buildNodePackage {

     
···

       5090
       5154
        
           self.by-version."debug"."1.0.4";

     

       5091
       5155
        
         by-spec."debug"."~2.0.0" =

     

       5092
       5156
        
           self.by-version."debug"."2.0.0";

     

       5157
       5157
       +
         by-spec."debug"."~2.1.0" =

     

       5158
       5158
       +
           self.by-version."debug"."2.1.0";

     

       5093
       5159
        
         by-spec."debuglog"."^1.0.1" =

     

       5094
       5160
        
           self.by-version."debuglog"."1.0.1";

     

       5095
       5161
        
         by-version."debuglog"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     
···

       5131
       5197
        
             "touch-0.0.2" = self.by-version."touch"."0.0.2";

     

       5132
       5198
        
             "readable-stream-1.1.13" = self.by-version."readable-stream"."1.1.13";

     

       5133
       5199
        
             "nopt-2.2.1" = self.by-version."nopt"."2.2.1";

     

       5134
       5134
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       5200
       5200
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       5135
       5201
        
           };

     

       5136
       5202
        
           peerDependencies = [

     

       5137
       5203
        
           ];

     
···

       5346
       5412
        
           ];

     

       5347
       5413
        
           passthru.names = [ "depd" ];

     

       5348
       5414
        
         };

     

       5415
       5415
       +
         by-spec."depd"."~1.0.0" =

     

       5416
       5416
       +
           self.by-version."depd"."1.0.0";

     

       5417
       5417
       +
         by-version."depd"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     

       5418
       5418
       +
           name = "depd-1.0.0";

     

       5419
       5419
       +
           bin = false;

     

       5420
       5420
       +
           src = [

     

       5421
       5421
       +
             (fetchurl {

     

       5422
       5422
       +
               url = "http://registry.npmjs.org/depd/-/depd-1.0.0.tgz";

     

       5423
       5423
       +
               name = "depd-1.0.0.tgz";

     

       5424
       5424
       +
               sha1 = "2fda0d00e98aae2845d4991ab1bf1f2a199073d5";

     

       5425
       5425
       +
             })

     

       5426
       5426
       +
           ];

     

       5427
       5427
       +
           buildInputs =

     

       5428
       5428
       +
             (self.nativeDeps."depd" or []);

     

       5429
       5429
       +
           deps = {

     

       5430
       5430
       +
           };

     

       5431
       5431
       +
           peerDependencies = [

     

       5432
       5432
       +
           ];

     

       5433
       5433
       +
           passthru.names = [ "depd" ];

     

       5434
       5434
       +
         };

     

       5349
       5435
        
         by-spec."deprecated"."^0.0.1" =

     

       5350
       5436
        
           self.by-version."deprecated"."0.0.1";

     

       5351
       5437
        
         by-version."deprecated"."0.0.1" = lib.makeOverridable self.buildNodePackage {

     
···

       5499
       5585
        
           ];

     

       5500
       5586
        
           passthru.names = [ "diff" ];

     

       5501
       5587
        
         };

     

       5502
       5502
       -
         by-spec."diff"."~1.0.3" =

     

       5588
       5588
       +
         by-spec."diff"."1.0.8" =

     

       5503
       5589
        
           self.by-version."diff"."1.0.8";

     

       5504
       5590
        
         by-version."diff"."1.0.8" = lib.makeOverridable self.buildNodePackage {

     

       5505
       5591
        
           name = "diff-1.0.8";

     
···

       5519
       5605
        
           ];

     

       5520
       5606
        
           passthru.names = [ "diff" ];

     

       5521
       5607
        
         };

     

       5608
       5608
       +
         by-spec."diff"."~1.0.3" =

     

       5609
       5609
       +
           self.by-version."diff"."1.0.8";

     

       5522
       5610
        
         by-spec."diff"."~1.0.7" =

     

       5523
       5611
        
           self.by-version."diff"."1.0.8";

     

       5524
       5612
        
         by-spec."director"."1.1.10" =

     
···

       5584
       5672
        
           passthru.names = [ "dkim-signer" ];

     

       5585
       5673
        
         };

     

       5586
       5674
        
         by-spec."domain-browser"."~1.1.0" =

     

       5587
       5587
       -
           self.by-version."domain-browser"."1.1.2";

     

       5588
       5588
       -
         by-version."domain-browser"."1.1.2" = lib.makeOverridable self.buildNodePackage {

     

       5589
       5589
       -
           name = "domain-browser-1.1.2";

     

       5675
       5675
       +
           self.by-version."domain-browser"."1.1.3";

     

       5676
       5676
       +
         by-version."domain-browser"."1.1.3" = lib.makeOverridable self.buildNodePackage {

     

       5677
       5677
       +
           name = "domain-browser-1.1.3";

     

       5590
       5678
        
           bin = false;

     

       5591
       5679
        
           src = [

     

       5592
       5680
        
             (fetchurl {

     

       5593
       5593
       -
               url = "http://registry.npmjs.org/domain-browser/-/domain-browser-1.1.2.tgz";

     

       5594
       5594
       -
               name = "domain-browser-1.1.2.tgz";

     

       5595
       5595
       -
               sha1 = "5a21f30a29a9891533915061426974dc2f14e56b";

     

       5681
       5681
       +
               url = "http://registry.npmjs.org/domain-browser/-/domain-browser-1.1.3.tgz";

     

       5682
       5682
       +
               name = "domain-browser-1.1.3.tgz";

     

       5683
       5683
       +
               sha1 = "ee8b336f1c53dc990b302eac12b4c7fee24923c1";

     

       5596
       5684
        
             })

     

       5597
       5685
        
           ];

     

       5598
       5686
        
           buildInputs =

     
···

       5811
       5899
        
           passthru.names = [ "emitter-component" ];

     

       5812
       5900
        
         };

     

       5813
       5901
        
         by-spec."encoding"."~0.1.7" =

     

       5814
       5814
       -
           self.by-version."encoding"."0.1.8";

     

       5815
       5815
       -
         by-version."encoding"."0.1.8" = lib.makeOverridable self.buildNodePackage {

     

       5816
       5816
       -
           name = "encoding-0.1.8";

     

       5902
       5902
       +
           self.by-version."encoding"."0.1.10";

     

       5903
       5903
       +
         by-version."encoding"."0.1.10" = lib.makeOverridable self.buildNodePackage {

     

       5904
       5904
       +
           name = "encoding-0.1.10";

     

       5817
       5905
        
           bin = false;

     

       5818
       5906
        
           src = [

     

       5819
       5907
        
             (fetchurl {

     

       5820
       5820
       -
               url = "http://registry.npmjs.org/encoding/-/encoding-0.1.8.tgz";

     

       5821
       5821
       -
               name = "encoding-0.1.8.tgz";

     

       5822
       5822
       -
               sha1 = "3c48d355f6f4da0545de88c6f2673ccf70df11e7";

     

       5908
       5908
       +
               url = "http://registry.npmjs.org/encoding/-/encoding-0.1.10.tgz";

     

       5909
       5909
       +
               name = "encoding-0.1.10.tgz";

     

       5910
       5910
       +
               sha1 = "4463122033a7e3fdae4e81bf306f675dd8e4612c";

     

       5823
       5911
        
             })

     

       5824
       5912
        
           ];

     

       5825
       5913
        
           buildInputs =

     
···

       5914
       6002
        
           ];

     

       5915
       6003
        
           passthru.names = [ "entities" ];

     

       5916
       6004
        
         };

     

       5917
       5917
       -
         by-spec."envify"."^2.0.0" =

     

       5918
       5918
       -
           self.by-version."envify"."2.0.1";

     

       5919
       5919
       -
         by-version."envify"."2.0.1" = lib.makeOverridable self.buildNodePackage {

     

       5920
       5920
       -
           name = "envify-2.0.1";

     

       6005
       6005
       +
         by-spec."envify"."^3.0.0" =

     

       6006
       6006
       +
           self.by-version."envify"."3.0.0";

     

       6007
       6007
       +
         by-version."envify"."3.0.0" = lib.makeOverridable self.buildNodePackage {

     

       6008
       6008
       +
           name = "envify-3.0.0";

     

       5921
       6009
        
           bin = true;

     

       5922
       6010
        
           src = [

     

       5923
       6011
        
             (fetchurl {

     

       5924
       5924
       -
               url = "http://registry.npmjs.org/envify/-/envify-2.0.1.tgz";

     

       5925
       5925
       -
               name = "envify-2.0.1.tgz";

     

       5926
       5926
       -
               sha1 = "abab827e063efd8e6f4d485aa82b66688dd056b2";

     

       6012
       6012
       +
               url = "http://registry.npmjs.org/envify/-/envify-3.0.0.tgz";

     

       6013
       6013
       +
               name = "envify-3.0.0.tgz";

     

       6014
       6014
       +
               sha1 = "af81202306f69df13845d0bfcb25a19abcb5f510";

     

       5927
       6015
        
             })

     

       5928
       6016
        
           ];

     

       5929
       6017
        
           buildInputs =

     
···

       5931
       6019
        
           deps = {

     

       5932
       6020
        
             "xtend-2.1.2" = self.by-version."xtend"."2.1.2";

     

       5933
       6021
        
             "through-2.3.6" = self.by-version."through"."2.3.6";

     

       5934
       5934
       -
             "esprima-fb-3001.1.0-dev-harmony-fb" = self.by-version."esprima-fb"."3001.1.0-dev-harmony-fb";

     

       5935
       5935
       -
             "jstransform-3.0.0" = self.by-version."jstransform"."3.0.0";

     

       6022
       6022
       +
             "esprima-fb-4001.3001.0-dev-harmony-fb" = self.by-version."esprima-fb"."4001.3001.0-dev-harmony-fb";

     

       6023
       6023
       +
             "jstransform-6.3.2" = self.by-version."jstransform"."6.3.2";

     

       5936
       6024
        
           };

     

       5937
       6025
        
           peerDependencies = [

     

       5938
       6026
        
           ];

     

       5939
       6027
        
           passthru.names = [ "envify" ];

     

       5940
       6028
        
         };

     

       5941
       5941
       -
         by-spec."errorhandler"."~1.2.0" =

     

       5942
       5942
       -
           self.by-version."errorhandler"."1.2.0";

     

       5943
       5943
       -
         by-version."errorhandler"."1.2.0" = lib.makeOverridable self.buildNodePackage {

     

       5944
       5944
       -
           name = "errorhandler-1.2.0";

     

       6029
       6029
       +
         by-spec."errorhandler"."~1.2.2" =

     

       6030
       6030
       +
           self.by-version."errorhandler"."1.2.2";

     

       6031
       6031
       +
         by-version."errorhandler"."1.2.2" = lib.makeOverridable self.buildNodePackage {

     

       6032
       6032
       +
           name = "errorhandler-1.2.2";

     

       5945
       6033
        
           bin = false;

     

       5946
       6034
        
           src = [

     

       5947
       6035
        
             (fetchurl {

     

       5948
       5948
       -
               url = "http://registry.npmjs.org/errorhandler/-/errorhandler-1.2.0.tgz";

     

       5949
       5949
       -
               name = "errorhandler-1.2.0.tgz";

     

       5950
       5950
       -
               sha1 = "2f89db72c150580c65e8dd5180504f5b8a398bd9";

     

       6036
       6036
       +
               url = "http://registry.npmjs.org/errorhandler/-/errorhandler-1.2.2.tgz";

     

       6037
       6037
       +
               name = "errorhandler-1.2.2.tgz";

     

       6038
       6038
       +
               sha1 = "be0249eee868cf21649648e346da8899d0195984";

     

       5951
       6039
        
             })

     

       5952
       6040
        
           ];

     

       5953
       6041
        
           buildInputs =

     

       5954
       6042
        
             (self.nativeDeps."errorhandler" or []);

     

       5955
       6043
        
           deps = {

     

       5956
       5956
       -
             "accepts-1.1.1" = self.by-version."accepts"."1.1.1";

     

       6044
       6044
       +
             "accepts-1.1.2" = self.by-version."accepts"."1.1.2";

     

       5957
       6045
        
             "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";

     

       5958
       6046
        
           };

     

       5959
       6047
        
           peerDependencies = [

     
···

       5976
       6064
        
             (self.nativeDeps."es5-ext" or []);

     

       5977
       6065
        
           deps = {

     

       5978
       6066
        
             "es6-iterator-0.1.1" = self.by-version."es6-iterator"."0.1.1";

     

       5979
       5979
       -
             "es6-symbol-0.1.0" = self.by-version."es6-symbol"."0.1.0";

     

       6067
       6067
       +
             "es6-symbol-0.1.1" = self.by-version."es6-symbol"."0.1.1";

     

       5980
       6068
        
           };

     

       5981
       6069
        
           peerDependencies = [

     

       5982
       6070
        
           ];

     
···

       6001
       6089
        
           deps = {

     

       6002
       6090
        
             "d-0.1.1" = self.by-version."d"."0.1.1";

     

       6003
       6091
        
             "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";

     

       6004
       6004
       -
             "es6-symbol-0.1.0" = self.by-version."es6-symbol"."0.1.0";

     

       6092
       6092
       +
             "es6-symbol-0.1.1" = self.by-version."es6-symbol"."0.1.1";

     

       6005
       6093
        
           };

     

       6006
       6094
        
           peerDependencies = [

     

       6007
       6095
        
           ];

     

       6008
       6096
        
           passthru.names = [ "es6-iterator" ];

     

       6009
       6097
        
         };

     

       6010
       6098
        
         by-spec."es6-symbol"."0.1.x" =

     

       6011
       6011
       -
           self.by-version."es6-symbol"."0.1.0";

     

       6012
       6012
       -
         by-version."es6-symbol"."0.1.0" = lib.makeOverridable self.buildNodePackage {

     

       6013
       6013
       -
           name = "es6-symbol-0.1.0";

     

       6099
       6099
       +
           self.by-version."es6-symbol"."0.1.1";

     

       6100
       6100
       +
         by-version."es6-symbol"."0.1.1" = lib.makeOverridable self.buildNodePackage {

     

       6101
       6101
       +
           name = "es6-symbol-0.1.1";

     

       6014
       6102
        
           bin = false;

     

       6015
       6103
        
           src = [

     

       6016
       6104
        
             (fetchurl {

     

       6017
       6017
       -
               url = "http://registry.npmjs.org/es6-symbol/-/es6-symbol-0.1.0.tgz";

     

       6018
       6018
       -
               name = "es6-symbol-0.1.0.tgz";

     

       6019
       6019
       -
               sha1 = "ba5878f37a652f6c713244716fc7b24d61d2dc39";

     

       6105
       6105
       +
               url = "http://registry.npmjs.org/es6-symbol/-/es6-symbol-0.1.1.tgz";

     

       6106
       6106
       +
               name = "es6-symbol-0.1.1.tgz";

     

       6107
       6107
       +
               sha1 = "9cf7fab2edaff1b1da8fe8e68bfe3f5aca6ca218";

     

       6020
       6108
        
             })

     

       6021
       6109
        
           ];

     

       6022
       6110
        
           buildInputs =

     
···

       6029
       6117
        
           ];

     

       6030
       6118
        
           passthru.names = [ "es6-symbol" ];

     

       6031
       6119
        
         };

     

       6120
       6120
       +
         by-spec."es6-weak-map"."~0.1.2" =

     

       6121
       6121
       +
           self.by-version."es6-weak-map"."0.1.2";

     

       6122
       6122
       +
         by-version."es6-weak-map"."0.1.2" = lib.makeOverridable self.buildNodePackage {

     

       6123
       6123
       +
           name = "es6-weak-map-0.1.2";

     

       6124
       6124
       +
           bin = false;

     

       6125
       6125
       +
           src = [

     

       6126
       6126
       +
             (fetchurl {

     

       6127
       6127
       +
               url = "http://registry.npmjs.org/es6-weak-map/-/es6-weak-map-0.1.2.tgz";

     

       6128
       6128
       +
               name = "es6-weak-map-0.1.2.tgz";

     

       6129
       6129
       +
               sha1 = "bc5b5fab73f68f6f77a6b39c481fce3d7856d385";

     

       6130
       6130
       +
             })

     

       6131
       6131
       +
           ];

     

       6132
       6132
       +
           buildInputs =

     

       6133
       6133
       +
             (self.nativeDeps."es6-weak-map" or []);

     

       6134
       6134
       +
           deps = {

     

       6135
       6135
       +
             "d-0.1.1" = self.by-version."d"."0.1.1";

     

       6136
       6136
       +
             "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";

     

       6137
       6137
       +
             "es6-iterator-0.1.1" = self.by-version."es6-iterator"."0.1.1";

     

       6138
       6138
       +
             "es6-symbol-0.1.1" = self.by-version."es6-symbol"."0.1.1";

     

       6139
       6139
       +
           };

     

       6140
       6140
       +
           peerDependencies = [

     

       6141
       6141
       +
           ];

     

       6142
       6142
       +
           passthru.names = [ "es6-weak-map" ];

     

       6143
       6143
       +
         };

     

       6032
       6144
        
         by-spec."escape-html"."*" =

     

       6033
       6145
        
           self.by-version."escape-html"."1.0.1";

     

       6034
       6146
        
         by-version."escape-html"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     
···

       6052
       6164
        
         "escape-html" = self.by-version."escape-html"."1.0.1";

     

       6053
       6165
        
         by-spec."escape-html"."1.0.1" =

     

       6054
       6166
        
           self.by-version."escape-html"."1.0.1";

     

       6055
       6055
       -
         by-spec."escape-string-regexp"."^1.0.0" =

     

       6167
       6167
       +
         by-spec."escape-string-regexp"."1.0.2" =

     

       6056
       6168
        
           self.by-version."escape-string-regexp"."1.0.2";

     

       6057
       6169
        
         by-version."escape-string-regexp"."1.0.2" = lib.makeOverridable self.buildNodePackage {

     

       6058
       6170
        
           name = "escape-string-regexp-1.0.2";

     
···

       6072
       6184
        
           ];

     

       6073
       6185
        
           passthru.names = [ "escape-string-regexp" ];

     

       6074
       6186
        
         };

     

       6187
       6187
       +
         by-spec."escape-string-regexp"."^1.0.0" =

     

       6188
       6188
       +
           self.by-version."escape-string-regexp"."1.0.2";

     

       6075
       6189
        
         by-spec."escodegen"."1.3.x" =

     

       6076
       6190
        
           self.by-version."escodegen"."1.3.3";

     

       6077
       6191
        
         by-version."escodegen"."1.3.3" = lib.makeOverridable self.buildNodePackage {

     
···

       6160
       6274
        
           buildInputs =

     

       6161
       6275
        
             (self.nativeDeps."escope" or []);

     

       6162
       6276
        
           deps = {

     

       6163
       6163
       -
             "estraverse-1.5.1" = self.by-version."estraverse"."1.5.1";

     

       6277
       6277
       +
             "estraverse-1.7.0" = self.by-version."estraverse"."1.7.0";

     

       6164
       6278
        
           };

     

       6165
       6279
        
           peerDependencies = [

     

       6166
       6280
        
           ];

     
···

       6277
       6391
        
           ];

     

       6278
       6392
        
           passthru.names = [ "esprima-fb" ];

     

       6279
       6393
        
         };

     

       6280
       6280
       -
         by-spec."esprima-fb"."~3001.1.0-dev-harmony-fb" =

     

       6281
       6281
       -
           self.by-version."esprima-fb"."3001.1.0-dev-harmony-fb";

     

       6394
       6394
       +
         by-spec."esprima-fb"."^4001.3001.0-dev-harmony-fb" =

     

       6395
       6395
       +
           self.by-version."esprima-fb"."4001.3001.0-dev-harmony-fb";

     

       6396
       6396
       +
         by-version."esprima-fb"."4001.3001.0-dev-harmony-fb" = lib.makeOverridable self.buildNodePackage {

     

       6397
       6397
       +
           name = "esprima-fb-4001.3001.0-dev-harmony-fb";

     

       6398
       6398
       +
           bin = true;

     

       6399
       6399
       +
           src = [

     

       6400
       6400
       +
             (fetchurl {

     

       6401
       6401
       +
               url = "http://registry.npmjs.org/esprima-fb/-/esprima-fb-4001.3001.0-dev-harmony-fb.tgz";

     

       6402
       6402
       +
               name = "esprima-fb-4001.3001.0-dev-harmony-fb.tgz";

     

       6403
       6403
       +
               sha1 = "659f1f5dc87f2f474db234a7db2a1b6c3e40af14";

     

       6404
       6404
       +
             })

     

       6405
       6405
       +
           ];

     

       6406
       6406
       +
           buildInputs =

     

       6407
       6407
       +
             (self.nativeDeps."esprima-fb" or []);

     

       6408
       6408
       +
           deps = {

     

       6409
       6409
       +
           };

     

       6410
       6410
       +
           peerDependencies = [

     

       6411
       6411
       +
           ];

     

       6412
       6412
       +
           passthru.names = [ "esprima-fb" ];

     

       6413
       6413
       +
         };

     

       6414
       6414
       +
         by-spec."esprima-fb"."~6001.1.0-dev-harmony-fb" =

     

       6415
       6415
       +
           self.by-version."esprima-fb"."6001.1.0-dev-harmony-fb";

     

       6416
       6416
       +
         by-version."esprima-fb"."6001.1.0-dev-harmony-fb" = lib.makeOverridable self.buildNodePackage {

     

       6417
       6417
       +
           name = "esprima-fb-6001.1.0-dev-harmony-fb";

     

       6418
       6418
       +
           bin = true;

     

       6419
       6419
       +
           src = [

     

       6420
       6420
       +
             (fetchurl {

     

       6421
       6421
       +
               url = "http://registry.npmjs.org/esprima-fb/-/esprima-fb-6001.1.0-dev-harmony-fb.tgz";

     

       6422
       6422
       +
               name = "esprima-fb-6001.1.0-dev-harmony-fb.tgz";

     

       6423
       6423
       +
               sha1 = "72705de7030b45ca41bbf16400a3636ffa0ca4eb";

     

       6424
       6424
       +
             })

     

       6425
       6425
       +
           ];

     

       6426
       6426
       +
           buildInputs =

     

       6427
       6427
       +
             (self.nativeDeps."esprima-fb" or []);

     

       6428
       6428
       +
           deps = {

     

       6429
       6429
       +
           };

     

       6430
       6430
       +
           peerDependencies = [

     

       6431
       6431
       +
           ];

     

       6432
       6432
       +
           passthru.names = [ "esprima-fb" ];

     

       6433
       6433
       +
         };

     

       6282
       6434
        
         by-spec."esshorten"."~ 0.0.2" =

     

       6283
       6435
        
           self.by-version."esshorten"."0.0.2";

     

       6284
       6436
        
         by-version."esshorten"."0.0.2" = lib.makeOverridable self.buildNodePackage {

     
···

       6302
       6454
        
           passthru.names = [ "esshorten" ];

     

       6303
       6455
        
         };

     

       6304
       6456
        
         by-spec."estraverse".">= 0.0.2" =

     

       6305
       6305
       -
           self.by-version."estraverse"."1.5.1";

     

       6306
       6306
       -
         by-version."estraverse"."1.5.1" = lib.makeOverridable self.buildNodePackage {

     

       6307
       6307
       -
           name = "estraverse-1.5.1";

     

       6457
       6457
       +
           self.by-version."estraverse"."1.7.0";

     

       6458
       6458
       +
         by-version."estraverse"."1.7.0" = lib.makeOverridable self.buildNodePackage {

     

       6459
       6459
       +
           name = "estraverse-1.7.0";

     

       6308
       6460
        
           bin = false;

     

       6309
       6461
        
           src = [

     

       6310
       6462
        
             (fetchurl {

     

       6311
       6311
       -
               url = "http://registry.npmjs.org/estraverse/-/estraverse-1.5.1.tgz";

     

       6312
       6312
       -
               name = "estraverse-1.5.1.tgz";

     

       6313
       6313
       -
               sha1 = "867a3e8e58a9f84618afb6c2ddbcd916b7cbaf71";

     

       6463
       6463
       +
               url = "http://registry.npmjs.org/estraverse/-/estraverse-1.7.0.tgz";

     

       6464
       6464
       +
               name = "estraverse-1.7.0.tgz";

     

       6465
       6465
       +
               sha1 = "05dbae27f44ee7cd795e16d118ceff05f1b6a413";

     

       6314
       6466
        
             })

     

       6315
       6467
        
           ];

     

       6316
       6468
        
           buildInputs =

     
···

       6365
       6517
        
           self.by-version."estraverse"."1.3.2";

     

       6366
       6518
        
         by-spec."estraverse"."~1.5.0" =

     

       6367
       6519
        
           self.by-version."estraverse"."1.5.1";

     

       6520
       6520
       +
         by-version."estraverse"."1.5.1" = lib.makeOverridable self.buildNodePackage {

     

       6521
       6521
       +
           name = "estraverse-1.5.1";

     

       6522
       6522
       +
           bin = false;

     

       6523
       6523
       +
           src = [

     

       6524
       6524
       +
             (fetchurl {

     

       6525
       6525
       +
               url = "http://registry.npmjs.org/estraverse/-/estraverse-1.5.1.tgz";

     

       6526
       6526
       +
               name = "estraverse-1.5.1.tgz";

     

       6527
       6527
       +
               sha1 = "867a3e8e58a9f84618afb6c2ddbcd916b7cbaf71";

     

       6528
       6528
       +
             })

     

       6529
       6529
       +
           ];

     

       6530
       6530
       +
           buildInputs =

     

       6531
       6531
       +
             (self.nativeDeps."estraverse" or []);

     

       6532
       6532
       +
           deps = {

     

       6533
       6533
       +
           };

     

       6534
       6534
       +
           peerDependencies = [

     

       6535
       6535
       +
           ];

     

       6536
       6536
       +
           passthru.names = [ "estraverse" ];

     

       6537
       6537
       +
         };

     

       6368
       6538
        
         by-spec."esutils"."~1.0.0" =

     

       6369
       6539
        
           self.by-version."esutils"."1.0.0";

     

       6370
       6540
        
         by-version."esutils"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     
···

       6406
       6576
        
           ];

     

       6407
       6577
        
           passthru.names = [ "etag" ];

     

       6408
       6578
        
         };

     

       6579
       6579
       +
         by-spec."etag"."~1.5.0" =

     

       6580
       6580
       +
           self.by-version."etag"."1.5.0";

     

       6581
       6581
       +
         by-version."etag"."1.5.0" = lib.makeOverridable self.buildNodePackage {

     

       6582
       6582
       +
           name = "etag-1.5.0";

     

       6583
       6583
       +
           bin = false;

     

       6584
       6584
       +
           src = [

     

       6585
       6585
       +
             (fetchurl {

     

       6586
       6586
       +
               url = "http://registry.npmjs.org/etag/-/etag-1.5.0.tgz";

     

       6587
       6587
       +
               name = "etag-1.5.0.tgz";

     

       6588
       6588
       +
               sha1 = "8ca0f7a30b4b7305f034e8902fb8ec3c321491e4";

     

       6589
       6589
       +
             })

     

       6590
       6590
       +
           ];

     

       6591
       6591
       +
           buildInputs =

     

       6592
       6592
       +
             (self.nativeDeps."etag" or []);

     

       6593
       6593
       +
           deps = {

     

       6594
       6594
       +
             "crc-3.0.0" = self.by-version."crc"."3.0.0";

     

       6595
       6595
       +
           };

     

       6596
       6596
       +
           peerDependencies = [

     

       6597
       6597
       +
           ];

     

       6598
       6598
       +
           passthru.names = [ "etag" ];

     

       6599
       6599
       +
         };

     

       6409
       6600
        
         by-spec."event-emitter"."~0.3.1" =

     

       6410
       6601
        
           self.by-version."event-emitter"."0.3.1";

     

       6411
       6602
        
         by-version."event-emitter"."0.3.1" = lib.makeOverridable self.buildNodePackage {

     
···

       6576
       6767
        
             "node-swt-0.1.1" = self.by-version."node-swt"."0.1.1";

     

       6577
       6768
        
             "node-wsfederation-0.1.1" = self.by-version."node-wsfederation"."0.1.1";

     

       6578
       6769
        
             "debug-0.5.0" = self.by-version."debug"."0.5.0";

     

       6579
       6579
       -
             "express-3.17.6" = self.by-version."express"."3.17.6";

     

       6770
       6770
       +
             "express-3.18.0" = self.by-version."express"."3.18.0";

     

       6580
       6771
        
           };

     

       6581
       6772
        
           peerDependencies = [

     

       6582
       6773
        
           ];

     
···

       6607
       6798
        
         by-spec."exit"."~0.1.1" =

     

       6608
       6799
        
           self.by-version."exit"."0.1.2";

     

       6609
       6800
        
         by-spec."express"."*" =

     

       6610
       6610
       -
           self.by-version."express"."4.9.5";

     

       6611
       6611
       -
         by-version."express"."4.9.5" = lib.makeOverridable self.buildNodePackage {

     

       6612
       6612
       -
           name = "express-4.9.5";

     

       6801
       6801
       +
           self.by-version."express"."4.9.8";

     

       6802
       6802
       +
         by-version."express"."4.9.8" = lib.makeOverridable self.buildNodePackage {

     

       6803
       6803
       +
           name = "express-4.9.8";

     

       6613
       6804
        
           bin = false;

     

       6614
       6805
        
           src = [

     

       6615
       6806
        
             (fetchurl {

     

       6616
       6616
       -
               url = "http://registry.npmjs.org/express/-/express-4.9.5.tgz";

     

       6617
       6617
       -
               name = "express-4.9.5.tgz";

     

       6618
       6618
       -
               sha1 = "7f62aa84ac8f5e96acfb98e2944dde0bf1cf8688";

     

       6807
       6807
       +
               url = "http://registry.npmjs.org/express/-/express-4.9.8.tgz";

     

       6808
       6808
       +
               name = "express-4.9.8.tgz";

     

       6809
       6809
       +
               sha1 = "f360f596baeabbd0e5223b603d6eb578d9d2d10d";

     

       6619
       6810
        
             })

     

       6620
       6811
        
           ];

     

       6621
       6812
        
           buildInputs =

     

       6622
       6813
        
             (self.nativeDeps."express" or []);

     

       6623
       6814
        
           deps = {

     

       6624
       6624
       -
             "accepts-1.1.1" = self.by-version."accepts"."1.1.1";

     

       6815
       6815
       +
             "accepts-1.1.2" = self.by-version."accepts"."1.1.2";

     

       6625
       6816
        
             "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";

     

       6626
       6817
        
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       6627
       6818
        
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     
···

       6638
       6829
        
             "qs-2.2.4" = self.by-version."qs"."2.2.4";

     

       6639
       6830
        
             "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";

     

       6640
       6831
        
             "send-0.9.3" = self.by-version."send"."0.9.3";

     

       6641
       6641
       -
             "serve-static-1.6.3" = self.by-version."serve-static"."1.6.3";

     

       6832
       6832
       +
             "serve-static-1.6.4" = self.by-version."serve-static"."1.6.4";

     

       6642
       6833
        
             "type-is-1.5.2" = self.by-version."type-is"."1.5.2";

     

       6643
       6834
        
             "vary-1.0.0" = self.by-version."vary"."1.0.0";

     

       6644
       6835
        
             "cookie-0.1.2" = self.by-version."cookie"."0.1.2";

     
···

       6649
       6840
        
           ];

     

       6650
       6841
        
           passthru.names = [ "express" ];

     

       6651
       6842
        
         };

     

       6652
       6652
       -
         "express" = self.by-version."express"."4.9.5";

     

       6843
       6843
       +
         "express" = self.by-version."express"."4.9.8";

     

       6653
       6844
        
         by-spec."express"."2.5.11" =

     

       6654
       6845
        
           self.by-version."express"."2.5.11";

     

       6655
       6846
        
         by-version."express"."2.5.11" = lib.makeOverridable self.buildNodePackage {

     
···

       6699
       6890
        
             "methods-0.0.1" = self.by-version."methods"."0.0.1";

     

       6700
       6891
        
             "send-0.1.0" = self.by-version."send"."0.1.0";

     

       6701
       6892
        
             "cookie-signature-1.0.1" = self.by-version."cookie-signature"."1.0.1";

     

       6702
       6702
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       6893
       6893
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       6703
       6894
        
           };

     

       6704
       6895
        
           peerDependencies = [

     

       6705
       6896
        
           ];

     
···

       6730
       6921
        
             "methods-0.1.0" = self.by-version."methods"."0.1.0";

     

       6731
       6922
        
             "send-0.1.4" = self.by-version."send"."0.1.4";

     

       6732
       6923
        
             "cookie-signature-1.0.1" = self.by-version."cookie-signature"."1.0.1";

     

       6733
       6733
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       6924
       6924
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       6734
       6925
        
           };

     

       6735
       6926
        
           peerDependencies = [

     

       6736
       6927
        
           ];

     

       6737
       6928
        
           passthru.names = [ "express" ];

     

       6738
       6929
        
         };

     

       6739
       6930
        
         by-spec."express"."3.x" =

     

       6740
       6740
       -
           self.by-version."express"."3.17.6";

     

       6741
       6741
       -
         by-version."express"."3.17.6" = lib.makeOverridable self.buildNodePackage {

     

       6742
       6742
       -
           name = "express-3.17.6";

     

       6931
       6931
       +
           self.by-version."express"."3.18.0";

     

       6932
       6932
       +
         by-version."express"."3.18.0" = lib.makeOverridable self.buildNodePackage {

     

       6933
       6933
       +
           name = "express-3.18.0";

     

       6743
       6934
        
           bin = true;

     

       6744
       6935
        
           src = [

     

       6745
       6936
        
             (fetchurl {

     

       6746
       6746
       -
               url = "http://registry.npmjs.org/express/-/express-3.17.6.tgz";

     

       6747
       6747
       -
               name = "express-3.17.6.tgz";

     

       6748
       6748
       -
               sha1 = "e2f9a6a48b85233afc4f7b6c5cd6799c53f5f46f";

     

       6937
       6937
       +
               url = "http://registry.npmjs.org/express/-/express-3.18.0.tgz";

     

       6938
       6938
       +
               name = "express-3.18.0.tgz";

     

       6939
       6939
       +
               sha1 = "ff1f4ee689ba6e622a087e397994f7c2115c5c57";

     

       6749
       6940
        
             })

     

       6750
       6941
        
           ];

     

       6751
       6942
        
           buildInputs =

     

       6752
       6943
        
             (self.nativeDeps."express" or []);

     

       6753
       6944
        
           deps = {

     

       6754
       6945
        
             "basic-auth-1.0.0" = self.by-version."basic-auth"."1.0.0";

     

       6755
       6755
       -
             "connect-2.26.4" = self.by-version."connect"."2.26.4";

     

       6946
       6946
       +
             "connect-2.27.0" = self.by-version."connect"."2.27.0";

     

       6947
       6947
       +
             "content-disposition-0.5.0" = self.by-version."content-disposition"."0.5.0";

     

       6756
       6948
        
             "commander-1.3.2" = self.by-version."commander"."1.3.2";

     

       6757
       6949
        
             "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";

     

       6758
       6758
       -
             "crc-3.0.0" = self.by-version."crc"."3.0.0";

     

       6759
       6759
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       6760
       6760
       -
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       6950
       6950
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       6951
       6951
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       6761
       6952
        
             "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";

     

       6953
       6953
       +
             "etag-1.5.0" = self.by-version."etag"."1.5.0";

     

       6762
       6954
        
             "fresh-0.2.4" = self.by-version."fresh"."0.2.4";

     

       6763
       6955
        
             "media-typer-0.3.0" = self.by-version."media-typer"."0.3.0";

     

       6764
       6956
        
             "methods-1.1.0" = self.by-version."methods"."1.1.0";

     
···

       6766
       6958
        
             "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";

     

       6767
       6959
        
             "proxy-addr-1.0.3" = self.by-version."proxy-addr"."1.0.3";

     

       6768
       6960
        
             "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";

     

       6769
       6769
       -
             "send-0.9.3" = self.by-version."send"."0.9.3";

     

       6961
       6961
       +
             "send-0.10.0" = self.by-version."send"."0.10.0";

     

       6770
       6962
        
             "vary-1.0.0" = self.by-version."vary"."1.0.0";

     

       6771
       6963
        
             "cookie-0.1.2" = self.by-version."cookie"."0.1.2";

     

       6772
       6964
        
             "merge-descriptors-0.0.2" = self.by-version."merge-descriptors"."0.0.2";

     
···

       6776
       6968
        
           passthru.names = [ "express" ];

     

       6777
       6969
        
         };

     

       6778
       6970
        
         by-spec."express".">=3.0.0" =

     

       6779
       6779
       -
           self.by-version."express"."4.9.5";

     

       6971
       6971
       +
           self.by-version."express"."4.9.8";

     

       6780
       6972
        
         by-spec."express"."~3.1.1" =

     

       6781
       6973
        
           self.by-version."express"."3.1.2";

     

       6782
       6974
        
         by-version."express"."3.1.2" = lib.makeOverridable self.buildNodePackage {

     
···

       6802
       6994
        
             "methods-0.0.1" = self.by-version."methods"."0.0.1";

     

       6803
       6995
        
             "send-0.1.0" = self.by-version."send"."0.1.0";

     

       6804
       6996
        
             "cookie-signature-1.0.0" = self.by-version."cookie-signature"."1.0.0";

     

       6805
       6805
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       6997
       6997
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       6806
       6998
        
           };

     

       6807
       6999
        
           peerDependencies = [

     

       6808
       7000
        
           ];

     
···

       6907
       7099
        
             "async-0.7.0" = self.by-version."async"."0.7.0";

     

       6908
       7100
        
           };

     

       6909
       7101
        
           peerDependencies = [

     

       6910
       6910
       -
             self.by-version."express"."4.9.5"

     

       7102
       7102
       +
             self.by-version."express"."4.9.8"

     

       6911
       7103
        
           ];

     

       6912
       7104
        
           passthru.names = [ "express-form" ];

     

       6913
       7105
        
         };

     
···

       6961
       7153
        
           ];

     

       6962
       7154
        
           passthru.names = [ "express-session" ];

     

       6963
       7155
        
         };

     

       6964
       6964
       -
         by-spec."express-session"."~1.8.2" =

     

       6965
       6965
       -
           self.by-version."express-session"."1.8.2";

     

       6966
       6966
       -
         by-version."express-session"."1.8.2" = lib.makeOverridable self.buildNodePackage {

     

       6967
       6967
       -
           name = "express-session-1.8.2";

     

       7156
       7156
       +
         by-spec."express-session"."~1.9.0" =

     

       7157
       7157
       +
           self.by-version."express-session"."1.9.0";

     

       7158
       7158
       +
         by-version."express-session"."1.9.0" = lib.makeOverridable self.buildNodePackage {

     

       7159
       7159
       +
           name = "express-session-1.9.0";

     

       6968
       7160
        
           bin = false;

     

       6969
       7161
        
           src = [

     

       6970
       7162
        
             (fetchurl {

     

       6971
       6971
       -
               url = "http://registry.npmjs.org/express-session/-/express-session-1.8.2.tgz";

     

       6972
       6972
       -
               name = "express-session-1.8.2.tgz";

     

       6973
       6973
       -
               sha1 = "c4011e728a2349b3c18f117a5409908985e83483";

     

       7163
       7163
       +
               url = "http://registry.npmjs.org/express-session/-/express-session-1.9.0.tgz";

     

       7164
       7164
       +
               name = "express-session-1.9.0.tgz";

     

       7165
       7165
       +
               sha1 = "75ceb80194e5f3d0c71922e4affb90bc40c119f1";

     

       6974
       7166
        
             })

     

       6975
       7167
        
           ];

     

       6976
       7168
        
           buildInputs =

     
···

       6979
       7171
        
             "cookie-0.1.2" = self.by-version."cookie"."0.1.2";

     

       6980
       7172
        
             "cookie-signature-1.0.5" = self.by-version."cookie-signature"."1.0.5";

     

       6981
       7173
        
             "crc-3.0.0" = self.by-version."crc"."3.0.0";

     

       6982
       6982
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       6983
       6983
       -
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       7174
       7174
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       7175
       7175
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       6984
       7176
        
             "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";

     

       6985
       7177
        
             "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";

     

       6986
       7178
        
             "uid-safe-1.0.1" = self.by-version."uid-safe"."1.0.1";

     
···

       7202
       7394
        
           passthru.names = [ "fetch-bower" ];

     

       7203
       7395
        
         };

     

       7204
       7396
        
         by-spec."fields"."~0.1.11" =

     

       7205
       7205
       -
           self.by-version."fields"."0.1.16";

     

       7206
       7206
       -
         by-version."fields"."0.1.16" = lib.makeOverridable self.buildNodePackage {

     

       7207
       7207
       -
           name = "fields-0.1.16";

     

       7397
       7397
       +
           self.by-version."fields"."0.1.17";

     

       7398
       7398
       +
         by-version."fields"."0.1.17" = lib.makeOverridable self.buildNodePackage {

     

       7399
       7399
       +
           name = "fields-0.1.17";

     

       7208
       7400
        
           bin = false;

     

       7209
       7401
        
           src = [

     

       7210
       7402
        
             (fetchurl {

     

       7211
       7211
       -
               url = "http://registry.npmjs.org/fields/-/fields-0.1.16.tgz";

     

       7212
       7212
       -
               name = "fields-0.1.16.tgz";

     

       7213
       7213
       -
               sha1 = "a6d127f93636050c7407bd7a5e26265f82f58c22";

     

       7403
       7403
       +
               url = "http://registry.npmjs.org/fields/-/fields-0.1.17.tgz";

     

       7404
       7404
       +
               name = "fields-0.1.17.tgz";

     

       7405
       7405
       +
               sha1 = "4d5d87d68f7e6f5b46098546821aa939a248cdbf";

     

       7214
       7406
        
             })

     

       7215
       7407
        
           ];

     

       7216
       7408
        
           buildInputs =

     
···

       7312
       7504
        
           ];

     

       7313
       7505
        
           passthru.names = [ "finalhandler" ];

     

       7314
       7506
        
         };

     

       7507
       7507
       +
         by-spec."finalhandler"."0.3.1" =

     

       7508
       7508
       +
           self.by-version."finalhandler"."0.3.1";

     

       7509
       7509
       +
         by-version."finalhandler"."0.3.1" = lib.makeOverridable self.buildNodePackage {

     

       7510
       7510
       +
           name = "finalhandler-0.3.1";

     

       7511
       7511
       +
           bin = false;

     

       7512
       7512
       +
           src = [

     

       7513
       7513
       +
             (fetchurl {

     

       7514
       7514
       +
               url = "http://registry.npmjs.org/finalhandler/-/finalhandler-0.3.1.tgz";

     

       7515
       7515
       +
               name = "finalhandler-0.3.1.tgz";

     

       7516
       7516
       +
               sha1 = "ffda7643228678c6b088c89421a8381663961808";

     

       7517
       7517
       +
             })

     

       7518
       7518
       +
           ];

     

       7519
       7519
       +
           buildInputs =

     

       7520
       7520
       +
             (self.nativeDeps."finalhandler" or []);

     

       7521
       7521
       +
           deps = {

     

       7522
       7522
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       7523
       7523
       +
             "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";

     

       7524
       7524
       +
             "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";

     

       7525
       7525
       +
           };

     

       7526
       7526
       +
           peerDependencies = [

     

       7527
       7527
       +
           ];

     

       7528
       7528
       +
           passthru.names = [ "finalhandler" ];

     

       7529
       7529
       +
         };

     

       7315
       7530
        
         by-spec."findit".">=1.1.0 <2.0.0" =

     

       7316
       7531
        
           self.by-version."findit"."1.2.0";

     

       7317
       7532
        
         by-version."findit"."1.2.0" = lib.makeOverridable self.buildNodePackage {

     
···

       7375
       7590
        
           peerDependencies = [

     

       7376
       7591
        
           ];

     

       7377
       7592
        
           passthru.names = [ "first-chunk-stream" ];

     

       7593
       7593
       +
         };

     

       7594
       7594
       +
         by-spec."flagged-respawn"."~0.3.0" =

     

       7595
       7595
       +
           self.by-version."flagged-respawn"."0.3.1";

     

       7596
       7596
       +
         by-version."flagged-respawn"."0.3.1" = lib.makeOverridable self.buildNodePackage {

     

       7597
       7597
       +
           name = "flagged-respawn-0.3.1";

     

       7598
       7598
       +
           bin = false;

     

       7599
       7599
       +
           src = [

     

       7600
       7600
       +
             (fetchurl {

     

       7601
       7601
       +
               url = "http://registry.npmjs.org/flagged-respawn/-/flagged-respawn-0.3.1.tgz";

     

       7602
       7602
       +
               name = "flagged-respawn-0.3.1.tgz";

     

       7603
       7603
       +
               sha1 = "397700925df6e12452202a71e89d89545fbbbe9d";

     

       7604
       7604
       +
             })

     

       7605
       7605
       +
           ];

     

       7606
       7606
       +
           buildInputs =

     

       7607
       7607
       +
             (self.nativeDeps."flagged-respawn" or []);

     

       7608
       7608
       +
           deps = {

     

       7609
       7609
       +
           };

     

       7610
       7610
       +
           peerDependencies = [

     

       7611
       7611
       +
           ];

     

       7612
       7612
       +
           passthru.names = [ "flagged-respawn" ];

     

       7378
       7613
        
         };

     

       7379
       7614
        
         by-spec."flatiron"."*" =

     

       7380
       7615
        
           self.by-version."flatiron"."0.4.2";

     
···

       7970
       8205
        
           buildInputs =

     

       7971
       8206
        
             (self.nativeDeps."fs-vacuum" or []);

     

       7972
       8207
        
           deps = {

     

       7973
       7973
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       8208
       8208
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       7974
       8209
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     

       7975
       8210
        
           };

     

       7976
       8211
        
           peerDependencies = [

     
···

       8014
       8249
        
           buildInputs =

     

       8015
       8250
        
             (self.nativeDeps."fs-write-stream-atomic" or []);

     

       8016
       8251
        
           deps = {

     

       8017
       8017
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       8252
       8252
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       8018
       8253
        
           };

     

       8019
       8254
        
           peerDependencies = [

     

       8020
       8255
        
           ];

     
···

       8081
       8316
        
           buildInputs =

     

       8082
       8317
        
             (self.nativeDeps."fstream" or []);

     

       8083
       8318
        
           deps = {

     

       8084
       8084
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       8319
       8319
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       8085
       8320
        
             "inherits-2.0.1" = self.by-version."inherits"."2.0.1";

     

       8086
       8321
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       8087
       8322
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     
···

       8107
       8342
        
           buildInputs =

     

       8108
       8343
        
             (self.nativeDeps."fstream" or []);

     

       8109
       8344
        
           deps = {

     

       8110
       8110
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       8345
       8345
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       8111
       8346
        
             "inherits-2.0.1" = self.by-version."inherits"."2.0.1";

     

       8112
       8347
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       8113
       8348
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     
···

       8144
       8379
        
         by-spec."fstream-ignore"."~1.0.1" =

     

       8145
       8380
        
           self.by-version."fstream-ignore"."1.0.1";

     

       8146
       8381
        
         by-spec."fstream-npm"."~1.0.0" =

     

       8147
       8147
       -
           self.by-version."fstream-npm"."1.0.0";

     

       8148
       8148
       -
         by-version."fstream-npm"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     

       8149
       8149
       -
           name = "fstream-npm-1.0.0";

     

       8382
       8382
       +
           self.by-version."fstream-npm"."1.0.1";

     

       8383
       8383
       +
         by-version."fstream-npm"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     

       8384
       8384
       +
           name = "fstream-npm-1.0.1";

     

       8150
       8385
        
           bin = false;

     

       8151
       8386
        
           src = [

     

       8152
       8387
        
             (fetchurl {

     

       8153
       8153
       -
               url = "http://registry.npmjs.org/fstream-npm/-/fstream-npm-1.0.0.tgz";

     

       8154
       8154
       -
               name = "fstream-npm-1.0.0.tgz";

     

       8155
       8155
       -
               sha1 = "0262c95c771d393e7cf59fcfeabce621703f3d27";

     

       8388
       8388
       +
               url = "http://registry.npmjs.org/fstream-npm/-/fstream-npm-1.0.1.tgz";

     

       8389
       8389
       +
               name = "fstream-npm-1.0.1.tgz";

     

       8390
       8390
       +
               sha1 = "1e35c77f0fa24f5d6367e6d447ae7d6ddb482db2";

     

       8156
       8391
        
             })

     

       8157
       8392
        
           ];

     

       8158
       8393
        
           buildInputs =

     
···

       8331
       8566
        
           buildInputs =

     

       8332
       8567
        
             (self.nativeDeps."glob" or []);

     

       8333
       8568
        
           deps = {

     

       8334
       8334
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       8569
       8569
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       8335
       8570
        
             "inherits-2.0.1" = self.by-version."inherits"."2.0.1";

     

       8336
       8571
        
             "minimatch-1.0.0" = self.by-version."minimatch"."1.0.0";

     

       8337
       8572
        
             "once-1.3.1" = self.by-version."once"."1.3.1";

     
···

       8432
       8667
        
           self.by-version."glob"."3.2.11";

     

       8433
       8668
        
         by-spec."glob"."~4.0.2" =

     

       8434
       8669
        
           self.by-version."glob"."4.0.6";

     

       8435
       8435
       -
         by-spec."glob"."~4.0.5" =

     

       8670
       8670
       +
         by-spec."glob"."~4.0.6" =

     

       8436
       8671
        
           self.by-version."glob"."4.0.6";

     

       8437
       8672
        
         by-spec."glob-stream"."^3.1.5" =

     

       8438
       8673
        
           self.by-version."glob-stream"."3.1.15";

     
···

       8454
       8689
        
             "ordered-read-streams-0.0.8" = self.by-version."ordered-read-streams"."0.0.8";

     

       8455
       8690
        
             "glob2base-0.0.11" = self.by-version."glob2base"."0.0.11";

     

       8456
       8691
        
             "unique-stream-1.0.0" = self.by-version."unique-stream"."1.0.0";

     

       8457
       8457
       -
             "through2-0.6.2" = self.by-version."through2"."0.6.2";

     

       8692
       8692
       +
             "through2-0.6.3" = self.by-version."through2"."0.6.3";

     

       8458
       8693
        
           };

     

       8459
       8694
        
           peerDependencies = [

     

       8460
       8695
        
           ];

     
···

       8547
       8782
        
           passthru.names = [ "got" ];

     

       8548
       8783
        
         };

     

       8549
       8784
        
         by-spec."graceful-fs"."2 || 3" =

     

       8550
       8550
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8551
       8551
       -
         by-version."graceful-fs"."3.0.3" = lib.makeOverridable self.buildNodePackage {

     

       8552
       8552
       -
           name = "graceful-fs-3.0.3";

     

       8785
       8785
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8786
       8786
       +
         by-version."graceful-fs"."3.0.4" = lib.makeOverridable self.buildNodePackage {

     

       8787
       8787
       +
           name = "graceful-fs-3.0.4";

     

       8553
       8788
        
           bin = false;

     

       8554
       8789
        
           src = [

     

       8555
       8790
        
             (fetchurl {

     

       8556
       8556
       -
               url = "http://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.3.tgz";

     

       8557
       8557
       -
               name = "graceful-fs-3.0.3.tgz";

     

       8558
       8558
       -
               sha1 = "277141085e739ae7d54361119a62797b08a1d8c0";

     

       8791
       8791
       +
               url = "http://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.4.tgz";

     

       8792
       8792
       +
               name = "graceful-fs-3.0.4.tgz";

     

       8793
       8793
       +
               sha1 = "a0306d9b0940e0fc512d33b5df1014e88e0637a3";

     

       8559
       8794
        
             })

     

       8560
       8795
        
           ];

     

       8561
       8796
        
           buildInputs =

     
···

       8567
       8802
        
           passthru.names = [ "graceful-fs" ];

     

       8568
       8803
        
         };

     

       8569
       8804
        
         by-spec."graceful-fs"."3" =

     

       8570
       8570
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8805
       8805
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8571
       8806
        
         by-spec."graceful-fs".">3.0.1 <4.0.0-0" =

     

       8572
       8572
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8807
       8807
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8573
       8808
        
         by-spec."graceful-fs"."^3.0.0" =

     

       8574
       8574
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8809
       8809
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8575
       8810
        
         by-spec."graceful-fs"."^3.0.2" =

     

       8576
       8576
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8811
       8811
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8577
       8812
        
         by-spec."graceful-fs"."~1" =

     

       8578
       8813
        
           self.by-version."graceful-fs"."1.2.3";

     

       8579
       8814
        
         by-version."graceful-fs"."1.2.3" = lib.makeOverridable self.buildNodePackage {

     
···

       8619
       8854
        
         by-spec."graceful-fs"."~2.0.1" =

     

       8620
       8855
        
           self.by-version."graceful-fs"."2.0.3";

     

       8621
       8856
        
         by-spec."graceful-fs"."~3.0.0" =

     

       8622
       8622
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8857
       8857
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8623
       8858
        
         by-spec."graceful-fs"."~3.0.1" =

     

       8624
       8624
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8859
       8859
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8625
       8860
        
         by-spec."graceful-fs"."~3.0.2" =

     

       8626
       8626
       -
           self.by-version."graceful-fs"."3.0.3";

     

       8861
       8861
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8862
       8862
       +
         by-spec."graceful-fs"."~3.0.4" =

     

       8863
       8863
       +
           self.by-version."graceful-fs"."3.0.4";

     

       8627
       8864
        
         by-spec."gridfs-stream"."*" =

     

       8628
       8865
        
           self.by-version."gridfs-stream"."0.5.1";

     

       8629
       8866
        
         by-version."gridfs-stream"."0.5.1" = lib.makeOverridable self.buildNodePackage {

     
···

       8665
       8902
        
           ];

     

       8666
       8903
        
           passthru.names = [ "growl" ];

     

       8667
       8904
        
         };

     

       8668
       8668
       -
         by-spec."growl"."1.8.x" =

     

       8905
       8905
       +
         by-spec."growl"."1.8.1" =

     

       8669
       8906
        
           self.by-version."growl"."1.8.1";

     

       8670
       8907
        
         by-version."growl"."1.8.1" = lib.makeOverridable self.buildNodePackage {

     

       8671
       8908
        
           name = "growl-1.8.1";

     
···

       9006
       9243
        
         };

     

       9007
       9244
        
         "guifi-earth" = self.by-version."guifi-earth"."0.2.1";

     

       9008
       9245
        
         by-spec."gulp"."*" =

     

       9009
       9009
       -
           self.by-version."gulp"."3.8.8";

     

       9010
       9010
       -
         by-version."gulp"."3.8.8" = lib.makeOverridable self.buildNodePackage {

     

       9011
       9011
       -
           name = "gulp-3.8.8";

     

       9246
       9246
       +
           self.by-version."gulp"."3.8.9";

     

       9247
       9247
       +
         by-version."gulp"."3.8.9" = lib.makeOverridable self.buildNodePackage {

     

       9248
       9248
       +
           name = "gulp-3.8.9";

     

       9012
       9249
        
           bin = true;

     

       9013
       9250
        
           src = [

     

       9014
       9251
        
             (fetchurl {

     

       9015
       9015
       -
               url = "http://registry.npmjs.org/gulp/-/gulp-3.8.8.tgz";

     

       9016
       9016
       -
               name = "gulp-3.8.8.tgz";

     

       9017
       9017
       -
               sha1 = "0b0473e7cdfd04c785184513938397d4552cfe96";

     

       9252
       9252
       +
               url = "http://registry.npmjs.org/gulp/-/gulp-3.8.9.tgz";

     

       9253
       9253
       +
               name = "gulp-3.8.9.tgz";

     

       9254
       9254
       +
               sha1 = "90773dc79cb0b3087e5443c695b0f5a21548ccce";

     

       9018
       9255
        
             })

     

       9019
       9256
        
           ];

     

       9020
       9257
        
           buildInputs =

     
···

       9025
       9262
        
             "deprecated-0.0.1" = self.by-version."deprecated"."0.0.1";

     

       9026
       9263
        
             "gulp-util-3.0.1" = self.by-version."gulp-util"."3.0.1";

     

       9027
       9264
        
             "interpret-0.3.7" = self.by-version."interpret"."0.3.7";

     

       9028
       9028
       -
             "liftoff-0.12.1" = self.by-version."liftoff"."0.12.1";

     

       9265
       9265
       +
             "liftoff-0.13.5" = self.by-version."liftoff"."0.13.5";

     

       9029
       9266
        
             "minimist-1.1.0" = self.by-version."minimist"."1.1.0";

     

       9030
       9267
        
             "orchestrator-0.3.7" = self.by-version."orchestrator"."0.3.7";

     

       9031
       9268
        
             "pretty-hrtime-0.2.2" = self.by-version."pretty-hrtime"."0.2.2";

     

       9032
       9269
        
             "semver-3.0.1" = self.by-version."semver"."3.0.1";

     

       9033
       9270
        
             "tildify-1.0.0" = self.by-version."tildify"."1.0.0";

     

       9034
       9034
       -
             "vinyl-fs-0.3.8" = self.by-version."vinyl-fs"."0.3.8";

     

       9271
       9271
       +
             "v8flags-1.0.1" = self.by-version."v8flags"."1.0.1";

     

       9272
       9272
       +
             "vinyl-fs-0.3.10" = self.by-version."vinyl-fs"."0.3.10";

     

       9035
       9273
        
           };

     

       9036
       9274
        
           peerDependencies = [

     

       9037
       9275
        
           ];

     

       9038
       9276
        
           passthru.names = [ "gulp" ];

     

       9039
       9277
        
         };

     

       9040
       9040
       -
         "gulp" = self.by-version."gulp"."3.8.8";

     

       9278
       9278
       +
         "gulp" = self.by-version."gulp"."3.8.9";

     

       9041
       9279
        
         by-spec."gulp-util"."^3.0.0" =

     

       9042
       9280
        
           self.by-version."gulp-util"."3.0.1";

     

       9043
       9281
        
         by-version."gulp-util"."3.0.1" = lib.makeOverridable self.buildNodePackage {

     
···

       9060
       9298
        
             "lodash.template-2.4.1" = self.by-version."lodash.template"."2.4.1";

     

       9061
       9299
        
             "minimist-1.1.0" = self.by-version."minimist"."1.1.0";

     

       9062
       9300
        
             "multipipe-0.1.1" = self.by-version."multipipe"."0.1.1";

     

       9063
       9063
       -
             "through2-0.6.2" = self.by-version."through2"."0.6.2";

     

       9301
       9301
       +
             "through2-0.6.3" = self.by-version."through2"."0.6.3";

     

       9064
       9302
        
             "vinyl-0.4.3" = self.by-version."vinyl"."0.4.3";

     

       9065
       9303
        
           };

     

       9066
       9304
        
           peerDependencies = [

     
···

       9148
       9386
        
           buildInputs =

     

       9149
       9387
        
             (self.nativeDeps."gzippo" or []);

     

       9150
       9388
        
           deps = {

     

       9151
       9151
       -
             "send-0.9.3" = self.by-version."send"."0.9.3";

     

       9389
       9389
       +
             "send-0.10.0" = self.by-version."send"."0.10.0";

     

       9152
       9390
        
           };

     

       9153
       9391
        
           peerDependencies = [

     

       9154
       9392
        
           ];

     
···

       9591
       9829
        
           ];

     

       9592
       9830
        
           passthru.names = [ "http-browserify" ];

     

       9593
       9831
        
         };

     

       9832
       9832
       +
         by-spec."http-errors"."~1.2.6" =

     

       9833
       9833
       +
           self.by-version."http-errors"."1.2.7";

     

       9834
       9834
       +
         by-version."http-errors"."1.2.7" = lib.makeOverridable self.buildNodePackage {

     

       9835
       9835
       +
           name = "http-errors-1.2.7";

     

       9836
       9836
       +
           bin = false;

     

       9837
       9837
       +
           src = [

     

       9838
       9838
       +
             (fetchurl {

     

       9839
       9839
       +
               url = "http://registry.npmjs.org/http-errors/-/http-errors-1.2.7.tgz";

     

       9840
       9840
       +
               name = "http-errors-1.2.7.tgz";

     

       9841
       9841
       +
               sha1 = "b881fa12c59b0079fd4ced456bf8dbc9610d3b78";

     

       9842
       9842
       +
             })

     

       9843
       9843
       +
           ];

     

       9844
       9844
       +
           buildInputs =

     

       9845
       9845
       +
             (self.nativeDeps."http-errors" or []);

     

       9846
       9846
       +
           deps = {

     

       9847
       9847
       +
             "inherits-2.0.1" = self.by-version."inherits"."2.0.1";

     

       9848
       9848
       +
             "statuses-1.2.0" = self.by-version."statuses"."1.2.0";

     

       9849
       9849
       +
           };

     

       9850
       9850
       +
           peerDependencies = [

     

       9851
       9851
       +
           ];

     

       9852
       9852
       +
           passthru.names = [ "http-errors" ];

     

       9853
       9853
       +
         };

     

       9854
       9854
       +
         by-spec."http-errors"."~1.2.7" =

     

       9855
       9855
       +
           self.by-version."http-errors"."1.2.7";

     

       9594
       9856
        
         by-spec."http-proxy"."1.0.2" =

     

       9595
       9857
        
           self.by-version."http-proxy"."1.0.2";

     

       9596
       9858
        
         by-version."http-proxy"."1.0.2" = lib.makeOverridable self.buildNodePackage {

     
···

       9832
       10094
        
           ];

     

       9833
       10095
        
           passthru.names = [ "iconv-lite" ];

     

       9834
       10096
        
         };

     

       9835
       9835
       -
         by-spec."iconv-lite"."~0.4.3" =

     

       10097
       10097
       +
         by-spec."iconv-lite"."~0.4.4" =

     

       9836
       10098
        
           self.by-version."iconv-lite"."0.4.4";

     

       9837
       10099
        
         by-spec."ieee754"."^1.1.4" =

     

       9838
       10100
        
           self.by-version."ieee754"."1.1.4";

     
···

       9874
       10136
        
           ];

     

       9875
       10137
        
           passthru.names = [ "indexof" ];

     

       9876
       10138
        
         };

     

       9877
       9877
       -
         by-spec."inflight"."~1.0.3" =

     

       10139
       10139
       +
         by-spec."inflight"."~1.0.4" =

     

       9878
       10140
        
           self.by-version."inflight"."1.0.4";

     

       9879
       10141
        
         by-version."inflight"."1.0.4" = lib.makeOverridable self.buildNodePackage {

     

       9880
       10142
        
           name = "inflight-1.0.4";

     
···

       9992
       10254
        
           ];

     

       9993
       10255
        
           passthru.names = [ "ini" ];

     

       9994
       10256
        
         };

     

       9995
       9995
       -
         by-spec."ini"."~1.2.0" =

     

       9996
       9996
       -
           self.by-version."ini"."1.2.1";

     

       9997
       9997
       -
         by-version."ini"."1.2.1" = lib.makeOverridable self.buildNodePackage {

     

       9998
       9998
       -
           name = "ini-1.2.1";

     

       9999
       9999
       -
           bin = false;

     

       10000
       10000
       -
           src = [

     

       10001
       10001
       -
             (fetchurl {

     

       10002
       10002
       -
               url = "http://registry.npmjs.org/ini/-/ini-1.2.1.tgz";

     

       10003
       10003
       -
               name = "ini-1.2.1.tgz";

     

       10004
       10004
       -
               sha1 = "7f774e2f22752cd1dacbf9c63323df2a164ebca3";

     

       10005
       10005
       -
             })

     

       10006
       10006
       -
           ];

     

       10007
       10007
       -
           buildInputs =

     

       10008
       10008
       -
             (self.nativeDeps."ini" or []);

     

       10009
       10009
       -
           deps = {

     

       10010
       10010
       -
           };

     

       10011
       10011
       -
           peerDependencies = [

     

       10012
       10012
       -
           ];

     

       10013
       10013
       -
           passthru.names = [ "ini" ];

     

       10014
       10014
       -
         };

     

       10257
       10257
       +
         by-spec."ini"."~1.3.0" =

     

       10258
       10258
       +
           self.by-version."ini"."1.3.0";

     

       10015
       10259
        
         by-spec."init-package-json"."~1.1.0" =

     

       10016
       10260
        
           self.by-version."init-package-json"."1.1.0";

     

       10017
       10261
        
         by-version."init-package-json"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     
···

       10031
       10275
        
             "promzard-0.2.2" = self.by-version."promzard"."0.2.2";

     

       10032
       10276
        
             "read-1.0.5" = self.by-version."read"."1.0.5";

     

       10033
       10277
        
             "read-package-json-1.2.7" = self.by-version."read-package-json"."1.2.7";

     

       10034
       10034
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       10278
       10278
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       10035
       10279
        
           };

     

       10036
       10280
        
           peerDependencies = [

     

       10037
       10281
        
           ];

     
···

       10079
       10323
        
             "lodash-2.4.1" = self.by-version."lodash"."2.4.1";

     

       10080
       10324
        
             "mute-stream-0.0.4" = self.by-version."mute-stream"."0.0.4";

     

       10081
       10325
        
             "readline2-0.1.0" = self.by-version."readline2"."0.1.0";

     

       10082
       10082
       -
             "rx-2.3.12" = self.by-version."rx"."2.3.12";

     

       10326
       10326
       +
             "rx-2.3.13" = self.by-version."rx"."2.3.13";

     

       10083
       10327
        
             "through-2.3.6" = self.by-version."through"."2.3.6";

     

       10084
       10328
        
           };

     

       10085
       10329
        
           peerDependencies = [

     
···

       10106
       10350
        
             "lodash-2.4.1" = self.by-version."lodash"."2.4.1";

     

       10107
       10351
        
             "mute-stream-0.0.4" = self.by-version."mute-stream"."0.0.4";

     

       10108
       10352
        
             "readline2-0.1.0" = self.by-version."readline2"."0.1.0";

     

       10109
       10109
       -
             "rx-2.3.12" = self.by-version."rx"."2.3.12";

     

       10353
       10353
       +
             "rx-2.3.13" = self.by-version."rx"."2.3.13";

     

       10110
       10354
        
             "through-2.3.6" = self.by-version."through"."2.3.6";

     

       10111
       10355
        
           };

     

       10112
       10356
        
           peerDependencies = [

     
···

       10264
       10508
        
             (self.nativeDeps."ironhorse" or []);

     

       10265
       10509
        
           deps = {

     

       10266
       10510
        
             "underscore-1.5.2" = self.by-version."underscore"."1.5.2";

     

       10267
       10267
       -
             "winston-0.8.0" = self.by-version."winston"."0.8.0";

     

       10511
       10511
       +
             "winston-0.8.1" = self.by-version."winston"."0.8.1";

     

       10268
       10512
        
             "nconf-0.6.9" = self.by-version."nconf"."0.6.9";

     

       10269
       10513
        
             "fs-walk-0.0.1" = self.by-version."fs-walk"."0.0.1";

     

       10270
       10514
        
             "async-0.9.0" = self.by-version."async"."0.9.0";

     

       10271
       10271
       -
             "express-4.9.5" = self.by-version."express"."4.9.5";

     

       10515
       10515
       +
             "express-4.9.8" = self.by-version."express"."4.9.8";

     

       10272
       10516
        
             "jade-1.7.0" = self.by-version."jade"."1.7.0";

     

       10273
       10517
        
             "passport-0.2.1" = self.by-version."passport"."0.2.1";

     

       10274
       10518
        
             "passport-http-0.2.2" = self.by-version."passport-http"."0.2.2";

     
···

       10778
       11022
        
           deps = {

     

       10779
       11023
        
             "shelljs-0.3.0" = self.by-version."shelljs"."0.3.0";

     

       10780
       11024
        
             "underscore-1.6.0" = self.by-version."underscore"."1.6.0";

     

       10781
       10781
       -
             "cli-0.6.4" = self.by-version."cli"."0.6.4";

     

       11025
       11025
       +
             "cli-0.6.5" = self.by-version."cli"."0.6.5";

     

       10782
       11026
        
             "minimatch-1.0.0" = self.by-version."minimatch"."1.0.0";

     

       10783
       11027
        
             "htmlparser2-3.7.3" = self.by-version."htmlparser2"."3.7.3";

     

       10784
       11028
        
             "console-browserify-1.1.0" = self.by-version."console-browserify"."1.1.0";

     

       10785
       11029
        
             "exit-0.1.2" = self.by-version."exit"."0.1.2";

     

       10786
       10786
       -
             "strip-json-comments-1.0.1" = self.by-version."strip-json-comments"."1.0.1";

     

       11030
       11030
       +
             "strip-json-comments-1.0.2" = self.by-version."strip-json-comments"."1.0.2";

     

       10787
       11031
        
           };

     

       10788
       11032
        
           peerDependencies = [

     

       10789
       11033
        
           ];

     
···

       10977
       11221
        
           ];

     

       10978
       11222
        
           passthru.names = [ "jsprim" ];

     

       10979
       11223
        
         };

     

       10980
       10980
       -
         by-spec."jstransform"."~3.0.0" =

     

       10981
       10981
       -
           self.by-version."jstransform"."3.0.0";

     

       10982
       10982
       -
         by-version."jstransform"."3.0.0" = lib.makeOverridable self.buildNodePackage {

     

       10983
       10983
       -
           name = "jstransform-3.0.0";

     

       11224
       11224
       +
         by-spec."jstransform"."^6.1.0" =

     

       11225
       11225
       +
           self.by-version."jstransform"."6.3.2";

     

       11226
       11226
       +
         by-version."jstransform"."6.3.2" = lib.makeOverridable self.buildNodePackage {

     

       11227
       11227
       +
           name = "jstransform-6.3.2";

     

       10984
       11228
        
           bin = false;

     

       10985
       11229
        
           src = [

     

       10986
       11230
        
             (fetchurl {

     

       10987
       10987
       -
               url = "http://registry.npmjs.org/jstransform/-/jstransform-3.0.0.tgz";

     

       10988
       10988
       -
               name = "jstransform-3.0.0.tgz";

     

       10989
       10989
       -
               sha1 = "a2591ab6cee8d97bf3be830dbfa2313b87cd640b";

     

       11231
       11231
       +
               url = "http://registry.npmjs.org/jstransform/-/jstransform-6.3.2.tgz";

     

       11232
       11232
       +
               name = "jstransform-6.3.2.tgz";

     

       11233
       11233
       +
               sha1 = "1e7a99ca7540b26676d972ab75f1d2e74e6b23a9";

     

       10990
       11234
        
             })

     

       10991
       11235
        
           ];

     

       10992
       11236
        
           buildInputs =

     

       10993
       11237
        
             (self.nativeDeps."jstransform" or []);

     

       10994
       11238
        
           deps = {

     

       10995
       11239
        
             "base62-0.1.1" = self.by-version."base62"."0.1.1";

     

       10996
       10996
       -
             "esprima-fb-3001.1.0-dev-harmony-fb" = self.by-version."esprima-fb"."3001.1.0-dev-harmony-fb";

     

       11240
       11240
       +
             "esprima-fb-6001.1.0-dev-harmony-fb" = self.by-version."esprima-fb"."6001.1.0-dev-harmony-fb";

     

       10997
       11241
        
             "source-map-0.1.31" = self.by-version."source-map"."0.1.31";

     

       10998
       11242
        
           };

     

       10999
       11243
        
           peerDependencies = [

     
···

       11037
       11281
        
           deps = {

     

       11038
       11282
        
             "di-0.0.1" = self.by-version."di"."0.0.1";

     

       11039
       11283
        
             "socket.io-0.9.17" = self.by-version."socket.io"."0.9.17";

     

       11040
       11040
       -
             "chokidar-0.9.0" = self.by-version."chokidar"."0.9.0";

     

       11284
       11284
       +
             "chokidar-0.10.1" = self.by-version."chokidar"."0.10.1";

     

       11041
       11285
        
             "glob-3.2.11" = self.by-version."glob"."3.2.11";

     

       11042
       11286
        
             "minimatch-0.2.14" = self.by-version."minimatch"."0.2.14";

     

       11043
       11287
        
             "http-proxy-0.10.4" = self.by-version."http-proxy"."0.10.4";

     
···

       11157
       11401
        
           };

     

       11158
       11402
        
           peerDependencies = [

     

       11159
       11403
        
             self.by-version."karma"."0.12.24"

     

       11160
       11160
       -
             self.by-version."mocha"."1.21.4"

     

       11404
       11404
       +
             self.by-version."mocha"."2.0.0"

     

       11161
       11405
        
           ];

     

       11162
       11406
        
           passthru.names = [ "karma-mocha" ];

     

       11163
       11407
        
         };

     
···

       11200
       11444
        
           buildInputs =

     

       11201
       11445
        
             (self.nativeDeps."karma-sauce-launcher" or []);

     

       11202
       11446
        
           deps = {

     

       11203
       11203
       -
             "wd-0.3.8" = self.by-version."wd"."0.3.8";

     

       11447
       11447
       +
             "wd-0.3.9" = self.by-version."wd"."0.3.9";

     

       11204
       11448
        
             "sauce-connect-launcher-0.6.1" = self.by-version."sauce-connect-launcher"."0.6.1";

     

       11205
       11449
        
             "q-0.9.7" = self.by-version."q"."0.9.7";

     

       11206
       11450
        
             "saucelabs-0.1.1" = self.by-version."saucelabs"."0.1.1";

     
···

       11548
       11792
        
           buildInputs =

     

       11549
       11793
        
             (self.nativeDeps."lazystream" or []);

     

       11550
       11794
        
           deps = {

     

       11551
       11551
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       11795
       11795
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       11552
       11796
        
           };

     

       11553
       11797
        
           peerDependencies = [

     

       11554
       11798
        
           ];

     
···

       11591
       11835
        
           deps = {

     

       11592
       11836
        
             "through2-0.5.1" = self.by-version."through2"."0.5.1";

     

       11593
       11837
        
             "vinyl-0.2.3" = self.by-version."vinyl"."0.2.3";

     

       11594
       11594
       -
             "vinyl-fs-0.3.8" = self.by-version."vinyl-fs"."0.3.8";

     

       11838
       11838
       +
             "vinyl-fs-0.3.10" = self.by-version."vinyl-fs"."0.3.10";

     

       11595
       11839
        
           };

     

       11596
       11840
        
           peerDependencies = [

     

       11597
       11841
        
           ];

     
···

       11599
       11843
        
         };

     

       11600
       11844
        
         "lcov-result-merger" = self.by-version."lcov-result-merger"."1.0.0";

     

       11601
       11845
        
         by-spec."less"."*" =

     

       11846
       11846
       +
           self.by-version."less"."2.0.0-b1";

     

       11847
       11847
       +
         by-version."less"."2.0.0-b1" = lib.makeOverridable self.buildNodePackage {

     

       11848
       11848
       +
           name = "less-2.0.0-b1";

     

       11849
       11849
       +
           bin = true;

     

       11850
       11850
       +
           src = [

     

       11851
       11851
       +
             (fetchurl {

     

       11852
       11852
       +
               url = "http://registry.npmjs.org/less/-/less-2.0.0-b1.tgz";

     

       11853
       11853
       +
               name = "less-2.0.0-b1.tgz";

     

       11854
       11854
       +
               sha1 = "3dcb5815b2052c89435c00def2aeb58ddb321b6a";

     

       11855
       11855
       +
             })

     

       11856
       11856
       +
           ];

     

       11857
       11857
       +
           buildInputs =

     

       11858
       11858
       +
             (self.nativeDeps."less" or []);

     

       11859
       11859
       +
           deps = {

     

       11860
       11860
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       11861
       11861
       +
             "mime-1.2.11" = self.by-version."mime"."1.2.11";

     

       11862
       11862
       +
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       11863
       11863
       +
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       11864
       11864
       +
             "source-map-0.1.40" = self.by-version."source-map"."0.1.40";

     

       11865
       11865
       +
             "promise-6.0.1" = self.by-version."promise"."6.0.1";

     

       11866
       11866
       +
           };

     

       11867
       11867
       +
           peerDependencies = [

     

       11868
       11868
       +
           ];

     

       11869
       11869
       +
           passthru.names = [ "less" ];

     

       11870
       11870
       +
         };

     

       11871
       11871
       +
         "less" = self.by-version."less"."2.0.0-b1";

     

       11872
       11872
       +
         by-spec."less"."^1.7.2" =

     

       11602
       11873
        
           self.by-version."less"."1.7.5";

     

       11603
       11874
        
         by-version."less"."1.7.5" = lib.makeOverridable self.buildNodePackage {

     

       11604
       11875
        
           name = "less-1.7.5";

     
···

       11613
       11884
        
           buildInputs =

     

       11614
       11885
        
             (self.nativeDeps."less" or []);

     

       11615
       11886
        
           deps = {

     

       11616
       11616
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       11887
       11887
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       11617
       11888
        
             "mime-1.2.11" = self.by-version."mime"."1.2.11";

     

       11618
       11889
        
             "request-2.40.0" = self.by-version."request"."2.40.0";

     

       11619
       11890
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     
···

       11624
       11895
        
           ];

     

       11625
       11896
        
           passthru.names = [ "less" ];

     

       11626
       11897
        
         };

     

       11627
       11627
       -
         "less" = self.by-version."less"."1.7.5";

     

       11628
       11628
       -
         by-spec."less"."^1.7.2" =

     

       11629
       11629
       -
           self.by-version."less"."1.7.5";

     

       11630
       11898
        
         by-spec."lexical-scope"."~1.1.0" =

     

       11631
       11899
        
           self.by-version."lexical-scope"."1.1.0";

     

       11632
       11900
        
         by-version."lexical-scope"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     
···

       11691
       11959
        
           passthru.names = [ "libyaml" ];

     

       11692
       11960
        
         };

     

       11693
       11961
        
         "libyaml" = self.by-version."libyaml"."0.2.5";

     

       11694
       11694
       -
         by-spec."liftoff"."^0.12.0" =

     

       11695
       11695
       -
           self.by-version."liftoff"."0.12.1";

     

       11696
       11696
       -
         by-version."liftoff"."0.12.1" = lib.makeOverridable self.buildNodePackage {

     

       11697
       11697
       -
           name = "liftoff-0.12.1";

     

       11962
       11962
       +
         by-spec."liftoff"."^0.13.2" =

     

       11963
       11963
       +
           self.by-version."liftoff"."0.13.5";

     

       11964
       11964
       +
         by-version."liftoff"."0.13.5" = lib.makeOverridable self.buildNodePackage {

     

       11965
       11965
       +
           name = "liftoff-0.13.5";

     

       11698
       11966
        
           bin = false;

     

       11699
       11967
        
           src = [

     

       11700
       11968
        
             (fetchurl {

     

       11701
       11701
       -
               url = "http://registry.npmjs.org/liftoff/-/liftoff-0.12.1.tgz";

     

       11702
       11702
       -
               name = "liftoff-0.12.1.tgz";

     

       11703
       11703
       -
               sha1 = "bcaa49759c68396b83b984ad0b2d8cc226f9526d";

     

       11969
       11969
       +
               url = "http://registry.npmjs.org/liftoff/-/liftoff-0.13.5.tgz";

     

       11970
       11970
       +
               name = "liftoff-0.13.5.tgz";

     

       11971
       11971
       +
               sha1 = "fb603b0ba34e9ab77a3737529f452d344562386c";

     

       11704
       11972
        
             })

     

       11705
       11973
        
           ];

     

       11706
       11974
        
           buildInputs =

     

       11707
       11975
        
             (self.nativeDeps."liftoff" or []);

     

       11708
       11976
        
           deps = {

     

       11709
       11977
        
             "findup-sync-0.1.3" = self.by-version."findup-sync"."0.1.3";

     

       11710
       11710
       -
             "resolve-0.7.4" = self.by-version."resolve"."0.7.4";

     

       11711
       11711
       -
             "minimist-0.2.0" = self.by-version."minimist"."0.2.0";

     

       11978
       11978
       +
             "resolve-1.0.0" = self.by-version."resolve"."1.0.0";

     

       11979
       11979
       +
             "minimist-1.1.0" = self.by-version."minimist"."1.1.0";

     

       11712
       11980
        
             "extend-1.3.0" = self.by-version."extend"."1.3.0";

     

       11981
       11981
       +
             "flagged-respawn-0.3.1" = self.by-version."flagged-respawn"."0.3.1";

     

       11713
       11982
        
           };

     

       11714
       11983
        
           peerDependencies = [

     

       11715
       11984
        
           ];

     
···

       12267
       12536
        
             (self.nativeDeps."log4js" or []);

     

       12268
       12537
        
           deps = {

     

       12269
       12538
        
             "async-0.2.10" = self.by-version."async"."0.2.10";

     

       12270
       12270
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       12539
       12539
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       12271
       12540
        
             "semver-1.1.4" = self.by-version."semver"."1.1.4";

     

       12272
       12541
        
           };

     

       12273
       12542
        
           peerDependencies = [

     
···

       12418
       12687
        
         };

     

       12419
       12688
        
         by-spec."lru-cache"."~2.5.0" =

     

       12420
       12689
        
           self.by-version."lru-cache"."2.5.0";

     

       12421
       12421
       -
         by-spec."lru-queue"."0.1.x" =

     

       12690
       12690
       +
         by-spec."lru-queue"."0.1" =

     

       12422
       12691
        
           self.by-version."lru-queue"."0.1.0";

     

       12423
       12692
        
         by-version."lru-queue"."0.1.0" = lib.makeOverridable self.buildNodePackage {

     

       12424
       12693
        
           name = "lru-queue-0.1.0";

     
···

       12646
       12915
        
           passthru.names = [ "media-typer" ];

     

       12647
       12916
        
         };

     

       12648
       12917
        
         by-spec."memoizee"."0.3.x" =

     

       12649
       12649
       -
           self.by-version."memoizee"."0.3.7";

     

       12650
       12650
       -
         by-version."memoizee"."0.3.7" = lib.makeOverridable self.buildNodePackage {

     

       12651
       12651
       -
           name = "memoizee-0.3.7";

     

       12918
       12918
       +
           self.by-version."memoizee"."0.3.8";

     

       12919
       12919
       +
         by-version."memoizee"."0.3.8" = lib.makeOverridable self.buildNodePackage {

     

       12920
       12920
       +
           name = "memoizee-0.3.8";

     

       12652
       12921
        
           bin = false;

     

       12653
       12922
        
           src = [

     

       12654
       12923
        
             (fetchurl {

     

       12655
       12655
       -
               url = "http://registry.npmjs.org/memoizee/-/memoizee-0.3.7.tgz";

     

       12656
       12656
       -
               name = "memoizee-0.3.7.tgz";

     

       12657
       12657
       -
               sha1 = "13ccfdd580e56cf7c10f4b6342a6800ef87e975b";

     

       12924
       12924
       +
               url = "http://registry.npmjs.org/memoizee/-/memoizee-0.3.8.tgz";

     

       12925
       12925
       +
               name = "memoizee-0.3.8.tgz";

     

       12926
       12926
       +
               sha1 = "b5faf419f02fafe3c2cc1cf5d3907c210fc7efdc";

     

       12658
       12927
        
             })

     

       12659
       12928
        
           ];

     

       12660
       12929
        
           buildInputs =

     
···

       12662
       12931
        
           deps = {

     

       12663
       12932
        
             "d-0.1.1" = self.by-version."d"."0.1.1";

     

       12664
       12933
        
             "es5-ext-0.10.4" = self.by-version."es5-ext"."0.10.4";

     

       12934
       12934
       +
             "es6-weak-map-0.1.2" = self.by-version."es6-weak-map"."0.1.2";

     

       12665
       12935
        
             "event-emitter-0.3.1" = self.by-version."event-emitter"."0.3.1";

     

       12666
       12936
        
             "lru-queue-0.1.0" = self.by-version."lru-queue"."0.1.0";

     

       12667
       12937
        
             "next-tick-0.2.2" = self.by-version."next-tick"."0.2.2";

     
···

       12691
       12961
        
           ];

     

       12692
       12962
        
           passthru.names = [ "merge-descriptors" ];

     

       12693
       12963
        
         };

     

       12694
       12694
       -
         by-spec."method-override"."~2.2.0" =

     

       12695
       12695
       -
           self.by-version."method-override"."2.2.0";

     

       12696
       12696
       -
         by-version."method-override"."2.2.0" = lib.makeOverridable self.buildNodePackage {

     

       12697
       12697
       -
           name = "method-override-2.2.0";

     

       12964
       12964
       +
         by-spec."method-override"."~2.3.0" =

     

       12965
       12965
       +
           self.by-version."method-override"."2.3.0";

     

       12966
       12966
       +
         by-version."method-override"."2.3.0" = lib.makeOverridable self.buildNodePackage {

     

       12967
       12967
       +
           name = "method-override-2.3.0";

     

       12698
       12968
        
           bin = false;

     

       12699
       12969
        
           src = [

     

       12700
       12970
        
             (fetchurl {

     

       12701
       12701
       -
               url = "http://registry.npmjs.org/method-override/-/method-override-2.2.0.tgz";

     

       12702
       12702
       -
               name = "method-override-2.2.0.tgz";

     

       12703
       12703
       -
               sha1 = "177e852b6add3b4f9177033a9446b01e7801a0c0";

     

       12971
       12971
       +
               url = "http://registry.npmjs.org/method-override/-/method-override-2.3.0.tgz";

     

       12972
       12972
       +
               name = "method-override-2.3.0.tgz";

     

       12973
       12973
       +
               sha1 = "fe820769594247ede8a6ca87b8eaa413084e595e";

     

       12704
       12974
        
             })

     

       12705
       12975
        
           ];

     

       12706
       12976
        
           buildInputs =

     

       12707
       12977
        
             (self.nativeDeps."method-override" or []);

     

       12708
       12978
        
           deps = {

     

       12709
       12709
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       12979
       12979
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       12710
       12980
        
             "methods-1.1.0" = self.by-version."methods"."1.1.0";

     

       12711
       12981
        
             "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";

     

       12712
       12982
        
             "vary-1.0.0" = self.by-version."vary"."1.0.0";

     
···

       12928
       13198
        
         by-spec."mime"."~1.2.9" =

     

       12929
       13199
        
           self.by-version."mime"."1.2.11";

     

       12930
       13200
        
         by-spec."mime-db"."1.x" =

     

       12931
       12931
       -
           self.by-version."mime-db"."1.1.0";

     

       12932
       12932
       -
         by-version."mime-db"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     

       12933
       12933
       -
           name = "mime-db-1.1.0";

     

       13201
       13201
       +
           self.by-version."mime-db"."1.1.1";

     

       13202
       13202
       +
         by-version."mime-db"."1.1.1" = lib.makeOverridable self.buildNodePackage {

     

       13203
       13203
       +
           name = "mime-db-1.1.1";

     

       12934
       13204
        
           bin = false;

     

       12935
       13205
        
           src = [

     

       12936
       13206
        
             (fetchurl {

     

       12937
       12937
       -
               url = "http://registry.npmjs.org/mime-db/-/mime-db-1.1.0.tgz";

     

       12938
       12938
       -
               name = "mime-db-1.1.0.tgz";

     

       12939
       12939
       -
               sha1 = "4613f418ab995450bf4bda240cd0ab38016a07a9";

     

       13207
       13207
       +
               url = "http://registry.npmjs.org/mime-db/-/mime-db-1.1.1.tgz";

     

       13208
       13208
       +
               name = "mime-db-1.1.1.tgz";

     

       13209
       13209
       +
               sha1 = "0fc890cda05d0edadefde73d241ef7e28d110a98";

     

       12940
       13210
        
             })

     

       12941
       13211
        
           ];

     

       12942
       13212
        
           buildInputs =

     
···

       12948
       13218
        
           passthru.names = [ "mime-db" ];

     

       12949
       13219
        
         };

     

       12950
       13220
        
         by-spec."mime-db"."~1.1.0" =

     

       12951
       12951
       -
           self.by-version."mime-db"."1.1.0";

     

       13221
       13221
       +
           self.by-version."mime-db"."1.1.1";

     

       12952
       13222
        
         by-spec."mime-types"."~1.0.0" =

     

       12953
       13223
        
           self.by-version."mime-types"."1.0.2";

     

       12954
       13224
        
         by-version."mime-types"."1.0.2" = lib.makeOverridable self.buildNodePackage {

     
···

       12986
       13256
        
           buildInputs =

     

       12987
       13257
        
             (self.nativeDeps."mime-types" or []);

     

       12988
       13258
        
           deps = {

     

       12989
       12989
       -
             "mime-db-1.1.0" = self.by-version."mime-db"."1.1.0";

     

       13259
       13259
       +
             "mime-db-1.1.1" = self.by-version."mime-db"."1.1.1";

     

       12990
       13260
        
           };

     

       12991
       13261
        
           peerDependencies = [

     

       12992
       13262
        
           ];

     
···

       13007
       13277
        
           buildInputs =

     

       13008
       13278
        
             (self.nativeDeps."mimelib" or []);

     

       13009
       13279
        
           deps = {

     

       13010
       13010
       -
             "encoding-0.1.8" = self.by-version."encoding"."0.1.8";

     

       13280
       13280
       +
             "encoding-0.1.10" = self.by-version."encoding"."0.1.10";

     

       13011
       13281
        
             "addressparser-0.2.1" = self.by-version."addressparser"."0.2.1";

     

       13012
       13282
        
           };

     

       13013
       13283
        
           peerDependencies = [

     
···

       13264
       13534
        
           ];

     

       13265
       13535
        
           passthru.names = [ "minimist" ];

     

       13266
       13536
        
         };

     

       13537
       13537
       +
         by-spec."minimist"."~1.1.0" =

     

       13538
       13538
       +
           self.by-version."minimist"."1.1.0";

     

       13267
       13539
        
         by-spec."ministyle"."~0.1.3" =

     

       13268
       13540
        
           self.by-version."ministyle"."0.1.4";

     

       13269
       13541
        
         by-version."ministyle"."0.1.4" = lib.makeOverridable self.buildNodePackage {

     
···

       13410
       13682
        
           passthru.names = [ "mkpath" ];

     

       13411
       13683
        
         };

     

       13412
       13684
        
         by-spec."mocha"."*" =

     

       13413
       13413
       -
           self.by-version."mocha"."1.21.4";

     

       13414
       13414
       -
         by-version."mocha"."1.21.4" = lib.makeOverridable self.buildNodePackage {

     

       13415
       13415
       -
           name = "mocha-1.21.4";

     

       13685
       13685
       +
           self.by-version."mocha"."2.0.0";

     

       13686
       13686
       +
         by-version."mocha"."2.0.0" = lib.makeOverridable self.buildNodePackage {

     

       13687
       13687
       +
           name = "mocha-2.0.0";

     

       13416
       13688
        
           bin = true;

     

       13417
       13689
        
           src = [

     

       13418
       13690
        
             (fetchurl {

     

       13419
       13419
       -
               url = "http://registry.npmjs.org/mocha/-/mocha-1.21.4.tgz";

     

       13420
       13420
       -
               name = "mocha-1.21.4.tgz";

     

       13421
       13421
       -
               sha1 = "e77d69c3773ba3e2b4fe6b628c28b5dd43880adc";

     

       13691
       13691
       +
               url = "http://registry.npmjs.org/mocha/-/mocha-2.0.0.tgz";

     

       13692
       13692
       +
               name = "mocha-2.0.0.tgz";

     

       13693
       13693
       +
               sha1 = "4f737685475046533432494b76c3e81cb5005c54";

     

       13422
       13694
        
             })

     

       13423
       13695
        
           ];

     

       13424
       13696
        
           buildInputs =

     

       13425
       13697
        
             (self.nativeDeps."mocha" or []);

     

       13426
       13698
        
           deps = {

     

       13427
       13427
       -
             "commander-2.0.0" = self.by-version."commander"."2.0.0";

     

       13428
       13428
       -
             "growl-1.8.1" = self.by-version."growl"."1.8.1";

     

       13429
       13429
       -
             "jade-0.26.3" = self.by-version."jade"."0.26.3";

     

       13430
       13430
       -
             "diff-1.0.7" = self.by-version."diff"."1.0.7";

     

       13699
       13699
       +
             "commander-2.3.0" = self.by-version."commander"."2.3.0";

     

       13431
       13700
        
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       13432
       13432
       -
             "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";

     

       13701
       13701
       +
             "diff-1.0.8" = self.by-version."diff"."1.0.8";

     

       13702
       13702
       +
             "escape-string-regexp-1.0.2" = self.by-version."escape-string-regexp"."1.0.2";

     

       13433
       13703
        
             "glob-3.2.3" = self.by-version."glob"."3.2.3";

     

       13704
       13704
       +
             "growl-1.8.1" = self.by-version."growl"."1.8.1";

     

       13705
       13705
       +
             "jade-0.26.3" = self.by-version."jade"."0.26.3";

     

       13706
       13706
       +
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       13434
       13707
        
           };

     

       13435
       13708
        
           peerDependencies = [

     

       13436
       13709
        
           ];

     

       13437
       13710
        
           passthru.names = [ "mocha" ];

     

       13438
       13711
        
         };

     

       13439
       13439
       -
         "mocha" = self.by-version."mocha"."1.21.4";

     

       13712
       13712
       +
         "mocha" = self.by-version."mocha"."2.0.0";

     

       13440
       13713
        
         by-spec."mocha"."~1.20.1" =

     

       13441
       13714
        
           self.by-version."mocha"."1.20.1";

     

       13442
       13715
        
         by-version."mocha"."1.20.1" = lib.makeOverridable self.buildNodePackage {

     
···

       13456
       13729
        
             "growl-1.7.0" = self.by-version."growl"."1.7.0";

     

       13457
       13730
        
             "jade-0.26.3" = self.by-version."jade"."0.26.3";

     

       13458
       13731
        
             "diff-1.0.7" = self.by-version."diff"."1.0.7";

     

       13459
       13459
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       13732
       13732
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       13460
       13733
        
             "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";

     

       13461
       13734
        
             "glob-3.2.3" = self.by-version."glob"."3.2.3";

     

       13462
       13735
        
           };

     
···

       13465
       13738
        
           passthru.names = [ "mocha" ];

     

       13466
       13739
        
         };

     

       13467
       13740
        
         by-spec."mocha-phantomjs"."*" =

     

       13468
       13468
       -
           self.by-version."mocha-phantomjs"."3.5.0";

     

       13469
       13469
       -
         by-version."mocha-phantomjs"."3.5.0" = lib.makeOverridable self.buildNodePackage {

     

       13470
       13470
       -
           name = "mocha-phantomjs-3.5.0";

     

       13741
       13741
       +
           self.by-version."mocha-phantomjs"."3.5.1";

     

       13742
       13742
       +
         by-version."mocha-phantomjs"."3.5.1" = lib.makeOverridable self.buildNodePackage {

     

       13743
       13743
       +
           name = "mocha-phantomjs-3.5.1";

     

       13471
       13744
        
           bin = true;

     

       13472
       13745
        
           src = [

     

       13473
       13746
        
             (fetchurl {

     

       13474
       13474
       -
               url = "http://registry.npmjs.org/mocha-phantomjs/-/mocha-phantomjs-3.5.0.tgz";

     

       13475
       13475
       -
               name = "mocha-phantomjs-3.5.0.tgz";

     

       13476
       13476
       -
               sha1 = "56fb4072122b4061b21e9c3901e35f4a7c58a93e";

     

       13747
       13747
       +
               url = "http://registry.npmjs.org/mocha-phantomjs/-/mocha-phantomjs-3.5.1.tgz";

     

       13748
       13748
       +
               name = "mocha-phantomjs-3.5.1.tgz";

     

       13749
       13749
       +
               sha1 = "e5460eff3e859b98be73a743f11cb5cae3c58d00";

     

       13477
       13750
        
             })

     

       13478
       13751
        
           ];

     

       13479
       13752
        
           buildInputs =

     
···

       13483
       13756
        
             "commander-2.0.0" = self.by-version."commander"."2.0.0";

     

       13484
       13757
        
           };

     

       13485
       13758
        
           peerDependencies = [

     

       13486
       13486
       -
             self.by-version."phantomjs"."1.9.10"

     

       13759
       13759
       +
             self.by-version."phantomjs"."1.9.11"

     

       13487
       13760
        
           ];

     

       13488
       13761
        
           passthru.names = [ "mocha-phantomjs" ];

     

       13489
       13762
        
         };

     

       13490
       13490
       -
         "mocha-phantomjs" = self.by-version."mocha-phantomjs"."3.5.0";

     

       13763
       13763
       +
         "mocha-phantomjs" = self.by-version."mocha-phantomjs"."3.5.1";

     

       13491
       13764
        
         by-spec."mocha-unfunk-reporter"."*" =

     

       13492
       13765
        
           self.by-version."mocha-unfunk-reporter"."0.4.0";

     

       13493
       13766
        
         by-version."mocha-unfunk-reporter"."0.4.0" = lib.makeOverridable self.buildNodePackage {

     
···

       13608
       13881
        
           passthru.names = [ "moment" ];

     

       13609
       13882
        
         };

     

       13610
       13883
        
         by-spec."mongodb"."*" =

     

       13611
       13611
       -
           self.by-version."mongodb"."2.0.0-alpha2";

     

       13612
       13612
       -
         by-version."mongodb"."2.0.0-alpha2" = lib.makeOverridable self.buildNodePackage {

     

       13613
       13613
       -
           name = "mongodb-2.0.0-alpha2";

     

       13884
       13884
       +
           self.by-version."mongodb"."2.0.3";

     

       13885
       13885
       +
         by-version."mongodb"."2.0.3" = lib.makeOverridable self.buildNodePackage {

     

       13886
       13886
       +
           name = "mongodb-2.0.3";

     

       13614
       13887
        
           bin = false;

     

       13615
       13888
        
           src = [

     

       13616
       13889
        
             (fetchurl {

     

       13617
       13617
       -
               url = "http://registry.npmjs.org/mongodb/-/mongodb-2.0.0-alpha2.tgz";

     

       13618
       13618
       -
               name = "mongodb-2.0.0-alpha2.tgz";

     

       13619
       13619
       -
               sha1 = "04541787b29a7db6a03ca4e44e593dd726d03d91";

     

       13890
       13890
       +
               url = "http://registry.npmjs.org/mongodb/-/mongodb-2.0.3.tgz";

     

       13891
       13891
       +
               name = "mongodb-2.0.3.tgz";

     

       13892
       13892
       +
               sha1 = "78dd12c11aaa8cf8666c16128fd19f55a8f9b313";

     

       13620
       13893
        
             })

     

       13621
       13894
        
           ];

     

       13622
       13895
        
           buildInputs =

     

       13623
       13896
        
             (self.nativeDeps."mongodb" or []);

     

       13624
       13897
        
           deps = {

     

       13625
       13625
       -
             "mongodb-core-1.0.0-alpha9" = self.by-version."mongodb-core"."1.0.0-alpha9";

     

       13898
       13898
       +
             "mongodb-core-1.0.3" = self.by-version."mongodb-core"."1.0.3";

     

       13626
       13899
        
             "readable-stream-1.0.31" = self.by-version."readable-stream"."1.0.31";

     

       13627
       13900
        
           };

     

       13628
       13901
        
           peerDependencies = [

     

       13629
       13902
        
           ];

     

       13630
       13903
        
           passthru.names = [ "mongodb" ];

     

       13631
       13904
        
         };

     

       13632
       13632
       -
         "mongodb" = self.by-version."mongodb"."2.0.0-alpha2";

     

       13905
       13905
       +
         "mongodb" = self.by-version."mongodb"."2.0.3";

     

       13633
       13906
        
         by-spec."mongodb"."1.2.14" =

     

       13634
       13907
        
           self.by-version."mongodb"."1.2.14";

     

       13635
       13908
        
         by-version."mongodb"."1.2.14" = lib.makeOverridable self.buildNodePackage {

     
···

       13719
       13992
        
           passthru.names = [ "mongodb" ];

     

       13720
       13993
        
         };

     

       13721
       13994
        
         by-spec."mongodb-core"."~1.0" =

     

       13722
       13722
       -
           self.by-version."mongodb-core"."1.0.0-alpha9";

     

       13723
       13723
       -
         by-version."mongodb-core"."1.0.0-alpha9" = lib.makeOverridable self.buildNodePackage {

     

       13724
       13724
       -
           name = "mongodb-core-1.0.0-alpha9";

     

       13995
       13995
       +
           self.by-version."mongodb-core"."1.0.3";

     

       13996
       13996
       +
         by-version."mongodb-core"."1.0.3" = lib.makeOverridable self.buildNodePackage {

     

       13997
       13997
       +
           name = "mongodb-core-1.0.3";

     

       13725
       13998
        
           bin = false;

     

       13726
       13999
        
           src = [

     

       13727
       14000
        
             (fetchurl {

     

       13728
       13728
       -
               url = "http://registry.npmjs.org/mongodb-core/-/mongodb-core-1.0.0-alpha9.tgz";

     

       13729
       13729
       -
               name = "mongodb-core-1.0.0-alpha9.tgz";

     

       13730
       13730
       -
               sha1 = "895cf88ad00d20462c417cc2f59d261ec15f0c23";

     

       14001
       14001
       +
               url = "http://registry.npmjs.org/mongodb-core/-/mongodb-core-1.0.3.tgz";

     

       14002
       14002
       +
               name = "mongodb-core-1.0.3.tgz";

     

       14003
       14003
       +
               sha1 = "387649e432368dcd02c983f39454700d6958619a";

     

       13731
       14004
        
             })

     

       13732
       14005
        
           ];

     

       13733
       14006
        
           buildInputs =

     
···

       13911
       14184
        
           ];

     

       13912
       14185
        
           passthru.names = [ "monocle" ];

     

       13913
       14186
        
         };

     

       13914
       13914
       -
         by-spec."morgan"."~1.3.2" =

     

       13915
       13915
       -
           self.by-version."morgan"."1.3.2";

     

       13916
       13916
       -
         by-version."morgan"."1.3.2" = lib.makeOverridable self.buildNodePackage {

     

       13917
       13917
       -
           name = "morgan-1.3.2";

     

       14187
       14187
       +
         by-spec."morgan"."~1.4.0" =

     

       14188
       14188
       +
           self.by-version."morgan"."1.4.0";

     

       14189
       14189
       +
         by-version."morgan"."1.4.0" = lib.makeOverridable self.buildNodePackage {

     

       14190
       14190
       +
           name = "morgan-1.4.0";

     

       13918
       14191
        
           bin = false;

     

       13919
       14192
        
           src = [

     

       13920
       14193
        
             (fetchurl {

     

       13921
       13921
       -
               url = "http://registry.npmjs.org/morgan/-/morgan-1.3.2.tgz";

     

       13922
       13922
       -
               name = "morgan-1.3.2.tgz";

     

       13923
       13923
       -
               sha1 = "ac41aa15221ee4e5f2ac843896b6918139a18efd";

     

       14194
       14194
       +
               url = "http://registry.npmjs.org/morgan/-/morgan-1.4.0.tgz";

     

       14195
       14195
       +
               name = "morgan-1.4.0.tgz";

     

       14196
       14196
       +
               sha1 = "ce3c6ee28f794f85f59165476575b70ed386eb3d";

     

       13924
       14197
        
             })

     

       13925
       14198
        
           ];

     

       13926
       14199
        
           buildInputs =

     

       13927
       14200
        
             (self.nativeDeps."morgan" or []);

     

       13928
       14201
        
           deps = {

     

       13929
       14202
        
             "basic-auth-1.0.0" = self.by-version."basic-auth"."1.0.0";

     

       13930
       13930
       -
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       14203
       14203
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       14204
       14204
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       13931
       14205
        
             "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";

     

       13932
       14206
        
           };

     

       13933
       14207
        
           peerDependencies = [

     
···

       14227
       14501
        
           passthru.names = [ "mv" ];

     

       14228
       14502
        
         };

     

       14229
       14503
        
         by-spec."mz"."1" =

     

       14230
       14230
       -
           self.by-version."mz"."1.0.1";

     

       14231
       14231
       -
         by-version."mz"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     

       14232
       14232
       -
           name = "mz-1.0.1";

     

       14504
       14504
       +
           self.by-version."mz"."1.0.2";

     

       14505
       14505
       +
         by-version."mz"."1.0.2" = lib.makeOverridable self.buildNodePackage {

     

       14506
       14506
       +
           name = "mz-1.0.2";

     

       14233
       14507
        
           bin = false;

     

       14234
       14508
        
           src = [

     

       14235
       14509
        
             (fetchurl {

     

       14236
       14236
       -
               url = "http://registry.npmjs.org/mz/-/mz-1.0.1.tgz";

     

       14237
       14237
       -
               name = "mz-1.0.1.tgz";

     

       14238
       14238
       -
               sha1 = "5ce1d3fe5cb3267c9c3141fb6a070f8d17f215d8";

     

       14510
       14510
       +
               url = "http://registry.npmjs.org/mz/-/mz-1.0.2.tgz";

     

       14511
       14511
       +
               name = "mz-1.0.2.tgz";

     

       14512
       14512
       +
               sha1 = "1c861e902ed75527399ca0d95152b9726aea73ac";

     

       14239
       14513
        
             })

     

       14240
       14514
        
           ];

     

       14241
       14515
        
           buildInputs =

     
···

       14528
       14802
        
           ];

     

       14529
       14803
        
           passthru.names = [ "negotiator" ];

     

       14530
       14804
        
         };

     

       14531
       14531
       -
         by-spec."negotiator"."0.4.8" =

     

       14532
       14532
       -
           self.by-version."negotiator"."0.4.8";

     

       14533
       14533
       -
         by-version."negotiator"."0.4.8" = lib.makeOverridable self.buildNodePackage {

     

       14534
       14534
       -
           name = "negotiator-0.4.8";

     

       14805
       14805
       +
         by-spec."negotiator"."0.4.9" =

     

       14806
       14806
       +
           self.by-version."negotiator"."0.4.9";

     

       14807
       14807
       +
         by-version."negotiator"."0.4.9" = lib.makeOverridable self.buildNodePackage {

     

       14808
       14808
       +
           name = "negotiator-0.4.9";

     

       14535
       14809
        
           bin = false;

     

       14536
       14810
        
           src = [

     

       14537
       14811
        
             (fetchurl {

     

       14538
       14538
       -
               url = "http://registry.npmjs.org/negotiator/-/negotiator-0.4.8.tgz";

     

       14539
       14539
       -
               name = "negotiator-0.4.8.tgz";

     

       14540
       14540
       -
               sha1 = "96010b23b63c387f47a4bed96762a831cda39eab";

     

       14812
       14812
       +
               url = "http://registry.npmjs.org/negotiator/-/negotiator-0.4.9.tgz";

     

       14813
       14813
       +
               name = "negotiator-0.4.9.tgz";

     

       14814
       14814
       +
               sha1 = "92e46b6db53c7e421ed64a2bc94f08be7630df3f";

     

       14541
       14815
        
             })

     

       14542
       14816
        
           ];

     

       14543
       14817
        
           buildInputs =

     
···

       14612
       14886
        
           passthru.names = [ "nib" ];

     

       14613
       14887
        
         };

     

       14614
       14888
        
         by-spec."nijs"."*" =

     

       14615
       14615
       -
           self.by-version."nijs"."0.0.18";

     

       14616
       14616
       -
         by-version."nijs"."0.0.18" = lib.makeOverridable self.buildNodePackage {

     

       14617
       14617
       -
           name = "nijs-0.0.18";

     

       14889
       14889
       +
           self.by-version."nijs"."0.0.20";

     

       14890
       14890
       +
         by-version."nijs"."0.0.20" = lib.makeOverridable self.buildNodePackage {

     

       14891
       14891
       +
           name = "nijs-0.0.20";

     

       14618
       14892
        
           bin = true;

     

       14619
       14893
        
           src = [

     

       14620
       14894
        
             (fetchurl {

     

       14621
       14621
       -
               url = "http://registry.npmjs.org/nijs/-/nijs-0.0.18.tgz";

     

       14622
       14622
       -
               name = "nijs-0.0.18.tgz";

     

       14623
       14623
       -
               sha1 = "bfdf140350d2bb3edae6b094dbc31035d6c7bec8";

     

       14895
       14895
       +
               url = "http://registry.npmjs.org/nijs/-/nijs-0.0.20.tgz";

     

       14896
       14896
       +
               name = "nijs-0.0.20.tgz";

     

       14897
       14897
       +
               sha1 = "db193f4ed5fc9571ee6fb58542778e96e38f0f7e";

     

       14624
       14898
        
             })

     

       14625
       14899
        
           ];

     

       14626
       14900
        
           buildInputs =

     
···

       14633
       14907
        
           ];

     

       14634
       14908
        
           passthru.names = [ "nijs" ];

     

       14635
       14909
        
         };

     

       14636
       14636
       -
         "nijs" = self.by-version."nijs"."0.0.18";

     

       14910
       14910
       +
         "nijs" = self.by-version."nijs"."0.0.20";

     

       14637
       14911
        
         by-spec."node-appc"."0.2.14" =

     

       14638
       14912
        
           self.by-version."node-appc"."0.2.14";

     

       14639
       14913
        
         by-version."node-appc"."0.2.14" = lib.makeOverridable self.buildNodePackage {

     
···

       14709
       14983
        
           deps = {

     

       14710
       14984
        
             "fstream-1.0.2" = self.by-version."fstream"."1.0.2";

     

       14711
       14985
        
             "glob-4.0.6" = self.by-version."glob"."4.0.6";

     

       14712
       14712
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       14986
       14986
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       14713
       14987
        
             "minimatch-1.0.0" = self.by-version."minimatch"."1.0.0";

     

       14714
       14988
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       14715
       14989
        
             "nopt-3.0.1" = self.by-version."nopt"."3.0.1";

     
···

       14717
       14991
        
             "osenv-0.1.0" = self.by-version."osenv"."0.1.0";

     

       14718
       14992
        
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       14719
       14993
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     

       14720
       14720
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       14994
       14994
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       14721
       14995
        
             "tar-1.0.1" = self.by-version."tar"."1.0.1";

     

       14722
       14996
        
             "which-1.0.5" = self.by-version."which"."1.0.5";

     

       14723
       14997
        
           };

     
···

       14760
       15034
        
         };

     

       14761
       15035
        
         "node-inspector" = self.by-version."node-inspector"."0.7.4";

     

       14762
       15036
        
         by-spec."node-protobuf"."*" =

     

       14763
       14763
       -
           self.by-version."node-protobuf"."1.2.1";

     

       14764
       14764
       -
         by-version."node-protobuf"."1.2.1" = lib.makeOverridable self.buildNodePackage {

     

       14765
       14765
       -
           name = "node-protobuf-1.2.1";

     

       15037
       15037
       +
           self.by-version."node-protobuf"."1.2.2";

     

       15038
       15038
       +
         by-version."node-protobuf"."1.2.2" = lib.makeOverridable self.buildNodePackage {

     

       15039
       15039
       +
           name = "node-protobuf-1.2.2";

     

       14766
       15040
        
           bin = false;

     

       14767
       15041
        
           src = [

     

       14768
       15042
        
             (fetchurl {

     

       14769
       14769
       -
               url = "http://registry.npmjs.org/node-protobuf/-/node-protobuf-1.2.1.tgz";

     

       14770
       14770
       -
               name = "node-protobuf-1.2.1.tgz";

     

       14771
       14771
       -
               sha1 = "d517eb4cdcfac002390ace6b8f0b865322eef049";

     

       15043
       15043
       +
               url = "http://registry.npmjs.org/node-protobuf/-/node-protobuf-1.2.2.tgz";

     

       15044
       15044
       +
               name = "node-protobuf-1.2.2.tgz";

     

       15045
       15045
       +
               sha1 = "8d512499fe012358c1fd89d6b4d84ad80317acb3";

     

       14772
       15046
        
             })

     

       14773
       15047
        
           ];

     

       14774
       15048
        
           buildInputs =

     
···

       14781
       15055
        
           ];

     

       14782
       15056
        
           passthru.names = [ "node-protobuf" ];

     

       14783
       15057
        
         };

     

       14784
       14784
       -
         "node-protobuf" = self.by-version."node-protobuf"."1.2.1";

     

       15058
       15058
       +
         "node-protobuf" = self.by-version."node-protobuf"."1.2.2";

     

       14785
       15059
        
         by-spec."node-swt".">=0.1.1" =

     

       14786
       15060
        
           self.by-version."node-swt"."0.1.1";

     

       14787
       15061
        
         by-version."node-swt"."0.1.1" = lib.makeOverridable self.buildNodePackage {

     
···

       15164
       15438
        
           deps = {

     

       15165
       15439
        
             "github-url-from-git-1.4.0" = self.by-version."github-url-from-git"."1.4.0";

     

       15166
       15440
        
             "github-url-from-username-repo-1.0.2" = self.by-version."github-url-from-username-repo"."1.0.2";

     

       15167
       15167
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15441
       15441
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15168
       15442
        
           };

     

       15169
       15443
        
           peerDependencies = [

     

       15170
       15444
        
           ];

     
···

       15175
       15449
        
         by-spec."normalize-package-data"."~1.0.3" =

     

       15176
       15450
        
           self.by-version."normalize-package-data"."1.0.3";

     

       15177
       15451
        
         by-spec."npm"."*" =

     

       15178
       15178
       -
           self.by-version."npm"."2.1.3";

     

       15179
       15179
       -
         by-version."npm"."2.1.3" = lib.makeOverridable self.buildNodePackage {

     

       15180
       15180
       -
           name = "npm-2.1.3";

     

       15452
       15452
       +
           self.by-version."npm"."2.1.5";

     

       15453
       15453
       +
         by-version."npm"."2.1.5" = lib.makeOverridable self.buildNodePackage {

     

       15454
       15454
       +
           name = "npm-2.1.5";

     

       15181
       15455
        
           bin = true;

     

       15182
       15456
        
           src = [

     

       15183
       15457
        
             (fetchurl {

     

       15184
       15184
       -
               url = "http://registry.npmjs.org/npm/-/npm-2.1.3.tgz";

     

       15185
       15185
       -
               name = "npm-2.1.3.tgz";

     

       15186
       15186
       -
               sha1 = "f6dfc9d4bdaefe712a50bb75ae5c8bbdf2cd3a3b";

     

       15458
       15458
       +
               url = "http://registry.npmjs.org/npm/-/npm-2.1.5.tgz";

     

       15459
       15459
       +
               name = "npm-2.1.5.tgz";

     

       15460
       15460
       +
               sha1 = "ce343163a56f1ff14ffa295c140d99833b9764cb";

     

       15187
       15461
        
             })

     

       15188
       15462
        
           ];

     

       15189
       15463
        
           buildInputs =

     
···

       15193
       15467
        
             "ansi-0.3.0" = self.by-version."ansi"."0.3.0";

     

       15194
       15468
        
             "ansicolors-0.3.2" = self.by-version."ansicolors"."0.3.2";

     

       15195
       15469
        
             "ansistyles-0.1.3" = self.by-version."ansistyles"."0.1.3";

     

       15196
       15196
       -
             "archy-0.0.2" = self.by-version."archy"."0.0.2";

     

       15470
       15470
       +
             "archy-1.0.0" = self.by-version."archy"."1.0.0";

     

       15197
       15471
        
             "async-some-1.0.1" = self.by-version."async-some"."1.0.1";

     

       15198
       15472
        
             "block-stream-0.0.7" = self.by-version."block-stream"."0.0.7";

     

       15199
       15473
        
             "char-spinner-1.0.1" = self.by-version."char-spinner"."1.0.1";

     
···

       15202
       15476
        
             "chownr-0.0.1" = self.by-version."chownr"."0.0.1";

     

       15203
       15477
        
             "cmd-shim-2.0.1" = self.by-version."cmd-shim"."2.0.1";

     

       15204
       15478
        
             "columnify-1.2.1" = self.by-version."columnify"."1.2.1";

     

       15479
       15479
       +
             "config-chain-1.1.8" = self.by-version."config-chain"."1.1.8";

     

       15205
       15480
        
             "dezalgo-1.0.1" = self.by-version."dezalgo"."1.0.1";

     

       15206
       15481
        
             "editor-0.1.0" = self.by-version."editor"."0.1.0";

     

       15207
       15482
        
             "fs-vacuum-1.2.1" = self.by-version."fs-vacuum"."1.2.1";

     

       15208
       15483
        
             "fs-write-stream-atomic-1.0.2" = self.by-version."fs-write-stream-atomic"."1.0.2";

     

       15209
       15484
        
             "fstream-1.0.2" = self.by-version."fstream"."1.0.2";

     

       15210
       15210
       -
             "fstream-npm-1.0.0" = self.by-version."fstream-npm"."1.0.0";

     

       15485
       15485
       +
             "fstream-npm-1.0.1" = self.by-version."fstream-npm"."1.0.1";

     

       15211
       15486
        
             "github-url-from-git-1.4.0" = self.by-version."github-url-from-git"."1.4.0";

     

       15212
       15487
        
             "github-url-from-username-repo-1.0.2" = self.by-version."github-url-from-username-repo"."1.0.2";

     

       15213
       15488
        
             "glob-4.0.6" = self.by-version."glob"."4.0.6";

     

       15214
       15214
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       15489
       15489
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       15215
       15490
        
             "inflight-1.0.4" = self.by-version."inflight"."1.0.4";

     

       15216
       15491
        
             "inherits-2.0.1" = self.by-version."inherits"."2.0.1";

     

       15217
       15217
       -
             "ini-1.2.1" = self.by-version."ini"."1.2.1";

     

       15492
       15492
       +
             "ini-1.3.0" = self.by-version."ini"."1.3.0";

     

       15218
       15493
        
             "init-package-json-1.1.0" = self.by-version."init-package-json"."1.1.0";

     

       15219
       15494
        
             "lockfile-1.0.0" = self.by-version."lockfile"."1.0.0";

     

       15220
       15495
        
             "lru-cache-2.5.0" = self.by-version."lru-cache"."2.5.0";

     
···

       15226
       15501
        
             "npm-cache-filename-1.0.1" = self.by-version."npm-cache-filename"."1.0.1";

     

       15227
       15502
        
             "npm-install-checks-1.0.4" = self.by-version."npm-install-checks"."1.0.4";

     

       15228
       15503
        
             "npm-package-arg-2.1.3" = self.by-version."npm-package-arg"."2.1.3";

     

       15229
       15229
       -
             "npm-registry-client-3.2.2" = self.by-version."npm-registry-client"."3.2.2";

     

       15230
       15230
       -
             "npm-user-validate-0.1.0" = self.by-version."npm-user-validate"."0.1.0";

     

       15231
       15231
       -
             "npmconf-2.1.0" = self.by-version."npmconf"."2.1.0";

     

       15504
       15504
       +
             "npm-registry-client-3.2.4" = self.by-version."npm-registry-client"."3.2.4";

     

       15505
       15505
       +
             "npm-user-validate-0.1.1" = self.by-version."npm-user-validate"."0.1.1";

     

       15232
       15506
        
             "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";

     

       15233
       15507
        
             "once-1.3.1" = self.by-version."once"."1.3.1";

     

       15234
       15234
       -
             "opener-1.3.0" = self.by-version."opener"."1.3.0";

     

       15508
       15508
       +
             "opener-1.4.0" = self.by-version."opener"."1.4.0";

     

       15235
       15509
        
             "osenv-0.1.0" = self.by-version."osenv"."0.1.0";

     

       15236
       15510
        
             "path-is-inside-1.0.1" = self.by-version."path-is-inside"."1.0.1";

     

       15237
       15511
        
             "read-1.0.5" = self.by-version."read"."1.0.5";

     

       15238
       15512
        
             "read-installed-3.1.3" = self.by-version."read-installed"."3.1.3";

     

       15239
       15513
        
             "read-package-json-1.2.7" = self.by-version."read-package-json"."1.2.7";

     

       15240
       15240
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       15241
       15241
       -
             "realize-package-specifier-1.1.0" = self.by-version."realize-package-specifier"."1.1.0";

     

       15242
       15242
       -
             "request-2.44.0" = self.by-version."request"."2.44.0";

     

       15514
       15514
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       15515
       15515
       +
             "realize-package-specifier-1.2.0" = self.by-version."realize-package-specifier"."1.2.0";

     

       15516
       15516
       +
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       15243
       15517
        
             "retry-0.6.1" = self.by-version."retry"."0.6.1";

     

       15244
       15518
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     

       15245
       15245
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15246
       15246
       -
             "sha-1.2.4" = self.by-version."sha"."1.2.4";

     

       15519
       15519
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15520
       15520
       +
             "sha-1.3.0" = self.by-version."sha"."1.3.0";

     

       15247
       15521
        
             "slide-1.1.6" = self.by-version."slide"."1.1.6";

     

       15248
       15522
        
             "sorted-object-1.0.0" = self.by-version."sorted-object"."1.0.0";

     

       15249
       15523
        
             "tar-1.0.1" = self.by-version."tar"."1.0.1";

     
···

       15257
       15531
        
           ];

     

       15258
       15532
        
           passthru.names = [ "npm" ];

     

       15259
       15533
        
         };

     

       15260
       15260
       -
         "npm" = self.by-version."npm"."2.1.3";

     

       15534
       15534
       +
         "npm" = self.by-version."npm"."2.1.5";

     

       15261
       15535
        
         by-spec."npm-cache-filename"."^1.0.0" =

     

       15262
       15536
        
           self.by-version."npm-cache-filename"."1.0.1";

     

       15263
       15537
        
         by-version."npm-cache-filename"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     
···

       15296
       15570
        
             (self.nativeDeps."npm-install-checks" or []);

     

       15297
       15571
        
           deps = {

     

       15298
       15572
        
             "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";

     

       15299
       15299
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15573
       15573
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15300
       15574
        
           };

     

       15301
       15575
        
           peerDependencies = [

     

       15302
       15576
        
           ];

     
···

       15317
       15591
        
           buildInputs =

     

       15318
       15592
        
             (self.nativeDeps."npm-package-arg" or []);

     

       15319
       15593
        
           deps = {

     

       15320
       15320
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15594
       15594
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15321
       15595
        
           };

     

       15322
       15596
        
           peerDependencies = [

     

       15323
       15597
        
           ];

     
···

       15371
       15645
        
             (self.nativeDeps."npm-registry-client" or []);

     

       15372
       15646
        
           deps = {

     

       15373
       15647
        
             "chownr-0.0.1" = self.by-version."chownr"."0.0.1";

     

       15374
       15374
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       15648
       15648
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       15375
       15649
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       15376
       15650
        
             "normalize-package-data-1.0.3" = self.by-version."normalize-package-data"."1.0.3";

     

       15377
       15651
        
             "npm-cache-filename-1.0.1" = self.by-version."npm-cache-filename"."1.0.1";

     
···

       15379
       15653
        
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       15380
       15654
        
             "retry-0.6.0" = self.by-version."retry"."0.6.0";

     

       15381
       15655
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     

       15382
       15382
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15656
       15656
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15383
       15657
        
             "slide-1.1.6" = self.by-version."slide"."1.1.6";

     

       15384
       15658
        
             "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";

     

       15385
       15659
        
           };

     
···

       15387
       15661
        
           ];

     

       15388
       15662
        
           passthru.names = [ "npm-registry-client" ];

     

       15389
       15663
        
         };

     

       15390
       15390
       -
         by-spec."npm-registry-client"."~3.2.2" =

     

       15391
       15391
       -
           self.by-version."npm-registry-client"."3.2.2";

     

       15392
       15392
       -
         by-version."npm-registry-client"."3.2.2" = lib.makeOverridable self.buildNodePackage {

     

       15393
       15393
       -
           name = "npm-registry-client-3.2.2";

     

       15664
       15664
       +
         by-spec."npm-registry-client"."~3.2.4" =

     

       15665
       15665
       +
           self.by-version."npm-registry-client"."3.2.4";

     

       15666
       15666
       +
         by-version."npm-registry-client"."3.2.4" = lib.makeOverridable self.buildNodePackage {

     

       15667
       15667
       +
           name = "npm-registry-client-3.2.4";

     

       15394
       15668
        
           bin = false;

     

       15395
       15669
        
           src = [

     

       15396
       15670
        
             (fetchurl {

     

       15397
       15397
       -
               url = "http://registry.npmjs.org/npm-registry-client/-/npm-registry-client-3.2.2.tgz";

     

       15398
       15398
       -
               name = "npm-registry-client-3.2.2.tgz";

     

       15399
       15399
       -
               sha1 = "7c4ef979cf61b411d15421a24ac2b3b846f8bd53";

     

       15671
       15671
       +
               url = "http://registry.npmjs.org/npm-registry-client/-/npm-registry-client-3.2.4.tgz";

     

       15672
       15672
       +
               name = "npm-registry-client-3.2.4.tgz";

     

       15673
       15673
       +
               sha1 = "8659b3449e1c9a9f8181dad142cadb048bfe521f";

     

       15400
       15674
        
             })

     

       15401
       15675
        
           ];

     

       15402
       15676
        
           buildInputs =

     

       15403
       15677
        
             (self.nativeDeps."npm-registry-client" or []);

     

       15404
       15678
        
           deps = {

     

       15405
       15679
        
             "chownr-0.0.1" = self.by-version."chownr"."0.0.1";

     

       15406
       15406
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       15680
       15680
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       15407
       15681
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       15408
       15682
        
             "normalize-package-data-1.0.3" = self.by-version."normalize-package-data"."1.0.3";

     

       15409
       15683
        
             "npm-cache-filename-1.0.1" = self.by-version."npm-cache-filename"."1.0.1";

     

       15410
       15684
        
             "once-1.3.1" = self.by-version."once"."1.3.1";

     

       15411
       15685
        
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       15412
       15412
       -
             "retry-0.6.0" = self.by-version."retry"."0.6.0";

     

       15686
       15686
       +
             "retry-0.6.1" = self.by-version."retry"."0.6.1";

     

       15413
       15687
        
             "rimraf-2.2.8" = self.by-version."rimraf"."2.2.8";

     

       15414
       15414
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15688
       15688
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15415
       15689
        
             "slide-1.1.6" = self.by-version."slide"."1.1.6";

     

       15416
       15690
        
             "npmlog-0.1.1" = self.by-version."npmlog"."0.1.1";

     

       15417
       15691
        
           };

     

       15418
       15692
        
           peerDependencies = [

     

       15419
       15419
       -
             self.by-version."npmconf"."2.1.0"

     

       15420
       15693
        
           ];

     

       15421
       15694
        
           passthru.names = [ "npm-registry-client" ];

     

       15422
       15695
        
         };

     

       15423
       15423
       -
         by-spec."npm-user-validate"."~0.1.0" =

     

       15424
       15424
       -
           self.by-version."npm-user-validate"."0.1.0";

     

       15425
       15425
       -
         by-version."npm-user-validate"."0.1.0" = lib.makeOverridable self.buildNodePackage {

     

       15426
       15426
       -
           name = "npm-user-validate-0.1.0";

     

       15696
       15696
       +
         by-spec."npm-user-validate"."~0.1.1" =

     

       15697
       15697
       +
           self.by-version."npm-user-validate"."0.1.1";

     

       15698
       15698
       +
         by-version."npm-user-validate"."0.1.1" = lib.makeOverridable self.buildNodePackage {

     

       15699
       15699
       +
           name = "npm-user-validate-0.1.1";

     

       15427
       15700
        
           bin = false;

     

       15428
       15701
        
           src = [

     

       15429
       15702
        
             (fetchurl {

     

       15430
       15430
       -
               url = "http://registry.npmjs.org/npm-user-validate/-/npm-user-validate-0.1.0.tgz";

     

       15431
       15431
       -
               name = "npm-user-validate-0.1.0.tgz";

     

       15432
       15432
       -
               sha1 = "358a5b5148ed3f79771d980388c6e34c4a61f638";

     

       15703
       15703
       +
               url = "http://registry.npmjs.org/npm-user-validate/-/npm-user-validate-0.1.1.tgz";

     

       15704
       15704
       +
               name = "npm-user-validate-0.1.1.tgz";

     

       15705
       15705
       +
               sha1 = "ea7774636c3c8fe6d01e174bd9f2ee0e22eeed57";

     

       15433
       15706
        
             })

     

       15434
       15707
        
           ];

     

       15435
       15708
        
           buildInputs =

     
···

       15519
       15792
        
             "nopt-3.0.1" = self.by-version."nopt"."3.0.1";

     

       15520
       15793
        
             "once-1.3.1" = self.by-version."once"."1.3.1";

     

       15521
       15794
        
             "osenv-0.1.0" = self.by-version."osenv"."0.1.0";

     

       15522
       15522
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15795
       15795
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15523
       15796
        
             "uid-number-0.0.5" = self.by-version."uid-number"."0.0.5";

     

       15524
       15797
        
           };

     

       15525
       15798
        
           peerDependencies = [

     

       15526
       15799
        
           ];

     

       15527
       15800
        
           passthru.names = [ "npmconf" ];

     

       15528
       15801
        
         };

     

       15529
       15529
       -
         by-spec."npmconf".">=2.1.0-0 >=2.1.0-0 <2.2.0-0" =

     

       15530
       15530
       -
           self.by-version."npmconf"."2.1.0";

     

       15531
       15531
       -
         by-version."npmconf"."2.1.0" = lib.makeOverridable self.buildNodePackage {

     

       15532
       15532
       -
           name = "npmconf-2.1.0";

     

       15802
       15802
       +
         by-spec."npmconf"."^2.0.1" =

     

       15803
       15803
       +
           self.by-version."npmconf"."2.1.1";

     

       15804
       15804
       +
         by-version."npmconf"."2.1.1" = lib.makeOverridable self.buildNodePackage {

     

       15805
       15805
       +
           name = "npmconf-2.1.1";

     

       15533
       15806
        
           bin = false;

     

       15534
       15807
        
           src = [

     

       15535
       15808
        
             (fetchurl {

     

       15536
       15536
       -
               url = "http://registry.npmjs.org/npmconf/-/npmconf-2.1.0.tgz";

     

       15537
       15537
       -
               name = "npmconf-2.1.0.tgz";

     

       15538
       15538
       -
               sha1 = "6dcdbd1fe3d7373b78ec74ab69e919d4954f76b0";

     

       15809
       15809
       +
               url = "http://registry.npmjs.org/npmconf/-/npmconf-2.1.1.tgz";

     

       15810
       15810
       +
               name = "npmconf-2.1.1.tgz";

     

       15811
       15811
       +
               sha1 = "a266c7e5c56695eb7f55caf3a5a7328f24510dae";

     

       15539
       15812
        
             })

     

       15540
       15813
        
           ];

     

       15541
       15814
        
           buildInputs =

     
···

       15548
       15821
        
             "nopt-3.0.1" = self.by-version."nopt"."3.0.1";

     

       15549
       15822
        
             "once-1.3.1" = self.by-version."once"."1.3.1";

     

       15550
       15823
        
             "osenv-0.1.0" = self.by-version."osenv"."0.1.0";

     

       15551
       15551
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       15824
       15824
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       15552
       15825
        
             "uid-number-0.0.5" = self.by-version."uid-number"."0.0.5";

     

       15553
       15826
        
           };

     

       15554
       15827
        
           peerDependencies = [

     

       15555
       15828
        
           ];

     

       15556
       15829
        
           passthru.names = [ "npmconf" ];

     

       15557
       15830
        
         };

     

       15558
       15558
       -
         by-spec."npmconf"."^2.0.1" =

     

       15559
       15559
       -
           self.by-version."npmconf"."2.1.0";

     

       15560
       15560
       -
         by-spec."npmconf"."^2.1.0" =

     

       15561
       15561
       -
           self.by-version."npmconf"."2.1.0";

     

       15562
       15831
        
         by-spec."npmconf"."~0.1.2" =

     

       15563
       15832
        
           self.by-version."npmconf"."0.1.16";

     

       15564
       15833
        
         by-version."npmconf"."0.1.16" = lib.makeOverridable self.buildNodePackage {

     
···

       15589
       15858
        
         };

     

       15590
       15859
        
         by-spec."npmconf"."~2.0.5" =

     

       15591
       15860
        
           self.by-version."npmconf"."2.0.9";

     

       15592
       15592
       -
         by-spec."npmconf"."~2.1.0" =

     

       15593
       15593
       -
           self.by-version."npmconf"."2.1.0";

     

       15594
       15861
        
         by-spec."npmlog"."*" =

     

       15595
       15862
        
           self.by-version."npmlog"."0.1.1";

     

       15596
       15863
        
         by-version."npmlog"."0.1.1" = lib.makeOverridable self.buildNodePackage {

     
···

       15649
       15916
        
             (fetchurl {

     

       15650
       15917
        
               url = "https://github.com/ciaranj/node-oauth/tarball/master";

     

       15651
       15918
        
               name = "oauth-0.9.11.tgz";

     

       15652
       15652
       -
               sha256 = "81deda1451b8103f278cbede8aab0a929a63882dbc604214fd7690d72390d083";

     

       15919
       15919
       +
               sha256 = "783dead39b8df22dfff8961fcfb3e65622375d4308c12c1fbce2ae2e4da20184";

     

       15653
       15920
        
             })

     

       15654
       15921
        
           ];

     

       15655
       15922
        
           buildInputs =

     
···

       15912
       16179
        
         };

     

       15913
       16180
        
         by-spec."once"."~1.3.0" =

     

       15914
       16181
        
           self.by-version."once"."1.3.1";

     

       16182
       16182
       +
         by-spec."once"."~1.3.1" =

     

       16183
       16183
       +
           self.by-version."once"."1.3.1";

     

       15915
       16184
        
         by-spec."open"."0.0.2" =

     

       15916
       16185
        
           self.by-version."open"."0.0.2";

     

       15917
       16186
        
         by-version."open"."0.0.2" = lib.makeOverridable self.buildNodePackage {

     
···

       15962
       16231
        
               url = "http://registry.npmjs.org/opener/-/opener-1.3.0.tgz";

     

       15963
       16232
        
               name = "opener-1.3.0.tgz";

     

       15964
       16233
        
               sha1 = "130ba662213fa842edb4cd0361d31a15301a43e2";

     

       16234
       16234
       +
             })

     

       16235
       16235
       +
           ];

     

       16236
       16236
       +
           buildInputs =

     

       16237
       16237
       +
             (self.nativeDeps."opener" or []);

     

       16238
       16238
       +
           deps = {

     

       16239
       16239
       +
           };

     

       16240
       16240
       +
           peerDependencies = [

     

       16241
       16241
       +
           ];

     

       16242
       16242
       +
           passthru.names = [ "opener" ];

     

       16243
       16243
       +
         };

     

       16244
       16244
       +
         by-spec."opener"."~1.4.0" =

     

       16245
       16245
       +
           self.by-version."opener"."1.4.0";

     

       16246
       16246
       +
         by-version."opener"."1.4.0" = lib.makeOverridable self.buildNodePackage {

     

       16247
       16247
       +
           name = "opener-1.4.0";

     

       16248
       16248
       +
           bin = true;

     

       16249
       16249
       +
           src = [

     

       16250
       16250
       +
             (fetchurl {

     

       16251
       16251
       +
               url = "http://registry.npmjs.org/opener/-/opener-1.4.0.tgz";

     

       16252
       16252
       +
               name = "opener-1.4.0.tgz";

     

       16253
       16253
       +
               sha1 = "d11f86eeeb076883735c9d509f538fe82d10b941";

     

       15965
       16254
        
             })

     

       15966
       16255
        
           ];

     

       15967
       16256
        
           buildInputs =

     
···

       16725
       17014
        
           passthru.names = [ "pbkdf2-compat" ];

     

       16726
       17015
        
         };

     

       16727
       17016
        
         by-spec."phantomjs"."*" =

     

       16728
       16728
       -
           self.by-version."phantomjs"."1.9.10";

     

       16729
       16729
       -
         by-version."phantomjs"."1.9.10" = lib.makeOverridable self.buildNodePackage {

     

       16730
       16730
       -
           name = "phantomjs-1.9.10";

     

       17017
       17017
       +
           self.by-version."phantomjs"."1.9.11";

     

       17018
       17018
       +
         by-version."phantomjs"."1.9.11" = lib.makeOverridable self.buildNodePackage {

     

       17019
       17019
       +
           name = "phantomjs-1.9.11";

     

       16731
       17020
        
           bin = true;

     

       16732
       17021
        
           src = [

     

       16733
       17022
        
             (fetchurl {

     

       16734
       16734
       -
               url = "http://registry.npmjs.org/phantomjs/-/phantomjs-1.9.10.tgz";

     

       16735
       16735
       -
               name = "phantomjs-1.9.10.tgz";

     

       16736
       16736
       -
               sha1 = "be174e20b03f42c39beaaf84cc153fb65b225a4a";

     

       17023
       17023
       +
               url = "http://registry.npmjs.org/phantomjs/-/phantomjs-1.9.11.tgz";

     

       17024
       17024
       +
               name = "phantomjs-1.9.11.tgz";

     

       17025
       17025
       +
               sha1 = "de822affca7858382b6ab9c931ba4541e5b8a0ae";

     

       16737
       17026
        
             })

     

       16738
       17027
        
           ];

     

       16739
       17028
        
           buildInputs =

     
···

       16754
       17043
        
           ];

     

       16755
       17044
        
           passthru.names = [ "phantomjs" ];

     

       16756
       17045
        
         };

     

       16757
       16757
       -
         "phantomjs" = self.by-version."phantomjs"."1.9.10";

     

       17046
       17046
       +
         "phantomjs" = self.by-version."phantomjs"."1.9.11";

     

       16758
       17047
        
         by-spec."phantomjs"."~1.9.1" =

     

       16759
       16759
       -
           self.by-version."phantomjs"."1.9.10";

     

       17048
       17048
       +
           self.by-version."phantomjs"."1.9.11";

     

       16760
       17049
        
         by-spec."phantomjs"."~1.9.10" =

     

       16761
       16761
       -
           self.by-version."phantomjs"."1.9.10";

     

       17050
       17050
       +
           self.by-version."phantomjs"."1.9.11";

     

       16762
       17051
        
         by-spec."pkginfo"."0.2.x" =

     

       16763
       17052
        
           self.by-version."pkginfo"."0.2.3";

     

       16764
       17053
        
         by-version."pkginfo"."0.2.3" = lib.makeOverridable self.buildNodePackage {

     
···

       17048
       17337
        
           ];

     

       17049
       17338
        
           passthru.names = [ "promise" ];

     

       17050
       17339
        
         };

     

       17340
       17340
       +
         by-spec."promise"."~6.0.1" =

     

       17341
       17341
       +
           self.by-version."promise"."6.0.1";

     

       17342
       17342
       +
         by-version."promise"."6.0.1" = lib.makeOverridable self.buildNodePackage {

     

       17343
       17343
       +
           name = "promise-6.0.1";

     

       17344
       17344
       +
           bin = false;

     

       17345
       17345
       +
           src = [

     

       17346
       17346
       +
             (fetchurl {

     

       17347
       17347
       +
               url = "http://registry.npmjs.org/promise/-/promise-6.0.1.tgz";

     

       17348
       17348
       +
               name = "promise-6.0.1.tgz";

     

       17349
       17349
       +
               sha1 = "d475cff81c083a27fe87ae19952b72c1a6936237";

     

       17350
       17350
       +
             })

     

       17351
       17351
       +
           ];

     

       17352
       17352
       +
           buildInputs =

     

       17353
       17353
       +
             (self.nativeDeps."promise" or []);

     

       17354
       17354
       +
           deps = {

     

       17355
       17355
       +
             "asap-1.0.0" = self.by-version."asap"."1.0.0";

     

       17356
       17356
       +
           };

     

       17357
       17357
       +
           peerDependencies = [

     

       17358
       17358
       +
           ];

     

       17359
       17359
       +
           passthru.names = [ "promise" ];

     

       17360
       17360
       +
         };

     

       17051
       17361
        
         by-spec."prompt"."0.2.11" =

     

       17052
       17362
        
           self.by-version."prompt"."0.2.11";

     

       17053
       17363
        
         by-version."prompt"."0.2.11" = lib.makeOverridable self.buildNodePackage {

     
···

       17092
       17402
        
             "read-1.0.5" = self.by-version."read"."1.0.5";

     

       17093
       17403
        
             "revalidator-0.1.8" = self.by-version."revalidator"."0.1.8";

     

       17094
       17404
        
             "utile-0.2.1" = self.by-version."utile"."0.2.1";

     

       17095
       17095
       -
             "winston-0.8.0" = self.by-version."winston"."0.8.0";

     

       17405
       17405
       +
             "winston-0.8.1" = self.by-version."winston"."0.8.1";

     

       17096
       17406
        
           };

     

       17097
       17407
        
           peerDependencies = [

     

       17098
       17408
        
           ];

     
···

       17269
       17579
        
           passthru.names = [ "punycode" ];

     

       17270
       17580
        
         };

     

       17271
       17581
        
         by-spec."punycode".">=0.2.0" =

     

       17272
       17272
       -
           self.by-version."punycode"."1.3.1";

     

       17273
       17273
       -
         by-version."punycode"."1.3.1" = lib.makeOverridable self.buildNodePackage {

     

       17274
       17274
       -
           name = "punycode-1.3.1";

     

       17582
       17582
       +
           self.by-version."punycode"."1.3.2";

     

       17583
       17583
       +
         by-version."punycode"."1.3.2" = lib.makeOverridable self.buildNodePackage {

     

       17584
       17584
       +
           name = "punycode-1.3.2";

     

       17275
       17585
        
           bin = false;

     

       17276
       17586
        
           src = [

     

       17277
       17587
        
             (fetchurl {

     

       17278
       17278
       -
               url = "http://registry.npmjs.org/punycode/-/punycode-1.3.1.tgz";

     

       17279
       17279
       -
               name = "punycode-1.3.1.tgz";

     

       17280
       17280
       -
               sha1 = "710afe5123c20a1530b712e3e682b9118fe8058e";

     

       17588
       17588
       +
               url = "http://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz";

     

       17589
       17589
       +
               name = "punycode-1.3.2.tgz";

     

       17590
       17590
       +
               sha1 = "9653a036fb7c1ee42342f2325cceefea3926c48d";

     

       17281
       17591
        
             })

     

       17282
       17592
        
           ];

     

       17283
       17593
        
           buildInputs =

     
···

       17628
       17938
        
           passthru.names = [ "qs" ];

     

       17629
       17939
        
         };

     

       17630
       17940
        
         by-spec."querystring-es3"."~0.2.0" =

     

       17631
       17631
       -
           self.by-version."querystring-es3"."0.2.1-0";

     

       17632
       17632
       -
         by-version."querystring-es3"."0.2.1-0" = lib.makeOverridable self.buildNodePackage {

     

       17633
       17633
       -
           name = "querystring-es3-0.2.1-0";

     

       17941
       17941
       +
           self.by-version."querystring-es3"."0.2.1";

     

       17942
       17942
       +
         by-version."querystring-es3"."0.2.1" = lib.makeOverridable self.buildNodePackage {

     

       17943
       17943
       +
           name = "querystring-es3-0.2.1";

     

       17634
       17944
        
           bin = false;

     

       17635
       17945
        
           src = [

     

       17636
       17946
        
             (fetchurl {

     

       17637
       17637
       -
               url = "http://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1-0.tgz";

     

       17638
       17638
       -
               name = "querystring-es3-0.2.1-0.tgz";

     

       17639
       17639
       -
               sha1 = "bd38cbd701040e7ef66c94a93db4a5b45be39565";

     

       17947
       17947
       +
               url = "http://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz";

     

       17948
       17948
       +
               name = "querystring-es3-0.2.1.tgz";

     

       17949
       17949
       +
               sha1 = "9ec61f79049875707d69414596fd907a4d711e73";

     

       17640
       17950
        
             })

     

       17641
       17951
        
           ];

     

       17642
       17952
        
           buildInputs =

     
···

       17905
       18215
        
           passthru.names = [ "rc" ];

     

       17906
       18216
        
         };

     

       17907
       18217
        
         by-spec."react"."*" =

     

       17908
       17908
       -
           self.by-version."react"."0.11.2";

     

       17909
       17909
       -
         by-version."react"."0.11.2" = lib.makeOverridable self.buildNodePackage {

     

       17910
       17910
       -
           name = "react-0.11.2";

     

       18218
       18218
       +
           self.by-version."react"."0.12.0-rc1";

     

       18219
       18219
       +
         by-version."react"."0.12.0-rc1" = lib.makeOverridable self.buildNodePackage {

     

       18220
       18220
       +
           name = "react-0.12.0-rc1";

     

       17911
       18221
        
           bin = false;

     

       17912
       18222
        
           src = [

     

       17913
       18223
        
             (fetchurl {

     

       17914
       17914
       -
               url = "http://registry.npmjs.org/react/-/react-0.11.2.tgz";

     

       17915
       17915
       -
               name = "react-0.11.2.tgz";

     

       17916
       17916
       -
               sha1 = "eaeb787e9b1e266a3540c07c06f4ea80fe1e3766";

     

       18224
       18224
       +
               url = "http://registry.npmjs.org/react/-/react-0.12.0-rc1.tgz";

     

       18225
       18225
       +
               name = "react-0.12.0-rc1.tgz";

     

       18226
       18226
       +
               sha1 = "de56afc07e834fdf2f988a9c1026c25b93a61636";

     

       17917
       18227
        
             })

     

       17918
       18228
        
           ];

     

       17919
       18229
        
           buildInputs =

     

       17920
       18230
        
             (self.nativeDeps."react" or []);

     

       17921
       18231
        
           deps = {

     

       17922
       17922
       -
             "envify-2.0.1" = self.by-version."envify"."2.0.1";

     

       18232
       18232
       +
             "envify-3.0.0" = self.by-version."envify"."3.0.0";

     

       17923
       18233
        
           };

     

       17924
       18234
        
           peerDependencies = [

     

       17925
       18235
        
           ];

     

       17926
       18236
        
           passthru.names = [ "react" ];

     

       17927
       18237
        
         };

     

       17928
       17928
       -
         "react" = self.by-version."react"."0.11.2";

     

       18238
       18238
       +
         "react" = self.by-version."react"."0.12.0-rc1";

     

       17929
       18239
        
         by-spec."read"."1" =

     

       17930
       18240
        
           self.by-version."read"."1.0.5";

     

       17931
       18241
        
         by-version."read"."1.0.5" = lib.makeOverridable self.buildNodePackage {

     
···

       17971
       18281
        
             "debuglog-1.0.1" = self.by-version."debuglog"."1.0.1";

     

       17972
       18282
        
             "read-package-json-1.2.7" = self.by-version."read-package-json"."1.2.7";

     

       17973
       18283
        
             "readdir-scoped-modules-1.0.0" = self.by-version."readdir-scoped-modules"."1.0.0";

     

       17974
       17974
       -
             "semver-4.0.3" = self.by-version."semver"."4.0.3";

     

       18284
       18284
       +
             "semver-4.1.0" = self.by-version."semver"."4.1.0";

     

       17975
       18285
        
             "slide-1.1.6" = self.by-version."slide"."1.1.6";

     

       17976
       18286
        
             "util-extend-1.0.1" = self.by-version."util-extend"."1.0.1";

     

       17977
       17977
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       18287
       18287
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       17978
       18288
        
           };

     

       17979
       18289
        
           peerDependencies = [

     

       17980
       18290
        
           ];

     
···

       18000
       18310
        
             "glob-4.0.6" = self.by-version."glob"."4.0.6";

     

       18001
       18311
        
             "lru-cache-2.5.0" = self.by-version."lru-cache"."2.5.0";

     

       18002
       18312
        
             "normalize-package-data-1.0.3" = self.by-version."normalize-package-data"."1.0.3";

     

       18003
       18003
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       18313
       18313
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       18004
       18314
        
           };

     

       18005
       18315
        
           peerDependencies = [

     

       18006
       18316
        
           ];

     
···

       18032
       18342
        
           ];

     

       18033
       18343
        
           passthru.names = [ "readable-stream" ];

     

       18034
       18344
        
         };

     

       18035
       18035
       -
         by-spec."readable-stream"."1.0" =

     

       18036
       18036
       -
           self.by-version."readable-stream"."1.0.32";

     

       18037
       18037
       -
         by-version."readable-stream"."1.0.32" = lib.makeOverridable self.buildNodePackage {

     

       18038
       18038
       -
           name = "readable-stream-1.0.32";

     

       18345
       18345
       +
         by-spec."readable-stream"."1.0.27-1" =

     

       18346
       18346
       +
           self.by-version."readable-stream"."1.0.27-1";

     

       18347
       18347
       +
         by-version."readable-stream"."1.0.27-1" = lib.makeOverridable self.buildNodePackage {

     

       18348
       18348
       +
           name = "readable-stream-1.0.27-1";

     

       18039
       18349
        
           bin = false;

     

       18040
       18350
        
           src = [

     

       18041
       18351
        
             (fetchurl {

     

       18042
       18042
       -
               url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.32.tgz";

     

       18043
       18043
       -
               name = "readable-stream-1.0.32.tgz";

     

       18044
       18044
       -
               sha1 = "6b44a88ba984cd0ec0834ae7d59a47c39aef48ec";

     

       18352
       18352
       +
               url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.27-1.tgz";

     

       18353
       18353
       +
               name = "readable-stream-1.0.27-1.tgz";

     

       18354
       18354
       +
               sha1 = "6b67983c20357cefd07f0165001a16d710d91078";

     

       18045
       18355
        
             })

     

       18046
       18356
        
           ];

     

       18047
       18357
        
           buildInputs =

     
···

       18056
       18366
        
           ];

     

       18057
       18367
        
           passthru.names = [ "readable-stream" ];

     

       18058
       18368
        
         };

     

       18059
       18059
       -
         by-spec."readable-stream"."1.0.27-1" =

     

       18060
       18060
       -
           self.by-version."readable-stream"."1.0.27-1";

     

       18061
       18061
       -
         by-version."readable-stream"."1.0.27-1" = lib.makeOverridable self.buildNodePackage {

     

       18062
       18062
       -
           name = "readable-stream-1.0.27-1";

     

       18369
       18369
       +
         by-spec."readable-stream"."1.0.31" =

     

       18370
       18370
       +
           self.by-version."readable-stream"."1.0.31";

     

       18371
       18371
       +
         by-version."readable-stream"."1.0.31" = lib.makeOverridable self.buildNodePackage {

     

       18372
       18372
       +
           name = "readable-stream-1.0.31";

     

       18063
       18373
        
           bin = false;

     

       18064
       18374
        
           src = [

     

       18065
       18375
        
             (fetchurl {

     

       18066
       18066
       -
               url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.27-1.tgz";

     

       18067
       18067
       -
               name = "readable-stream-1.0.27-1.tgz";

     

       18068
       18068
       -
               sha1 = "6b67983c20357cefd07f0165001a16d710d91078";

     

       18376
       18376
       +
               url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.31.tgz";

     

       18377
       18377
       +
               name = "readable-stream-1.0.31.tgz";

     

       18378
       18378
       +
               sha1 = "8f2502e0bc9e3b0da1b94520aabb4e2603ecafae";

     

       18069
       18379
        
             })

     

       18070
       18380
        
           ];

     

       18071
       18381
        
           buildInputs =

     
···

       18080
       18390
        
           ];

     

       18081
       18391
        
           passthru.names = [ "readable-stream" ];

     

       18082
       18392
        
         };

     

       18083
       18083
       -
         by-spec."readable-stream"."1.0.31" =

     

       18084
       18084
       -
           self.by-version."readable-stream"."1.0.31";

     

       18085
       18085
       -
         by-version."readable-stream"."1.0.31" = lib.makeOverridable self.buildNodePackage {

     

       18086
       18086
       -
           name = "readable-stream-1.0.31";

     

       18393
       18393
       +
         by-spec."readable-stream"."1.1" =

     

       18394
       18394
       +
           self.by-version."readable-stream"."1.1.13";

     

       18395
       18395
       +
         by-spec."readable-stream".">=1.0.33-1 <1.1.0-0" =

     

       18396
       18396
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18397
       18397
       +
         by-version."readable-stream"."1.0.33-1" = lib.makeOverridable self.buildNodePackage {

     

       18398
       18398
       +
           name = "readable-stream-1.0.33-1";

     

       18087
       18399
        
           bin = false;

     

       18088
       18400
        
           src = [

     

       18089
       18401
        
             (fetchurl {

     

       18090
       18090
       -
               url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.31.tgz";

     

       18091
       18091
       -
               name = "readable-stream-1.0.31.tgz";

     

       18092
       18092
       -
               sha1 = "8f2502e0bc9e3b0da1b94520aabb4e2603ecafae";

     

       18402
       18402
       +
               url = "http://registry.npmjs.org/readable-stream/-/readable-stream-1.0.33-1.tgz";

     

       18403
       18403
       +
               name = "readable-stream-1.0.33-1.tgz";

     

       18404
       18404
       +
               sha1 = "40d0d91338691291a9117c05d78adb5497c37810";

     

       18093
       18405
        
             })

     

       18094
       18406
        
           ];

     

       18095
       18407
        
           buildInputs =

     
···

       18104
       18416
        
           ];

     

       18105
       18417
        
           passthru.names = [ "readable-stream" ];

     

       18106
       18418
        
         };

     

       18107
       18107
       -
         by-spec."readable-stream"."1.1" =

     

       18108
       18108
       -
           self.by-version."readable-stream"."1.1.13";

     

       18109
       18109
       -
         by-spec."readable-stream".">=1.0.28 <1.1.0-0" =

     

       18110
       18110
       -
           self.by-version."readable-stream"."1.0.32";

     

       18111
       18419
        
         by-spec."readable-stream".">=1.1.13-1 <1.2.0-0" =

     

       18112
       18420
        
           self.by-version."readable-stream"."1.1.13";

     

       18113
       18421
        
         by-spec."readable-stream"."^1.0.27-1" =

     
···

       18115
       18423
        
         by-spec."readable-stream"."^1.1.13-1" =

     

       18116
       18424
        
           self.by-version."readable-stream"."1.1.13";

     

       18117
       18425
        
         by-spec."readable-stream"."~1.0.17" =

     

       18118
       18118
       -
           self.by-version."readable-stream"."1.0.32";

     

       18426
       18426
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18119
       18427
        
         by-spec."readable-stream"."~1.0.2" =

     

       18120
       18120
       -
           self.by-version."readable-stream"."1.0.32";

     

       18428
       18428
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18121
       18429
        
         by-spec."readable-stream"."~1.0.24" =

     

       18122
       18122
       -
           self.by-version."readable-stream"."1.0.32";

     

       18430
       18430
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18123
       18431
        
         by-spec."readable-stream"."~1.0.26" =

     

       18124
       18124
       -
           self.by-version."readable-stream"."1.0.32";

     

       18432
       18432
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18433
       18433
       +
         by-spec."readable-stream"."~1.0.26-2" =

     

       18434
       18434
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18125
       18435
        
         by-spec."readable-stream"."~1.0.32" =

     

       18126
       18126
       -
           self.by-version."readable-stream"."1.0.32";

     

       18436
       18436
       +
           self.by-version."readable-stream"."1.0.33-1";

     

       18437
       18437
       +
         by-spec."readable-stream"."~1.1" =

     

       18438
       18438
       +
           self.by-version."readable-stream"."1.1.13";

     

       18127
       18439
        
         by-spec."readable-stream"."~1.1.8" =

     

       18128
       18440
        
           self.by-version."readable-stream"."1.1.13";

     

       18129
       18441
        
         by-spec."readable-stream"."~1.1.9" =

     
···

       18193
       18505
        
           ];

     

       18194
       18506
        
           passthru.names = [ "readdirp" ];

     

       18195
       18507
        
         };

     

       18508
       18508
       +
         by-spec."readdirp"."~1.1.0" =

     

       18509
       18509
       +
           self.by-version."readdirp"."1.1.0";

     

       18510
       18510
       +
         by-version."readdirp"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     

       18511
       18511
       +
           name = "readdirp-1.1.0";

     

       18512
       18512
       +
           bin = false;

     

       18513
       18513
       +
           src = [

     

       18514
       18514
       +
             (fetchurl {

     

       18515
       18515
       +
               url = "http://registry.npmjs.org/readdirp/-/readdirp-1.1.0.tgz";

     

       18516
       18516
       +
               name = "readdirp-1.1.0.tgz";

     

       18517
       18517
       +
               sha1 = "6506f9d5d8bb2edc19c855a60bb92feca5fae39c";

     

       18518
       18518
       +
             })

     

       18519
       18519
       +
           ];

     

       18520
       18520
       +
           buildInputs =

     

       18521
       18521
       +
             (self.nativeDeps."readdirp" or []);

     

       18522
       18522
       +
           deps = {

     

       18523
       18523
       +
             "graceful-fs-2.0.3" = self.by-version."graceful-fs"."2.0.3";

     

       18524
       18524
       +
             "minimatch-0.2.14" = self.by-version."minimatch"."0.2.14";

     

       18525
       18525
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       18526
       18526
       +
           };

     

       18527
       18527
       +
           peerDependencies = [

     

       18528
       18528
       +
           ];

     

       18529
       18529
       +
           passthru.names = [ "readdirp" ];

     

       18530
       18530
       +
         };

     

       18196
       18531
        
         by-spec."readline2"."~0.1.0" =

     

       18197
       18532
        
           self.by-version."readline2"."0.1.0";

     

       18198
       18533
        
         by-version."readline2"."0.1.0" = lib.makeOverridable self.buildNodePackage {

     
···

       18216
       18551
        
           ];

     

       18217
       18552
        
           passthru.names = [ "readline2" ];

     

       18218
       18553
        
         };

     

       18219
       18219
       -
         by-spec."realize-package-specifier"."~1.1.0" =

     

       18220
       18220
       -
           self.by-version."realize-package-specifier"."1.1.0";

     

       18221
       18221
       -
         by-version."realize-package-specifier"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     

       18222
       18222
       -
           name = "realize-package-specifier-1.1.0";

     

       18554
       18554
       +
         by-spec."realize-package-specifier"."~1.2.0" =

     

       18555
       18555
       +
           self.by-version."realize-package-specifier"."1.2.0";

     

       18556
       18556
       +
         by-version."realize-package-specifier"."1.2.0" = lib.makeOverridable self.buildNodePackage {

     

       18557
       18557
       +
           name = "realize-package-specifier-1.2.0";

     

       18223
       18558
        
           bin = false;

     

       18224
       18559
        
           src = [

     

       18225
       18560
        
             (fetchurl {

     

       18226
       18226
       -
               url = "http://registry.npmjs.org/realize-package-specifier/-/realize-package-specifier-1.1.0.tgz";

     

       18227
       18227
       -
               name = "realize-package-specifier-1.1.0.tgz";

     

       18228
       18228
       -
               sha1 = "b6922638b7224186ae9278bdebbb63cba23a0160";

     

       18561
       18561
       +
               url = "http://registry.npmjs.org/realize-package-specifier/-/realize-package-specifier-1.2.0.tgz";

     

       18562
       18562
       +
               name = "realize-package-specifier-1.2.0.tgz";

     

       18563
       18563
       +
               sha1 = "93364e40dee38369f92e9b0c76124500342132f2";

     

       18229
       18564
        
             })

     

       18230
       18565
        
           ];

     

       18231
       18566
        
           buildInputs =

     
···

       18238
       18573
        
           ];

     

       18239
       18574
        
           passthru.names = [ "realize-package-specifier" ];

     

       18240
       18575
        
         };

     

       18241
       18241
       -
         by-spec."recursive-readdir"."0.0.2" =

     

       18242
       18242
       -
           self.by-version."recursive-readdir"."0.0.2";

     

       18243
       18243
       -
         by-version."recursive-readdir"."0.0.2" = lib.makeOverridable self.buildNodePackage {

     

       18244
       18244
       -
           name = "recursive-readdir-0.0.2";

     

       18245
       18245
       -
           bin = false;

     

       18246
       18246
       -
           src = [

     

       18247
       18247
       -
             (fetchurl {

     

       18248
       18248
       -
               url = "http://registry.npmjs.org/recursive-readdir/-/recursive-readdir-0.0.2.tgz";

     

       18249
       18249
       -
               name = "recursive-readdir-0.0.2.tgz";

     

       18250
       18250
       -
               sha1 = "0bc47dc4838e646dccfba0507b5e57ffbff35f7c";

     

       18251
       18251
       -
             })

     

       18252
       18252
       -
           ];

     

       18253
       18253
       -
           buildInputs =

     

       18254
       18254
       -
             (self.nativeDeps."recursive-readdir" or []);

     

       18255
       18255
       -
           deps = {

     

       18256
       18256
       -
           };

     

       18257
       18257
       -
           peerDependencies = [

     

       18258
       18258
       -
           ];

     

       18259
       18259
       -
           passthru.names = [ "recursive-readdir" ];

     

       18260
       18260
       -
         };

     

       18261
       18576
        
         by-spec."redeyed"."~0.4.0" =

     

       18262
       18577
        
           self.by-version."redeyed"."0.4.4";

     

       18263
       18578
        
         by-version."redeyed"."0.4.4" = lib.makeOverridable self.buildNodePackage {

     
···

       18440
       18755
        
           buildInputs =

     

       18441
       18756
        
             (self.nativeDeps."registry-url" or []);

     

       18442
       18757
        
           deps = {

     

       18443
       18443
       -
             "npmconf-2.1.0" = self.by-version."npmconf"."2.1.0";

     

       18758
       18758
       +
             "npmconf-2.1.1" = self.by-version."npmconf"."2.1.1";

     

       18444
       18759
        
           };

     

       18445
       18760
        
           peerDependencies = [

     

       18446
       18761
        
           ];

     
···

       18669
       18984
        
           self.by-version."request"."2.40.0";

     

       18670
       18985
        
         by-spec."request"."~2.42.0" =

     

       18671
       18986
        
           self.by-version."request"."2.42.0";

     

       18672
       18672
       -
         by-spec."request"."~2.44.0" =

     

       18673
       18673
       -
           self.by-version."request"."2.44.0";

     

       18674
       18674
       -
         by-version."request"."2.44.0" = lib.makeOverridable self.buildNodePackage {

     

       18675
       18675
       -
           name = "request-2.44.0";

     

       18676
       18676
       -
           bin = false;

     

       18677
       18677
       -
           src = [

     

       18678
       18678
       -
             (fetchurl {

     

       18679
       18679
       -
               url = "http://registry.npmjs.org/request/-/request-2.44.0.tgz";

     

       18680
       18680
       -
               name = "request-2.44.0.tgz";

     

       18681
       18681
       -
               sha1 = "78d62454d68853cadfb07ad31f58b9ec98072ea8";

     

       18682
       18682
       -
             })

     

       18683
       18683
       -
           ];

     

       18684
       18684
       -
           buildInputs =

     

       18685
       18685
       -
             (self.nativeDeps."request" or []);

     

       18686
       18686
       -
           deps = {

     

       18687
       18687
       -
             "bl-0.9.3" = self.by-version."bl"."0.9.3";

     

       18688
       18688
       -
             "caseless-0.6.0" = self.by-version."caseless"."0.6.0";

     

       18689
       18689
       -
             "forever-agent-0.5.2" = self.by-version."forever-agent"."0.5.2";

     

       18690
       18690
       -
             "qs-1.2.2" = self.by-version."qs"."1.2.2";

     

       18691
       18691
       -
             "json-stringify-safe-5.0.0" = self.by-version."json-stringify-safe"."5.0.0";

     

       18692
       18692
       -
             "mime-types-1.0.2" = self.by-version."mime-types"."1.0.2";

     

       18693
       18693
       -
             "node-uuid-1.4.1" = self.by-version."node-uuid"."1.4.1";

     

       18694
       18694
       -
             "tunnel-agent-0.4.0" = self.by-version."tunnel-agent"."0.4.0";

     

       18695
       18695
       -
             "tough-cookie-0.12.1" = self.by-version."tough-cookie"."0.12.1";

     

       18696
       18696
       -
             "form-data-0.1.4" = self.by-version."form-data"."0.1.4";

     

       18697
       18697
       -
             "http-signature-0.10.0" = self.by-version."http-signature"."0.10.0";

     

       18698
       18698
       -
             "oauth-sign-0.4.0" = self.by-version."oauth-sign"."0.4.0";

     

       18699
       18699
       -
             "hawk-1.1.1" = self.by-version."hawk"."1.1.1";

     

       18700
       18700
       -
             "aws-sign2-0.5.0" = self.by-version."aws-sign2"."0.5.0";

     

       18701
       18701
       -
             "stringstream-0.0.4" = self.by-version."stringstream"."0.0.4";

     

       18702
       18702
       -
           };

     

       18703
       18703
       -
           peerDependencies = [

     

       18704
       18704
       -
           ];

     

       18705
       18705
       -
           passthru.names = [ "request" ];

     

       18706
       18706
       -
         };

     

       18987
       18987
       +
         by-spec."request"."~2.45.0" =

     

       18988
       18988
       +
           self.by-version."request"."2.45.0";

     

       18707
       18989
        
         by-spec."request-progress"."0.3.0" =

     

       18708
       18990
        
           self.by-version."request-progress"."0.3.0";

     

       18709
       18991
        
         by-version."request-progress"."0.3.0" = lib.makeOverridable self.buildNodePackage {

     
···

       18833
       19115
        
         };

     

       18834
       19116
        
         by-spec."resolve"."~0.3.1" =

     

       18835
       19117
        
           self.by-version."resolve"."0.3.1";

     

       18836
       18836
       -
         by-spec."resolve"."~0.7.0" =

     

       18837
       18837
       -
           self.by-version."resolve"."0.7.4";

     

       18838
       19118
        
         by-spec."resolve"."~0.7.1" =

     

       18839
       19119
        
           self.by-version."resolve"."0.7.4";

     

       18840
       19120
        
         by-spec."resolve"."~0.7.2" =

     

       18841
       19121
        
           self.by-version."resolve"."0.7.4";

     

       18842
       18842
       -
         by-spec."response-time"."~2.0.1" =

     

       18843
       18843
       -
           self.by-version."response-time"."2.0.1";

     

       18844
       18844
       -
         by-version."response-time"."2.0.1" = lib.makeOverridable self.buildNodePackage {

     

       18845
       18845
       -
           name = "response-time-2.0.1";

     

       19122
       19122
       +
         by-spec."resolve"."~1.0.0" =

     

       19123
       19123
       +
           self.by-version."resolve"."1.0.0";

     

       19124
       19124
       +
         by-version."resolve"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     

       19125
       19125
       +
           name = "resolve-1.0.0";

     

       18846
       19126
        
           bin = false;

     

       18847
       19127
        
           src = [

     

       18848
       19128
        
             (fetchurl {

     

       18849
       18849
       -
               url = "http://registry.npmjs.org/response-time/-/response-time-2.0.1.tgz";

     

       18850
       18850
       -
               name = "response-time-2.0.1.tgz";

     

       18851
       18851
       -
               sha1 = "c6d2cbadeac4cb251b21016fe182640c02aff343";

     

       19129
       19129
       +
               url = "http://registry.npmjs.org/resolve/-/resolve-1.0.0.tgz";

     

       19130
       19130
       +
               name = "resolve-1.0.0.tgz";

     

       19131
       19131
       +
               sha1 = "2a6e3b314dcd57c6519e8e2282af8687e8de61c6";

     

       19132
       19132
       +
             })

     

       19133
       19133
       +
           ];

     

       19134
       19134
       +
           buildInputs =

     

       19135
       19135
       +
             (self.nativeDeps."resolve" or []);

     

       19136
       19136
       +
           deps = {

     

       19137
       19137
       +
           };

     

       19138
       19138
       +
           peerDependencies = [

     

       19139
       19139
       +
           ];

     

       19140
       19140
       +
           passthru.names = [ "resolve" ];

     

       19141
       19141
       +
         };

     

       19142
       19142
       +
         by-spec."response-time"."~2.2.0" =

     

       19143
       19143
       +
           self.by-version."response-time"."2.2.0";

     

       19144
       19144
       +
         by-version."response-time"."2.2.0" = lib.makeOverridable self.buildNodePackage {

     

       19145
       19145
       +
           name = "response-time-2.2.0";

     

       19146
       19146
       +
           bin = false;

     

       19147
       19147
       +
           src = [

     

       19148
       19148
       +
             (fetchurl {

     

       19149
       19149
       +
               url = "http://registry.npmjs.org/response-time/-/response-time-2.2.0.tgz";

     

       19150
       19150
       +
               name = "response-time-2.2.0.tgz";

     

       19151
       19151
       +
               sha1 = "77ab4688cbf030e9c5f82dc1eac7fe5226d3c8eb";

     

       18852
       19152
        
             })

     

       18853
       19153
        
           ];

     

       18854
       19154
        
           buildInputs =

     

       18855
       19155
        
             (self.nativeDeps."response-time" or []);

     

       18856
       19156
        
           deps = {

     

       19157
       19157
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       18857
       19158
        
             "on-headers-1.0.0" = self.by-version."on-headers"."1.0.0";

     

       18858
       19159
        
           };

     

       18859
       19160
        
           peerDependencies = [

     
···

       18912
       19213
        
           buildInputs =

     

       18913
       19214
        
             (self.nativeDeps."rethinkdb" or []);

     

       18914
       19215
        
           deps = {

     

       18915
       18915
       -
             "bluebird-2.3.5" = self.by-version."bluebird"."2.3.5";

     

       19216
       19216
       +
             "bluebird-2.3.6" = self.by-version."bluebird"."2.3.6";

     

       18916
       19217
        
           };

     

       18917
       19218
        
           peerDependencies = [

     

       18918
       19219
        
           ];

     
···

       18939
       19240
        
           ];

     

       18940
       19241
        
           passthru.names = [ "retry" ];

     

       18941
       19242
        
         };

     

       18942
       18942
       -
         by-spec."retry"."~0.6.0" =

     

       19243
       19243
       +
         by-spec."retry"."^0.6.1" =

     

       18943
       19244
        
           self.by-version."retry"."0.6.1";

     

       18944
       19245
        
         by-version."retry"."0.6.1" = lib.makeOverridable self.buildNodePackage {

     

       18945
       19246
        
           name = "retry-0.6.1";

     
···

       18959
       19260
        
           ];

     

       18960
       19261
        
           passthru.names = [ "retry" ];

     

       18961
       19262
        
         };

     

       19263
       19263
       +
         by-spec."retry"."~0.6.0" =

     

       19264
       19264
       +
           self.by-version."retry"."0.6.1";

     

       19265
       19265
       +
         by-spec."retry"."~0.6.1" =

     

       19266
       19266
       +
           self.by-version."retry"."0.6.1";

     

       18962
       19267
        
         by-spec."revalidator"."0.1.x" =

     

       18963
       19268
        
           self.by-version."revalidator"."0.1.8";

     

       18964
       19269
        
         by-version."revalidator"."0.1.8" = lib.makeOverridable self.buildNodePackage {

     
···

       19092
       19397
        
         };

     

       19093
       19398
        
         by-spec."rimraf"."~2.2.0" =

     

       19094
       19399
        
           self.by-version."rimraf"."2.2.8";

     

       19095
       19095
       -
         by-spec."rimraf"."~2.2.2" =

     

       19096
       19096
       -
           self.by-version."rimraf"."2.2.8";

     

       19097
       19400
        
         by-spec."rimraf"."~2.2.5" =

     

       19098
       19401
        
           self.by-version."rimraf"."2.2.8";

     

       19099
       19402
        
         by-spec."rimraf"."~2.2.6" =

     
···

       19163
       19466
        
           passthru.names = [ "ruglify" ];

     

       19164
       19467
        
         };

     

       19165
       19468
        
         by-spec."rx"."^2.2.27" =

     

       19166
       19166
       -
           self.by-version."rx"."2.3.12";

     

       19167
       19167
       -
         by-version."rx"."2.3.12" = lib.makeOverridable self.buildNodePackage {

     

       19168
       19168
       -
           name = "rx-2.3.12";

     

       19469
       19469
       +
           self.by-version."rx"."2.3.13";

     

       19470
       19470
       +
         by-version."rx"."2.3.13" = lib.makeOverridable self.buildNodePackage {

     

       19471
       19471
       +
           name = "rx-2.3.13";

     

       19169
       19472
        
           bin = false;

     

       19170
       19473
        
           src = [

     

       19171
       19474
        
             (fetchurl {

     

       19172
       19172
       -
               url = "http://registry.npmjs.org/rx/-/rx-2.3.12.tgz";

     

       19173
       19173
       -
               name = "rx-2.3.12.tgz";

     

       19174
       19174
       -
               sha1 = "9bdc2c8e12cb0a62e528947de458277849f0c2f4";

     

       19475
       19475
       +
               url = "http://registry.npmjs.org/rx/-/rx-2.3.13.tgz";

     

       19476
       19476
       +
               name = "rx-2.3.13.tgz";

     

       19477
       19477
       +
               sha1 = "8a42c6079e4bf7a712c17780ed17c408633a6cbc";

     

       19175
       19478
        
             })

     

       19176
       19479
        
           ];

     

       19177
       19480
        
           buildInputs =

     
···

       19316
       19619
        
           passthru.names = [ "sax" ];

     

       19317
       19620
        
         };

     

       19318
       19621
        
         by-spec."sax"."0.6.x" =

     

       19319
       19319
       -
           self.by-version."sax"."0.6.0";

     

       19320
       19320
       -
         by-version."sax"."0.6.0" = lib.makeOverridable self.buildNodePackage {

     

       19321
       19321
       -
           name = "sax-0.6.0";

     

       19622
       19622
       +
           self.by-version."sax"."0.6.1";

     

       19623
       19623
       +
         by-version."sax"."0.6.1" = lib.makeOverridable self.buildNodePackage {

     

       19624
       19624
       +
           name = "sax-0.6.1";

     

       19322
       19625
        
           bin = false;

     

       19323
       19626
        
           src = [

     

       19324
       19627
        
             (fetchurl {

     

       19325
       19325
       -
               url = "http://registry.npmjs.org/sax/-/sax-0.6.0.tgz";

     

       19326
       19326
       -
               name = "sax-0.6.0.tgz";

     

       19327
       19327
       -
               sha1 = "7a155519b712e3ec56f102ab984f15e15d3859f0";

     

       19628
       19628
       +
               url = "http://registry.npmjs.org/sax/-/sax-0.6.1.tgz";

     

       19629
       19629
       +
               name = "sax-0.6.1.tgz";

     

       19630
       19630
       +
               sha1 = "563b19c7c1de892e09bfc4f2fc30e3c27f0952b9";

     

       19328
       19631
        
             })

     

       19329
       19632
        
           ];

     

       19330
       19633
        
           buildInputs =

     
···

       19336
       19639
        
           passthru.names = [ "sax" ];

     

       19337
       19640
        
         };

     

       19338
       19641
        
         by-spec."sax".">=0.4.2" =

     

       19339
       19339
       -
           self.by-version."sax"."0.6.0";

     

       19642
       19642
       +
           self.by-version."sax"."0.6.1";

     

       19340
       19643
        
         by-spec."scmp"."0.0.3" =

     

       19341
       19644
        
           self.by-version."scmp"."0.0.3";

     

       19342
       19645
        
         by-version."scmp"."0.0.3" = lib.makeOverridable self.buildNodePackage {

     
···

       19382
       19685
        
         };

     

       19383
       19686
        
         "selenium-webdriver" = self.by-version."selenium-webdriver"."2.43.5";

     

       19384
       19687
        
         by-spec."semver"."*" =

     

       19385
       19385
       -
           self.by-version."semver"."4.0.3";

     

       19386
       19386
       -
         by-version."semver"."4.0.3" = lib.makeOverridable self.buildNodePackage {

     

       19387
       19387
       -
           name = "semver-4.0.3";

     

       19688
       19688
       +
           self.by-version."semver"."4.1.0";

     

       19689
       19689
       +
         by-version."semver"."4.1.0" = lib.makeOverridable self.buildNodePackage {

     

       19690
       19690
       +
           name = "semver-4.1.0";

     

       19388
       19691
        
           bin = true;

     

       19389
       19692
        
           src = [

     

       19390
       19693
        
             (fetchurl {

     

       19391
       19391
       -
               url = "http://registry.npmjs.org/semver/-/semver-4.0.3.tgz";

     

       19392
       19392
       -
               name = "semver-4.0.3.tgz";

     

       19393
       19393
       -
               sha1 = "f79c9ba670efccc029d98a5017def64b0ce1644e";

     

       19694
       19694
       +
               url = "http://registry.npmjs.org/semver/-/semver-4.1.0.tgz";

     

       19695
       19695
       +
               name = "semver-4.1.0.tgz";

     

       19696
       19696
       +
               sha1 = "bc80a9ff68532814362cc3cfda3c7b75ed9c321c";

     

       19394
       19697
        
             })

     

       19395
       19698
        
           ];

     

       19396
       19699
        
           buildInputs =

     
···

       19401
       19704
        
           ];

     

       19402
       19705
        
           passthru.names = [ "semver" ];

     

       19403
       19706
        
         };

     

       19404
       19404
       -
         "semver" = self.by-version."semver"."4.0.3";

     

       19707
       19707
       +
         "semver" = self.by-version."semver"."4.1.0";

     

       19405
       19708
        
         by-spec."semver"."1.1.0" =

     

       19406
       19709
        
           self.by-version."semver"."1.1.0";

     

       19407
       19710
        
         by-version."semver"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     
···

       19463
       19766
        
           passthru.names = [ "semver" ];

     

       19464
       19767
        
         };

     

       19465
       19768
        
         by-spec."semver"."2 >=2.2.1 || 3.x || 4" =

     

       19466
       19466
       -
           self.by-version."semver"."4.0.3";

     

       19769
       19769
       +
           self.by-version."semver"."4.1.0";

     

       19467
       19770
        
         by-spec."semver"."2 || 3 || 4" =

     

       19468
       19468
       -
           self.by-version."semver"."4.0.3";

     

       19771
       19771
       +
           self.by-version."semver"."4.1.0";

     

       19469
       19772
        
         by-spec."semver"."2.x" =

     

       19470
       19773
        
           self.by-version."semver"."2.3.2";

     

       19471
       19774
        
         by-spec."semver"."2.x || 3.x || 4" =

     

       19472
       19472
       -
           self.by-version."semver"."4.0.3";

     

       19775
       19775
       +
           self.by-version."semver"."4.1.0";

     

       19473
       19776
        
         by-spec."semver"."4" =

     

       19474
       19474
       -
           self.by-version."semver"."4.0.3";

     

       19777
       19777
       +
           self.by-version."semver"."4.1.0";

     

       19475
       19778
        
         by-spec."semver".">=2.0.10 <3.0.0" =

     

       19476
       19779
        
           self.by-version."semver"."2.3.2";

     

       19477
       19780
        
         by-spec."semver".">=2.2.1 <3" =

     
···

       19481
       19784
        
         by-spec."semver"."^2.3.0" =

     

       19482
       19785
        
           self.by-version."semver"."2.3.2";

     

       19483
       19786
        
         by-spec."semver"."^2.3.0 || 3.x || 4" =

     

       19484
       19484
       -
           self.by-version."semver"."4.0.3";

     

       19787
       19787
       +
           self.by-version."semver"."4.1.0";

     

       19485
       19788
        
         by-spec."semver"."^3.0.1" =

     

       19486
       19789
        
           self.by-version."semver"."3.0.1";

     

       19487
       19790
        
         by-version."semver"."3.0.1" = lib.makeOverridable self.buildNodePackage {

     
···

       19568
       19871
        
           self.by-version."semver"."2.3.2";

     

       19569
       19872
        
         by-spec."semver"."~3.0.1" =

     

       19570
       19873
        
           self.by-version."semver"."3.0.1";

     

       19571
       19571
       -
         by-spec."semver"."~4.0.0" =

     

       19572
       19572
       -
           self.by-version."semver"."4.0.3";

     

       19874
       19874
       +
         by-spec."semver"."~4.1.0" =

     

       19875
       19875
       +
           self.by-version."semver"."4.1.0";

     

       19573
       19876
        
         by-spec."semver-diff"."^0.1.0" =

     

       19574
       19877
        
           self.by-version."semver-diff"."0.1.0";

     

       19575
       19878
        
         by-version."semver-diff"."0.1.0" = lib.makeOverridable self.buildNodePackage {

     
···

       19592
       19895
        
           passthru.names = [ "semver-diff" ];

     

       19593
       19896
        
         };

     

       19594
       19897
        
         by-spec."send"."*" =

     

       19595
       19595
       -
           self.by-version."send"."0.9.3";

     

       19596
       19596
       -
         by-version."send"."0.9.3" = lib.makeOverridable self.buildNodePackage {

     

       19597
       19597
       -
           name = "send-0.9.3";

     

       19898
       19898
       +
           self.by-version."send"."0.10.0";

     

       19899
       19899
       +
         by-version."send"."0.10.0" = lib.makeOverridable self.buildNodePackage {

     

       19900
       19900
       +
           name = "send-0.10.0";

     

       19598
       19901
        
           bin = false;

     

       19599
       19902
        
           src = [

     

       19600
       19903
        
             (fetchurl {

     

       19601
       19601
       -
               url = "http://registry.npmjs.org/send/-/send-0.9.3.tgz";

     

       19602
       19602
       -
               name = "send-0.9.3.tgz";

     

       19603
       19603
       -
               sha1 = "b43a7414cd089b7fbec9b755246f7c37b7b85cc0";

     

       19904
       19904
       +
               url = "http://registry.npmjs.org/send/-/send-0.10.0.tgz";

     

       19905
       19905
       +
               name = "send-0.10.0.tgz";

     

       19906
       19906
       +
               sha1 = "2f984b703934c628b72b72d70557b75ca906ea6c";

     

       19604
       19907
        
             })

     

       19605
       19908
        
           ];

     

       19606
       19909
        
           buildInputs =

     

       19607
       19910
        
             (self.nativeDeps."send" or []);

     

       19608
       19911
        
           deps = {

     

       19609
       19609
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       19610
       19610
       -
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       19912
       19912
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       19913
       19913
       +
             "depd-1.0.0" = self.by-version."depd"."1.0.0";

     

       19611
       19914
        
             "destroy-1.0.3" = self.by-version."destroy"."1.0.3";

     

       19612
       19915
        
             "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";

     

       19613
       19613
       -
             "etag-1.4.0" = self.by-version."etag"."1.4.0";

     

       19916
       19916
       +
             "etag-1.5.0" = self.by-version."etag"."1.5.0";

     

       19614
       19917
        
             "fresh-0.2.4" = self.by-version."fresh"."0.2.4";

     

       19615
       19918
        
             "mime-1.2.11" = self.by-version."mime"."1.2.11";

     

       19616
       19919
        
             "ms-0.6.2" = self.by-version."ms"."0.6.2";

     
···

       19636
       19939
        
           buildInputs =

     

       19637
       19940
        
             (self.nativeDeps."send" or []);

     

       19638
       19941
        
           deps = {

     

       19639
       19639
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       19942
       19942
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       19640
       19943
        
             "mime-1.2.6" = self.by-version."mime"."1.2.6";

     

       19641
       19944
        
             "fresh-0.1.0" = self.by-version."fresh"."0.1.0";

     

       19642
       19945
        
             "range-parser-0.0.4" = self.by-version."range-parser"."0.0.4";

     
···

       19660
       19963
        
           buildInputs =

     

       19661
       19964
        
             (self.nativeDeps."send" or []);

     

       19662
       19965
        
           deps = {

     

       19663
       19663
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       19966
       19966
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       19664
       19967
        
             "mime-1.2.6" = self.by-version."mime"."1.2.6";

     

       19665
       19968
        
             "fresh-0.1.0" = self.by-version."fresh"."0.1.0";

     

       19666
       19969
        
             "range-parser-0.0.4" = self.by-version."range-parser"."0.0.4";

     
···

       19684
       19987
        
           buildInputs =

     

       19685
       19988
        
             (self.nativeDeps."send" or []);

     

       19686
       19989
        
           deps = {

     

       19687
       19687
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       19990
       19990
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       19688
       19991
        
             "mime-1.2.11" = self.by-version."mime"."1.2.11";

     

       19689
       19992
        
             "fresh-0.2.0" = self.by-version."fresh"."0.2.0";

     

       19690
       19993
        
             "range-parser-0.0.4" = self.by-version."range-parser"."0.0.4";

     
···

       19693
       19996
        
           ];

     

       19694
       19997
        
           passthru.names = [ "send" ];

     

       19695
       19998
        
         };

     

       19999
       19999
       +
         by-spec."send"."0.10.0" =

     

       20000
       20000
       +
           self.by-version."send"."0.10.0";

     

       19696
       20001
        
         by-spec."send"."0.2.0" =

     

       19697
       20002
        
           self.by-version."send"."0.2.0";

     

       19698
       20003
        
         by-version."send"."0.2.0" = lib.makeOverridable self.buildNodePackage {

     
···

       19708
       20013
        
           buildInputs =

     

       19709
       20014
        
             (self.nativeDeps."send" or []);

     

       19710
       20015
        
           deps = {

     

       19711
       19711
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       20016
       20016
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       19712
       20017
        
             "mime-1.2.11" = self.by-version."mime"."1.2.11";

     

       19713
       20018
        
             "fresh-0.2.4" = self.by-version."fresh"."0.2.4";

     

       19714
       20019
        
             "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";

     
···

       19748
       20053
        
         };

     

       19749
       20054
        
         by-spec."send"."0.9.3" =

     

       19750
       20055
        
           self.by-version."send"."0.9.3";

     

       20056
       20056
       +
         by-version."send"."0.9.3" = lib.makeOverridable self.buildNodePackage {

     

       20057
       20057
       +
           name = "send-0.9.3";

     

       20058
       20058
       +
           bin = false;

     

       20059
       20059
       +
           src = [

     

       20060
       20060
       +
             (fetchurl {

     

       20061
       20061
       +
               url = "http://registry.npmjs.org/send/-/send-0.9.3.tgz";

     

       20062
       20062
       +
               name = "send-0.9.3.tgz";

     

       20063
       20063
       +
               sha1 = "b43a7414cd089b7fbec9b755246f7c37b7b85cc0";

     

       20064
       20064
       +
             })

     

       20065
       20065
       +
           ];

     

       20066
       20066
       +
           buildInputs =

     

       20067
       20067
       +
             (self.nativeDeps."send" or []);

     

       20068
       20068
       +
           deps = {

     

       20069
       20069
       +
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       20070
       20070
       +
             "depd-0.4.5" = self.by-version."depd"."0.4.5";

     

       20071
       20071
       +
             "destroy-1.0.3" = self.by-version."destroy"."1.0.3";

     

       20072
       20072
       +
             "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";

     

       20073
       20073
       +
             "etag-1.4.0" = self.by-version."etag"."1.4.0";

     

       20074
       20074
       +
             "fresh-0.2.4" = self.by-version."fresh"."0.2.4";

     

       20075
       20075
       +
             "mime-1.2.11" = self.by-version."mime"."1.2.11";

     

       20076
       20076
       +
             "ms-0.6.2" = self.by-version."ms"."0.6.2";

     

       20077
       20077
       +
             "on-finished-2.1.0" = self.by-version."on-finished"."2.1.0";

     

       20078
       20078
       +
             "range-parser-1.0.2" = self.by-version."range-parser"."1.0.2";

     

       20079
       20079
       +
           };

     

       20080
       20080
       +
           peerDependencies = [

     

       20081
       20081
       +
           ];

     

       20082
       20082
       +
           passthru.names = [ "send" ];

     

       20083
       20083
       +
         };

     

       19751
       20084
        
         by-spec."sequence"."2.2.1" =

     

       19752
       20085
        
           self.by-version."sequence"."2.2.1";

     

       19753
       20086
        
         by-version."sequence"."2.2.1" = lib.makeOverridable self.buildNodePackage {

     
···

       19790
       20123
        
           ];

     

       19791
       20124
        
           passthru.names = [ "sequencify" ];

     

       19792
       20125
        
         };

     

       19793
       19793
       -
         by-spec."serve-favicon"."~2.1.5" =

     

       19794
       19794
       -
           self.by-version."serve-favicon"."2.1.5";

     

       19795
       19795
       -
         by-version."serve-favicon"."2.1.5" = lib.makeOverridable self.buildNodePackage {

     

       19796
       19796
       -
           name = "serve-favicon-2.1.5";

     

       20126
       20126
       +
         by-spec."serve-favicon"."~2.1.6" =

     

       20127
       20127
       +
           self.by-version."serve-favicon"."2.1.6";

     

       20128
       20128
       +
         by-version."serve-favicon"."2.1.6" = lib.makeOverridable self.buildNodePackage {

     

       20129
       20129
       +
           name = "serve-favicon-2.1.6";

     

       19797
       20130
        
           bin = false;

     

       19798
       20131
        
           src = [

     

       19799
       20132
        
             (fetchurl {

     

       19800
       19800
       -
               url = "http://registry.npmjs.org/serve-favicon/-/serve-favicon-2.1.5.tgz";

     

       19801
       19801
       -
               name = "serve-favicon-2.1.5.tgz";

     

       19802
       19802
       -
               sha1 = "8eba1830890bddbbf042e8d5c6456c7d004f6175";

     

       20133
       20133
       +
               url = "http://registry.npmjs.org/serve-favicon/-/serve-favicon-2.1.6.tgz";

     

       20134
       20134
       +
               name = "serve-favicon-2.1.6.tgz";

     

       20135
       20135
       +
               sha1 = "46326a9eb64a0fa5cf012a4f85efe9fda95820e5";

     

       19803
       20136
        
             })

     

       19804
       20137
        
           ];

     

       19805
       20138
        
           buildInputs =

     

       19806
       20139
        
             (self.nativeDeps."serve-favicon" or []);

     

       19807
       20140
        
           deps = {

     

       19808
       19808
       -
             "etag-1.4.0" = self.by-version."etag"."1.4.0";

     

       20141
       20141
       +
             "etag-1.5.0" = self.by-version."etag"."1.5.0";

     

       19809
       20142
        
             "fresh-0.2.4" = self.by-version."fresh"."0.2.4";

     

       19810
       20143
        
             "ms-0.6.2" = self.by-version."ms"."0.6.2";

     

       19811
       20144
        
           };

     
···

       19813
       20146
        
           ];

     

       19814
       20147
        
           passthru.names = [ "serve-favicon" ];

     

       19815
       20148
        
         };

     

       19816
       19816
       -
         by-spec."serve-index"."~1.2.1" =

     

       19817
       19817
       -
           self.by-version."serve-index"."1.2.1";

     

       19818
       19818
       -
         by-version."serve-index"."1.2.1" = lib.makeOverridable self.buildNodePackage {

     

       19819
       19819
       -
           name = "serve-index-1.2.1";

     

       20149
       20149
       +
         by-spec."serve-index"."~1.5.0" =

     

       20150
       20150
       +
           self.by-version."serve-index"."1.5.0";

     

       20151
       20151
       +
         by-version."serve-index"."1.5.0" = lib.makeOverridable self.buildNodePackage {

     

       20152
       20152
       +
           name = "serve-index-1.5.0";

     

       19820
       20153
        
           bin = false;

     

       19821
       20154
        
           src = [

     

       19822
       20155
        
             (fetchurl {

     

       19823
       19823
       -
               url = "http://registry.npmjs.org/serve-index/-/serve-index-1.2.1.tgz";

     

       19824
       19824
       -
               name = "serve-index-1.2.1.tgz";

     

       19825
       19825
       -
               sha1 = "854daef00ac9ff2f5bfda1c019b78fb0ed6d2e6f";

     

       20156
       20156
       +
               url = "http://registry.npmjs.org/serve-index/-/serve-index-1.5.0.tgz";

     

       20157
       20157
       +
               name = "serve-index-1.5.0.tgz";

     

       20158
       20158
       +
               sha1 = "066a35ff1564146cceb2105014a5b070af68707e";

     

       19826
       20159
        
             })

     

       19827
       20160
        
           ];

     

       19828
       20161
        
           buildInputs =

     

       19829
       20162
        
             (self.nativeDeps."serve-index" or []);

     

       19830
       20163
        
           deps = {

     

       19831
       19831
       -
             "accepts-1.1.1" = self.by-version."accepts"."1.1.1";

     

       20164
       20164
       +
             "accepts-1.1.2" = self.by-version."accepts"."1.1.2";

     

       19832
       20165
        
             "batch-0.5.1" = self.by-version."batch"."0.5.1";

     

       19833
       19833
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       20166
       20166
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       20167
       20167
       +
             "http-errors-1.2.7" = self.by-version."http-errors"."1.2.7";

     

       20168
       20168
       +
             "mime-types-2.0.2" = self.by-version."mime-types"."2.0.2";

     

       19834
       20169
        
             "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";

     

       19835
       20170
        
           };

     

       19836
       20171
        
           peerDependencies = [

     
···

       19884
       20219
        
         };

     

       19885
       20220
        
         by-spec."serve-static"."~1.5.4" =

     

       19886
       20221
        
           self.by-version."serve-static"."1.5.4";

     

       19887
       19887
       -
         by-spec."serve-static"."~1.6.3" =

     

       19888
       19888
       -
           self.by-version."serve-static"."1.6.3";

     

       19889
       19889
       -
         by-version."serve-static"."1.6.3" = lib.makeOverridable self.buildNodePackage {

     

       19890
       19890
       -
           name = "serve-static-1.6.3";

     

       20222
       20222
       +
         by-spec."serve-static"."~1.6.4" =

     

       20223
       20223
       +
           self.by-version."serve-static"."1.6.4";

     

       20224
       20224
       +
         by-version."serve-static"."1.6.4" = lib.makeOverridable self.buildNodePackage {

     

       20225
       20225
       +
           name = "serve-static-1.6.4";

     

       19891
       20226
        
           bin = false;

     

       19892
       20227
        
           src = [

     

       19893
       20228
        
             (fetchurl {

     

       19894
       19894
       -
               url = "http://registry.npmjs.org/serve-static/-/serve-static-1.6.3.tgz";

     

       19895
       19895
       -
               name = "serve-static-1.6.3.tgz";

     

       19896
       19896
       -
               sha1 = "b214235d4d4516db050ea9f7b429b46212e79132";

     

       20229
       20229
       +
               url = "http://registry.npmjs.org/serve-static/-/serve-static-1.6.4.tgz";

     

       20230
       20230
       +
               name = "serve-static-1.6.4.tgz";

     

       20231
       20231
       +
               sha1 = "c512e4188d7a9366672db24e40d294f0c6212367";

     

       19897
       20232
        
             })

     

       19898
       20233
        
           ];

     

       19899
       20234
        
           buildInputs =

     
···

       19908
       20243
        
           ];

     

       19909
       20244
        
           passthru.names = [ "serve-static" ];

     

       19910
       20245
        
         };

     

       19911
       19911
       -
         by-spec."sha"."~1.2.1" =

     

       19912
       19912
       -
           self.by-version."sha"."1.2.4";

     

       19913
       19913
       -
         by-version."sha"."1.2.4" = lib.makeOverridable self.buildNodePackage {

     

       19914
       19914
       -
           name = "sha-1.2.4";

     

       20246
       20246
       +
         by-spec."serve-static"."~1.7.0" =

     

       20247
       20247
       +
           self.by-version."serve-static"."1.7.0";

     

       20248
       20248
       +
         by-version."serve-static"."1.7.0" = lib.makeOverridable self.buildNodePackage {

     

       20249
       20249
       +
           name = "serve-static-1.7.0";

     

       19915
       20250
        
           bin = false;

     

       19916
       20251
        
           src = [

     

       19917
       20252
        
             (fetchurl {

     

       19918
       19918
       -
               url = "http://registry.npmjs.org/sha/-/sha-1.2.4.tgz";

     

       19919
       19919
       -
               name = "sha-1.2.4.tgz";

     

       19920
       19920
       -
               sha1 = "1f9a377f27b6fdee409b9b858e43da702be48a4d";

     

       20253
       20253
       +
               url = "http://registry.npmjs.org/serve-static/-/serve-static-1.7.0.tgz";

     

       20254
       20254
       +
               name = "serve-static-1.7.0.tgz";

     

       20255
       20255
       +
               sha1 = "af2ad4e619fa2d46dcd19dd59e3b034c92510e4d";

     

       20256
       20256
       +
             })

     

       20257
       20257
       +
           ];

     

       20258
       20258
       +
           buildInputs =

     

       20259
       20259
       +
             (self.nativeDeps."serve-static" or []);

     

       20260
       20260
       +
           deps = {

     

       20261
       20261
       +
             "escape-html-1.0.1" = self.by-version."escape-html"."1.0.1";

     

       20262
       20262
       +
             "parseurl-1.3.0" = self.by-version."parseurl"."1.3.0";

     

       20263
       20263
       +
             "send-0.10.0" = self.by-version."send"."0.10.0";

     

       20264
       20264
       +
             "utils-merge-1.0.0" = self.by-version."utils-merge"."1.0.0";

     

       20265
       20265
       +
           };

     

       20266
       20266
       +
           peerDependencies = [

     

       20267
       20267
       +
           ];

     

       20268
       20268
       +
           passthru.names = [ "serve-static" ];

     

       20269
       20269
       +
         };

     

       20270
       20270
       +
         by-spec."sha"."~1.3.0" =

     

       20271
       20271
       +
           self.by-version."sha"."1.3.0";

     

       20272
       20272
       +
         by-version."sha"."1.3.0" = lib.makeOverridable self.buildNodePackage {

     

       20273
       20273
       +
           name = "sha-1.3.0";

     

       20274
       20274
       +
           bin = false;

     

       20275
       20275
       +
           src = [

     

       20276
       20276
       +
             (fetchurl {

     

       20277
       20277
       +
               url = "http://registry.npmjs.org/sha/-/sha-1.3.0.tgz";

     

       20278
       20278
       +
               name = "sha-1.3.0.tgz";

     

       20279
       20279
       +
               sha1 = "79f4787045d0ede7327d702c25c443460dbc6764";

     

       19921
       20280
        
             })

     

       19922
       20281
        
           ];

     

       19923
       20282
        
           buildInputs =

     

       19924
       20283
        
             (self.nativeDeps."sha" or []);

     

       19925
       20284
        
           deps = {

     

       19926
       19926
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       19927
       19927
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       20285
       20285
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       20286
       20286
       +
             "readable-stream-1.1.13" = self.by-version."readable-stream"."1.1.13";

     

       19928
       20287
        
           };

     

       19929
       20288
        
           peerDependencies = [

     

       19930
       20289
        
           ];

     
···

       20059
       20418
        
         by-spec."shelljs"."0.3.x" =

     

       20060
       20419
        
           self.by-version."shelljs"."0.3.0";

     

       20061
       20420
        
         by-spec."should"."*" =

     

       20062
       20062
       -
           self.by-version."should"."4.0.4";

     

       20063
       20063
       -
         by-version."should"."4.0.4" = lib.makeOverridable self.buildNodePackage {

     

       20064
       20064
       -
           name = "should-4.0.4";

     

       20421
       20421
       +
           self.by-version."should"."4.1.0";

     

       20422
       20422
       +
         by-version."should"."4.1.0" = lib.makeOverridable self.buildNodePackage {

     

       20423
       20423
       +
           name = "should-4.1.0";

     

       20065
       20424
        
           bin = false;

     

       20066
       20425
        
           src = [

     

       20067
       20426
        
             (fetchurl {

     

       20068
       20068
       -
               url = "http://registry.npmjs.org/should/-/should-4.0.4.tgz";

     

       20069
       20069
       -
               name = "should-4.0.4.tgz";

     

       20070
       20070
       -
               sha1 = "8efaa304f1f148cf3d2e955862990f9ab9ea628f";

     

       20427
       20427
       +
               url = "http://registry.npmjs.org/should/-/should-4.1.0.tgz";

     

       20428
       20428
       +
               name = "should-4.1.0.tgz";

     

       20429
       20429
       +
               sha1 = "ae3335655a1fdbb156e0b338bf191106f59dab21";

     

       20071
       20430
        
             })

     

       20072
       20431
        
           ];

     

       20073
       20432
        
           buildInputs =

     

       20074
       20433
        
             (self.nativeDeps."should" or []);

     

       20075
       20434
        
           deps = {

     

       20435
       20435
       +
             "should-equal-0.0.1" = self.by-version."should-equal"."0.0.1";

     

       20076
       20436
        
           };

     

       20077
       20437
        
           peerDependencies = [

     

       20078
       20438
        
           ];

     

       20079
       20439
        
           passthru.names = [ "should" ];

     

       20080
       20440
        
         };

     

       20081
       20081
       -
         "should" = self.by-version."should"."4.0.4";

     

       20441
       20441
       +
         "should" = self.by-version."should"."4.1.0";

     

       20442
       20442
       +
         by-spec."should-equal"."0.0.1" =

     

       20443
       20443
       +
           self.by-version."should-equal"."0.0.1";

     

       20444
       20444
       +
         by-version."should-equal"."0.0.1" = lib.makeOverridable self.buildNodePackage {

     

       20445
       20445
       +
           name = "should-equal-0.0.1";

     

       20446
       20446
       +
           bin = false;

     

       20447
       20447
       +
           src = [

     

       20448
       20448
       +
             (fetchurl {

     

       20449
       20449
       +
               url = "http://registry.npmjs.org/should-equal/-/should-equal-0.0.1.tgz";

     

       20450
       20450
       +
               name = "should-equal-0.0.1.tgz";

     

       20451
       20451
       +
               sha1 = "55066653a9f03211da695a2fea768b19956a9c0b";

     

       20452
       20452
       +
             })

     

       20453
       20453
       +
           ];

     

       20454
       20454
       +
           buildInputs =

     

       20455
       20455
       +
             (self.nativeDeps."should-equal" or []);

     

       20456
       20456
       +
           deps = {

     

       20457
       20457
       +
           };

     

       20458
       20458
       +
           peerDependencies = [

     

       20459
       20459
       +
           ];

     

       20460
       20460
       +
           passthru.names = [ "should-equal" ];

     

       20461
       20461
       +
         };

     

       20082
       20462
        
         by-spec."sigmund"."~1.0.0" =

     

       20083
       20463
        
           self.by-version."sigmund"."1.0.0";

     

       20084
       20464
        
         by-version."sigmund"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     
···

       20828
       21208
        
           passthru.names = [ "statsd-librato-backend" ];

     

       20829
       21209
        
         };

     

       20830
       21210
        
         "statsd-librato-backend" = self.by-version."statsd-librato-backend"."0.1.3";

     

       21211
       21211
       +
         by-spec."statuses"."1" =

     

       21212
       21212
       +
           self.by-version."statuses"."1.2.0";

     

       21213
       21213
       +
         by-version."statuses"."1.2.0" = lib.makeOverridable self.buildNodePackage {

     

       21214
       21214
       +
           name = "statuses-1.2.0";

     

       21215
       21215
       +
           bin = false;

     

       21216
       21216
       +
           src = [

     

       21217
       21217
       +
             (fetchurl {

     

       21218
       21218
       +
               url = "http://registry.npmjs.org/statuses/-/statuses-1.2.0.tgz";

     

       21219
       21219
       +
               name = "statuses-1.2.0.tgz";

     

       21220
       21220
       +
               sha1 = "4445790d65bec29184f50d54810f67e290c1679e";

     

       21221
       21221
       +
             })

     

       21222
       21222
       +
           ];

     

       21223
       21223
       +
           buildInputs =

     

       21224
       21224
       +
             (self.nativeDeps."statuses" or []);

     

       21225
       21225
       +
           deps = {

     

       21226
       21226
       +
           };

     

       21227
       21227
       +
           peerDependencies = [

     

       21228
       21228
       +
           ];

     

       21229
       21229
       +
           passthru.names = [ "statuses" ];

     

       21230
       21230
       +
         };

     

       20831
       21231
        
         by-spec."stream-browserify"."^1.0.0" =

     

       20832
       21232
        
           self.by-version."stream-browserify"."1.0.0";

     

       20833
       21233
        
         by-version."stream-browserify"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     
···

       21210
       21610
        
           passthru.names = [ "strip-json-comments" ];

     

       21211
       21611
        
         };

     

       21212
       21612
        
         by-spec."strip-json-comments"."1.0.x" =

     

       21213
       21213
       -
           self.by-version."strip-json-comments"."1.0.1";

     

       21214
       21214
       -
         by-version."strip-json-comments"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     

       21215
       21215
       -
           name = "strip-json-comments-1.0.1";

     

       21613
       21613
       +
           self.by-version."strip-json-comments"."1.0.2";

     

       21614
       21614
       +
         by-version."strip-json-comments"."1.0.2" = lib.makeOverridable self.buildNodePackage {

     

       21615
       21615
       +
           name = "strip-json-comments-1.0.2";

     

       21216
       21616
        
           bin = true;

     

       21217
       21617
        
           src = [

     

       21218
       21618
        
             (fetchurl {

     

       21219
       21219
       -
               url = "http://registry.npmjs.org/strip-json-comments/-/strip-json-comments-1.0.1.tgz";

     

       21220
       21220
       -
               name = "strip-json-comments-1.0.1.tgz";

     

       21221
       21221
       -
               sha1 = "a91252d95ddee4ff38a66135cd6c78de5709f374";

     

       21619
       21619
       +
               url = "http://registry.npmjs.org/strip-json-comments/-/strip-json-comments-1.0.2.tgz";

     

       21620
       21620
       +
               name = "strip-json-comments-1.0.2.tgz";

     

       21621
       21621
       +
               sha1 = "5a48ab96023dbac1b7b8d0ffabf6f63f1677be9f";

     

       21222
       21622
        
             })

     

       21223
       21623
        
           ];

     

       21224
       21624
        
           buildInputs =

     
···

       21244
       21644
        
           buildInputs =

     

       21245
       21645
        
             (self.nativeDeps."strong-data-uri" or []);

     

       21246
       21646
        
           deps = {

     

       21247
       21247
       -
             "truncate-1.0.2" = self.by-version."truncate"."1.0.2";

     

       21647
       21647
       +
             "truncate-1.0.4" = self.by-version."truncate"."1.0.4";

     

       21248
       21648
        
           };

     

       21249
       21649
        
           peerDependencies = [

     

       21250
       21650
        
           ];

     

       21251
       21651
        
           passthru.names = [ "strong-data-uri" ];

     

       21252
       21652
        
         };

     

       21253
       21653
        
         by-spec."stylus"."*" =

     

       21254
       21254
       -
           self.by-version."stylus"."0.49.1";

     

       21255
       21255
       -
         by-version."stylus"."0.49.1" = lib.makeOverridable self.buildNodePackage {

     

       21256
       21256
       -
           name = "stylus-0.49.1";

     

       21654
       21654
       +
           self.by-version."stylus"."0.49.2";

     

       21655
       21655
       +
         by-version."stylus"."0.49.2" = lib.makeOverridable self.buildNodePackage {

     

       21656
       21656
       +
           name = "stylus-0.49.2";

     

       21257
       21657
        
           bin = true;

     

       21258
       21658
        
           src = [

     

       21259
       21659
        
             (fetchurl {

     

       21260
       21260
       -
               url = "http://registry.npmjs.org/stylus/-/stylus-0.49.1.tgz";

     

       21261
       21261
       -
               name = "stylus-0.49.1.tgz";

     

       21262
       21262
       -
               sha1 = "c915495675ca77847a7d4285dd6d6572bae34448";

     

       21660
       21660
       +
               url = "http://registry.npmjs.org/stylus/-/stylus-0.49.2.tgz";

     

       21661
       21661
       +
               name = "stylus-0.49.2.tgz";

     

       21662
       21662
       +
               sha1 = "c72a9ea9d904d24bb07c8fd609e6abc28620000a";

     

       21263
       21663
        
             })

     

       21264
       21664
        
           ];

     

       21265
       21665
        
           buildInputs =

     
···

       21267
       21667
        
           deps = {

     

       21268
       21668
        
             "css-parse-1.7.0" = self.by-version."css-parse"."1.7.0";

     

       21269
       21669
        
             "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";

     

       21270
       21270
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       21670
       21670
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       21271
       21671
        
             "sax-0.5.8" = self.by-version."sax"."0.5.8";

     

       21272
       21672
        
             "glob-3.2.11" = self.by-version."glob"."3.2.11";

     

       21273
       21673
        
             "source-map-0.1.40" = self.by-version."source-map"."0.1.40";

     
···

       21276
       21676
        
           ];

     

       21277
       21677
        
           passthru.names = [ "stylus" ];

     

       21278
       21678
        
         };

     

       21279
       21279
       -
         "stylus" = self.by-version."stylus"."0.49.1";

     

       21679
       21679
       +
         "stylus" = self.by-version."stylus"."0.49.2";

     

       21280
       21680
        
         by-spec."stylus"."0.42.2" =

     

       21281
       21681
        
           self.by-version."stylus"."0.42.2";

     

       21282
       21682
        
         by-version."stylus"."0.42.2" = lib.makeOverridable self.buildNodePackage {

     
···

       21294
       21694
        
           deps = {

     

       21295
       21695
        
             "css-parse-1.7.0" = self.by-version."css-parse"."1.7.0";

     

       21296
       21696
        
             "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";

     

       21297
       21297
       -
             "debug-2.0.0" = self.by-version."debug"."2.0.0";

     

       21697
       21697
       +
             "debug-2.1.0" = self.by-version."debug"."2.1.0";

     

       21298
       21698
        
             "sax-0.5.8" = self.by-version."sax"."0.5.8";

     

       21299
       21699
        
             "glob-3.2.11" = self.by-version."glob"."3.2.11";

     

       21300
       21700
        
           };

     
···

       21808
       22208
        
           buildInputs =

     

       21809
       22209
        
             (self.nativeDeps."through2" or []);

     

       21810
       22210
        
           deps = {

     

       21811
       21811
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       22211
       22211
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       21812
       22212
        
             "xtend-3.0.0" = self.by-version."xtend"."3.0.0";

     

       21813
       22213
        
           };

     

       21814
       22214
        
           peerDependencies = [

     
···

       21816
       22216
        
           passthru.names = [ "through2" ];

     

       21817
       22217
        
         };

     

       21818
       22218
        
         by-spec."through2"."^0.6.1" =

     

       21819
       21819
       -
           self.by-version."through2"."0.6.2";

     

       21820
       21820
       -
         by-version."through2"."0.6.2" = lib.makeOverridable self.buildNodePackage {

     

       21821
       21821
       -
           name = "through2-0.6.2";

     

       22219
       22219
       +
           self.by-version."through2"."0.6.3";

     

       22220
       22220
       +
         by-version."through2"."0.6.3" = lib.makeOverridable self.buildNodePackage {

     

       22221
       22221
       +
           name = "through2-0.6.3";

     

       21822
       22222
        
           bin = false;

     

       21823
       22223
        
           src = [

     

       21824
       22224
        
             (fetchurl {

     

       21825
       21825
       -
               url = "http://registry.npmjs.org/through2/-/through2-0.6.2.tgz";

     

       21826
       21826
       -
               name = "through2-0.6.2.tgz";

     

       21827
       21827
       -
               sha1 = "53265824c555e7fcdc4111dcdc52c7de64636c75";

     

       22225
       22225
       +
               url = "http://registry.npmjs.org/through2/-/through2-0.6.3.tgz";

     

       22226
       22226
       +
               name = "through2-0.6.3.tgz";

     

       22227
       22227
       +
               sha1 = "795292fde9f254c2a368b38f9cc5d1bd4663afb6";

     

       21828
       22228
        
             })

     

       21829
       22229
        
           ];

     

       21830
       22230
        
           buildInputs =

     

       21831
       22231
        
             (self.nativeDeps."through2" or []);

     

       21832
       22232
        
           deps = {

     

       21833
       21833
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       22233
       22233
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       21834
       22234
        
             "xtend-4.0.0" = self.by-version."xtend"."4.0.0";

     

       21835
       22235
        
           };

     

       21836
       22236
        
           peerDependencies = [

     
···

       21874
       22274
        
           buildInputs =

     

       21875
       22275
        
             (self.nativeDeps."through2" or []);

     

       21876
       22276
        
           deps = {

     

       21877
       21877
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       22277
       22277
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       21878
       22278
        
             "xtend-2.1.2" = self.by-version."xtend"."2.1.2";

     

       21879
       22279
        
           };

     

       21880
       22280
        
           peerDependencies = [

     
···

       21898
       22298
        
           buildInputs =

     

       21899
       22299
        
             (self.nativeDeps."tildify" or []);

     

       21900
       22300
        
           deps = {

     

       21901
       21901
       -
             "user-home-1.0.0" = self.by-version."user-home"."1.0.0";

     

       22301
       22301
       +
             "user-home-1.1.0" = self.by-version."user-home"."1.1.0";

     

       21902
       22302
        
           };

     

       21903
       22303
        
           peerDependencies = [

     

       21904
       22304
        
           ];

     
···

       21925
       22325
        
           ];

     

       21926
       22326
        
           passthru.names = [ "timers-browserify" ];

     

       21927
       22327
        
         };

     

       21928
       21928
       -
         by-spec."timers-ext"."0.1.x" =

     

       22328
       22328
       +
         by-spec."timers-ext"."0.1" =

     

       21929
       22329
        
           self.by-version."timers-ext"."0.1.0";

     

       21930
       22330
        
         by-version."timers-ext"."0.1.0" = lib.makeOverridable self.buildNodePackage {

     

       21931
       22331
        
           name = "timers-ext-0.1.0";

     
···

       21947
       22347
        
           ];

     

       21948
       22348
        
           passthru.names = [ "timers-ext" ];

     

       21949
       22349
        
         };

     

       22350
       22350
       +
         by-spec."timers-ext"."0.1.x" =

     

       22351
       22351
       +
           self.by-version."timers-ext"."0.1.0";

     

       21950
       22352
        
         by-spec."timespan"."~2.3.0" =

     

       21951
       22353
        
           self.by-version."timespan"."2.3.0";

     

       21952
       22354
        
         by-version."timespan"."2.3.0" = lib.makeOverridable self.buildNodePackage {

     
···

       22025
       22427
        
           deps = {

     

       22026
       22428
        
             "async-0.2.10" = self.by-version."async"."0.2.10";

     

       22027
       22429
        
             "colors-0.6.2" = self.by-version."colors"."0.6.2";

     

       22028
       22028
       -
             "fields-0.1.16" = self.by-version."fields"."0.1.16";

     

       22430
       22430
       +
             "fields-0.1.17" = self.by-version."fields"."0.1.17";

     

       22029
       22431
        
             "humanize-0.0.9" = self.by-version."humanize"."0.0.9";

     

       22030
       22432
        
             "jade-0.35.0" = self.by-version."jade"."0.35.0";

     

       22031
       22433
        
             "longjohn-0.2.4" = self.by-version."longjohn"."0.2.4";

     
···

       22122
       22524
        
           buildInputs =

     

       22123
       22525
        
             (self.nativeDeps."tough-cookie" or []);

     

       22124
       22526
        
           deps = {

     

       22125
       22125
       -
             "punycode-1.3.1" = self.by-version."punycode"."1.3.1";

     

       22527
       22527
       +
             "punycode-1.3.2" = self.by-version."punycode"."1.3.2";

     

       22126
       22528
        
           };

     

       22127
       22529
        
           peerDependencies = [

     

       22128
       22530
        
           ];

     
···

       22145
       22547
        
           buildInputs =

     

       22146
       22548
        
             (self.nativeDeps."traceur" or []);

     

       22147
       22549
        
           deps = {

     

       22148
       22148
       -
             "commander-2.3.0" = self.by-version."commander"."2.3.0";

     

       22550
       22550
       +
             "commander-2.4.0" = self.by-version."commander"."2.4.0";

     

       22149
       22551
        
             "glob-4.0.6" = self.by-version."glob"."4.0.6";

     

       22150
       22552
        
             "semver-2.3.2" = self.by-version."semver"."2.3.2";

     

       22151
       22553
        
           };

     
···

       22197
       22599
        
           passthru.names = [ "traverse" ];

     

       22198
       22600
        
         };

     

       22199
       22601
        
         by-spec."truncate"."~1.0.2" =

     

       22200
       22200
       -
           self.by-version."truncate"."1.0.2";

     

       22201
       22201
       -
         by-version."truncate"."1.0.2" = lib.makeOverridable self.buildNodePackage {

     

       22202
       22202
       -
           name = "truncate-1.0.2";

     

       22602
       22602
       +
           self.by-version."truncate"."1.0.4";

     

       22603
       22603
       +
         by-version."truncate"."1.0.4" = lib.makeOverridable self.buildNodePackage {

     

       22604
       22604
       +
           name = "truncate-1.0.4";

     

       22203
       22605
        
           bin = false;

     

       22204
       22606
        
           src = [

     

       22205
       22607
        
             (fetchurl {

     

       22206
       22206
       -
               url = "http://registry.npmjs.org/truncate/-/truncate-1.0.2.tgz";

     

       22207
       22207
       -
               name = "truncate-1.0.2.tgz";

     

       22208
       22208
       -
               sha1 = "3221c41f6e747f83e8613f5466c8bfb596226a66";

     

       22608
       22608
       +
               url = "http://registry.npmjs.org/truncate/-/truncate-1.0.4.tgz";

     

       22609
       22609
       +
               name = "truncate-1.0.4.tgz";

     

       22610
       22610
       +
               sha1 = "2bcfbbff4a97b9089b693c1ae37c5105ec8775aa";

     

       22209
       22611
        
             })

     

       22210
       22612
        
           ];

     

       22211
       22613
        
           buildInputs =

     
···

       22623
       23025
        
           buildInputs =

     

       22624
       23026
        
             (self.nativeDeps."uid-safe" or []);

     

       22625
       23027
        
           deps = {

     

       22626
       22626
       -
             "mz-1.0.1" = self.by-version."mz"."1.0.1";

     

       23028
       23028
       +
             "mz-1.0.2" = self.by-version."mz"."1.0.2";

     

       22627
       23029
        
             "base64-url-1.0.0" = self.by-version."base64-url"."1.0.0";

     

       22628
       23030
        
           };

     

       22629
       23031
        
           peerDependencies = [

     
···

       22867
       23269
        
             "signals-1.0.0" = self.by-version."signals"."1.0.0";

     

       22868
       23270
        
             "hasher-1.2.0" = self.by-version."hasher"."1.2.0";

     

       22869
       23271
        
             "blueimp-md5-1.1.0" = self.by-version."blueimp-md5"."1.1.0";

     

       22870
       22870
       -
             "color-0.7.1" = self.by-version."color"."0.7.1";

     

       23272
       23272
       +
             "color-0.7.3" = self.by-version."color"."0.7.3";

     

       22871
       23273
        
             "keen.io-0.1.2" = self.by-version."keen.io"."0.1.2";

     

       22872
       23274
        
             "getmac-1.0.6" = self.by-version."getmac"."1.0.6";

     

       22873
       23275
        
             "deep-extend-0.2.11" = self.by-version."deep-extend"."0.2.11";

     
···

       22997
       23399
        
           passthru.names = [ "url" ];

     

       22998
       23400
        
         };

     

       22999
       23401
        
         by-spec."user-home"."^1.0.0" =

     

       23000
       23000
       -
           self.by-version."user-home"."1.0.0";

     

       23001
       23001
       -
         by-version."user-home"."1.0.0" = lib.makeOverridable self.buildNodePackage {

     

       23002
       23002
       -
           name = "user-home-1.0.0";

     

       23402
       23402
       +
           self.by-version."user-home"."1.1.0";

     

       23403
       23403
       +
         by-version."user-home"."1.1.0" = lib.makeOverridable self.buildNodePackage {

     

       23404
       23404
       +
           name = "user-home-1.1.0";

     

       23003
       23405
        
           bin = true;

     

       23004
       23406
        
           src = [

     

       23005
       23407
        
             (fetchurl {

     

       23006
       23006
       -
               url = "http://registry.npmjs.org/user-home/-/user-home-1.0.0.tgz";

     

       23007
       23007
       -
               name = "user-home-1.0.0.tgz";

     

       23008
       23008
       -
               sha1 = "54ecb631e0fa420e9b0a6b946b158d137825b38b";

     

       23408
       23408
       +
               url = "http://registry.npmjs.org/user-home/-/user-home-1.1.0.tgz";

     

       23409
       23409
       +
               name = "user-home-1.1.0.tgz";

     

       23410
       23410
       +
               sha1 = "1f4e6bce5458aeec4ac80ebcdcc66119c1070cdf";

     

       23009
       23411
        
             })

     

       23010
       23412
        
           ];

     

       23011
       23413
        
           buildInputs =

     
···

       23219
       23621
        
           ];

     

       23220
       23622
        
           passthru.names = [ "uuid" ];

     

       23221
       23623
        
         };

     

       23624
       23624
       +
         by-spec."v8flags"."^1.0.1" =

     

       23625
       23625
       +
           self.by-version."v8flags"."1.0.1";

     

       23626
       23626
       +
         by-version."v8flags"."1.0.1" = lib.makeOverridable self.buildNodePackage {

     

       23627
       23627
       +
           name = "v8flags-1.0.1";

     

       23628
       23628
       +
           bin = false;

     

       23629
       23629
       +
           src = [

     

       23630
       23630
       +
             (fetchurl {

     

       23631
       23631
       +
               url = "http://registry.npmjs.org/v8flags/-/v8flags-1.0.1.tgz";

     

       23632
       23632
       +
               name = "v8flags-1.0.1.tgz";

     

       23633
       23633
       +
               sha1 = "a35328d86fd040ef9cdeed5387a8e5bcb25216ec";

     

       23634
       23634
       +
             })

     

       23635
       23635
       +
           ];

     

       23636
       23636
       +
           buildInputs =

     

       23637
       23637
       +
             (self.nativeDeps."v8flags" or []);

     

       23638
       23638
       +
           deps = {

     

       23639
       23639
       +
           };

     

       23640
       23640
       +
           peerDependencies = [

     

       23641
       23641
       +
           ];

     

       23642
       23642
       +
           passthru.names = [ "v8flags" ];

     

       23643
       23643
       +
         };

     

       23222
       23644
        
         by-spec."validator"."0.4.x" =

     

       23223
       23645
        
           self.by-version."validator"."0.4.28";

     

       23224
       23646
        
         by-version."validator"."0.4.28" = lib.makeOverridable self.buildNodePackage {

     
···

       23491
       23913
        
           passthru.names = [ "vinyl" ];

     

       23492
       23914
        
         };

     

       23493
       23915
        
         by-spec."vinyl-fs"."^0.3.0" =

     

       23494
       23494
       -
           self.by-version."vinyl-fs"."0.3.8";

     

       23495
       23495
       -
         by-version."vinyl-fs"."0.3.8" = lib.makeOverridable self.buildNodePackage {

     

       23496
       23496
       -
           name = "vinyl-fs-0.3.8";

     

       23916
       23916
       +
           self.by-version."vinyl-fs"."0.3.10";

     

       23917
       23917
       +
         by-version."vinyl-fs"."0.3.10" = lib.makeOverridable self.buildNodePackage {

     

       23918
       23918
       +
           name = "vinyl-fs-0.3.10";

     

       23497
       23919
        
           bin = false;

     

       23498
       23920
        
           src = [

     

       23499
       23921
        
             (fetchurl {

     

       23500
       23500
       -
               url = "http://registry.npmjs.org/vinyl-fs/-/vinyl-fs-0.3.8.tgz";

     

       23501
       23501
       -
               name = "vinyl-fs-0.3.8.tgz";

     

       23502
       23502
       -
               sha1 = "bea09db28e558e5e903a51a5363fcdb59e5aabe4";

     

       23922
       23922
       +
               url = "http://registry.npmjs.org/vinyl-fs/-/vinyl-fs-0.3.10.tgz";

     

       23923
       23923
       +
               name = "vinyl-fs-0.3.10.tgz";

     

       23924
       23924
       +
               sha1 = "f59ac977cb040e95df865ad34cdeb00f57f31f47";

     

       23503
       23925
        
             })

     

       23504
       23926
        
           ];

     

       23505
       23927
        
           buildInputs =

     
···

       23507
       23929
        
           deps = {

     

       23508
       23930
        
             "glob-stream-3.1.15" = self.by-version."glob-stream"."3.1.15";

     

       23509
       23931
        
             "glob-watcher-0.0.6" = self.by-version."glob-watcher"."0.0.6";

     

       23510
       23510
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       23932
       23932
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       23511
       23933
        
             "lodash-2.4.1" = self.by-version."lodash"."2.4.1";

     

       23512
       23934
        
             "mkdirp-0.5.0" = self.by-version."mkdirp"."0.5.0";

     

       23513
       23935
        
             "strip-bom-1.0.0" = self.by-version."strip-bom"."1.0.0";

     

       23514
       23514
       -
             "through2-0.6.2" = self.by-version."through2"."0.6.2";

     

       23936
       23936
       +
             "through2-0.6.3" = self.by-version."through2"."0.6.3";

     

       23515
       23937
        
             "vinyl-0.4.3" = self.by-version."vinyl"."0.4.3";

     

       23516
       23938
        
           };

     

       23517
       23939
        
           peerDependencies = [

     
···

       23519
       23941
        
           passthru.names = [ "vinyl-fs" ];

     

       23520
       23942
        
         };

     

       23521
       23943
        
         by-spec."vinyl-fs"."^0.3.3" =

     

       23522
       23522
       -
           self.by-version."vinyl-fs"."0.3.8";

     

       23944
       23944
       +
           self.by-version."vinyl-fs"."0.3.10";

     

       23523
       23945
        
         by-spec."vm-browserify"."~0.0.1" =

     

       23524
       23946
        
           self.by-version."vm-browserify"."0.0.4";

     

       23525
       23947
        
         by-version."vm-browserify"."0.0.4" = lib.makeOverridable self.buildNodePackage {

     
···

       23688
       24110
        
           passthru.names = [ "wcwidth" ];

     

       23689
       24111
        
         };

     

       23690
       24112
        
         by-spec."wd"."~0.3.4" =

     

       23691
       23691
       -
           self.by-version."wd"."0.3.8";

     

       23692
       23692
       -
         by-version."wd"."0.3.8" = lib.makeOverridable self.buildNodePackage {

     

       23693
       23693
       -
           name = "wd-0.3.8";

     

       24113
       24113
       +
           self.by-version."wd"."0.3.9";

     

       24114
       24114
       +
         by-version."wd"."0.3.9" = lib.makeOverridable self.buildNodePackage {

     

       24115
       24115
       +
           name = "wd-0.3.9";

     

       23694
       24116
        
           bin = true;

     

       23695
       24117
        
           src = [

     

       23696
       24118
        
             (fetchurl {

     

       23697
       23697
       -
               url = "http://registry.npmjs.org/wd/-/wd-0.3.8.tgz";

     

       23698
       23698
       -
               name = "wd-0.3.8.tgz";

     

       23699
       23699
       -
               sha1 = "68c4371561ac32b986dd93f42f89072746c09c84";

     

       24119
       24119
       +
               url = "http://registry.npmjs.org/wd/-/wd-0.3.9.tgz";

     

       24120
       24120
       +
               name = "wd-0.3.9.tgz";

     

       24121
       24121
       +
               sha1 = "857130517e5976203653dd325edc4bdc2dbd946f";

     

       23700
       24122
        
             })

     

       23701
       24123
        
           ];

     

       23702
       24124
        
           buildInputs =

     
···

       23704
       24126
        
           deps = {

     

       23705
       24127
        
             "archiver-0.11.0" = self.by-version."archiver"."0.11.0";

     

       23706
       24128
        
             "async-0.9.0" = self.by-version."async"."0.9.0";

     

       23707
       23707
       -
             "colors-0.6.2" = self.by-version."colors"."0.6.2";

     

       23708
       24129
        
             "lodash-2.4.1" = self.by-version."lodash"."2.4.1";

     

       23709
       24130
        
             "q-1.0.1" = self.by-version."q"."1.0.1";

     

       23710
       23710
       -
             "request-2.42.0" = self.by-version."request"."2.42.0";

     

       24131
       24131
       +
             "request-2.45.0" = self.by-version."request"."2.45.0";

     

       23711
       24132
        
             "underscore.string-2.3.3" = self.by-version."underscore.string"."2.3.3";

     

       23712
       24133
        
             "vargs-0.1.0" = self.by-version."vargs"."0.1.0";

     

       23713
       24134
        
           };

     
···

       23754
       24175
        
             "kew-0.1.7" = self.by-version."kew"."0.1.7";

     

       23755
       24176
        
             "mkdirp-0.3.5" = self.by-version."mkdirp"."0.3.5";

     

       23756
       24177
        
             "npmconf-0.1.16" = self.by-version."npmconf"."0.1.16";

     

       23757
       23757
       -
             "phantomjs-1.9.10" = self.by-version."phantomjs"."1.9.10";

     

       24178
       24178
       +
             "phantomjs-1.9.11" = self.by-version."phantomjs"."1.9.11";

     

       23758
       24179
        
             "tmp-0.0.24" = self.by-version."tmp"."0.0.24";

     

       23759
       24180
        
             "follow-redirects-0.0.3" = self.by-version."follow-redirects"."0.0.3";

     

       23760
       24181
        
           };

     
···

       23852
       24273
        
           passthru.names = [ "winser" ];

     

       23853
       24274
        
         };

     

       23854
       24275
        
         by-spec."winston"."*" =

     

       23855
       23855
       -
           self.by-version."winston"."0.8.0";

     

       23856
       23856
       -
         by-version."winston"."0.8.0" = lib.makeOverridable self.buildNodePackage {

     

       23857
       23857
       -
           name = "winston-0.8.0";

     

       24276
       24276
       +
           self.by-version."winston"."0.8.1";

     

       24277
       24277
       +
         by-version."winston"."0.8.1" = lib.makeOverridable self.buildNodePackage {

     

       24278
       24278
       +
           name = "winston-0.8.1";

     

       23858
       24279
        
           bin = false;

     

       23859
       24280
        
           src = [

     

       23860
       24281
        
             (fetchurl {

     

       23861
       23861
       -
               url = "http://registry.npmjs.org/winston/-/winston-0.8.0.tgz";

     

       23862
       23862
       -
               name = "winston-0.8.0.tgz";

     

       23863
       23863
       -
               sha1 = "61d0830fa699706212206b0a2b5ca69a93043668";

     

       24282
       24282
       +
               url = "http://registry.npmjs.org/winston/-/winston-0.8.1.tgz";

     

       24283
       24283
       +
               name = "winston-0.8.1.tgz";

     

       24284
       24284
       +
               sha1 = "86bc9ec6c02aefe5c6dfdb88f3aff1b19d629216";

     

       23864
       24285
        
             })

     

       23865
       24286
        
           ];

     

       23866
       24287
        
           buildInputs =

     
···

       23877
       24298
        
           ];

     

       23878
       24299
        
           passthru.names = [ "winston" ];

     

       23879
       24300
        
         };

     

       23880
       23880
       -
         "winston" = self.by-version."winston"."0.8.0";

     

       24301
       24301
       +
         "winston" = self.by-version."winston"."0.8.1";

     

       23881
       24302
        
         by-spec."winston"."0.6.2" =

     

       23882
       24303
        
           self.by-version."winston"."0.6.2";

     

       23883
       24304
        
         by-version."winston"."0.6.2" = lib.makeOverridable self.buildNodePackage {

     
···

       23936
       24357
        
         };

     

       23937
       24358
        
         by-spec."winston"."0.8.0" =

     

       23938
       24359
        
           self.by-version."winston"."0.8.0";

     

       24360
       24360
       +
         by-version."winston"."0.8.0" = lib.makeOverridable self.buildNodePackage {

     

       24361
       24361
       +
           name = "winston-0.8.0";

     

       24362
       24362
       +
           bin = false;

     

       24363
       24363
       +
           src = [

     

       24364
       24364
       +
             (fetchurl {

     

       24365
       24365
       +
               url = "http://registry.npmjs.org/winston/-/winston-0.8.0.tgz";

     

       24366
       24366
       +
               name = "winston-0.8.0.tgz";

     

       24367
       24367
       +
               sha1 = "61d0830fa699706212206b0a2b5ca69a93043668";

     

       24368
       24368
       +
             })

     

       24369
       24369
       +
           ];

     

       24370
       24370
       +
           buildInputs =

     

       24371
       24371
       +
             (self.nativeDeps."winston" or []);

     

       24372
       24372
       +
           deps = {

     

       24373
       24373
       +
             "async-0.2.10" = self.by-version."async"."0.2.10";

     

       24374
       24374
       +
             "colors-0.6.2" = self.by-version."colors"."0.6.2";

     

       24375
       24375
       +
             "cycle-1.0.3" = self.by-version."cycle"."1.0.3";

     

       24376
       24376
       +
             "eyes-0.1.8" = self.by-version."eyes"."0.1.8";

     

       24377
       24377
       +
             "pkginfo-0.3.0" = self.by-version."pkginfo"."0.3.0";

     

       24378
       24378
       +
             "stack-trace-0.0.9" = self.by-version."stack-trace"."0.0.9";

     

       24379
       24379
       +
           };

     

       24380
       24380
       +
           peerDependencies = [

     

       24381
       24381
       +
           ];

     

       24382
       24382
       +
           passthru.names = [ "winston" ];

     

       24383
       24383
       +
         };

     

       23939
       24384
        
         by-spec."winston"."0.8.x" =

     

       23940
       23940
       -
           self.by-version."winston"."0.8.0";

     

       24385
       24385
       +
           self.by-version."winston"."0.8.1";

     

       23941
       24386
        
         by-spec."winston"."~0.7.2" =

     

       23942
       24387
        
           self.by-version."winston"."0.7.3";

     

       23943
       24388
        
         by-version."winston"."0.7.3" = lib.makeOverridable self.buildNodePackage {

     
···

       24113
       24558
        
           buildInputs =

     

       24114
       24559
        
             (self.nativeDeps."write-file-atomic" or []);

     

       24115
       24560
        
           deps = {

     

       24116
       24116
       -
             "graceful-fs-3.0.3" = self.by-version."graceful-fs"."3.0.3";

     

       24561
       24561
       +
             "graceful-fs-3.0.4" = self.by-version."graceful-fs"."3.0.4";

     

       24117
       24562
        
             "slide-1.1.6" = self.by-version."slide"."1.1.6";

     

       24118
       24563
        
           };

     

       24119
       24564
        
           peerDependencies = [

     
···

       24205
       24650
        
           buildInputs =

     

       24206
       24651
        
             (self.nativeDeps."xml2js" or []);

     

       24207
       24652
        
           deps = {

     

       24208
       24208
       -
             "sax-0.6.0" = self.by-version."sax"."0.6.0";

     

       24653
       24653
       +
             "sax-0.6.1" = self.by-version."sax"."0.6.1";

     

       24209
       24654
        
           };

     

       24210
       24655
        
           peerDependencies = [

     

       24211
       24656
        
           ];

     
···

       24247
       24692
        
           buildInputs =

     

       24248
       24693
        
             (self.nativeDeps."xml2js" or []);

     

       24249
       24694
        
           deps = {

     

       24250
       24250
       -
             "sax-0.6.0" = self.by-version."sax"."0.6.0";

     

       24695
       24695
       +
             "sax-0.6.1" = self.by-version."sax"."0.6.1";

     

       24251
       24696
        
             "xmlbuilder-2.4.4" = self.by-version."xmlbuilder"."2.4.4";

     

       24252
       24697
        
           };

     

       24253
       24698
        
           peerDependencies = [

     
···

       24486
       24931
        
           deps = {

     

       24487
       24932
        
             "compress-commons-0.1.6" = self.by-version."compress-commons"."0.1.6";

     

       24488
       24933
        
             "lodash-2.4.1" = self.by-version."lodash"."2.4.1";

     

       24489
       24489
       -
             "readable-stream-1.0.32" = self.by-version."readable-stream"."1.0.32";

     

       24934
       24934
       +
             "readable-stream-1.0.33-1" = self.by-version."readable-stream"."1.0.33-1";

     

       24490
       24935
        
           };

     

       24491
       24936
        
           peerDependencies = [

     

       24492
       24937
        
           ];

+220 -120

pkgs/top-level/perl-packages.nix

···

       780
       780
        
         };

     

       781
       781
        
       

     

       782
       782
        
         CatalystModelDBICSchema = buildPerlPackage {

     

       783
       783
       -
           name = "Catalyst-Model-DBIC-Schema-0.60";

     

       783
       783
       +
           name = "Catalyst-Model-DBIC-Schema-0.65";

     

       784
       784
        
           src = fetchurl {

     

       785
       785
       -
             url = mirror://cpan/authors/id/R/RK/RKITOVER/Catalyst-Model-DBIC-Schema-0.60.tar.gz;

     

       786
       786
       -
             sha256 = "176jqvrmhp0wng446m0qlmh1kgqj4z1czg6s418ffr4a7c3jqyld";

     

       785
       785
       +
             url = mirror://cpan/authors/id/G/GB/GBJK/Catalyst-Model-DBIC-Schema-0.65.tar.gz;

     

       786
       786
       +
             sha256 = "26a911ef5ef7ffc81b6ce65c3156f71fb35083c456ad27e6d82d2dc02493eeea";

     

       787
       787
        
           };

     

       788
       788
        
           buildInputs = [ DBDSQLite TestException TestRequires ];

     

       789
       789
       -
           propagatedBuildInputs = [ CarpClan CatalystComponentInstancePerContext CatalystDevel CatalystRuntime CatalystXComponentTraits DBIxClass DBIxClassCursorCached DBIxClassSchemaLoader HashMerge ListMoreUtils Moose MooseXMarkAsMethods MooseXNonMoose MooseXTypes namespaceautoclean namespaceclean TieIxHash TryTiny ];

     

       789
       789
       +
           propagatedBuildInputs = [ CarpClan CatalystComponentInstancePerContext CatalystRuntime CatalystXComponentTraits DBIxClass DBIxClassSchemaLoader HashMerge ListMoreUtils ModuleRuntime Moose MooseXMarkAsMethods MooseXNonMoose MooseXTypes MooseXTypesLoadableClass TieIxHash TryTiny namespaceautoclean namespaceclean ];

     

       790
       790
        
           meta = {

     

       791
       791
        
             description = "DBIx::Class::Schema Model Class";

     

       792
       792
        
             license = "perl";

     
···

       795
       795
        
         };

     

       796
       796
        
       

     

       797
       797
        
         CatalystRuntime = buildPerlPackage {

     

       798
       798
       -
           name = "Catalyst-Runtime-5.90030";

     

       798
       798
       +
           name = "Catalyst-Runtime-5.90075";

     

       799
       799
        
           src = fetchurl {

     

       800
       800
       -
             url = mirror://cpan/authors/id/J/JJ/JJNAPIORK/Catalyst-Runtime-5.90030.tar.gz;

     

       801
       801
       -
             sha256 = "c27357f744fa0d2f9b2682c5f86723d90de43f30cd50089306dd13eb8849eb0c";

     

       800
       800
       +
             url = mirror://cpan/authors/id/J/JJ/JJNAPIORK/Catalyst-Runtime-5.90075.tar.gz;

     

       801
       801
       +
             sha256 = "a80ed1b1600a8ababda34bc024756a6fb0275b0fff3fa1bb17104813e3ce8752";

     

       802
       802
        
           };

     

       803
       803
       -
           buildInputs = [ ClassDataInheritable DataDump HTTPMessage TestException ];

     

       804
       804
       -
           propagatedBuildInputs = [ CGISimple CatalystDispatchTypeRegex ClassC3AdoptNEXT ClassLoad DataDump DataOptList HTMLParser HTTPBody HTTPMessage HTTPRequestAsCGI LWP ListMoreUtils MROCompat Moose MooseXEmulateClassAccessorFast MooseXGetopt MooseXMethodAttributes MooseXRoleWithOverloading PathClass Plack PlackMiddlewareReverseProxy PlackTestExternalServer SafeIsa StringRewritePrefix SubExporter TaskWeaken TextSimpleTable TreeSimple TreeSimpleVisitorFactory TryTiny URI namespaceautoclean namespaceclean ];

     

       803
       803
       +
           buildInputs = [ DataDump HTTPMessage IOstringy JSONMaybeXS TestFatal ];

     

       804
       804
       +
           propagatedBuildInputs = [ CGISimple CGIStruct ClassC3AdoptNEXT ClassDataInheritable ClassLoad DataDump DataOptList Encode HTMLParser HTTPBody HTTPMessage HTTPRequestAsCGI HashMultiValue JSONMaybeXS LWP ListMoreUtils MROCompat ModulePluggable Moose MooseXEmulateClassAccessorFast MooseXGetopt MooseXMethodAttributes MooseXRoleWithOverloading PathClass Plack PlackMiddlewareFixMissingBodyInRedirect PlackMiddlewareMethodOverride PlackMiddlewareRemoveRedundantBody PlackMiddlewareReverseProxy PlackTestExternalServer SafeIsa StreamBuffered StringRewritePrefix SubExporter TaskWeaken TextSimpleTable TreeSimple TreeSimpleVisitorFactory TryTiny URI namespaceautoclean namespaceclean ];

     

       805
       805
        
           meta = {

     

       806
       806
        
             homepage = http://dev.catalyst.perl.org/;

     

       807
       807
        
             description = "The Catalyst Framework Runtime";

     
···

       817
       817
        
             sha256 = "0hqvckaw91q5yc25a33bp0d4qqxlgkp7rxlvi8n8svxd1406r55s";

     

       818
       818
        
           };

     

       819
       819
        
           propagatedBuildInputs = [ CatalystRuntime DateTime Moose namespaceautoclean ];

     

       820
       820
       +
           doCheck = false;

     

       820
       821
        
           meta = {

     

       821
       822
        
             description = "Request logging from within Catalyst";

     

       822
       823
        
             license = "perl";

     
···

       1144
       1145
        
           };

     

       1145
       1146
        
         };

     

       1146
       1147
        
       

     

       1148
       1148
       +
         CGIStruct = buildPerlPackage {

     

       1149
       1149
       +
           name = "CGI-Struct-1.21";

     

       1150
       1150
       +
           src = fetchurl {

     

       1151
       1151
       +
             url = mirror://cpan/authors/id/F/FU/FULLERMD/CGI-Struct-1.21.tar.gz;

     

       1152
       1152
       +
             sha256 = "d13d8da7fdcd6d906054e4760fc28a718aec91bd3cf067a58927fb7cb1c09d6c";

     

       1153
       1153
       +
           };

     

       1154
       1154
       +
           buildInputs = [ TestDeep ];

     

       1155
       1155
       +
           meta = {

     

       1156
       1156
       +
             description = "Build structures from CGI data";

     

       1157
       1157
       +
             license = "bsd";

     

       1158
       1158
       +
           };

     

       1159
       1159
       +
         };

     

       1160
       1160
       +
       

     

       1147
       1161
        
         ClassAccessor = buildPerlPackage {

     

       1148
       1162
        
           name = "Class-Accessor-0.34";

     

       1149
       1163
        
           src = fetchurl {

     
···

       1178
       1192
        
         };

     

       1179
       1193
        
       

     

       1180
       1194
        
         ClassAccessorGrouped = buildPerlPackage {

     

       1181
       1181
       -
           name = "Class-Accessor-Grouped-0.10010";

     

       1195
       1195
       +
           name = "Class-Accessor-Grouped-0.10012";

     

       1182
       1196
        
           src = fetchurl {

     

       1183
       1183
       -
             url = mirror://cpan/authors/id/R/RI/RIBASUSHI/Class-Accessor-Grouped-0.10010.tar.gz;

     

       1184
       1184
       -
             sha256 = "1hlfjfhagsksskv01viq1z14wlr0i4xl3nvznvq1qrnqwqxs4qi1";

     

       1197
       1197
       +
             url = mirror://cpan/authors/id/R/RI/RIBASUSHI/Class-Accessor-Grouped-0.10012.tar.gz;

     

       1198
       1198
       +
             sha256 = "c4613ee3307939f47a9afd40e8b173f3a22f501c3b139799aa030f01b627e7fe";

     

       1185
       1199
        
           };

     

       1186
       1186
       -
           buildInputs = [ TestException ];

     

       1187
       1187
       -
           propagatedBuildInputs = [ ClassXSAccessor ModuleRuntime SubName ];

     

       1200
       1200
       +
           buildInputs = [ ClassXSAccessor DevelHide PackageStash SubName TestException ];

     

       1201
       1201
       +
           propagatedBuildInputs = [ ModuleRuntime ];

     

       1188
       1202
        
           meta = {

     

       1189
       1203
        
             description = "Lets you build groups of accessors";

     

       1190
       1204
        
             license = "perl";

     
···

       1640
       1654
        
         };

     

       1641
       1655
        
       

     

       1642
       1656
        
         CPANMeta = buildPerlPackage {

     

       1643
       1643
       -
           name = "CPAN-Meta-2.120921";

     

       1657
       1657
       +
           name = "CPAN-Meta-2.142690";

     

       1644
       1658
        
           src = fetchurl {

     

       1645
       1645
       -
             url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-2.120921.tar.gz;

     

       1646
       1646
       -
             sha256 = "12cprk636jaklc97vdh55yjvzcr13h3csdnv3dgna84r2jijka79";

     

       1659
       1659
       +
             url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-2.142690.tar.gz;

     

       1660
       1660
       +
             sha256 = "495770e22e91e3d2bd04dc364f05061cabacfdce35baa3868bc0c05733d145db";

     

       1647
       1661
        
           };

     

       1648
       1648
       -
           propagatedBuildInputs = [ ParseCPANMeta CPANMetaYAML CPANMetaRequirements ];

     

       1662
       1662
       +
           propagatedBuildInputs = [ ParseCPANMeta CPANMetaYAML CPANMetaRequirements JSONPP ];

     

       1649
       1663
        
           meta = {

     

       1650
       1650
       -
             homepage = https://github.com/dagolden/cpan-meta;

     

       1664
       1664
       +
             homepage = https://github.com/Perl-Toolchain-Gang/CPAN-Meta;

     

       1651
       1665
        
             description = "The distribution metadata for a CPAN dist";

     

       1652
       1652
       -
             license = "perl5";

     

       1666
       1666
       +
             license = "perl";

     

       1653
       1667
        
           };

     

       1654
       1668
        
         };

     

       1655
       1669
        
       

     

       1656
       1670
        
         CPANMetaCheck = buildPerlPackage {

     

       1657
       1657
       -
           name = "CPAN-Meta-Check-0.004";

     

       1671
       1671
       +
           name = "CPAN-Meta-Check-0.009";

     

       1658
       1672
        
           src = fetchurl {

     

       1659
       1659
       -
             url = mirror://cpan/authors/id/L/LE/LEONT/CPAN-Meta-Check-0.004.tar.gz;

     

       1660
       1660
       -
             sha256 = "0ccybgfc0p41shmc6nmbg20xljq2ygfjcxmyaf6y07yk6wdcyf7s";

     

       1673
       1673
       +
             url = mirror://cpan/authors/id/L/LE/LEONT/CPAN-Meta-Check-0.009.tar.gz;

     

       1674
       1674
       +
             sha256 = "eb2d43afd1da276e4acdebd24937f5171d0aaca8d19a5ef0c3e834b8792b7361";

     

       1661
       1675
        
           };

     

       1662
       1662
       -
           buildInputs = [ TestDifferences ];

     

       1676
       1676
       +
           buildInputs = [ TestDeep ];

     

       1663
       1677
        
           propagatedBuildInputs = [ CPANMeta CPANMetaRequirements ];

     

       1664
       1678
        
           meta = {

     

       1665
       1665
       -
             homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;

     

       1666
       1679
        
             description = "Verify requirements in a CPAN::Meta object";

     

       1667
       1667
       -
             license = "perl5";

     

       1680
       1680
       +
             license = "perl";

     

       1668
       1681
        
           };

     

       1669
       1682
        
         };

     

       1670
       1683
        
       

     

       1671
       1684
        
         CPANMetaRequirements = buildPerlPackage {

     

       1672
       1672
       -
           name = "CPAN-Meta-Requirements-2.125";

     

       1685
       1685
       +
           name = "CPAN-Meta-Requirements-2.128";

     

       1673
       1686
        
           src = fetchurl {

     

       1674
       1674
       -
             url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-Requirements-2.125.tar.gz;

     

       1675
       1675
       -
             sha256 = "1d6sryjkk52n4m8h7l0jc4hr9xrq2d02l8clzm48rq1h6j6q49hq";

     

       1687
       1687
       +
             url = mirror://cpan/authors/id/D/DA/DAGOLDEN/CPAN-Meta-Requirements-2.128.tar.gz;

     

       1688
       1688
       +
             sha256 = "ff0ae309ed76d8c7381fdb8436659a594e6884eeac1c9a742ba9aa7ee2a1d52d";

     

       1676
       1689
        
           };

     

       1677
       1677
       -
           buildInputs = [ TestMore ];

     

       1678
       1690
        
           meta = {

     

       1679
       1679
       -
             homepage = https://github.com/dagolden/cpan-meta-requirements;

     

       1691
       1691
       +
             homepage = https://github.com/dagolden/CPAN-Meta-Requirements;

     

       1680
       1692
        
             description = "A set of version requirements for a CPAN dist";

     

       1681
       1681
       -
             license = "perl5";

     

       1693
       1693
       +
             license = "perl";

     

       1682
       1694
        
           };

     

       1683
       1695
        
         };

     

       1684
       1696
        
       

     
···

       2436
       2448
        
         };

     

       2437
       2449
        
       

     

       2438
       2450
        
         DBIxClass = buildPerlPackage {

     

       2439
       2439
       -
           name = "DBIx-Class-0.08250";

     

       2451
       2451
       +
           name = "DBIx-Class-0.082801";

     

       2440
       2452
        
           src = fetchurl {

     

       2441
       2441
       -
             url = mirror://cpan/authors/id/R/RI/RIBASUSHI/DBIx-Class-0.08250.tar.gz;

     

       2442
       2442
       -
             sha256 = "0nsqvj34klc9pf4l5kj3nqkq7agbsn11ys4115100awf7gxjbad6";

     

       2453
       2453
       +
             url = mirror://cpan/authors/id/R/RI/RIBASUSHI/DBIx-Class-0.082801.tar.gz;

     

       2454
       2454
       +
             sha256 = "889d6f9139d8e73f5524dfa211019126042e84cb7a0ec30cd2ed7d315d73484b";

     

       2443
       2455
        
           };

     

       2444
       2444
       -
           patches = [ ../development/perl-modules/dbix-class-fix-tests.patch ];

     

       2445
       2445
       -
           buildInputs = [ DBDSQLite PackageStash TestException TestWarn TestDeep ];

     

       2446
       2446
       -
           propagatedBuildInputs = [ ClassAccessorGrouped ClassC3Componentised ClassInspector ClassMethodModifiers ConfigAny ContextPreserve DataCompare DataDumperConcise DataPage DBI DevelGlobalDestruction HashMerge ModuleFind Moo MROCompat namespaceclean PathClass ScopeGuard SQLAbstract strictures SubName TryTiny ];

     

       2456
       2456
       +
           buildInputs = [ DBDSQLite PackageStash TestDeep TestException TestWarn ];

     

       2457
       2457
       +
           propagatedBuildInputs = [ ClassAccessorGrouped ClassC3Componentised ClassInspector ConfigAny ContextPreserve DBI DataDumperConcise DataPage DevelGlobalDestruction HashMerge MROCompat ModuleFind Moo PathClass SQLAbstract ScopeGuard SubName TryTiny namespaceclean ];

     

       2447
       2458
        
           meta = {

     

       2448
       2459
        
             homepage = http://www.dbix-class.org/;

     

       2449
       2460
        
             description = "Extensible and flexible object <-> relational mapper";

     
···

       2636
       2647
        
         };

     

       2637
       2648
        
       

     

       2638
       2649
        
         DevelStackTrace = buildPerlPackage {

     

       2639
       2639
       -
           name = "Devel-StackTrace-1.31";

     

       2650
       2650
       +
           name = "Devel-StackTrace-1.34";

     

       2640
       2651
        
           src = fetchurl {

     

       2641
       2641
       -
             url = mirror://cpan/authors/id/D/DR/DROLSKY/Devel-StackTrace-1.31.tar.gz;

     

       2642
       2642
       -
             sha256 = "0djvqfbq9ag1bpw0bcksidfy13n91xbl53py3d7w0y2323hjc957";

     

       2652
       2652
       +
             url = mirror://cpan/authors/id/D/DR/DROLSKY/Devel-StackTrace-1.34.tar.gz;

     

       2653
       2653
       +
             sha256 = "e882ccd7f4cbab0d0cdad53897f3f3bf29bdcf47d2bdfde1ac07f1bc7d7ebd16";

     

       2643
       2654
        
           };

     

       2644
       2655
        
           meta = {

     

       2645
       2645
       -
             homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;

     

       2656
       2656
       +
             homepage = http://metacpan.org/release/Devel-StackTrace;

     

       2646
       2657
        
             description = "An object representing a stack trace";

     

       2647
       2658
        
             license = "artistic_2";

     

       2648
       2659
        
           };

     
···

       4440
       4451
        
           };

     

       4441
       4452
        
         };

     

       4442
       4453
        
       

     

       4443
       4443
       -
         "if" = buildPerlPackage {

     

       4444
       4444
       -
           name = "if-0.01000001";

     

       4454
       4454
       +
         if_ = buildPerlPackage {

     

       4455
       4455
       +
           name = "if-0.0601";

     

       4445
       4456
        
           src = fetchurl {

     

       4446
       4446
       -
             url = mirror://cpan/authors/id/I/IL/ILYAZ/modules/if-0.01000001.tar.gz;

     

       4447
       4447
       -
             sha256 = "0vb40cb20b22layp5v9xa30hmcnhxidwjkfwcrxwhrvwypy2cmgw";

     

       4448
       4448
       -
           };

     

       4449
       4449
       -
           meta = {

     

       4457
       4457
       +
             url = mirror://cpan/authors/id/I/IL/ILYAZ/modules/if-0.0601.tar.gz;

     

       4458
       4458
       +
             sha256 = "fb2b7329aa111a673cd22dc2889167e52058aead0de2fe0855b32dd658d5c1b7";

     

       4450
       4459
        
           };

     

       4451
       4460
        
         };

     

       4452
       4461
        
       

     
···

       4792
       4801
        
           propagatedBuildInputs = [ JSON ];

     

       4793
       4802
        
           meta = {

     

       4794
       4803
        
             description = "Wrapper Class for the various JSON classes";

     

       4804
       4804
       +
             license = "perl";

     

       4805
       4805
       +
           };

     

       4806
       4806
       +
         };

     

       4807
       4807
       +
       

     

       4808
       4808
       +
         JSONMaybeXS = buildPerlPackage {

     

       4809
       4809
       +
           name = "JSON-MaybeXS-1.002005";

     

       4810
       4810
       +
           src = fetchurl {

     

       4811
       4811
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/JSON-MaybeXS-1.002005.tar.gz;

     

       4812
       4812
       +
             sha256 = "f576caf2b10bf3a8eedaf05c0d65e7d3deb52f9c5e1894579ff9ffe71207157f";

     

       4813
       4813
       +
           };

     

       4814
       4814
       +
           buildInputs = [ TestWithoutModule ];

     

       4815
       4815
       +
           propagatedBuildInputs = [ JSONPP ];

     

       4816
       4816
       +
           meta = {

     

       4817
       4817
       +
             description = "Use L<Cpanel::JSON::XS> with a fallback to L<JSON::XS> and L<JSON::PP>";

     

       4795
       4818
        
             license = "perl";

     

       4796
       4819
        
           };

     

       4797
       4820
        
         };

     
···

       5490
       5513
        
         };

     

       5491
       5514
        
       

     

       5492
       5515
        
         ModuleBuildTiny = buildPerlModule {

     

       5493
       5493
       -
           name = "Module-Build-Tiny-0.026";

     

       5516
       5516
       +
           name = "Module-Build-Tiny-0.039";

     

       5494
       5517
        
           src = fetchurl {

     

       5495
       5495
       -
             url = mirror://cpan/authors/id/L/LE/LEONT/Module-Build-Tiny-0.026.tar.gz;

     

       5496
       5496
       -
             sha256 = "9a1860325404c4ea20e2a79e7236c5ad9203ab71bacab9667044e3fad1eb31ad";

     

       5518
       5518
       +
             url = mirror://cpan/authors/id/L/LE/LEONT/Module-Build-Tiny-0.039.tar.gz;

     

       5519
       5519
       +
             sha256 = "7d580ff6ace0cbe555bf36b86dc8ea232581530cbeaaea09bccb57b55797f11c";

     

       5497
       5520
        
           };

     

       5498
       5498
       -
           buildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP perl ];

     

       5499
       5499
       -
           propagatedBuildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP ];

     

       5521
       5521
       +
           buildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP TestHarness perl ];

     

       5522
       5522
       +
           propagatedBuildInputs = [ ExtUtilsConfig ExtUtilsHelpers ExtUtilsInstallPaths JSONPP TestHarness ];

     

       5500
       5523
        
           meta = {

     

       5501
       5524
        
             description = "A tiny replacement for Module::Build";

     

       5502
       5525
        
             license = "perl";

     
···

       5696
       5719
        
           };

     

       5697
       5720
        
         };

     

       5698
       5721
        
       

     

       5722
       5722
       +
         ModuleRuntimeConflicts = buildPerlPackage {

     

       5723
       5723
       +
           name = "Module-Runtime-Conflicts-0.001";

     

       5724
       5724
       +
           src = fetchurl {

     

       5725
       5725
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/Module-Runtime-Conflicts-0.001.tar.gz;

     

       5726
       5726
       +
             sha256 = "0f73d03846575dd1492d3760deeb9627afaa1f8b04d4d526b1775174201be25f";

     

       5727
       5727
       +
           };

     

       5728
       5728
       +
           buildInputs = [ ModuleBuildTiny ];

     

       5729
       5729
       +
           propagatedBuildInputs = [ DistCheckConflicts ModuleRuntime ];

     

       5730
       5730
       +
           meta = {

     

       5731
       5731
       +
             homepage = https://github.com/karenetheridge/Module-Runtime-Conflicts;

     

       5732
       5732
       +
             description = "Provide information on conflicts for Module::Runtime";

     

       5733
       5733
       +
             license = "perl";

     

       5734
       5734
       +
           };

     

       5735
       5735
       +
         };

     

       5736
       5736
       +
       

     

       5699
       5737
        
         ModuleScanDeps = buildPerlPackage {

     

       5700
       5738
        
           name = "Module-ScanDeps-1.10";

     

       5701
       5739
        
           src = fetchurl {

     
···

       5762
       5800
        
         };

     

       5763
       5801
        
       

     

       5764
       5802
        
         Moose = buildPerlPackage {

     

       5765
       5765
       -
           name = "Moose-2.0604";

     

       5803
       5803
       +
           name = "Moose-2.1213";

     

       5766
       5804
        
           src = fetchurl {

     

       5767
       5767
       -
             url = mirror://cpan/authors/id/D/DO/DOY/Moose-2.0604.tar.gz;

     

       5768
       5768
       -
             sha256 = "0nwvklb8dwf8lskwxik3gi9gsqzrix2jhc56zvfzlf1q5q1s07qj";

     

       5805
       5805
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/Moose-2.1213.tar.gz;

     

       5806
       5806
       +
             sha256 = "0f3b196ae67dc1daaa43c44ae7703f27c4f92c391ad3e252a90e90c50c851e03";

     

       5769
       5807
        
           };

     

       5770
       5770
       -
           buildInputs = [ DistCheckConflicts TestFatal TestRequires ];

     

       5771
       5771
       -
           propagatedBuildInputs = [ ClassLoad ClassLoadXS DataOptList DevelGlobalDestruction DistCheckConflicts EvalClosure ListMoreUtils MROCompat PackageDeprecationManager PackageStash PackageStashXS ParamsUtil SubExporter SubName TaskWeaken TryTiny ];

     

       5808
       5808
       +
           buildInputs = [ CPANMetaCheck CPANMetaRequirements DistCheckConflicts TestCleanNamespaces TestFatal TestRequires ];

     

       5809
       5809
       +
           propagatedBuildInputs = [ ClassLoad ClassLoadXS DataOptList DevelGlobalDestruction DevelStackTrace DistCheckConflicts EvalClosure ListMoreUtils MROCompat ModuleRuntime ModuleRuntimeConflicts PackageDeprecationManager PackageStash PackageStashXS ParamsUtil SubExporter SubName TaskWeaken TryTiny ];

     

       5772
       5810
        
           meta = {

     

       5773
       5773
       -
             homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;

     

       5811
       5811
       +
             homepage = http://moose.perl.org/;

     

       5774
       5812
        
             description = "A postmodern object system for Perl 5";

     

       5775
       5775
       -
             license = "perl5";

     

       5813
       5813
       +
             license = "perl";

     

       5814
       5814
       +
             maintainers = [ maintainers.eelco ];

     

       5815
       5815
       +
             platforms   = stdenv.lib.platforms.linux;

     

       5776
       5816
        
           };

     

       5777
       5817
        
         };

     

       5778
       5818
        
       

     
···

       5926
       5966
        
         };

     

       5927
       5967
        
       

     

       5928
       5968
        
         MooseXGetopt = buildPerlPackage {

     

       5929
       5929
       -
           name = "MooseX-Getopt-0.50";

     

       5969
       5969
       +
           name = "MooseX-Getopt-0.65";

     

       5930
       5970
        
           src = fetchurl {

     

       5931
       5931
       -
             url = mirror://cpan/authors/id/E/ET/ETHER/MooseX-Getopt-0.50.tar.gz;

     

       5932
       5932
       -
             sha256 = "0fwm5vb8z8q4b6fmf7gz4xzw5z713mmfnxzjph6vfyyymlr5bll9";

     

       5971
       5971
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/MooseX-Getopt-0.65.tar.gz;

     

       5972
       5972
       +
             sha256 = "c07c2b7312c471bf2d331025c0ad6cc02068633eda1e208cbdb5511ef5da7fda";

     

       5933
       5973
        
           };

     

       5934
       5934
       -
           buildInputs = [ PathClass TestCheckDeps TestFatal TestMoose TestNoWarnings TestRequires TestTrap TestWarn ];

     

       5935
       5935
       -
           propagatedBuildInputs = [ GetoptLongDescriptive Moose MooseXRoleParameterized ];

     

       5974
       5974
       +
           buildInputs = [ CPANMeta ModuleBuildTiny ModuleRuntime Moose PathTiny TestDeep TestFatal TestRequires TestTrap TestWarnings if_ ];

     

       5975
       5975
       +
           propagatedBuildInputs = [ GetoptLongDescriptive Moose MooseXRoleParameterized TryTiny namespaceautoclean ];

     

       5936
       5976
        
           meta = {

     

       5937
       5937
       -
             homepage = http://metacpan.org/release/MooseX-Getopt;

     

       5977
       5977
       +
             homepage = https://github.com/moose/MooseX-Getopt;

     

       5938
       5978
        
             description = "A Moose role for processing command line options";

     

       5939
       5939
       -
             license = "perl5";

     

       5979
       5979
       +
             license = "perl";

     

       5940
       5980
        
           };

     

       5941
       5981
        
         };

     

       5942
       5982
        
       

     
···

       6237
       6277
        
           };

     

       6238
       6278
        
         };

     

       6239
       6279
        
       

     

       6240
       6240
       -
         MooseXTypesLoadableClass = buildPerlPackage rec {

     

       6241
       6241
       -
           name = "MooseX-Types-LoadableClass-0.008";

     

       6280
       6280
       +
         MooseXTypesLoadableClass = buildPerlPackage {

     

       6281
       6281
       +
           name = "MooseX-Types-LoadableClass-0.012";

     

       6242
       6282
        
           src = fetchurl {

     

       6243
       6243
       -
             url = mirror://cpan/authors/id/B/BO/BOBTFISH/MooseX-Types-LoadableClass-0.008.tar.gz;

     

       6244
       6244
       -
             sha256 = "0wh4zxknqv98nrmsp6yg6mazjyl3vacrgywarzjg5gks78c84i8g";

     

       6283
       6283
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/MooseX-Types-LoadableClass-0.012.tar.gz;

     

       6284
       6284
       +
             sha256 = "a1d2b186c2b69f416bb0c9271dc8692c2287c2f6ce144cc3b9b2c922427060df";

     

       6245
       6285
        
           };

     

       6246
       6246
       -
           propagatedBuildInputs = [ ClassLoad Moose MooseXTypes namespaceclean ];

     

       6286
       6286
       +
           buildInputs = [ ModuleBuildTiny Moose TestFatal ];

     

       6287
       6287
       +
           propagatedBuildInputs = [ ClassLoad ModuleRuntime Moose MooseXTypes namespaceautoclean ];

     

       6247
       6288
        
           meta = {

     

       6248
       6289
        
             maintainers = with maintainers; [ ocharles ];

     

       6249
       6290
        
             platforms   = stdenv.lib.platforms.unix;

     

       6291
       6291
       +
             homepage = https://github.com/moose/MooseX-Types-LoadableClass;

     

       6292
       6292
       +
             description = "ClassName type constraint with coercion to load the class";

     

       6293
       6293
       +
             license = "perl";

     

       6250
       6294
        
           };

     

       6251
       6295
        
         };

     

       6252
       6296
        
       

     
···

       6414
       6458
        
           doCheck = false; # Test performs network access.

     

       6415
       6459
        
         };

     

       6416
       6460
        
       

     

       6417
       6417
       -
         namespaceautoclean = buildPerlPackage rec {

     

       6418
       6418
       -
           name = "namespace-autoclean-0.13";

     

       6461
       6461
       +
         namespaceautoclean = buildPerlPackage {

     

       6462
       6462
       +
           name = "namespace-autoclean-0.20";

     

       6419
       6463
        
           src = fetchurl {

     

       6420
       6420
       -
             url = mirror://cpan/authors/id/B/BO/BOBTFISH/namespace-autoclean-0.13.tar.gz;

     

       6421
       6421
       -
             sha256 = "1w53k9f9zla90qdn7cyc9dx8zcv26gwy2y87gcazqsq1aj371m04";

     

       6464
       6464
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/namespace-autoclean-0.20.tar.gz;

     

       6465
       6465
       +
             sha256 = "42a199314d07b7a29044d6072529ca53037c75a43550193b1586bd19c690a05f";

     

       6422
       6466
        
           };

     

       6423
       6423
       -
           buildInputs = [ Moose SubName ];

     

       6424
       6424
       -
           propagatedBuildInputs = [ BHooksEndOfScope ClassMOP namespaceclean ];

     

       6467
       6467
       +
           buildInputs = [ ModuleBuildTiny TestRequires ];

     

       6468
       6468
       +
           propagatedBuildInputs = [ BHooksEndOfScope SubIdentify namespaceclean ];

     

       6425
       6469
        
           meta = {

     

       6426
       6426
       -
             homepage = http://metacpan.org/release/namespace-autoclean;

     

       6470
       6470
       +
             homepage = https://github.com/moose/namespace-autoclean;

     

       6427
       6471
        
             description = "Keep imports out of your namespace";

     

       6428
       6428
       -
             license = "perl5";

     

       6472
       6472
       +
             license = "perl";

     

       6429
       6473
        
           };

     

       6430
       6474
        
         };

     

       6431
       6475
        
       

     
···

       6500
       6544
        
         };

     

       6501
       6545
        
       

     

       6502
       6546
        
         NetAmazonS3 = buildPerlPackage {

     

       6503
       6503
       -
           name = "Net-Amazon-S3-0.59";

     

       6547
       6547
       +
           name = "Net-Amazon-S3-0.60";

     

       6504
       6548
        
           src = fetchurl {

     

       6505
       6505
       -
             url = mirror://cpan/authors/id/P/PF/PFIG/Net-Amazon-S3-0.59.tar.gz;

     

       6506
       6506
       -
             sha256 = "94f2bd6b317a9142e400d7d17bd573dc9d22284c3ceaa4864474ba674e0e2e9f";

     

       6549
       6549
       +
             url = mirror://cpan/authors/id/P/PF/PFIG/Net-Amazon-S3-0.60.tar.gz;

     

       6550
       6550
       +
             sha256 = "628937132268e501fb82410f96636e01b183423ea133b6c362894da109d6ac81";

     

       6507
       6551
        
           };

     

       6508
       6552
        
           buildInputs = [ LWP TestException ];

     

       6509
       6553
        
           propagatedBuildInputs = [ DataStreamBulk DateTimeFormatHTTP DigestHMAC DigestMD5File FileFindRule HTTPDate HTTPMessage LWPUserAgentDetermined MIMETypes Moose MooseXStrictConstructor MooseXTypesDateTimeMoreCoercions PathClass RegexpCommon TermEncoding TermProgressBarSimple URI XMLLibXML JSON ];

     
···

       6807
       6851
        
         };

     

       6808
       6852
        
       

     

       6809
       6853
        
         PackageStash = buildPerlPackage {

     

       6810
       6810
       -
           name = "Package-Stash-0.34";

     

       6854
       6854
       +
           name = "Package-Stash-0.37";

     

       6811
       6855
        
           src = fetchurl {

     

       6812
       6812
       -
             url = mirror://cpan/authors/id/D/DO/DOY/Package-Stash-0.34.tar.gz;

     

       6813
       6813
       -
             sha256 = "1674zs96ndq3czs6v8xkdqqz4fnka0i2835nnns9zbw2q01yirj6";

     

       6856
       6856
       +
             url = mirror://cpan/authors/id/D/DO/DOY/Package-Stash-0.37.tar.gz;

     

       6857
       6857
       +
             sha256 = "06ab05388f9130cd377c0e1d3e3bafeed6ef6a1e22104571a9e1d7bfac787b2c";

     

       6814
       6858
        
           };

     

       6815
       6859
        
           buildInputs = [ DistCheckConflicts TestFatal TestRequires ];

     

       6816
       6816
       -
           propagatedBuildInputs = [ DistCheckConflicts ModuleImplementation PackageDeprecationManager ];

     

       6860
       6860
       +
           propagatedBuildInputs = [ DistCheckConflicts ModuleImplementation ];

     

       6817
       6861
        
           meta = {

     

       6818
       6862
        
             homepage = http://metacpan.org/release/Package-Stash;

     

       6819
       6863
        
             description = "Routines for manipulating stashes";

     

       6820
       6820
       -
             license = "perl5";

     

       6864
       6864
       +
             license = "perl";

     

       6821
       6865
        
           };

     

       6822
       6866
        
         };

     

       6823
       6867
        
       

     
···

       7070
       7114
        
           };

     

       7071
       7115
        
         };

     

       7072
       7116
        
       

     

       7117
       7117
       +
         PlackMiddlewareFixMissingBodyInRedirect = buildPerlPackage {

     

       7118
       7118
       +
           name = "Plack-Middleware-FixMissingBodyInRedirect-0.11";

     

       7119
       7119
       +
           src = fetchurl {

     

       7120
       7120
       +
             url = mirror://cpan/authors/id/S/SW/SWEETKID/Plack-Middleware-FixMissingBodyInRedirect-0.11.tar.gz;

     

       7121
       7121
       +
             sha256 = "eb4d4232344e7da3217347b847736ea55df962d11b870a225315d9241e8fbefb";

     

       7122
       7122
       +
           };

     

       7123
       7123
       +
           buildInputs = [ HTTPMessage Plack ];

     

       7124
       7124
       +
           propagatedBuildInputs = [ HTMLParser Plack ];

     

       7125
       7125
       +
           meta = {

     

       7126
       7126
       +
             homepage = https://github.com/Sweet-kid/Plack-Middleware-FixMissingBodyInRedirect;

     

       7127
       7127
       +
             description = "Plack::Middleware which sets body for redirect response, if it's not already set";

     

       7128
       7128
       +
             license = "perl";

     

       7129
       7129
       +
           };

     

       7130
       7130
       +
         };

     

       7131
       7131
       +
       

     

       7132
       7132
       +
         PlackMiddlewareMethodOverride = buildPerlModule {

     

       7133
       7133
       +
           name = "Plack-Middleware-MethodOverride-0.10";

     

       7134
       7134
       +
           src = fetchurl {

     

       7135
       7135
       +
             url = mirror://cpan/authors/id/D/DW/DWHEELER/Plack-Middleware-MethodOverride-0.10.tar.gz;

     

       7136
       7136
       +
             sha256 = "f8d6a33b56d69dddd5db289f855e100d86ff39099abe31ef40e2672d0dc5568d";

     

       7137
       7137
       +
           };

     

       7138
       7138
       +
           propagatedBuildInputs = [ Plack URI ];

     

       7139
       7139
       +
           meta = {

     

       7140
       7140
       +
             homepage = http://search.cpan.org/dist/Plack-Middleware-MethodOverride/;

     

       7141
       7141
       +
             description = "Override REST methods to Plack apps via POST";

     

       7142
       7142
       +
             license = "perl";

     

       7143
       7143
       +
           };

     

       7144
       7144
       +
         };

     

       7145
       7145
       +
       

     

       7146
       7146
       +
         PlackMiddlewareRemoveRedundantBody = buildPerlPackage {

     

       7147
       7147
       +
           name = "Plack-Middleware-RemoveRedundantBody-0.05";

     

       7148
       7148
       +
           src = fetchurl {

     

       7149
       7149
       +
             url = mirror://cpan/authors/id/S/SW/SWEETKID/Plack-Middleware-RemoveRedundantBody-0.05.tar.gz;

     

       7150
       7150
       +
             sha256 = "a0676e1c792bea7f25f1d901bee59054d35012d5ea8cd42529d336143fa87cd8";

     

       7151
       7151
       +
           };

     

       7152
       7152
       +
           buildInputs = [ HTTPMessage Plack ];

     

       7153
       7153
       +
           propagatedBuildInputs = [ Plack ];

     

       7154
       7154
       +
           meta = {

     

       7155
       7155
       +
             homepage = https://github.com/Sweet-kid/Plack-Middleware-RemoveRedundantBody;

     

       7156
       7156
       +
             description = "Plack::Middleware which sets removes body for HTTP response if it's not required";

     

       7157
       7157
       +
             license = "perl";

     

       7158
       7158
       +
           };

     

       7159
       7159
       +
         };

     

       7160
       7160
       +
       

     

       7073
       7161
        
         PlackMiddlewareReverseProxy = buildPerlPackage {

     

       7074
       7162
        
           name = "Plack-Middleware-ReverseProxy-0.15";

     

       7075
       7163
        
           src = fetchurl {

     
···

       7670
       7758
        
         };

     

       7671
       7759
        
       

     

       7672
       7760
        
         SQLAbstract = buildPerlPackage {

     

       7673
       7673
       -
           name = "SQL-Abstract-1.73";

     

       7761
       7761
       +
           name = "SQL-Abstract-1.80";

     

       7674
       7762
        
           src = fetchurl {

     

       7675
       7675
       -
             url = mirror://cpan/authors/id/F/FR/FREW/SQL-Abstract-1.73.tar.gz;

     

       7676
       7676
       -
             sha256 = "081ppyvsc66yshmfr9q9v7hp9g58725nnibd771i9g153vzs49kb";

     

       7763
       7763
       +
             url = mirror://cpan/authors/id/R/RI/RIBASUSHI/SQL-Abstract-1.80.tar.gz;

     

       7764
       7764
       +
             sha256 = "de4d0507fca0c6340c17867abca0632017bd56594443e67ea6ace826ba9a07a2";

     

       7677
       7765
        
           };

     

       7678
       7678
       -
           buildInputs = [ TestException TestWarn ];

     

       7679
       7679
       -
           propagatedBuildInputs = [ ClassAccessorGrouped GetoptLongDescriptive HashMerge ];

     

       7766
       7766
       +
           buildInputs = [ TestDeep TestException TestWarn ];

     

       7767
       7767
       +
           propagatedBuildInputs = [ HashMerge MROCompat Moo ];

     

       7680
       7768
        
           meta = {

     

       7681
       7769
        
             description = "Generate SQL from Perl data structures";

     

       7682
       7770
        
             license = "perl";

     
···

       8488
       8576
        
           };

     

       8489
       8577
        
         };

     

       8490
       8578
        
       

     

       8579
       8579
       +
         TestCleanNamespaces = buildPerlPackage {

     

       8580
       8580
       +
           name = "Test-CleanNamespaces-0.16";

     

       8581
       8581
       +
           src = fetchurl {

     

       8582
       8582
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/Test-CleanNamespaces-0.16.tar.gz;

     

       8583
       8583
       +
             sha256 = "9779378394b9be32cf04129fafe2d40d74f6f200f593f1494998bd128a6ed9fa";

     

       8584
       8584
       +
           };

     

       8585
       8585
       +
           buildInputs = [ ModuleRuntime TestDeep TestRequires TestTester TestWarnings if_ ];

     

       8586
       8586
       +
           propagatedBuildInputs = [ FileFindRule FileFindRulePerl ModuleRuntime PackageStash SubExporter SubIdentify namespaceclean ];

     

       8587
       8587
       +
           meta = {

     

       8588
       8588
       +
             homepage = https://github.com/karenetheridge/Test-CleanNamespaces;

     

       8589
       8589
       +
             description = "Check for uncleaned imports";

     

       8590
       8590
       +
             license = "perl";

     

       8591
       8591
       +
           };

     

       8592
       8592
       +
         };

     

       8593
       8593
       +
       

     

       8491
       8594
        
         TestCPANMeta = buildPerlPackage {

     

       8492
       8595
        
           name = "Test-CPAN-Meta-0.23";

     

       8493
       8596
        
           src = fetchurl {

     
···

       8609
       8712
        
           };

     

       8610
       8713
        
         };

     

       8611
       8714
        
       

     

       8612
       8612
       -
         TestHarness = buildPerlPackage rec {

     

       8613
       8613
       -
           name = "Test-Harness-3.17";

     

       8715
       8715
       +
         TestHarness = buildPerlPackage {

     

       8716
       8716
       +
           name = "Test-Harness-3.33";

     

       8614
       8717
        
           src = fetchurl {

     

       8615
       8615
       -
             url = "mirror://cpan/authors/id/A/AN/ANDYA/${name}.tar.gz";

     

       8616
       8616
       -
             sha256 = "0j390xx6an88gh49n7zz8mj1s3z0xsxc8dynfq71xf7ba7i1afhr";

     

       8718
       8718
       +
             url = mirror://cpan/authors/id/L/LE/LEONT/Test-Harness-3.33.tar.gz;

     

       8719
       8719
       +
             sha256 = "c22e36287d5cee3c28fd2006e3c8b6e7cc76c6fc39d79c7ab74f1936d35e8fe2";

     

       8720
       8720
       +
           };

     

       8721
       8721
       +
           doCheck = false; # makes assumptions about path to Perl

     

       8722
       8722
       +
           meta = {

     

       8723
       8723
       +
             homepage = http://testanything.org/;

     

       8724
       8724
       +
             description = "Run Perl standard test scripts with statistics";

     

       8725
       8725
       +
             license = "perl";

     

       8617
       8726
        
           };

     

       8618
       8727
        
         };

     

       8619
       8728
        
       

     
···

       8701
       8810
        
           propagatedBuildInputs = [TestException UNIVERSALisa UNIVERSALcan];

     

       8702
       8811
        
         };

     

       8703
       8812
        
       

     

       8704
       8704
       -
         TestMoose = buildPerlPackage {

     

       8705
       8705
       -
           name = "Test-Moose-2.0604";

     

       8706
       8706
       -
           src = fetchurl {

     

       8707
       8707
       -
             url = mirror://cpan/authors/id/D/DO/DOY/Moose-2.0604.tar.gz;

     

       8708
       8708
       -
             sha256 = "0nwvklb8dwf8lskwxik3gi9gsqzrix2jhc56zvfzlf1q5q1s07qj";

     

       8709
       8709
       -
           };

     

       8710
       8710
       -
           buildInputs = [ DistCheckConflicts TestFatal TestRequires ];

     

       8711
       8711
       -
           propagatedBuildInputs = [ ClassLoad ClassLoadXS DataOptList DevelGlobalDestruction DistCheckConflicts EvalClosure ListMoreUtils MROCompat PackageDeprecationManager PackageStash PackageStashXS ParamsUtil SubExporter SubName TaskWeaken TryTiny ];

     

       8712
       8712
       -
           meta = {

     

       8713
       8713
       -
             homepage = http://search.cpan.org/perldoc?CPAN::Meta::Spec;

     

       8714
       8714
       -
             description = "A postmodern object system for Perl 5";

     

       8715
       8715
       -
             license = "perl5";

     

       8716
       8716
       -
           };

     

       8717
       8717
       -
         };

     

       8813
       8813
       +
         TestMoose = Moose;

     

       8718
       8814
        
       

     

       8719
       8815
        
         TestMockTime = buildPerlPackage rec {

     

       8720
       8816
        
           name = "Test-MockTime-0.12";

     
···

       9014
       9110
        
           };

     

       9015
       9111
        
         };

     

       9016
       9112
        
       

     

       9017
       9017
       -
         TestWarnings = buildPerlModule {

     

       9018
       9018
       -
           name = "Test-Warnings-0.008";

     

       9113
       9113
       +
         TestWarnings = buildPerlPackage {

     

       9114
       9114
       +
           name = "Test-Warnings-0.016";

     

       9019
       9115
        
           src = fetchurl {

     

       9020
       9020
       -
             url = mirror://cpan/authors/id/E/ET/ETHER/Test-Warnings-0.008.tar.gz;

     

       9021
       9021
       -
             sha256 = "119f2a279fe7d0681dcf4517f1bcb056e4596cfbae7b9ee447118f036cf089e4";

     

       9116
       9116
       +
             url = mirror://cpan/authors/id/E/ET/ETHER/Test-Warnings-0.016.tar.gz;

     

       9117
       9117
       +
             sha256 = "09ebc9afa29eb4d1d44fbd974dfcd52e0a2d9ce7ec3e3ee7602394157831aba9";

     

       9022
       9118
        
           };

     

       9023
       9023
       -
           buildInputs = [ CaptureTiny ModuleBuildTiny TestCheckDeps TestDeep TestTester pkgs.perlPackages."if" ];

     

       9119
       9119
       +
           buildInputs = [ TestTester if_ ];

     

       9024
       9120
        
           meta = {

     

       9025
       9121
        
             homepage = https://github.com/karenetheridge/Test-Warnings;

     

       9026
       9122
        
             description = "Test for warnings and the lack of them";

     
···

       9089
       9185
        
             url = mirror://cpan/authors/id/L/LB/LBROCARD/Test-WWW-Mechanize-PSGI-0.35.tar.gz;

     

       9090
       9186
        
             sha256 = "1hih8s49zf38bisvhnhzrrj0zwyiivkrbs7nmmdqm1qqy27wv7pc";

     

       9091
       9187
        
           };

     

       9188
       9188
       +
           buildInputs = [ TestPod ];

     

       9092
       9189
        
           propagatedBuildInputs = [ Plack TestWWWMechanize TryTiny ];

     

       9093
       9190
        
           meta = {

     

       9094
       9191
        
             description = "Test PSGI programs using WWW::Mechanize";

     
···

       9524
       9621
        
         };

     

       9525
       9622
        
       

     

       9526
       9623
        
         TryTiny = buildPerlPackage {

     

       9527
       9527
       -
           name = "Try-Tiny-0.12";

     

       9624
       9624
       +
           name = "Try-Tiny-0.22";

     

       9528
       9625
        
           src = fetchurl {

     

       9529
       9529
       -
             url = mirror://cpan/authors/id/D/DO/DOY/Try-Tiny-0.12.tar.gz;

     

       9530
       9530
       -
             sha256 = "0awv2w33jb1xw3bsrfwsz53dgwm8s8vnpk4ssxxp3n89i7116p2g";

     

       9626
       9626
       +
             url = mirror://cpan/authors/id/D/DO/DOY/Try-Tiny-0.22.tar.gz;

     

       9627
       9627
       +
             sha256 = "60fba46f4693d33d54539104f9001df008dabb400b6837e9605c39a6ee6a1b19";

     

       9531
       9628
        
           };

     

       9629
       9629
       +
           buildInputs = [ if_ ];

     

       9532
       9630
        
           meta = {

     

       9533
       9533
       -
             homepage = https://github.com/doy/try-tiny.git;

     

       9631
       9631
       +
             homepage = http://metacpan.org/release/Try-Tiny;

     

       9632
       9632
       +
             description = "Minimal try/catch with proper preservation of $@";

     

       9633
       9633
       +
             license = "mit";

     

       9534
       9634
        
           };

     

       9535
       9635
        
         };

     

       9536
       9636

+231 -12

pkgs/top-level/python-packages.nix

···

       102
       102
        
         };

     

       103
       103
        
       

     

       104
       104
        
         ipython = callPackage ../shells/ipython {

     

       105
       105
       +
           inherit pythonPackages;

     

       106
       106
       +
       

     

       105
       107
        
           qtconsoleSupport = !pkgs.stdenv.isDarwin; # qt is not supported on darwin

     

       106
       108
        
           pylabQtSupport = !pkgs.stdenv.isDarwin;

     

       107
       109
        
           pylabSupport = !pkgs.stdenv.isDarwin; # cups is not supported on darwin

     
···

       121
       123
        
       

     

       122
       124
        
         # This is used for NixOps to make sure we won't break it with the next major

     

       123
       125
        
         # version of nixpart.

     

       124
       124
       -
         nixpart0 = self.nixpart;

     

       126
       126
       +
         nixpart0 = callPackage ../tools/filesystems/nixpart/0.4 { };

     

       125
       127
        
       

     

       126
       128
        
         pitz = callPackage ../applications/misc/pitz { };

     

       127
       129
        
       

     
···

       389
       391
        
           meta = {

     

       390
       392
        
             homepage = http://code.google.com/p/py-amqplib/;

     

       391
       393
        
             description = "Python client for the Advanced Message Queuing Procotol (AMQP)";

     

       394
       394
       +
           };

     

       395
       395
       +
         };

     

       396
       396
       +
       

     

       397
       397
       +
       

     

       398
       398
       +
         application = buildPythonPackage rec {

     

       399
       399
       +
           name = "python-application-${version}";

     

       400
       400
       +
           version = "1.4.1";

     

       401
       401
       +
       

     

       402
       402
       +
           src = pkgs.fetchurl {

     

       403
       403
       +
             url = "https://pypi.python.org/packages/source/p/python-application/${name}.tar.gz";

     

       404
       404
       +
             sha256 = "3ae188e9dfd4bd63c9b43aebbf1d9de5df03fb5ac01e72f3bff5b41007570275";

     

       392
       405
        
           };

     

       393
       406
        
         };

     

       394
       407
        
       

     
···

       1277
       1290
        
         });

     

       1278
       1291
        
       

     

       1279
       1292
        
       

     

       1293
       1293
       +
         cjson = buildPythonPackage rec {

     

       1294
       1294
       +
           name = "python-cjson-${version}";

     

       1295
       1295
       +
           version = "1.1.0";

     

       1296
       1296
       +
           disabled = isPy3k || isPyPy;

     

       1297
       1297
       +
       

     

       1298
       1298
       +
           src = pkgs.fetchurl {

     

       1299
       1299
       +
             url = "https://pypi.python.org/packages/source/p/python-cjson/${name}.tar.gz";

     

       1300
       1300
       +
             sha256 = "a01fabb7593728c3d851e1cd9a3efbd18f72650a31a5aa8a74018640da3de8b3";

     

       1301
       1301
       +
           };

     

       1302
       1302
       +
       

     

       1303
       1303
       +
           meta = with stdenv.lib; {

     

       1304
       1304
       +
             description = "This module implements a very fast JSON encoder/decoder for Python.";

     

       1305
       1305
       +
             homepage    = "http://ag-projects.com/";

     

       1306
       1306
       +
             license     = licenses.lgpl2;

     

       1307
       1307
       +
             platforms   = platforms.all;

     

       1308
       1308
       +
           };

     

       1309
       1309
       +
         };

     

       1310
       1310
       +
       

     

       1311
       1311
       +
       

     

       1280
       1312
        
         click = buildPythonPackage {

     

       1281
       1313
        
           name = "click-2.1";

     

       1282
       1314
        
           src = pkgs.fetchurl {

     
···

       1952
       1984
        
           };

     

       1953
       1985
        
         };

     

       1954
       1986
        
       

     

       1987
       1987
       +
         dns = buildPythonPackage rec {

     

       1988
       1988
       +
           name = "dnspython-${version}";

     

       1989
       1989
       +
           version = "1.12.0";

     

       1990
       1990
       +
       

     

       1991
       1991
       +
           src = pkgs.fetchurl {

     

       1992
       1992
       +
             url = "http://www.dnspython.org/kits/1.12.0/dnspython-1.12.0.tar.gz";

     

       1993
       1993
       +
             sha256 = "0kvjlkp96qzh3j31szpjlzqbp02brixh4j4clnpw80b0hspq5yq3";

     

       1994
       1994
       +
           };

     

       1995
       1995
       +
         };

     

       1996
       1996
       +
       

     

       1955
       1997
        
         docker = buildPythonPackage rec {

     

       1956
       1998
        
           name = "docker-py-0.4.0";

     

       1957
       1999
        
       

     
···

       2118
       2160
        
         };

     

       2119
       2161
        
       

     

       2120
       2162
        
       

     

       2163
       2163
       +
         eventlib = buildPythonPackage rec {

     

       2164
       2164
       +
           name = "python-eventlib-${version}";

     

       2165
       2165
       +
           version = "0.2.0";

     

       2166
       2166
       +
       

     

       2167
       2167
       +
           src = pkgs.fetchurl {

     

       2168
       2168
       +
             url = "http://download.ag-projects.com/SipClient/${name}.tar.gz";

     

       2169
       2169
       +
             sha256 = "0fld5lb85ql4a5bgc38sdxi5pgzqljysp1p8f7abxnd6vymh4rgi";

     

       2170
       2170
       +
           };

     

       2171
       2171
       +
       

     

       2172
       2172
       +
           propagatedBuildInputs = with self; [ greenlet ];

     

       2173
       2173
       +
       

     

       2174
       2174
       +
           meta = with stdenv.lib; {

     

       2175
       2175
       +
             description = "Eventlib bindings for python.";

     

       2176
       2176
       +
             homepage    = "http://ag-projects.com/";

     

       2177
       2177
       +
             license     = licenses.lgpl2;

     

       2178
       2178
       +
             platforms   = platforms.all;

     

       2179
       2179
       +
           };

     

       2180
       2180
       +
         };

     

       2181
       2181
       +
       

     

       2182
       2182
       +
       

     

       2121
       2183
        
         eyeD3 = buildPythonPackage rec {

     

       2122
       2184
        
           version = "0.7.4";

     

       2123
       2185
        
           name    = "eyeD3-${version}";

     
···

       2316
       2378
        
           '';

     

       2317
       2379
        
       

     

       2318
       2380
        
           propagatedBuildInputs = with self; [ gflags iso8601_0_1_4 ipaddr httplib2 google_apputils google_api_python_client ];

     

       2381
       2381
       +
         };

     

       2382
       2382
       +
       

     

       2383
       2383
       +
         gnutls = buildPythonPackage rec {

     

       2384
       2384
       +
           name = "python-gnutls";

     

       2385
       2385
       +
           src = pkgs.fetchurl {

     

       2386
       2386
       +
             url = "https://pypi.python.org/packages/source/p/python-gnutls/python-gnutls-2.0.1.tar.gz";

     

       2387
       2387
       +
             sha256 = "d8fb368c6a4dd58bc6cd5e61d4a12d119c4506fd344a371b3429b3ac2623b9ac";

     

       2388
       2388
       +
           };

     

       2389
       2389
       +
       

     

       2390
       2390
       +
           propagatedBuildInputs = with self; [ pkgs.gnutls ];

     

       2319
       2391
        
         };

     

       2320
       2392
        
       

     

       2321
       2393
        
         gitdb = buildPythonPackage rec {

     
···

       4060
       4132
        
           };

     

       4061
       4133
        
         };

     

       4062
       4134
        
       

     

       4135
       4135
       +
       

     

       4063
       4136
        
         greenlet = buildPythonPackage rec {

     

       4064
       4064
       -
           name = "greenlet-0.4.3";

     

       4137
       4137
       +
           name = "greenlet-${version}";

     

       4138
       4138
       +
           version = "0.4.4";

     

       4065
       4139
        
           disabled = isPyPy;  # builtin for pypy

     

       4066
       4140
        
       

     

       4067
       4141
        
           src = pkgs.fetchurl {

     

       4068
       4068
       -
             url = "http://pypi.python.org/packages/source/g/greenlet/${name}.zip";

     

       4069
       4069
       -
             md5 = "a5e467a5876c415cd357c1ab9027e06c";

     

       4142
       4142
       +
             url = "https://pypi.python.org/packages/source/g/greenlet/${name}.zip";

     

       4143
       4143
       +
             sha256 = "935a76b7ad3c41846af26e136e2fd8ec763794cbc5b5fbc4b7b09d9a8de1d056";

     

       4070
       4144
        
           };

     

       4071
       4145
        
       

     

       4072
       4072
       -
           meta = {

     

       4146
       4146
       +
           meta = with stdenv.lib; {

     

       4073
       4147
        
             homepage = http://pypi.python.org/pypi/greenlet;

     

       4074
       4148
        
             description = "Module for lightweight in-process concurrent programming";

     

       4149
       4149
       +
             license     = licenses.lgpl2;

     

       4150
       4150
       +
             platforms   = platforms.all;

     

       4075
       4151
        
           };

     

       4076
       4152
        
         };

     

       4077
       4153
        
       

     
···

       5096
       5172
        
         };

     

       5097
       5173
        
       

     

       5098
       5174
        
       

     

       5175
       5175
       +
         msrplib = buildPythonPackage rec {

     

       5176
       5176
       +
           name = "python-msrplib-${version}";

     

       5177
       5177
       +
           version = "0.15.0";

     

       5178
       5178
       +
       

     

       5179
       5179
       +
           src = pkgs.fetchurl {

     

       5180
       5180
       +
             url = "http://download.ag-projects.com/SipClient/${name}.tar.gz";

     

       5181
       5181
       +
             sha256 = "1sm03jcz663xkbhfmrk7rr5l3wlkydn8xs56fvqjxyapx0m5sw6f";

     

       5182
       5182
       +
           };

     

       5183
       5183
       +
       

     

       5184
       5184
       +
           propagatedBuildInputs = with self; [ eventlib application gnutls ];

     

       5185
       5185
       +
         };

     

       5186
       5186
       +
       

     

       5187
       5187
       +
       

     

       5099
       5188
        
         munkres = buildPythonPackage rec {

     

       5100
       5189
        
           name = "munkres-1.0.6";

     

       5101
       5190
        
       

     
···

       5774
       5863
        
       

     

       5775
       5864
        
         });

     

       5776
       5865
        
       

     

       5866
       5866
       +
         pagerduty = buildPythonPackage rec {

     

       5867
       5867
       +
           name = "pagerduty-${version}";

     

       5868
       5868
       +
           version = "0.2.1";

     

       5869
       5869
       +
           disabled = isPy3k;

     

       5870
       5870
       +
       

     

       5871
       5871
       +
           src = pkgs.fetchurl {

     

       5872
       5872
       +
               url = "https://pypi.python.org/packages/source/p/pagerduty/pagerduty-${version}.tar.gz";

     

       5873
       5873
       +
               md5 = "8109a330d16751a7f4041c0ccedec787";

     

       5874
       5874
       +
           };

     

       5875
       5875
       +
         };

     

       5876
       5876
       +
       

     

       5777
       5877
        
         pandas = buildPythonPackage rec {

     

       5778
       5878
        
           name = "pandas-0.14.0";

     

       5779
       5879
        
       

     
···

       6092
       6192
        
             md5 = "56b6614499aacb7d6b5983c4914daea7";

     

       6093
       6193
        
           };

     

       6094
       6194
        
       

     

       6095
       6095
       -
           buildInputs = with self; [ pkgs.freetype pkgs.libjpeg pkgs.zlib pkgs.libtiff pkgs.libwebp ];

     

       6195
       6195
       +
           buildInputs = with self; [ pkgs.freetype pkgs.libjpeg pkgs.zlib pkgs.libtiff pkgs.libwebp pkgs.tcl ];

     

       6096
       6196
        
       

     

       6097
       6197
        
           # NOTE: we use LCMS_ROOT as WEBP root since there is not other setting for webp.

     

       6098
       6198
        
           preConfigure = ''

     
···

       6101
       6201
        
                     s|^JPEG_ROOT =.*$|JPEG_ROOT = _lib_include("${pkgs.libjpeg}")|g ;

     

       6102
       6202
        
                     s|^ZLIB_ROOT =.*$|ZLIB_ROOT = _lib_include("${pkgs.zlib}")|g ;

     

       6103
       6203
        
                     s|^LCMS_ROOT =.*$|LCMS_ROOT = _lib_include("${pkgs.libwebp}")|g ;

     

       6104
       6104
       -
                     s|^TIFF_ROOT =.*$|TIFF_ROOT = _lib_include("${pkgs.libtiff}")|g ;'

     

       6204
       6204
       +
                     s|^TIFF_ROOT =.*$|TIFF_ROOT = _lib_include("${pkgs.libtiff}")|g ;

     

       6205
       6205
       +
                     s|^TCL_ROOT=.*$|TCL_ROOT = _lib_include("${pkgs.tcl}")|g ;'

     

       6105
       6206
        
           '';

     

       6106
       6207
        
       

     

       6107
       6107
       -
       

     

       6108
       6108
       -
       

     

       6109
       6208
        
           meta = {

     

       6110
       6209
        
             homepage = http://python-imaging.github.com/Pillow;

     

       6111
       6210
        
       

     
···

       6418
       6517
        
             license = stdenv.lib.licenses.gpl2Plus;

     

       6419
       6518
        
           };

     

       6420
       6519
        
         };

     

       6520
       6520
       +
       

     

       6421
       6521
        
       

     

       6422
       6522
        
         pycapnp = buildPythonPackage rec {

     

       6423
       6523
        
           name = "pycapnp-0.4.4";

     
···

       6758
       6858
        
             sha256 = "17wq4invmv1nfazaksf59ymqyvgv3i8h4q03ry2az0s9lldyg3dv";

     

       6759
       6859
        
           };

     

       6760
       6860
        
       

     

       6861
       6861
       +
           patches = singleton (pkgs.fetchurl {

     

       6862
       6862
       +
             url = "https://www.redhat.com/archives/pyparted-devel/"

     

       6863
       6863
       +
                 + "2014-April/msg00000.html";

     

       6864
       6864
       +
             postFetch = ''

     

       6865
       6865
       +
               sed -i -ne '/<!--X-Body-of-Message-->/,/<!--X-Body-of-Message-End-->/ {

     

       6866
       6866
       +
                 s/^<[^>]*>//; /^$/!p

     

       6867
       6867
       +
               }' "$downloadedFile"

     

       6868
       6868
       +
             '';

     

       6869
       6869
       +
             sha256 = "1lakhz3nvx0qacn90bj1nq13zqxphiw4d9dsc44gwa8nj24j2zws";

     

       6870
       6870
       +
           });

     

       6871
       6871
       +
       

     

       6761
       6872
        
           postPatch = ''

     

       6762
       6873
        
             sed -i -e 's|/sbin/mke2fs|${pkgs.e2fsprogs}&|' tests/baseclass.py

     

       6763
       6874
        
             sed -i -e '

     
···

       6907
       7018
        
           propagatedBuildInputs = with self; [ kitchen requests bunch paver ];

     

       6908
       7019
        
           doCheck = false;

     

       6909
       7020
        
         });

     

       7021
       7021
       +
       

     

       7022
       7022
       +
         python_simple_hipchat = buildPythonPackage rec {

     

       7023
       7023
       +
           name = "python-simple-hipchat-${version}";

     

       7024
       7024
       +
           version = "0.1";

     

       7025
       7025
       +
       

     

       7026
       7026
       +
           src = pkgs.fetchurl {

     

       7027
       7027
       +
             url = "https://pypi.python.org/packages/source/p/python-simple-hipchat/python-simple-hipchat-${version}.zip";

     

       7028
       7028
       +
             md5 = "3806b3729a021511bac065360832f197";

     

       7029
       7029
       +
           };

     

       7030
       7030
       +
       

     

       7031
       7031
       +
           buildInputs = [ pkgs.unzip ];

     

       7032
       7032
       +
         };

     

       6910
       7033
        
       

     

       6911
       7034
        
         python_keyczar = buildPythonPackage rec {

     

       6912
       7035
        
           name = "python-keyczar-0.71c";

     
···

       7900
       8023
        
         };

     

       7901
       8024
        
       

     

       7902
       8025
        
       

     

       8026
       8026
       +
         scapy = buildPythonPackage rec {

     

       8027
       8027
       +
           name = "scapy-2.2.0";

     

       8028
       8028
       +
       

     

       8029
       8029
       +
           disabled = isPy3k || isPyPy;

     

       8030
       8030
       +
       

     

       8031
       8031
       +
           src = pkgs.fetchurl {

     

       8032
       8032
       +
             url = "http://www.secdev.org/projects/scapy/files/${name}.tar.gz";

     

       8033
       8033
       +
             sha256 = "1bqmp0xglkndrqgmybpwmzkv462mir8qlkfwsxwbvvzh9li3ndn5";

     

       8034
       8034
       +
           };

     

       8035
       8035
       +
       

     

       8036
       8036
       +
           propagatedBuildInputs = [ modules.readline ];

     

       8037
       8037
       +
       

     

       8038
       8038
       +
           meta = with stdenv.lib; {

     

       8039
       8039
       +
             description = "Powerful interactive network packet manipulation program";

     

       8040
       8040
       +
             homepage = http://www.secdev.org/projects/scapy/;

     

       8041
       8041
       +
             license = licenses.gpl2;

     

       8042
       8042
       +
             platforms = platforms.linux;

     

       8043
       8043
       +
             maintainers = [ maintainers.bjornfor ];

     

       8044
       8044
       +
           };

     

       8045
       8045
       +
         };

     

       8046
       8046
       +
       

     

       8047
       8047
       +
       

     

       7903
       8048
        
         scipy = buildPythonPackage rec {

     

       7904
       8049
        
           name = "scipy-0.14.0";

     

       7905
       8050
        
       

     
···

       8128
       8273
        
             sha256 = "bec9269cbfa58de4f0849ec79bb7d54eeeed9df8b5fbfa1637fbc68062822847";

     

       8129
       8274
        
           };

     

       8130
       8275
        
       

     

       8131
       8131
       -
           buildInputs = with self; [ pbr pip ];

     

       8276
       8276
       +
           buildInputs = with self; [ pbr pip ] ++ optional isPy26 argparse;

     

       8132
       8277
        
       

     

       8133
       8278
        
           propagatedBuildInputs = with self; [ setuptools ];

     

       8134
       8279
        
       

     
···

       8325
       8470
        
         };

     

       8326
       8471
        
       

     

       8327
       8472
        
       

     

       8473
       8473
       +
         sipsimple = buildPythonPackage rec {

     

       8474
       8474
       +
           name = "sipsimple-${version}";

     

       8475
       8475
       +
           version = "1.4.2";

     

       8476
       8476
       +
           disabled = isPy3k;

     

       8477
       8477
       +
       

     

       8478
       8478
       +
           configurePhase = "find -name 'configure' -exec chmod a+x {} \\; ; find -name 'aconfigure' -exec chmod a+x {} \\; ; ${python}/bin/${python.executable} setup.py build_ext --pjsip-clean-compile";

     

       8479
       8479
       +
       

     

       8480
       8480
       +
           src = pkgs.fetchurl {

     

       8481
       8481
       +
             url = "http://download.ag-projects.com/SipClient/python-${name}.tar.gz";

     

       8482
       8482
       +
             sha256 = "f6e6de7ab5f20e8ae08966b8811462e4271833db4f7fbab58ffba4e5c07ab114";

     

       8483
       8483
       +
           };

     

       8484
       8484
       +
       

     

       8485
       8485
       +
           propagatedBuildInputs = with self; [ cython pkgs.openssl dns dateutil xcaplib msrplib];

     

       8486
       8486
       +
       

     

       8487
       8487
       +
           buildInputs = with self; [ pkgs.alsaLib ];

     

       8488
       8488
       +
       

     

       8489
       8489
       +
           installPhase = "${python}/bin/${python.executable} setup.py install --prefix=$out";

     

       8490
       8490
       +
       

     

       8491
       8491
       +
           doCheck = false;

     

       8492
       8492
       +
         };

     

       8493
       8493
       +
       

     

       8494
       8494
       +
       

     

       8328
       8495
        
         six = buildPythonPackage rec {

     

       8329
       8329
       -
           name = "six-1.7.3";

     

       8496
       8496
       +
           name = "six-1.8.0";

     

       8330
       8497
        
       

     

       8331
       8498
        
           src = pkgs.fetchurl {

     

       8332
       8499
        
             url = "http://pypi.python.org/packages/source/s/six/${name}.tar.gz";

     

       8333
       8333
       -
             md5 = "784c6e5541c3c4952de9c0a966a0a80b";

     

       8500
       8500
       +
             md5 = "1626eb24cc889110c38f7e786ec69885";

     

       8334
       8501
        
           };

     

       8335
       8502
        
       

     

       8336
       8503
        
           # error: invalid command 'test'

     
···

       9509
       9676
        
       

     

       9510
       9677
        
         wxPython30 = callPackage ../development/python-modules/wxPython/3.0.nix {

     

       9511
       9678
        
           wxGTK = pkgs.wxGTK30;

     

       9679
       9679
       +
         };

     

       9680
       9680
       +
       

     

       9681
       9681
       +
         xcaplib = buildPythonPackage rec {

     

       9682
       9682
       +
           name = "python-xcaplib-${version}";

     

       9683
       9683
       +
           version = "1.0.17";

     

       9684
       9684
       +
       

     

       9685
       9685
       +
           src = pkgs.fetchurl {

     

       9686
       9686
       +
             url = "http://download.ag-projects.com/SipClient/${name}.tar.gz";

     

       9687
       9687
       +
             sha256 = "1bf8n9ghmgxz8kjgnwy4y7ajijy5hi7viabgh0pvzkhz9gfvck86";

     

       9688
       9688
       +
           };

     

       9689
       9689
       +
       

     

       9690
       9690
       +
           propagatedBuildInputs = with self; [ eventlib application ];

     

       9512
       9691
        
         };

     

       9513
       9692
        
       

     

       9514
       9693
        
         xe = buildPythonPackage rec {

     
···

       10763
       10942
        
           };

     

       10764
       10943
        
         };

     

       10765
       10944
        
       

     

       10945
       10945
       +
         graphite_pager = buildPythonPackage rec {

     

       10946
       10946
       +
           name = "graphite-pager-${version}";

     

       10947
       10947
       +
           version = "2bbfe91220ec1e0ca1cdf4b5564386482a44ed7d";

     

       10948
       10948
       +
       

     

       10949
       10949
       +
           src = pkgs.fetchgit {

     

       10950
       10950
       +
             url = "https://github.com/offlinehacker/graphite-pager.git";

     

       10951
       10951
       +
             sha256 = "aa932f941efe4ed89971fe7572218b020d1a144259739ef78db6397b968eef62";

     

       10952
       10952
       +
             rev = version;

     

       10953
       10953
       +
           };

     

       10954
       10954
       +
       

     

       10955
       10955
       +
           buildInputs = with self; [ nose mock ];

     

       10956
       10956
       +
           propagatedBuildInputs = with self; [

     

       10957
       10957
       +
             jinja2 pyyaml redis requests pagerduty 

     

       10958
       10958
       +
             python_simple_hipchat pushbullet

     

       10959
       10959
       +
           ];

     

       10960
       10960
       +
       

     

       10961
       10961
       +
           patchPhase = "> requirements.txt";

     

       10962
       10962
       +
           checkPhase = "nosetests";

     

       10963
       10963
       +
       

     

       10964
       10964
       +
           meta = {

     

       10965
       10965
       +
             description = "A simple alerting application for Graphite metrics";

     

       10966
       10966
       +
             homepage = https://github.com/seatgeek/graphite-pager;

     

       10967
       10967
       +
             maintainers = [ maintainers.offline ];

     

       10968
       10968
       +
             license = licenses.bsd2;

     

       10969
       10969
       +
           };

     

       10970
       10970
       +
         };

     

       10971
       10971
       +
       

     

       10766
       10972
        
       

     

       10767
       10973
        
         pyspotify = buildPythonPackage rec {

     

       10768
       10974
        
           name = "pyspotify-${version}";

     
···

       10953
       11159
        
           };

     

       10954
       11160
        
         };

     

       10955
       11161
        
       

     

       11162
       11162
       +
       

     

       10956
       11163
        
         grequests = buildPythonPackage rec {

     

       10957
       11164
        
           name = "grequests-0.2.0";

     

       10958
       11165
        
       

     
···

       11003
       11210
        
             license = "bsd";

     

       11004
       11211
        
             maintainers = [ stdenv.lib.maintainers.matejc ];

     

       11005
       11212
        
           };

     

       11213
       11213
       +
         };

     

       11214
       11214
       +
       

     

       11215
       11215
       +
         pushbullet = buildPythonPackage rec {

     

       11216
       11216
       +
           name = "pushbullet.py-${version}";

     

       11217
       11217
       +
           version = "0.5.0";

     

       11218
       11218
       +
       

     

       11219
       11219
       +
           src = pkgs.fetchurl {

     

       11220
       11220
       +
             url = "https://pypi.python.org/packages/source/p/pushbullet.py/pushbullet.py-0.5.0.tar.gz";

     

       11221
       11221
       +
             md5 = "36c83ba5f7d5208bb86c00eba633f921";

     

       11222
       11222
       +
           };

     

       11223
       11223
       +
       

     

       11224
       11224
       +
           propagatedBuildInputs = with self; [requests websocket_client python_magic ];

     

       11006
       11225
        
         };

     

       11007
       11226
        
       

     

       11008
       11227
        
         power = buildPythonPackage rec {

+1 -1

pkgs/top-level/release.nix

···

       12
       12
        
       { nixpkgs ? { outPath = (import ./all-packages.nix {}).lib.cleanSource ../..; revCount = 1234; shortRev = "abcdef"; }

     

       13
       13
        
       , officialRelease ? false

     

       14
       14
        
       , # The platforms for which we build Nixpkgs.

     

       15
       15
       -
         supportedSystems ? [ "x86_64-linux" "i686-linux" "x86_64-darwin" ]

     

       15
       15
       +
         supportedSystems ? [ "x86_64-linux" "i686-linux" /* "x86_64-darwin" */ ]

     

       16
       16
        
       }:

     

       17
       17
        
       

     

       18
       18
        
       with import ./release-lib.nix { inherit supportedSystems; };