coa 1.0.3 → 1.0.4

package/test/coa.js

@@ -0,0 +1,496 @@
+var assert = require('chai').assert,
+    COA = require('..');
+
+/**
+ * Mocha BDD interface.
+ */
+/** @name describe @function */
+/** @name it @function */
+/** @name before @function */
+/** @name after @function */
+/** @name beforeEach @function */
+/** @name afterEach @function */
+
+describe('Opt', function() {
+
+    describe('Unknown option', function() {
+
+        var cmd = COA.Cmd();
+
+        it('should fail', function() {
+            return cmd.do(['-a'])
+                .then(assert.fail, emptyFn);
+        });
+
+    });
+
+    describe('Short options', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('a')
+                .short('a')
+                .end()
+            .opt()
+                .name('b')
+                .short('b')
+                .end()
+            .act(function(opts) {
+                return opts;
+            });
+
+        it('should return passed values', function() {
+            return cmd.do(['-a', 'a', '-b', 'b'])
+                .then(function(res) {
+                    assert.deepEqual(res, { a: 'a', b: 'b' });
+                });
+        });
+
+    });
+
+    describe('Long options', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('long1')
+                .long('long1')
+                .end()
+            .opt()
+                .name('long2')
+                .long('long2')
+                .end()
+            .act(function(opts) {
+                return opts;
+            });
+
+        it('should return passed values', function() {
+            return cmd.do(['--long1', 'long value', '--long2=another long value'])
+                .then(function(res) {
+                    assert.deepEqual(res, { long1: 'long value', long2: 'another long value' });
+                });
+        });
+
+    });
+
+    describe('Array option', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('a')
+                .short('a')
+                .arr()
+                .end()
+            .act(function(opts) {
+                return opts;
+            });
+
+        it('should return array of passed values', function() {
+            return cmd.do(['-a', '1', '-a', '2'])
+                .then(function(res) {
+                    assert.deepEqual(res, { a: ['1', '2'] });
+                });
+        });
+
+    });
+
+    describe('Required option', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('a')
+                .short('a')
+                .req()
+                .end()
+            .act(function(opts) {
+                return opts;
+            });
+
+        it('should fail if not specified', function() {
+            return cmd.do()
+                .then(assert.fail, emptyFn);
+        });
+
+        it('should return passed value if specified', function() {
+            return cmd.do(['-a', 'test'])
+                .then(function(opts) {
+                    assert.equal(opts.a, 'test');
+                });
+        });
+
+    });
+
+    describe('Option with default value', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('a')
+                .short('a')
+                .def('aaa')
+                .end()
+            .act(function(opts) {
+                return opts;
+            });
+
+        it('should return default value if not specified', function() {
+            return cmd.do()
+                .then(function(opts) {
+                    assert.equal(opts.a, 'aaa');
+                });
+        });
+
+        it('should return passed value if specified', function() {
+            return cmd.do(['-a', 'test'])
+                .then(function(opts) {
+                    assert.equal(opts.a, 'test');
+                });
+        });
+
+    });
+
+    describe('Validated / transformed option', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('a')
+                .short('a')
+                .val(function(v) {
+                    if (v === 'invalid') return this.reject('fail');
+                    return { value: v };
+                })
+                .end()
+            .act(function(opts) {
+                return opts;
+            });
+
+        it('should fail if custom checks suppose to do so', function() {
+            return cmd.do(['-a', 'invalid'])
+                .then(assert.fail, emptyFn);
+        });
+
+        it('should return transformed value', function() {
+            return cmd.do(['-a', 'test'])
+                .then(function(opts) {
+                    assert.deepEqual(opts.a, { value: 'test' });
+                });
+        });
+
+    });
+
+    describe('Only option (--version case)', function() {
+
+        var ver = require('../package.json').version,
+            cmd = COA.Cmd()
+                .opt()
+                    .name('version')
+                    .long('version')
+                    .flag()
+                    .only()
+                    .act(function() {
+                        return ver;
+                    })
+                    .end()
+                .opt()
+                    .name('req')
+                    .short('r')
+                    .req()
+                    .end();
+
+        it('should process the only() option', function() {
+            return cmd.do(['--version'])
+                .then(assert.fail, function(res) {
+                    assert.equal(res, ver);
+                });
+        });
+
+    });
+
+    it('input()');
+    it('output()');
+
+});
+
+describe('Arg', function() {
+
+    describe('Unknown arg', function() {
+
+        var cmd = COA.Cmd();
+
+        it('should fail', function() {
+            return cmd.do(['test'])
+                .then(assert.fail, emptyFn);
+        });
+
+    });
+
+    describe('Unknown arg after known', function() {
+
+        var cmd = COA.Cmd()
+            .arg()
+                .name('a')
+                .end();
+
+        it('should fail', function() {
+            return cmd.do(['test', 'unknown'])
+                .then(assert.fail, emptyFn);
+        });
+
+    });
+
+    describe('Array arg', function() {
+
+        var cmd = COA.Cmd()
+            .arg()
+                .name('a')
+                .arr()
+                .end()
+            .act(function(opts, args) {
+                return args;
+            });
+
+        it('should return array of passed values', function() {
+            return cmd.do(['value 1', 'value 2'])
+                .then(function(args) {
+                    assert.deepEqual(args, { a: ['value 1', 'value 2'] });
+                });
+        });
+
+    });
+
+    describe('Required arg', function() {
+
+        var cmd = COA.Cmd()
+            .arg()
+                .name('a')
+                .req()
+                .end()
+            .act(function(opts, args) {
+                return args;
+            });
+
+        it('should fail if not specified', function() {
+            return cmd.do()
+                .then(assert.fail, emptyFn);
+        });
+
+        it('should return passed value if specified', function() {
+            return cmd.do(['value'])
+                .then(function(args) {
+                    assert.equal(args.a, 'value');
+                });
+        });
+
+    });
+
+    describe('Args after options', function() {
+
+        var cmd = COA.Cmd()
+            .opt()
+                .name('opt')
+                .long('opt')
+                .end()
+            .arg()
+                .name('arg1')
+                .end()
+            .arg()
+                .name('arg2')
+                .arr()
+                .end()
+            .act(function(opts, args) {
+                return { opts: opts, args: args };
+            });
+
+        it('should return passed values', function() {
+            return cmd.do(['--opt', 'value', 'value', 'value 1', 'value 2'])
+                .then(function(o) {
+                    assert.deepEqual(o, {
+                        opts: { opt: 'value' },
+                        args: {
+                            arg1: 'value',
+                            arg2: ['value 1', 'value 2']
+                        }
+                    });
+                });
+        });
+
+    });
+
+    describe('Raw args', function() {
+
+        var cmd = COA.Cmd()
+            .arg()
+                .name('raw')
+                .arr()
+                .end()
+            .act(function(opts, args) {
+                return args;
+            });
+
+        it('should return passed arg values', function() {
+            return cmd.do(['--', 'raw', 'arg', 'values'])
+                .then(function(args) {
+                    assert.deepEqual(args, { raw: ['raw', 'arg', 'values'] });
+                });
+        });
+
+    });
+
+});
+
+describe('Cmd', function() {
+
+    var doTest = function(o) {
+            assert.deepEqual(o, {
+                opts: { opt: 'value' },
+                args: {
+                    arg1: 'value',
+                    arg2: ['value 1', 'value 2']
+                }
+            });
+        },
+
+        invokeOpts = { opt: 'value' },
+        invokeArgs = {
+            arg1: 'value',
+            arg2:  ['value 1', 'value 2']
+        };
+
+    describe('Subcommand', function() {
+
+        var cmd = COA.Cmd()
+            .cmd()
+                .name('command')
+                .opt()
+                    .name('opt')
+                    .long('opt')
+                    .end()
+                .arg()
+                    .name('arg1')
+                    .end()
+                .arg()
+                    .name('arg2')
+                    .arr()
+                    .end()
+                .act(function(opts, args) {
+                    return { opts: opts, args: args };
+                })
+                .end();
+
+        describe('when specified on command line', function() {
+
+            it('should be invoked and accept passed opts and args', function() {
+                return cmd.do(['command', '--opt', 'value', 'value', 'value 1', 'value 2'])
+                    .then(doTest);
+            });
+
+        });
+
+        describe('when invoked using api', function() {
+
+            it('should be invoked and accept passed opts and args', function() {
+                return cmd.api.command(invokeOpts, invokeArgs)
+                    .then(doTest);
+            });
+
+        });
+
+        describe('when invoked using invoke()', function() {
+
+            it('should be invoked and accept passed opts and args', function() {
+                return cmd.invoke('command', invokeOpts, invokeArgs)
+                    .then(doTest);
+            });
+
+        });
+
+        describe('when unexisting command invoked using invoke()', function() {
+
+            it('should fail', function() {
+                return cmd.invoke('unexistent')
+                    .then(assert.fail, emptyFn);
+            });
+
+        });
+
+    });
+
+    describe('External subcommand', function() {
+
+        describe('default scheme: cmd.extendable()', function() {
+
+            describe('when described as a function', function() {
+                var cmd = COA.Cmd()
+                    .name('coa')
+                    .extendable();
+
+                it('should be invoked and accept passed opts and args', function() {
+                    return cmd.do(['test', '--opt', 'value', 'value', 'value 1', 'value 2'])
+                        .then(doTest);
+                });
+            });
+
+            describe('when described as an COA.Cmd() object', function() {
+                var cmd = COA.Cmd()
+                    .name('coa')
+                    .extendable();
+
+                it('should be invoked and accept passed opts and args', function() {
+                    return cmd.do(['test-obj', '--opt', 'value', 'value', 'value 1', 'value 2'])
+                        .then(doTest);
+                });
+            });
+
+            describe('2nd level subcommand', function() {
+                var cmd = COA.Cmd()
+                    .name('coa')
+                    .cmd()
+                    .name('test')
+                    .extendable()
+                    .end();
+
+                it('should be invoked and accept passed opts and args', function() {
+                    return cmd.do(['test', 'obj', '--opt', 'value', 'value', 'value 1', 'value 2'])
+                        .then(doTest);
+                });
+            });
+
+        });
+
+        describe("common prefix: cmd.extendable('coa-')", function() {
+
+            describe('when described as a function', function() {
+                var cmd = COA.Cmd()
+                    .name('coa')
+                    .extendable('coa-');
+
+                it('should be invoked and accept passed opts and args', function() {
+                    return cmd.do(['test', '--opt', 'value', 'value', 'value 1', 'value 2'])
+                        .then(doTest);
+                });
+            });
+
+        });
+
+        describe("format string: cmd.extendable('coa-%s')", function() {
+
+            describe('when described as a function', function() {
+                var cmd = COA.Cmd()
+                    .name('coa')
+                    .extendable('coa-%s');
+
+                it('should be invoked and accept passed opts and args', function() {
+                    return cmd.do(['test', '--opt', 'value', 'value', 'value 1', 'value 2'])
+                        .then(doTest);
+                });
+            });
+
+        });
+
+    });
+
+    it('helpful(), name(), title()');
+
+});
+
+function emptyFn() {
+    // empty function
+}

