commit nodejs-minimist for openSUSE:Factory

2 Jul 2015

Hello community,

here is the log from the commit of package nodejs-minimist for openSUSE:Factory checked in at 2015-07-02 22:43:30
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/nodejs-minimist (Old)
 and      /work/SRC/openSUSE:Factory/.nodejs-minimist.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "nodejs-minimist"

Changes:
--------

--- /work/SRC/openSUSE:Factory/nodejs-minimist/nodejs-minimist.changes	2015-04-27 13:01:49.000000000 +0200
+++ /work/SRC/openSUSE:Factory/.nodejs-minimist.new/nodejs-minimist.changes	2015-07-02 22:43:31.000000000 +0200
@@ -1,0 +2,10 @@
+Mon Jun 29 08:58:33 UTC 2015 - i@marguerite.su
+
+- revert to 0.0.8 for mkdirp
+
+-------------------------------------------------------------------
+Fri Jun  5 19:16:55 UTC 2015 - i@marguerite.su
+
+- update version 1.1.1
+
+-------------------------------------------------------------------

Old:
----
  minimist-1.1.0.tgz

New:
----
  minimist-0.0.8.tgz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ nodejs-minimist.spec ++++++
--- /var/tmp/diff_new_pack.Brla2D/_old	2015-07-02 22:43:31.000000000 +0200
+++ /var/tmp/diff_new_pack.Brla2D/_new	2015-07-02 22:43:31.000000000 +0200
@@ -19,7 +19,7 @@
 %define base_name minimist
 
 Name:           nodejs-minimist
-Version:        1.1.0
+Version:        0.0.8
 Release:        0
 Summary:        Argument parsing
 License:        MIT

++++++ minimist-1.1.0.tgz -> minimist-0.0.8.tgz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/index.js new/package/index.js
--- old/package/index.js	2014-08-11 04:08:52.000000000 +0200
+++ new/package/index.js	2014-02-21 05:46:01.000000000 +0100
@@ -1,19 +1,15 @@
 module.exports = function (args, opts) {
     if (!opts) opts = {};
     
-    var flags = { bools : {}, strings : {}, unknownFn: null };
-
-    if (typeof opts['unknown'] === 'function') {
-        flags.unknownFn = opts['unknown'];
-    }
-
-    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
-      flags.allBools = true;
-    } else {
-      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
-          flags.bools[key] = true;
-      });
-    }
+    var flags = { bools : {}, strings : {} };
+    
+    [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+        flags.bools[key] = true;
+    });
+    
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+    });
     
     var aliases = {};
     Object.keys(opts.alias || {}).forEach(function (key) {
@@ -24,14 +20,7 @@
             }));
         });
     });
-
-    [].concat(opts.string).filter(Boolean).forEach(function (key) {
-        flags.strings[key] = true;
-        if (aliases[key]) {
-            flags.strings[aliases[key]] = true;
-        }
-     });
-
+    
     var defaults = opts['default'] || {};
     
     var argv = { _ : [] };
@@ -46,16 +35,7 @@
         args = args.slice(0, args.indexOf('--'));
     }
 
