tagParser.js

/* parser generated by jison 0.4.13 */
const Parser = {
    trace: function trace() {
    },
    yy: {},
    symbols_: {
        "error": 2,
        "expressions": 3,
        "e": 4,
        "EOF": 5,
        "OR": 6,
        "AND": 7,
        "NOT": 8,
        "(": 9,
        ")": 10,
        "TAG": 11,
        "$accept": 0,
        "$end": 1
    },
    terminals_: {2: "error", 5: "EOF", 6: "OR", 7: "AND", 8: "NOT", 9: "(", 10: ")", 11: "TAG"},
    productions_: [0, [3, 2], [4, 3], [4, 3], [4, 2], [4, 3], [4, 1]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */
                                      /**/) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 1:
                return $$[$0 - 1];
                break;
            case 2:
                this.$ = '' + $$[$0 - 2] + ' || ' + $$[$0];
                break;
            case 3:
                this.$ = '' + $$[$0 - 2] + ' && ' + $$[$0];
                break;
            case 4:
                this.$ = "!" + $$[$0];
                break;
            case 5:
                this.$ = $$[$0 - 1];
                break;
            case 6:
                this.$ = "this.hasTag('" + yytext + "')";
                break;
        }
    },
    table: [{3: 1, 4: 2, 8: [1, 3], 9: [1, 4], 11: [1, 5]}, {1: [3]}, {5: [1, 6], 6: [1, 7], 7: [1, 8]}, {
        4: 9,
        8: [1, 3],
        9: [1, 4],
        11: [1, 5]
    }, {4: 10, 8: [1, 3], 9: [1, 4], 11: [1, 5]}, {5: [2, 6], 6: [2, 6], 7: [2, 6], 10: [2, 6]}, {1: [2, 1]}, {
        4: 11,
        8: [1, 3],
        9: [1, 4],
        11: [1, 5]
    }, {4: 12, 8: [1, 3], 9: [1, 4], 11: [1, 5]}, {5: [2, 4], 6: [2, 4], 7: [2, 4], 10: [2, 4]}, {
        6: [1, 7],
        7: [1, 8],
        10: [1, 13]
    }, {5: [2, 2], 6: [2, 2], 7: [1, 8], 10: [2, 2]}, {5: [2, 3], 6: [2, 3], 7: [2, 3], 10: [2, 3]}, {
        5: [2, 5],
        6: [2, 5],
        7: [2, 5],
        10: [2, 5]
    }],
    defaultActions: {6: [2, 1]},
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str)
        } else {
            throw new Error(str)
        }
    },
    parse: function parse(input) {
        var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0,
            yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        this.lexer.setInput(input);
        this.lexer.yy = this.yy;
        this.yy.lexer = this.lexer;
        this.yy.parser = this;
        if (typeof this.lexer.yylloc == 'undefined') {
            this.lexer.yylloc = {};
        }
        var yyloc = this.lexer.yylloc;
        lstack.push(yyloc);
        var ranges = this.lexer.options && this.lexer.options.ranges;
        if (typeof this.yy.parseError === 'function') {
            this.parseError = this.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }

        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }

        function lex() {
            var token;
            token = self.lexer.lex() || EOF;
            if (typeof token !== 'number') {
                token = self.symbols_[token] || token;
            }
            return token;
        }

        var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (this.lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + this.lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: this.lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: this.lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(this.lexer.yytext);
                    lstack.push(this.lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = this.lexer.yyleng;
                        yytext = this.lexer.yytext;
                        yylineno = this.lexer.yylineno;
                        yyloc = this.lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    // @ts-ignore
                    yyval.$ = vstack[vstack.length - len];
                    // @ts-ignore
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        // @ts-ignore
                        yyval._$.range = [
                            lstack[lstack.length - (len || 1)].range[0],
                            lstack[lstack.length - 1].range[1]
                        ];
                    }
                    r = this.performAction.apply(yyval, [
                        yytext,
                        yyleng,
                        yylineno,
                        this.yy,
                        action[1],
                        vstack,
                        lstack
                    ].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    // @ts-ignore
                    vstack.push(yyval.$);
                    // @ts-ignore
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    },
    lexer: {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash)
            } else {
                throw new Error(str)
            }
        },