package/test/mocha.opts

@@ -0,0 +1,2 @@
+--reporter spec
+--timeout 20

package/test/shell-test.js

@@ -0,0 +1,60 @@
+var assert = require('chai').assert,
+    shell = require('..').shell;
+
+/**
+ * Mocha BDD interface.
+ */
+/** @name describe @function */
+/** @name it @function */
+/** @name before @function */
+/** @name after @function */
+/** @name beforeEach @function */
+/** @name afterEach @function */
+
+describe('shell', function() {
+
+    describe('escape()', function() {
+
+        var escape = shell.escape;
+
+        it('Should wrap values with spaces in double quotes', function() {
+            assert.equal(escape('asd abc'), '"asd abc"');
+        });
+
+        it('Should escape double quote "', function() {
+            assert.equal(escape('"asd'), '\\"asd');
+        });
+
+        it("Should escape single quote '", function() {
+            assert.equal(escape("'asd"), "\\'asd");
+        });
+
+        it('Should escape backslash \\', function() {
+            assert.equal(escape('\\asd'), '\\\\asd');
+        });
+
+        it('Should escape dollar $', function() {
+            assert.equal(escape('$asd'), '\\$asd');
+        });
+
+        it('Should escape backtick `', function() {
+            assert.equal(escape('`asd'), '\\`asd');
+        });
+
+    });
+
+    describe('unescape()', function() {
+
+        var unescape = shell.unescape;
+
+        it('Should strip double quotes at the both ends', function() {
+            assert.equal(unescape('"asd"'), 'asd');
+        });
+
+        it('Should not strip escaped double quotes at the both ends', function() {
+            assert.equal(unescape('\\"asd\\"'), '"asd"');
+        });
+
+    });
+
+});

