Import other modules into monorepo

src/cli/directive/options/CLIOption.ts

@@ -0,0 +1,244 @@
+/**
+ * A CLI option. Supports basic comparative, and set-based validation.
+ * @class
+ */
+export abstract class CLIOption<T> {
+
+    /**
+     * Do we use the whitelist?
+     * @type {boolean}
+     * @private
+     */
+    protected _useWhitelist: boolean = false
+
+    /**
+     * Do we use the blacklist?
+     * @type {boolean}
+     * @private
+     */
+    protected _useBlacklist: boolean = false
+
+    /**
+     * Do we use the less-than comparison?
+     * @type {boolean}
+     * @private
+     */
+    protected _useLessThan: boolean = false
+
+    /**
+     * Do we use the greater-than comparison?
+     * @type {boolean}
+     * @private
+     */
+    protected _useGreaterThan: boolean = false
+
+    /**
+     * Do we use the equality operator?
+     * @type {boolean}
+     * @private
+     */
+    protected _useEquality: boolean = false
+
+    /**
+     * Is this option optional?
+     * @type {boolean}
+     * @private
+     */
+    protected _optional: boolean = false
+
+    /**
+     * Whitelisted values.
+     * @type {Array<*>}
+     * @private
+     */
+    protected _whitelist: T[] = []
+
+    /**
+     * Blacklisted values.
+     * @type {Array<*>}
+     * @private
+     */
+    protected _blacklist: T[] = []
+
+    /**
+     * Value to be compared in less than.
+     * @type {*}
+     * @private
+     */
+    protected _lessThanValue?: T
+
+    /**
+     * If true, the less than will be less than or equal to.
+     * @type {boolean}
+     * @private
+     */
+    protected _lessThanBit: boolean = false
+
+    /**
+     * Value to be compared in greater than.
+     * @type {*}
+     * @private
+     */
+    protected _greaterThanValue?: T
+
+    /**
+     * If true, the greater than will be greater than or equal to.
+     * @type {boolean}
+     * @private
+     */
+    protected _greateerThanBit: boolean = false
+
+    /**
+     * The value to be used to check equality.
+     * @type {*}
+     * @private
+     */
+    protected _equalityValue?: T
+
+    /**
+     * Whitelist the specified item or items and enable the whitelist.
+     * @param {...*} items - the items to whitelist
+     */
+    whitelist(...items: T[]) {
+        this._useWhitelist = true
+        items.forEach(item => this._whitelist.push(item))
+    }
+
+    /**
+     * Blacklist the specified item or items and enable the blacklist.
+     * @param {...*} items - the items to blacklist
+     */
+    blacklist(...items: T[]) {
+        this._useBlacklist = true
+        items.forEach(item => this._blacklist.push(item))
+    }
+
+    /**
+     * Specifies the value to be used in less-than comparison and enables less-than comparison.
+     * @param {*} value
+     */
+    lessThan(value: T) {
+        this._useLessThan = true
+        this._lessThanValue = value
+    }
+
+    /**
+     * Specifies the value to be used in less-than or equal-to comparison and enables that comparison.
+     * @param {*} value
+     */
+    lessThanOrEqualTo(value: T) {
+        this._lessThanBit = true
+        this.lessThan(value)
+    }
+
+    /**
+     * Specifies the value to be used in greater-than comparison and enables that comparison.
+     * @param {*} value
+     */
+    greaterThan(value: T) {
+        this._useGreaterThan = true
+        this._greaterThanValue = value
+    }
+
+    /**
+     * Specifies the value to be used in greater-than or equal-to comparison and enables that comparison.
+     * @param {*} value
+     */
+    greaterThanOrEqualTo(value: T) {
+        this._greateerThanBit = true
+        this.greaterThan(value)
+    }
+
+    /**
+     * Specifies the value to be used in equality comparison and enables that comparison.
+     * @param {*} value
+     */
+    equals(value: T) {
+        this._useEquality = true
+        this._equalityValue = value
+    }
+
+    /**
+     * Checks if the specified value passes the configured comparisons.
+     * @param {*} value
+     * @returns {boolean}
+     */
+    validate(value: any) {
+        let is_valid = true
+        if ( this._useEquality ) {
+            is_valid = is_valid && (this._equalityValue === value)
+        }
+
+        if ( this._useLessThan && typeof this._lessThanValue !== 'undefined' ) {
+            if ( this._lessThanBit ) {
+                is_valid = is_valid && (value <= this._lessThanValue)
+            } else {
+                is_valid = is_valid && (value < this._lessThanValue)
+            }
+        }
+
+        if ( this._useGreaterThan && typeof this._greaterThanValue !== 'undefined' ) {
+            if ( this._greateerThanBit ) {
+                is_valid = is_valid && (value >= this._greaterThanValue)
+            } else {
+                is_valid = is_valid && (value > this._greaterThanValue)
+            }
+        }
+
+        if ( this._useWhitelist ) {
+            is_valid = is_valid && this._whitelist.some(x => {
+                return x === value
+            })
+        }
+
+        if ( this._useBlacklist ) {
+            is_valid = is_valid && !(this._blacklist.some(x => x === value))
+        }
+
+        return is_valid
+    }
+
+    /**
+     * Sets the Option as optional.
+     */
+    optional() {
+        this._optional = true
+        return this
+    }
+
+    /**
+     * Get the argument name. Should be overridden by child classes.
+     * @returns {string}
+     */
+    abstract getArgumentName(): string
+
+    /**
+     * Get an array of strings denoting the human-readable requirements for this option to be valid.
+     * @returns {Array<string>}
+     */
+    getRequirementDisplays() {
+        const clauses = []
+
+        if ( this._useBlacklist ) {
+            clauses.push(`must not be one of: ${this._blacklist.map(x => String(x)).join(', ')}`)
+        }
+
+        if ( this._useWhitelist ) {
+            clauses.push(`must be one of: ${this._whitelist.map(x => String(x)).join(', ')}`)
+        }
+
+        if ( this._useGreaterThan ) {
+            clauses.push(`must be greater than${this._greateerThanBit ? ' or equal to' : ''}: ${String(this._greaterThanValue)}`)
+        }
+
+        if ( this._useLessThan ) {
+            clauses.push(`must be less than${this._lessThanBit ? ' or equal to' : ''}: ${String(this._lessThanValue)}`)
+        }
+
+        if ( this._useEquality ) {
+            clauses.push(`must be equal to: ${String(this._equalityValue)}`)
+        }
+
+        return clauses
+    }
+}