Code coverage report for coa/lib/coaparam.js

# All files / coa/lib coaparam.js

51.61% Statements 16/31
0% Branches 0/8
55.56% Functions 5/9
51.61% Lines 16/31

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126

    1x

    1x

    1x

    32x

    32x
    32x
    32x
    32x

    9x
    9x

    3x
    3x

    1x
    1x

    1x
    1x

     'use strict';

    const fs = require('fs');

    const CoaObject = require('./coaobject');

    /**
     * COA Parameter
     *
     * Base class for options and arguments
     *
     * --------|-----|-----|-----
     *         | Cmd | Opt | Arg
     * --------|-----|-----|-----
     *  arr    |     | ✓   | ✓
     *  req    |     | ✓   | ✓
     *  val    |     | ✓   | ✓
     *  def    |     | ✓   | ✓
     *  input  |     | ✓   | ✓
     *  output |     | ✓   | ✓
     *
     * @class CoaParam
     * @extends CoaObject
     */
    module.exports = class CoaParam extends CoaObject {
        constructor(cmd) {
            super(cmd);

            this._arr = false;
            this._req = false;
            this._val = undefined;
            this._def = undefined;
        }

        /**
         * Makes a param accepts multiple values.
         * Otherwise, the value will be used by the latter passed.
         *
         * @returns {COA.CoaParam} - this instance (for chainability)
         */
        arr() {
            this._arr = true;
            return this;
        }

        /**
         * Makes a param required.
         *
         * @returns {COA.CoaParam} - this instance (for chainability)
         */
        req() {
            this._req = true;
            return this;
        }

        /**
         * Set a validation (or value) function for param.
         * Value from command line passes through before becoming available from API.
         * Using for validation and convertion simple types to any values.
         *
         * @param {Function} val - validating function,
         *         invoked in the context of option instance
         *         and has one parameter with value from command line.
         * @returns {COA.CoaParam} - this instance (for chainability)
         */
        val(val) {
            this._val = val;
            return this;
        }

        /**
         * Set a default value for param.
         * Default value passed through validation function as ordinary value.
         *
         * @param {*} def - default value of function generator
         * @returns {COA.CoaParam} - this instance (for chainability)
         */
        def(def) {
            this._def = def;
            return this;
        }

        /**
         * Make option value inputting stream.
         * It's add useful validation and shortcut for STDIN.
         *
         * @returns {COA.CoaParam} - this instance (for chainability)
         */
        input() {
            process.stdin.pause();
            return this
                .def(process.stdin)
                .val(function(v) {
                    if(typeof v !== 'string')
                        return v;

                    if(v === '-')
                        return process.stdin;

                    const s = fs.createReadStream(v, { encoding : 'utf8' });
                    s.pause();
                    return s;
                });
        }

        /**
         * Make option value outputing stream.
         * It's add useful validation and shortcut for STDOUT.
         *
         * @returns {COA.CoaParam} - this instance (for chainability)
         */
        output() {
            return this
                .def(process.stdout)
                .val(function(v) {
                    if(typeof v !== 'string')
                        return v;

                    if(v === '-')
                        return process.stdout;

                    return fs.createWriteStream(v, { encoding : 'utf8' });
                });
        }
    };