package/tests/api-h.js

@@ -0,0 +1,9 @@
+require('..').Cmd()
+    .name('bla')
+    .title('Bla bla bla')
+    .helpful()
+    .invoke({ help: true })
+    .then(function(res) {
+        console.log(res);
+    })
+    .done(); // Q.done()

package/tests/h.js

@@ -0,0 +1,6 @@
+var argv = process.argv.slice(2);
+require('..').Cmd()
+    .name('bla')
+    .title('Bla bla bla')
+    .helpful()
+    .run(argv.length? argv : ['-h']);

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015-present Sergey Berezhnoy <veged@ya.ru>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/lib/coaobject.js

@@ -1,100 +0,0 @@
-'use strict';
-
-const Q = require('q');
-
-/**
- * COA Object
- *
- * Base class for all COA-related objects
- *
- * --------|-----|-----|-----
- *         | Cmd | Opt | Arg
- * --------|-----|-----|-----
- *  name   | ✓   | ✓   | ✓
- *  title  | ✓   | ✓   | ✓
- *  comp   | ✓   | ✓   | ✓
- *  reject | ✓   | ✓   | ✓
- *  end    | ✓   | ✓   | ✓
- *  apply  | ✓   | ✓   | ✓
- *
- * @class CoaObject
- */
-module.exports = class CoaObject {
-    constructor(cmd) {
-        this._cmd = cmd;
-        this._name = null;
-        this._title = null;
-        this._comp = null;
-    }
-
-    /**
-     * Set a canonical identifier to be used anywhere in the API.
-     *
-     * @param {String} name - command, option or argument name
-     * @returns {COA.CoaObject} - this instance (for chainability)
-     */
-    name(name) {
-        this._name = name;
-        return this;
-    }
-
-    /**
-     * Set a long description to be used anywhere in text messages.
-     * @param {String} title - human readable entity title
-     * @returns {COA.CoaObject} - this instance (for chainability)
-     */
-    title(title) {
-        this._title = title;
-        return this;
-    }
-
-    /**
-     * Set custom additional completion for current object.
-     *
-     * @param {Function} comp - completion generation function,
-     *         invoked in the context of object instance.
-     *         Accepts parameters:
-     *                 - {Object} opts - completion options
-     *         It can return promise or any other value threated as a result.
-     * @returns {COA.CoaObject} - this instance (for chainability)
-     */
-    comp(comp) {
-        this._comp = comp;
-        return this;
-    }
-
-    /**
-     * Apply function with arguments in a context of object instance.
-     *
-     * @param {Function} fn - body
-     * @param {Array.<*>} args... - arguments
-     * @returns {COA.CoaObject} - this instance (for chainability)
-     */
-    apply(fn) {
-        arguments.length > 1?
-            fn.apply(this, [].slice.call(arguments, 1))
-            : fn.call(this);
-
-        return this;
-    }
-
-    /**
-     * Return reject of actions results promise with error code.
-     * Use in .act() for return with error.
-     * @param {Object} reason - reject reason
-     *         You can customize toString() method and exitCode property
-     *         of reason object.
-     * @returns {Q.promise} rejected promise
-     */
-    reject(reason) {
-        return Q.reject(reason);
-    }
-
-    /**
-     * Finish chain for current subcommand and return parent command instance.
-     * @returns {COA.Cmd} parent command
-     */
-    end() {
-        return this._cmd;
-    }
-};