// resets the lexer, sets new input
        setInput: function (input) {
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = "";
            this.conditionStack = ["INITIAL"];
            this.yylloc = {first_line: 1, first_column: 0, last_line: 1, last_column: 0};
            if (this.options.ranges) {
                this.yylloc.range = [0, 0]
            }
            this.offset = 0;
            return this
        },

// consumes and returns one char from the input
        input: function () {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++
            } else {
                this.yylloc.last_column++
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++
            }
            this._input = this._input.slice(1);
            return ch
        },

// unshifts one char (or a string) into the input
        unput: function (ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);
            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len - 1);
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);
            if (lines.length - 1) {
                this.yylineno -= lines.length - 1
            }
            var r = this.yylloc.range;
            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };
            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len]
            }
            this.yyleng = this.yytext.length;
            return this
        },

// When called from action, caches matched text and appends it on next action
        more: function () {
            this._more = true;
            return this
        },

// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function () {
            if (this.options.backtrack_lexer) {
                this._backtrack = true
            } else {
                return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                })
            }
            return this
        },

// retain first n characters of the match
        less: function (n) {
            this.unput(this.match.slice(n))
        },

// displays already matched input, i.e. for error messages
        pastInput: function () {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "")
        },

// displays upcoming input, i.e. for error messages
        upcomingInput: function () {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length)
            }
            return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "")
        },

// displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function () {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^"
        },

// test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function (match, indexed_rule) {
            var token, lines, backup;
            if (this.options.backtrack_lexer) {
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0)
                }
            }
            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng]
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false
            }
            if (token) {
                return token
            } else if (this._backtrack) {
                for (var k in backup) {
                    this[k] = backup[k]
                }
                return false
            }
            return false
        },

// return next match in input
        next: function () {
            if (this.done) {
                return this.EOF
            }
            if (!this._input) {
                this.done = true
            }
            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = "";
                this.match = ""
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token
                        } else if (this._backtrack) {
                            match = false;
                            continue
                        } else {
                            return false
                        }
                    } else if (!this.options.flex) {
                        break
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token
                }
                return false
            }
            if (this._input === "") {
                return this.EOF
            } else {
                return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                })
            }
        },

// return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r
            } else {
                return this.lex()
            }
        },

// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition)
        },

// pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop()
            } else {
                return this.conditionStack[0]
            }
        },

// produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules
            } else {
                return this.conditions["INITIAL"].rules
            }
        },

// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n]
            } else {
                return "INITIAL"
            }
        },

// alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition)
        },

// return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length
        },
        options: {},
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START
                                          /**/) {

            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:/* skip whitespace */
                    break;
                case 1:
                    return 8
                    break;
                case 2:
                    return 6
                    break;
                case 3:
                    return 7
                    break;
                case 4:
                    return 11
                    break;
                case 5:
                    return 9
                    break;
                case 6:
                    return 10
                    break;
                case 7:
                    return 5
                    break;
                case 8:
                    return 'INVALID'
                    break;
            }
        },
        rules: [/^(?:\s+)/, /^(?:NOT|not\b)/, /^(?:OR|or\b)/, /^(?:AND|and\b)/, /^(?:\w+\b)/, /^(?:\()/, /^(?:\))/, /^(?:$)/, /^(?:.)/],
        conditions: {"INITIAL": {"rules": [0, 1, 2, 3, 4, 5, 6, 7, 8], "inclusive": true}}
    }
};

export default Parser;

usage.js

import Parser from "./tagParser";

/**
  * Check if an option is compatible with the currently selected options.
  */
const optionIsCompatible = (option, selectedOptions) => {
    // Store all tags of selected options in a global array
    let tagArray = []
    for (const option of selectedOptions) {
         tagArray.push(...option.expressions)
    }

    // Check if new option's expressions are compatible with the selected option's tags.
    let tagEvaluator = {}
    const expr = Parser.parse(option.expression[0]);
    tagEvaluator.hasTag = (tag) => tagArray.indexOf(tag) > -1;
    const evalExpression = Function('hasTag', `return ${expr};`);
    const isCompatible = evalExpression.call(tagEvaluator);
    return isCompatible
}