-    function argDefined(key, arg) {
-        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
-            flags.strings[key] || flags.bools[key] || aliases[key];
-    }
-
-    function setArg (key, val, arg) {
-        if (arg && flags.unknownFn && !argDefined(key, arg)) {
-            if (flags.unknownFn(arg) === false) return;
-        }
-
+    function setArg (key, val) {
         var value = !flags.strings[key] && isNumber(val)
             ? Number(val) : val
         ;
@@ -74,28 +54,27 @@
             // 'dotall' regex modifier. See:
             // http://stackoverflow.com/a/1068308/13216
             var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-            setArg(m[1], m[2], arg);
+            setArg(m[1], m[2]);
         }
         else if (/^--no-.+/.test(arg)) {
             var key = arg.match(/^--no-(.+)/)[1];
-            setArg(key, false, arg);
+            setArg(key, false);
         }
         else if (/^--.+/.test(arg)) {
             var key = arg.match(/^--(.+)/)[1];
             var next = args[i + 1];
             if (next !== undefined && !/^-/.test(next)
             && !flags.bools[key]
-            && !flags.allBools
             && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
-                setArg(key, next, arg);
+                setArg(key, next);
                 i++;
             }
             else if (/^(true|false)$/.test(next)) {
-                setArg(key, next === 'true', arg);
+                setArg(key, next === 'true');
                 i++;
             }
             else {
-                setArg(key, flags.strings[key] ? '' : true, arg);
+                setArg(key, flags.strings[key] ? '' : true);
             }
         }
         else if (/^-[^-]+/.test(arg)) {
@@ -106,24 +85,24 @@
                 var next = arg.slice(j+2);
                 
                 if (next === '-') {
-                    setArg(letters[j], next, arg)
+                    setArg(letters[j], next)
                     continue;
                 }
                 
                 if (/[A-Za-z]/.test(letters[j])
                 && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-                    setArg(letters[j], next, arg);
+                    setArg(letters[j], next);
                     broken = true;
                     break;
                 }
                 
                 if (letters[j+1] && letters[j+1].match(/\W/)) {
-                    setArg(letters[j], arg.slice(j+2), arg);
+                    setArg(letters[j], arg.slice(j+2));
                     broken = true;
                     break;
                 }
                 else {
-                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true);
                 }
             }
             
@@ -132,28 +111,22 @@
                 if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
                 && !flags.bools[key]
                 && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
-                    setArg(key, args[i+1], arg);
+                    setArg(key, args[i+1]);
                     i++;
                 }
                 else if (args[i+1] && /true|false/.test(args[i+1])) {
-                    setArg(key, args[i+1] === 'true', arg);
+                    setArg(key, args[i+1] === 'true');
                     i++;
                 }
                 else {
-                    setArg(key, flags.strings[key] ? '' : true, arg);
+                    setArg(key, flags.strings[key] ? '' : true);
                 }
             }
         }
         else {
-            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-                argv._.push(
-                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
-                );
-            }
-            if (opts.stopEarly) {
-                argv._.push.apply(argv._, args.slice(i + 1));
-                break;
-            }
+            argv._.push(
+                flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+            );
         }
     }
     
@@ -167,17 +140,9 @@
         }
     });
     
-    if (opts['--']) {
-        argv['--'] = new Array();
-        notFlags.forEach(function(key) {
-            argv['--'].push(key);
-        });
-    }
-    else {
-        notFlags.forEach(function(key) {
-            argv._.push(key);
-        });
-    }
+    notFlags.forEach(function(key) {
+        argv._.push(key);
+    });
 
     return argv;
 };
@@ -217,3 +182,6 @@
     return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
 }
 
+function longest (xs) {
+    return Math.max.apply(null, xs.map(function (x) { return x.length }));
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/package.json new/package/package.json
--- old/package/package.json	2014-08-11 05:18:21.000000000 +0200
+++ new/package/package.json	2014-02-21 05:46:10.000000000 +0100
@@ -1,42 +1,40 @@
 {
-  "name": "minimist",
-  "version": "1.1.0",
-  "description": "parse argument options",
-  "main": "index.js",
-  "devDependencies": {
-    "tape": "~1.0.4",
-    "tap": "~0.4.0",
-    "covert": "^1.0.0"
-  },
-  "scripts": {
-    "test": "tap test/*.js",
-    "coverage": "covert test/*.js"
-  },
-  "testling" : {
-    "files" : "test/*.js",
-    "browsers" : [
-      "ie/6..latest",
-      "ff/5", "firefox/latest",
-      "chrome/10", "chrome/latest",
-      "safari/5.1", "safari/latest",
-      "opera/12"
-    ]
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/substack/minimist.git"
-  },
-  "homepage": "https://github.com/substack/minimist",
-  "keywords": [
-    "argv",
-    "getopt",
-    "parser",
-    "optimist"
-  ],
-  "author": {
-    "name": "James Halliday",
-    "email": "mail@substack.net",
-    "url": "http://substack.net"
-  },
-  "license": "MIT"
+    "name": "minimist",
+    "version": "0.0.8",
+    "description": "parse argument options",
+    "main": "index.js",
+    "devDependencies": {
+        "tape": "~1.0.4",
+        "tap": "~0.4.0"
+    },
+    "scripts": {
+        "test": "tap test/*.js"
+    },
+    "testling" : {
+        "files" : "test/*.js",
+        "browsers" : [
+            "ie/6..latest",
+            "ff/5", "firefox/latest",
+            "chrome/10", "chrome/latest",
+            "safari/5.1", "safari/latest",
+            "opera/12"
+        ]
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/substack/minimist.git"
+    },
+    "homepage": "https://github.com/substack/minimist",
+    "keywords": [
+        "argv",
+        "getopt",
+        "parser",
+        "optimist"
+    ],
+    "author": {
+        "name": "James Halliday",
+        "email": "mail@substack.net",
+        "url": "http://substack.net"
+    },
+    "license": "MIT"
 }
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/readme.markdown new/package/readme.markdown
--- old/package/readme.markdown	2014-08-11 04:08:52.000000000 +0200
+++ new/package/readme.markdown	2013-06-25 10:16:36.000000000 +0200
@@ -55,28 +55,10 @@
 
 * `opts.string` - a string or array of strings argument names to always treat as
 strings
-* `opts.boolean` - a boolean, string or array of strings to always treat as
-booleans. if `true` will treat all double hyphenated arguments without equal signs
-as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`)
+* `opts.boolean` - a string or array of strings to always treat as booleans
 * `opts.alias` - an object mapping string names to strings or arrays of string
 argument names to use as aliases
 * `opts.default` - an object mapping string argument names to default values
-* `opts.stopEarly` - when true, populate `argv._` with everything after the
-first non-option
-* `opts['--']` - when true, populate `argv._` with everything before the `--`
-and `argv['--']` with everything after the `--`. Here's an example:
-* `opts.unknown` - a function which is invoked with a command line parameter not
-defined in the `opts` configuration object. If the function returns `false`, the
-unknown option is not added to `argv`.
-
-```
-> require('./')('one two three -- four five --six'.split(' '), { '--': true })
-{ _: [ 'one', 'two', 'three' ],
-  '--': [ 'four', 'five', '--six' ] }
-```
-
-Note that with `opts['--']` set, parsing for arguments still stops after the
-`--`.
 
 # install
 
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/all_bool.js new/package/test/all_bool.js
--- old/package/test/all_bool.js	2014-06-19 16:56:18.000000000 +0200
+++ new/package/test/all_bool.js	1970-01-01 01:00:00.000000000 +0100
@@ -1,32 +0,0 @@
-var parse = require('../');
-var test = require('tape');
-
-test('flag boolean true (default all --args to boolean)', function (t) {
-    var argv = parse(['moo', '--honk', 'cow'], {
-        boolean: true
-    });
-    
-    t.deepEqual(argv, {
-        honk: true,
-        _: ['moo', 'cow']
-    });
-    
-    t.deepEqual(typeof argv.honk, 'boolean');
-    t.end();
-});
-
-test('flag boolean true only affects double hyphen arguments without equals signs', function (t) {
-    var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
-        boolean: true
-    });
-    
-    t.deepEqual(argv, {
-        honk: true,
-        tacos: 'good',
-        p: '55',
-        _: ['moo', 'cow']
-    });
-    
-    t.deepEqual(typeof argv.honk, 'boolean');
-    t.end();
-});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/bool.js new/package/test/bool.js
--- old/package/test/bool.js	2014-05-11 23:42:12.000000000 +0200
+++ new/package/test/bool.js	1970-01-01 01:00:00.000000000 +0100
@@ -1,119 +0,0 @@
-var parse = require('../');
-var test = require('tape');
-
-test('flag boolean default false', function (t) {
-    var argv = parse(['moo'], {
-        boolean: ['t', 'verbose'],
-        default: { verbose: false, t: false }
-    });
-    
-    t.deepEqual(argv, {
-        verbose: false,
-        t: false,
-        _: ['moo']
-    });
-    
-    t.deepEqual(typeof argv.verbose, 'boolean');
-    t.deepEqual(typeof argv.t, 'boolean');
-    t.end();
-
-});
-
-test('boolean groups', function (t) {
-    var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], {
-        boolean: ['x','y','z']
-    });
-    
-    t.deepEqual(argv, {
-        x : true,
-        y : false,
-        z : true,
-        _ : [ 'one', 'two', 'three' ]
-    });
-    
-    t.deepEqual(typeof argv.x, 'boolean');
-    t.deepEqual(typeof argv.y, 'boolean');
-    t.deepEqual(typeof argv.z, 'boolean');
-    t.end();
-});
-test('boolean and alias with chainable api', function (t) {
-    var aliased = [ '-h', 'derp' ];
-    var regular = [ '--herp',  'derp' ];
-    var opts = {
-        herp: { alias: 'h', boolean: true }
-    };
-    var aliasedArgv = parse(aliased, {
-        boolean: 'herp',
-        alias: { h: 'herp' }
-    });
-    var propertyArgv = parse(regular, {
-        boolean: 'herp',
-        alias: { h: 'herp' }
-    });
-    var expected = {
-        herp: true,
-        h: true,
-        '_': [ 'derp' ]
-    };
-    
-    t.same(aliasedArgv, expected);
-    t.same(propertyArgv, expected); 
-    t.end();
-});
-
-test('boolean and alias with options hash', function (t) {
-    var aliased = [ '-h', 'derp' ];
-    var regular = [ '--herp', 'derp' ];
-    var opts = {
-        alias: { 'h': 'herp' },
-        boolean: 'herp'
-    };
-    var aliasedArgv = parse(aliased, opts);
-    var propertyArgv = parse(regular, opts);
-    var expected = {
-        herp: true,
-        h: true,
-        '_': [ 'derp' ]
-    };
-    t.same(aliasedArgv, expected);
-    t.same(propertyArgv, expected);
-    t.end();
-});
-
-test('boolean and alias using explicit true', function (t) {
-    var aliased = [ '-h', 'true' ];
-    var regular = [ '--herp',  'true' ];
-    var opts = {
-        alias: { h: 'herp' },
-        boolean: 'h'
-    };
-    var aliasedArgv = parse(aliased, opts);
-    var propertyArgv = parse(regular, opts);
-    var expected = {
-        herp: true,
-        h: true,
-        '_': [ ]
-    };
-
-    t.same(aliasedArgv, expected);
-    t.same(propertyArgv, expected); 
-    t.end();
-});
-
-// regression, see https://github.com/substack/node-optimist/issues/71
-test('boolean and --x=true', function(t) {
-    var parsed = parse(['--boool', '--other=true'], {
-        boolean: 'boool'
-    });
-
-    t.same(parsed.boool, true);
-    t.same(parsed.other, 'true');
-
-    parsed = parse(['--boool', '--other=false'], {
-        boolean: 'boool'
-    });
-    
-    t.same(parsed.boool, true);
-    t.same(parsed.other, 'false');
-    t.end();
-});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/dash.js new/package/test/dash.js
--- old/package/test/dash.js	2014-05-12 03:16:28.000000000 +0200
+++ new/package/test/dash.js	2014-01-10 19:26:37.000000000 +0100
@@ -22,10 +22,3 @@
     t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] });
     t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] });
 });
-
-test('move arguments after the -- into their own `--` array', function(t) {
-    t.plan(1);
-    t.deepEqual(
-        parse([ '--name', 'John', 'before', '--', 'after' ], { '--': true }),
-        { name: 'John', _: [ 'before' ], '--': [ 'after' ] });
-});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/dotted.js new/package/test/dotted.js
--- old/package/test/dotted.js	2014-05-11 23:37:47.000000000 +0200
+++ new/package/test/dotted.js	2013-08-29 00:57:59.000000000 +0200
@@ -14,9 +14,3 @@
     t.equal(argv.aa.bb, 11);
     t.end();
 });
-
-test('dotted default with no alias', function (t) {
-    var argv = parse('', {default: {'a.b': 11}});
-    t.equal(argv.a.b, 11);
-    t.end();
-});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/num.js new/package/test/num.js
--- old/package/test/num.js	2014-05-11 23:40:19.000000000 +0200
+++ new/package/test/num.js	1970-01-01 01:00:00.000000000 +0100
@@ -1,36 +0,0 @@
-var parse = require('../');
-var test = require('tape');
-
-test('nums', function (t) {
-    var argv = parse([
-        '-x', '1234',
-        '-y', '5.67',
-        '-z', '1e7',
-        '-w', '10f',
-        '--hex', '0xdeadbeef',
-        '789'
-    ]);
-    t.deepEqual(argv, {
-        x : 1234,
-        y : 5.67,
-        z : 1e7,
-        w : '10f',
-        hex : 0xdeadbeef,
-        _ : [ 789 ]
-    });
-    t.deepEqual(typeof argv.x, 'number');
-    t.deepEqual(typeof argv.y, 'number');
-    t.deepEqual(typeof argv.z, 'number');
-    t.deepEqual(typeof argv.w, 'string');
-    t.deepEqual(typeof argv.hex, 'number');
-    t.deepEqual(typeof argv._[0], 'number');
-    t.end();
-});
-
-test('already a number', function (t) {
-    var argv = parse([ '-x', 1234, 789 ]);
-    t.deepEqual(argv, { x : 1234, _ : [ 789 ] });
-    t.deepEqual(typeof argv.x, 'number');
-    t.deepEqual(typeof argv._[0], 'number');
-    t.end();
-});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/parse.js new/package/test/parse.js
--- old/package/test/parse.js	2014-05-11 23:42:14.000000000 +0200
+++ new/package/test/parse.js	2014-02-21 05:46:01.000000000 +0100
@@ -42,6 +42,32 @@
     t.end();
 });
 
+test('nums', function (t) {
+    var argv = parse([
+        '-x', '1234',
+        '-y', '5.67',
+        '-z', '1e7',
+        '-w', '10f',
+        '--hex', '0xdeadbeef',
+        '789'
+    ]);
+    t.deepEqual(argv, {
+        x : 1234,
+        y : 5.67,
+        z : 1e7,
+        w : '10f',
+        hex : 0xdeadbeef,
+        _ : [ 789 ]
+    });
+    t.deepEqual(typeof argv.x, 'number');
+    t.deepEqual(typeof argv.y, 'number');
+    t.deepEqual(typeof argv.z, 'number');
+    t.deepEqual(typeof argv.w, 'string');
+    t.deepEqual(typeof argv.hex, 'number');
+    t.deepEqual(typeof argv._[0], 'number');
+    t.end();
+});
+
 test('flag boolean', function (t) {
     var argv = parse([ '-t', 'moo' ], { boolean: 't' });
     t.deepEqual(argv, { t : true, _ : [ 'moo' ] });
@@ -66,6 +92,42 @@
     t.end();
 });
 
+test('flag boolean default false', function (t) {
+    var argv = parse(['moo'], {
+        boolean: ['t', 'verbose'],
+        default: { verbose: false, t: false }
+    });
+    
+    t.deepEqual(argv, {
+        verbose: false,
+        t: false,
+        _: ['moo']
+    });
+    
+    t.deepEqual(typeof argv.verbose, 'boolean');
+    t.deepEqual(typeof argv.t, 'boolean');
+    t.end();
+
+});
+
+test('boolean groups', function (t) {
+    var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], {
+        boolean: ['x','y','z']
+    });
+    
+    t.deepEqual(argv, {
+        x : true,
+        y : false,
+        z : true,
+        _ : [ 'one', 'two', 'three' ]
+    });
+    
+    t.deepEqual(typeof argv.x, 'boolean');
+    t.deepEqual(typeof argv.y, 'boolean');
+    t.deepEqual(typeof argv.z, 'boolean');
+    t.end();
+});
+
 test('newlines in params' , function (t) {
     var args = parse([ '-s', "X\nX" ])
     t.deepEqual(args, { _ : [], s : "X\nX" });
@@ -121,29 +183,6 @@
 });
 
 
-test('string and alias', function(t) {
-    var x = parse([ '--str',  '000123' ], {
-        string: 's',
-        alias: { s: 'str' }
-    });
-
-    t.equal(x.str, '000123');
-    t.equal(typeof x.str, 'string');
-    t.equal(x.s, '000123');
-    t.equal(typeof x.s, 'string');
-
-    var y = parse([ '-s',  '000123' ], {
-        string: 'str',
-        alias: { str: 's' }
-    });
-
-    t.equal(y.str, '000123');
-    t.equal(typeof y.str, 'string');
-    t.equal(y.s, '000123');
-    t.equal(typeof y.s, 'string');
-    t.end();
-});
-
 test('slashBreak', function (t) {
     t.same(
         parse([ '-I/foo/bar/baz' ]),
@@ -195,3 +234,85 @@
     t.same(argv.beep, { boop : true });
     t.end();
 });
+
+test('boolean and alias with chainable api', function (t) {
+    var aliased = [ '-h', 'derp' ];
+    var regular = [ '--herp',  'derp' ];
+    var opts = {
+        herp: { alias: 'h', boolean: true }
+    };
+    var aliasedArgv = parse(aliased, {
+        boolean: 'herp',
+        alias: { h: 'herp' }
+    });
+    var propertyArgv = parse(regular, {
+        boolean: 'herp',
+        alias: { h: 'herp' }
+    });
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ 'derp' ]
+    };
+    
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected); 
+    t.end();
+});
+
+test('boolean and alias with options hash', function (t) {
+    var aliased = [ '-h', 'derp' ];
+    var regular = [ '--herp', 'derp' ];
+    var opts = {
+        alias: { 'h': 'herp' },
+        boolean: 'herp'
+    };
+    var aliasedArgv = parse(aliased, opts);
+    var propertyArgv = parse(regular, opts);
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ 'derp' ]
+    };
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected);
+    t.end();
+});
+
+test('boolean and alias using explicit true', function (t) {
+    var aliased = [ '-h', 'true' ];
+    var regular = [ '--herp',  'true' ];
+    var opts = {
+        alias: { h: 'herp' },
+        boolean: 'h'
+    };
+    var aliasedArgv = parse(aliased, opts);
+    var propertyArgv = parse(regular, opts);
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ ]
+    };
+
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected); 
+    t.end();
+});
+
+// regression, see https://github.com/substack/node-optimist/issues/71
+test('boolean and --x=true', function(t) {
+    var parsed = parse(['--boool', '--other=true'], {
+        boolean: 'boool'
+    });
+
+    t.same(parsed.boool, true);
+    t.same(parsed.other, 'true');
+
+    parsed = parse(['--boool', '--other=false'], {
+        boolean: 'boool'
+    });
+    
+    t.same(parsed.boool, true);
+    t.same(parsed.other, 'false');
+    t.end();
+});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/stop_early.js new/package/test/stop_early.js
--- old/package/test/stop_early.js	2014-08-11 03:07:13.000000000 +0200
+++ new/package/test/stop_early.js	1970-01-01 01:00:00.000000000 +0100
@@ -1,15 +0,0 @@
-var parse = require('../');
-var test = require('tape');
-
-test('stops parsing on the first non-option when stopEarly is set', function (t) {
-    var argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], {
-        stopEarly: true
-    });
-
-    t.deepEqual(argv, {
-        aaa: 'bbb',
-        _: ['ccc', '--ddd']
-    });
-
-    t.end();
-});
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/package/test/unknown.js new/package/test/unknown.js
--- old/package/test/unknown.js	2014-08-11 04:10:40.000000000 +0200
+++ new/package/test/unknown.js	1970-01-01 01:00:00.000000000 +0100
@@ -1,102 +0,0 @@
-var parse = require('../');
-var test = require('tape');
-
-test('boolean and alias is not unknown', function (t) {
-    var unknown = [];
-    function unknownFn(arg) {
-        unknown.push(arg);
-        return false;
-    }
-    var aliased = [ '-h', 'true', '--derp', 'true' ];
-    var regular = [ '--herp',  'true', '-d', 'true' ];
-    var opts = {
-        alias: { h: 'herp' },
-        boolean: 'h',
-        unknown: unknownFn
-    };
-    var aliasedArgv = parse(aliased, opts);
-    var propertyArgv = parse(regular, opts);
-
-    t.same(unknown, ['--derp', '-d']);
-    t.end();
-});
-
-test('flag boolean true any double hyphen argument is not unknown', function (t) {
-    var unknown = [];
-    function unknownFn(arg) {
-        unknown.push(arg);
-        return false;
-    }
-    var argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], {
-        boolean: true,
-        unknown: unknownFn
-    });
-    t.same(unknown, ['--tacos=good', 'cow', '-p']);
-    t.same(argv, {
-        honk: true,
-        _: []
-    });
-    t.end();
-});
-
-test('string and alias is not unknown', function (t) {
-    var unknown = [];
-    function unknownFn(arg) {
-        unknown.push(arg);
-        return false;
-    }
-    var aliased = [ '-h', 'hello', '--derp', 'goodbye' ];
-    var regular = [ '--herp',  'hello', '-d', 'moon' ];
-    var opts = {
-        alias: { h: 'herp' },
-        string: 'h',
-        unknown: unknownFn
-    };
-    var aliasedArgv = parse(aliased, opts);
-    var propertyArgv = parse(regular, opts);
-
-    t.same(unknown, ['--derp', '-d']);
-    t.end();
-});
-
-test('default and alias is not unknown', function (t) {
-    var unknown = [];
-    function unknownFn(arg) {
-        unknown.push(arg);
-        return false;
-    }
-    var aliased = [ '-h', 'hello' ];
-    var regular = [ '--herp',  'hello' ];
-    var opts = {
-        default: { 'h': 'bar' },
-        alias: { 'h': 'herp' },
-        unknown: unknownFn
-    };
-    var aliasedArgv = parse(aliased, opts);
-    var propertyArgv = parse(regular, opts);
-
-    t.same(unknown, []);
-    t.end();
-    unknownFn(); // exercise fn for 100% coverage
-});
-
-test('value following -- is not unknown', function (t) {
-    var unknown = [];
-    function unknownFn(arg) {
-        unknown.push(arg);
-        return false;
-    }
-    var aliased = [ '--bad', '--', 'good', 'arg' ];
-    var opts = {
-        '--': true,
-        unknown: unknownFn
-    };
-    var argv = parse(aliased, opts);
-
-    t.same(unknown, ['--bad']);
-    t.same(argv, {
-        '--': ['good', 'arg'],
-        '_': []
-    })
-    t.end();
-});

    

commit nodejs-minimist for openSUSE:Factory

root＠hilbert.suse.de