occam-custom-grammars 5.0.1227 → 5.0.1229

package/lib/utilities/vocabulary.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get expressionsFromVocabulary () {
+        return expressionsFromVocabulary;
+    },
+    get validateVocabulary () {
+        return validateVocabulary;
+    }
+});
+var _necessary = require("necessary");
+var _query = require("../utilities/query");
+var _nominal = require("../utilities/nominal");
+var _constants = require("../constants");
+var _grammar = require("../utilities/grammar");
+var first = _necessary.arrayUtilities.first, second = _necessary.arrayUtilities.second;
+var expressionNodesQuery = (0, _query.nodesQuery)("//expression");
+function validateVocabulary(vocabulary) {
+    if (vocabulary === null || vocabulary === _constants.EMPTY_STRING) {
+        return;
+    }
+    var content = vocabulary, tokens = _grammar.customGrammarVocabularyLexer.tokenise(content), node = _grammar.customGrammarVocabularyParser.parse(tokens);
+    var expressionNodes = expressionNodesQuery(node);
+    expressionNodes.forEach(function(expressionNode) {
+        var content = contentFromExpressionNode(expressionNode), tokens = _nominal.nominalLexer.tokenise(content), tokensLength = tokens.length;
+        if (tokensLength > 1) {
+            throw new Error("Tokenising the '".concat(content, "' content results in more than one token."));
+        }
+        var firstToken = first(tokens), token = firstToken, type = token.getType();
+        if (type !== _constants.UNASSIGNED_TYPE) {
+            throw new Error("The '".concat(type, "' type of the '").concat(content, "' token is not 'unassigned'."));
+        }
+        if (content === _constants.UNDERSCORE_CHARACTER) {
+            throw new Error("The '".concat(content, "' token cannot be an underscore."));
+        }
+    });
+}
+function expressionsFromVocabulary(vocabulary, expressions) {
+    if (vocabulary === null || vocabulary === _constants.EMPTY_STRING) {
+        return;
+    }
+    var content = vocabulary, tokens = _grammar.customGrammarVocabularyLexer.tokenise(content), node = _grammar.customGrammarVocabularyParser.parse(tokens), expressionNodes = expressionNodesQuery(node);
+    expressionNodes.forEach(function(expressionNode) {
+        var content = contentFromExpressionNode(expressionNode), expression = content; ///
+        expressions.push(expression);
+    });
+}
+function contentFromExpressionNode(expressionNode) {
+    var nonTerminalNode = expressionNode, childNodes = nonTerminalNode.getChildNodes(), secondChildNode = second(childNodes), unassignedTerminalNode = secondChildNode, content = unassignedTerminalNode.getContent();
+    return content;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvdm9jYWJ1bGFyeS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgYXJyYXlVdGlsaXRpZXMgfSBmcm9tIFwibmVjZXNzYXJ5XCI7XG5cbmltcG9ydCB7IG5vZGVzUXVlcnkgfSBmcm9tIFwiLi4vdXRpbGl0aWVzL3F1ZXJ5XCI7XG5pbXBvcnQgeyBub21pbmFsTGV4ZXIgfSBmcm9tIFwiLi4vdXRpbGl0aWVzL25vbWluYWxcIjtcbmltcG9ydCB7IEVNUFRZX1NUUklORywgVU5BU1NJR05FRF9UWVBFLCBVTkRFUlNDT1JFX0NIQVJBQ1RFUiB9IGZyb20gXCIuLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IGN1c3RvbUdyYW1tYXJWb2NhYnVsYXJ5TGV4ZXIsIGN1c3RvbUdyYW1tYXJWb2NhYnVsYXJ5UGFyc2VyIH0gZnJvbSBcIi4uL3V0aWxpdGllcy9ncmFtbWFyXCJcblxuY29uc3QgeyBmaXJzdCwgc2Vjb25kIH0gPSBhcnJheVV0aWxpdGllcztcblxuY29uc3QgZXhwcmVzc2lvbk5vZGVzUXVlcnkgPSBub2Rlc1F1ZXJ5KFwiLy9leHByZXNzaW9uXCIpXG5cbmV4cG9ydCBmdW5jdGlvbiB2YWxpZGF0ZVZvY2FidWxhcnkodm9jYWJ1bGFyeSkge1xuICBpZiAoKHZvY2FidWxhcnkgPT09IG51bGwpIHx8ICh2b2NhYnVsYXJ5ID09PSBFTVBUWV9TVFJJTkcpKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgY29uc3QgY29udGVudCA9IHZvY2FidWxhcnksIC8vL1xuICAgICAgICB0b2tlbnMgPSBjdXN0b21HcmFtbWFyVm9jYWJ1bGFyeUxleGVyLnRva2VuaXNlKGNvbnRlbnQpLFxuICAgICAgICBub2RlID0gY3VzdG9tR3JhbW1hclZvY2FidWxhcnlQYXJzZXIucGFyc2UodG9rZW5zKTtcblxuICBjb25zdCBleHByZXNzaW9uTm9kZXMgPSBleHByZXNzaW9uTm9kZXNRdWVyeShub2RlKTtcblxuICBleHByZXNzaW9uTm9kZXMuZm9yRWFjaCgoZXhwcmVzc2lvbk5vZGUpID0+IHtcbiAgICBjb25zdCBjb250ZW50ID0gY29udGVudEZyb21FeHByZXNzaW9uTm9kZShleHByZXNzaW9uTm9kZSksXG4gICAgICAgICAgdG9rZW5zID0gbm9taW5hbExleGVyLnRva2VuaXNlKGNvbnRlbnQpLFxuICAgICAgICAgIHRva2Vuc0xlbmd0aCA9IHRva2Vucy5sZW5ndGg7XG5cbiAgICBpZiAodG9rZW5zTGVuZ3RoID4gMSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGBUb2tlbmlzaW5nIHRoZSAnJHtjb250ZW50fScgY29udGVudCByZXN1bHRzIGluIG1vcmUgdGhhbiBvbmUgdG9rZW4uYCk7XG4gICAgfVxuXG4gICAgY29uc3QgZmlyc3RUb2tlbiA9IGZpcnN0KHRva2VucyksXG4gICAgICAgICAgdG9rZW4gPSBmaXJzdFRva2VuLFxuICAgICAgICAgIHR5cGUgPSB0b2tlbi5nZXRUeXBlKCk7XG5cbiAgICBpZiAodHlwZSAhPT0gVU5BU1NJR05FRF9UWVBFKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoYFRoZSAnJHt0eXBlfScgdHlwZSBvZiB0aGUgJyR7Y29udGVudH0nIHRva2VuIGlzIG5vdCAndW5hc3NpZ25lZCcuYCk7XG4gICAgfVxuXG4gICAgaWYgKGNvbnRlbnQgPT09IFVOREVSU0NPUkVfQ0hBUkFDVEVSKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoYFRoZSAnJHtjb250ZW50fScgdG9rZW4gY2Fubm90IGJlIGFuIHVuZGVyc2NvcmUuYCk7XG4gICAgfVxuICB9KTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGV4cHJlc3Npb25zRnJvbVZvY2FidWxhcnkodm9jYWJ1bGFyeSwgZXhwcmVzc2lvbnMpIHtcbiAgaWYgKCh2b2NhYnVsYXJ5ID09PSBudWxsKSB8fCAodm9jYWJ1bGFyeSA9PT0gRU1QVFlfU1RSSU5HKSkge1xuICAgIHJldHVybjtcbiAgfVxuXG4gIGNvbnN0IGNvbnRlbnQgPSB2b2NhYnVsYXJ5LCAvLy9cbiAgICAgICAgdG9rZW5zID0gY3VzdG9tR3JhbW1hclZvY2FidWxhcnlMZXhlci50b2tlbmlzZShjb250ZW50KSxcbiAgICAgICAgbm9kZSA9IGN1c3RvbUdyYW1tYXJWb2NhYnVsYXJ5UGFyc2VyLnBhcnNlKHRva2VucyksXG4gICAgICAgIGV4cHJlc3Npb25Ob2RlcyA9IGV4cHJlc3Npb25Ob2Rlc1F1ZXJ5KG5vZGUpO1xuXG4gIGV4cHJlc3Npb25Ob2Rlcy5mb3JFYWNoKChleHByZXNzaW9uTm9kZSkgPT4ge1xuICAgIGNvbnN0IGNvbnRlbnQgPSBjb250ZW50RnJvbUV4cHJlc3Npb25Ob2RlKGV4cHJlc3Npb25Ob2RlKSxcbiAgICAgICAgICBleHByZXNzaW9uID0gY29udGVudDsgLy8vXG5cbiAgICBleHByZXNzaW9ucy5wdXNoKGV4cHJlc3Npb24pO1xuICB9KTtcbn1cblxuZnVuY3Rpb24gY29udGVudEZyb21FeHByZXNzaW9uTm9kZShleHByZXNzaW9uTm9kZSkge1xuICBjb25zdCBub25UZXJtaW5hbE5vZGUgPSBleHByZXNzaW9uTm9kZSwgLy8vXG4gICAgICAgIGNoaWxkTm9kZXMgPSBub25UZXJtaW5hbE5vZGUuZ2V0Q2hpbGROb2RlcygpLFxuICAgICAgICBzZWNvbmRDaGlsZE5vZGUgPSBzZWNvbmQoY2hpbGROb2RlcyksXG4gICAgICAgIHVuYXNzaWduZWRUZXJtaW5hbE5vZGUgPSBzZWNvbmRDaGlsZE5vZGUsICAvLy9cbiAgICAgICAgY29udGVudCA9IHVuYXNzaWduZWRUZXJtaW5hbE5vZGUuZ2V0Q29udGVudCgpO1xuXG4gIHJldHVybiBjb250ZW50O1xufVxuIl0sIm5hbWVzIjpbImV4cHJlc3Npb25zRnJvbVZvY2FidWxhcnkiLCJ2YWxpZGF0ZVZvY2FidWxhcnkiLCJmaXJzdCIsImFycmF5VXRpbGl0aWVzIiwic2Vjb25kIiwiZXhwcmVzc2lvbk5vZGVzUXVlcnkiLCJub2Rlc1F1ZXJ5Iiwidm9jYWJ1bGFyeSIsIkVNUFRZX1NUUklORyIsImNvbnRlbnQiLCJ0b2tlbnMiLCJjdXN0b21HcmFtbWFyVm9jYWJ1bGFyeUxleGVyIiwidG9rZW5pc2UiLCJub2RlIiwiY3VzdG9tR3JhbW1hclZvY2FidWxhcnlQYXJzZXIiLCJwYXJzZSIsImV4cHJlc3Npb25Ob2RlcyIsImZvckVhY2giLCJleHByZXNzaW9uTm9kZSIsImNvbnRlbnRGcm9tRXhwcmVzc2lvbk5vZGUiLCJub21pbmFsTGV4ZXIiLCJ0b2tlbnNMZW5ndGgiLCJsZW5ndGgiLCJFcnJvciIsImZpcnN0VG9rZW4iLCJ0b2tlbiIsInR5cGUiLCJnZXRUeXBlIiwiVU5BU1NJR05FRF9UWVBFIiwiVU5ERVJTQ09SRV9DSEFSQUNURVIiLCJleHByZXNzaW9ucyIsImV4cHJlc3Npb24iLCJwdXNoIiwibm9uVGVybWluYWxOb2RlIiwiY2hpbGROb2RlcyIsImdldENoaWxkTm9kZXMiLCJzZWNvbmRDaGlsZE5vZGUiLCJ1bmFzc2lnbmVkVGVybWluYWxOb2RlIiwiZ2V0Q29udGVudCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O1FBK0NnQkE7ZUFBQUE7O1FBbENBQztlQUFBQTs7O3lCQVhlO3FCQUVKO3VCQUNFO3lCQUN1Qzt1QkFDUTtBQUU1RSxJQUFRQyxRQUFrQkMseUJBQWMsQ0FBaENELE9BQU9FLFNBQVdELHlCQUFjLENBQXpCQztBQUVmLElBQU1DLHVCQUF1QkMsSUFBQUEsaUJBQVUsRUFBQztBQUVqQyxTQUFTTCxtQkFBbUJNLFVBQVU7SUFDM0MsSUFBSSxBQUFDQSxlQUFlLFFBQVVBLGVBQWVDLHVCQUFZLEVBQUc7UUFDMUQ7SUFDRjtJQUVBLElBQU1DLFVBQVVGLFlBQ1ZHLFNBQVNDLHFDQUE0QixDQUFDQyxRQUFRLENBQUNILFVBQy9DSSxPQUFPQyxzQ0FBNkIsQ0FBQ0MsS0FBSyxDQUFDTDtJQUVqRCxJQUFNTSxrQkFBa0JYLHFCQUFxQlE7SUFFN0NHLGdCQUFnQkMsT0FBTyxDQUFDLFNBQUNDO1FBQ3ZCLElBQU1ULFVBQVVVLDBCQUEwQkQsaUJBQ3BDUixTQUFTVSxxQkFBWSxDQUFDUixRQUFRLENBQUNILFVBQy9CWSxlQUFlWCxPQUFPWSxNQUFNO1FBRWxDLElBQUlELGVBQWUsR0FBRztZQUNwQixNQUFNLElBQUlFLE1BQU0sQUFBQyxtQkFBMEIsT0FBUmQsU0FBUTtRQUM3QztRQUVBLElBQU1lLGFBQWF0QixNQUFNUSxTQUNuQmUsUUFBUUQsWUFDUkUsT0FBT0QsTUFBTUUsT0FBTztRQUUxQixJQUFJRCxTQUFTRSwwQkFBZSxFQUFFO1lBQzVCLE1BQU0sSUFBSUwsTUFBTSxBQUFDLFFBQTZCZCxPQUF0QmlCLE1BQUssbUJBQXlCLE9BQVJqQixTQUFRO1FBQ3hEO1FBRUEsSUFBSUEsWUFBWW9CLCtCQUFvQixFQUFFO1lBQ3BDLE1BQU0sSUFBSU4sTUFBTSxBQUFDLFFBQWUsT0FBUmQsU0FBUTtRQUNsQztJQUNGO0FBQ0Y7QUFFTyxTQUFTVCwwQkFBMEJPLFVBQVUsRUFBRXVCLFdBQVc7SUFDL0QsSUFBSSxBQUFDdkIsZUFBZSxRQUFVQSxlQUFlQyx1QkFBWSxFQUFHO1FBQzFEO0lBQ0Y7SUFFQSxJQUFNQyxVQUFVRixZQUNWRyxTQUFTQyxxQ0FBNEIsQ0FBQ0MsUUFBUSxDQUFDSCxVQUMvQ0ksT0FBT0Msc0NBQTZCLENBQUNDLEtBQUssQ0FBQ0wsU0FDM0NNLGtCQUFrQlgscUJBQXFCUTtJQUU3Q0csZ0JBQWdCQyxPQUFPLENBQUMsU0FBQ0M7UUFDdkIsSUFBTVQsVUFBVVUsMEJBQTBCRCxpQkFDcENhLGFBQWF0QixTQUFTLEdBQUc7UUFFL0JxQixZQUFZRSxJQUFJLENBQUNEO0lBQ25CO0FBQ0Y7QUFFQSxTQUFTWiwwQkFBMEJELGNBQWM7SUFDL0MsSUFBTWUsa0JBQWtCZixnQkFDbEJnQixhQUFhRCxnQkFBZ0JFLGFBQWEsSUFDMUNDLGtCQUFrQmhDLE9BQU84QixhQUN6QkcseUJBQXlCRCxpQkFDekIzQixVQUFVNEIsdUJBQXVCQyxVQUFVO0lBRWpELE9BQU83QjtBQUNUIn0=

package/lib/vocabularyNames.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SYMBOL_VOCABULARY_NAME () {
+        return SYMBOL_VOCABULARY_NAME;
+    },
+    get TYPE_VOCABULARY_NAME () {
+        return TYPE_VOCABULARY_NAME;
+    },
+    get default () {
+        return _default;
+    }
+});
+var TYPE_VOCABULARY_NAME = "type";
+var SYMBOL_VOCABULARY_NAME = "symbol";
+var _default = {
+    TYPE_VOCABULARY_NAME: TYPE_VOCABULARY_NAME,
+    SYMBOL_VOCABULARY_NAME: SYMBOL_VOCABULARY_NAME
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy92b2NhYnVsYXJ5TmFtZXMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCBUWVBFX1ZPQ0FCVUxBUllfTkFNRSA9IFwidHlwZVwiO1xuZXhwb3J0IGNvbnN0IFNZTUJPTF9WT0NBQlVMQVJZX05BTUUgPSBcInN5bWJvbFwiO1xuXG5leHBvcnQgZGVmYXVsdCB7XG4gIFRZUEVfVk9DQUJVTEFSWV9OQU1FLFxuICBTWU1CT0xfVk9DQUJVTEFSWV9OQU1FXG59O1xuIl0sIm5hbWVzIjpbIlNZTUJPTF9WT0NBQlVMQVJZX05BTUUiLCJUWVBFX1ZPQ0FCVUxBUllfTkFNRSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O1FBR2FBO2VBQUFBOztRQURBQztlQUFBQTs7UUFHYjtlQUFBOzs7QUFITyxJQUFNQSx1QkFBdUI7QUFDN0IsSUFBTUQseUJBQXlCO0lBRXRDLFdBQWU7SUFDYkMsc0JBQUFBO0lBQ0FELHdCQUFBQTtBQUNGIn0=

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-custom-grammars",
   "author": "James Smith",
-  "version": "5.0.1227",
+  "version": "5.0.1229",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-custom-grammars",
   "description": "Occam's custom grammars.",
@@ -12,9 +12,10 @@
   "dependencies": {
     "necessary": "^14.3.2",
     "occam-grammar-utilities": "^8.0.345",
-    "occam-grammars": "^1.3.309",
+    "occam-grammars": "^1.3.311",
     "occam-lexers": "^23.1.1",
-    "occam-parsers": "^23.1.1"
+    "occam-parsers": "^23.1.3",
+    "occam-query": "^4.1.109"
   },
   "devDependencies": {
     "@swc/core": "^1.5.6",

package/src/constants.js

@@ -2,3 +2,7 @@
 
 export const EMPTY_STRING = "";
 export const VERTICAL_BAR = "|";
+export const UNASSIGNED_TYPE = "unassigned";
+export const STUFF_RULE_NAME = "stuff";
+export const NONSENSE_RULE_NAME = "nonsense";
+export const UNDERSCORE_CHARACTER = "_";

package/src/customGrammar/combined.js

@@ -6,8 +6,11 @@ import { eliminateLeftRecursion } from "occam-grammar-utilities";
 
 import defaultCustomGrammar from "../customGrammar/default";
 
+import { validateBNF } from "../utilities/bnf";
 import { EMPTY_STRING, VERTICAL_BAR } from "../constants";
-import { TYPE_PATTERN_NAME, SYMBOL_PATTERN_NAME } from "../patternNames";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import { validateVocabulary, expressionsFromVocabulary } from "../utilities/vocabulary";
+import { TYPE_VOCABULARY_NAME, SYMBOL_VOCABULARY_NAME } from "../vocabularyNames";
 
 const { rulesFromBNF } = parserUtilities,
       { unshift, backwardsForEach } = arrayUtilities;
@@ -44,7 +47,7 @@ export default class CombinedCustomGrammar {
       customGrammars = [ defaultCustomGrammar, ...customGrammars ]; ///
     }
 
-    const rules = rulesFromCustomGrammarsAndDefaultBNF(customGrammars),
+    const rules = rulesFromCustomGrammars(customGrammars),
           entries = entriesFromCustomGrammars(customGrammars),
           combinedCustomGrammar = new CombinedCustomGrammar(rules, entries);
 
@@ -56,7 +59,7 @@ export default class CombinedCustomGrammar {
       customGrammars = [ defaultCustomGrammar, ...customGrammars ]; ///
     }
 
-    const rules = rulesFromCustomGrammarsAndDefaultBNF(customGrammars),
+    const rules = rulesFromCustomGrammars(customGrammars),
           entries = entriesFromCustomGrammars(customGrammars),
           combinedCustomGrammar = new CombinedCustomGrammar(rules, entries);
     
@@ -64,9 +67,13 @@ export default class CombinedCustomGrammar {
   }
 }
 
-function rulesFromCustomGrammarsAndDefaultBNF(customGrammars) {
-  const bnfs = customGrammars.map((customGrammar) => {
-          const bnf = customGrammar.getBNF();
+function rulesFromCustomGrammars(customGrammars) {
+  const ruleNames = [
+          TERM_RULE_NAME,
+          STATEMENT_RULE_NAME,
+        ],
+        bnfs = ruleNames.map((ruleName) => {
+          const bnf = bnfFromCustomGrammars(customGrammars, ruleName);
 
           return bnf;
         }),
@@ -79,12 +86,12 @@ function rulesFromCustomGrammarsAndDefaultBNF(customGrammars) {
 }
 
 function entriesFromCustomGrammars(customGrammars) {
-  const patternNames = [
-          TYPE_PATTERN_NAME,
-          SYMBOL_PATTERN_NAME
+  const vocabularyNames = [
+          TYPE_VOCABULARY_NAME,
+          SYMBOL_VOCABULARY_NAME
         ],
-        entries = patternNames.map((patternName) => {
-          const entry = entryFromCustomGrammars(customGrammars, patternName);
+        entries = vocabularyNames.map((vocabularyName) => {
+          const entry = entryFromCustomGrammars(customGrammars, vocabularyName);
 
           return entry;
         });
@@ -92,28 +99,42 @@ function entriesFromCustomGrammars(customGrammars) {
   return entries;
 }
 
-function entryFromCustomGrammars(customGrammars, patternName) {
-  const patterns = [];
+function bnfFromCustomGrammars(customGrammars, ruleName) {
+  const bnfs = [];
 
   backwardsForEach(customGrammars, (customGrammar) => {
-    const pattern = customGrammar.getPattern(patternName);
+    const bnf = customGrammar.getBNF(ruleName),
+          customGrammarDefaultCustomGrammar = customGrammar.isDefaultCustomGrammar();
+
+    if (!customGrammarDefaultCustomGrammar) {
+      validateBNF(bnf, ruleName);
+    }
+
+    bnfs.push(bnf);
+  });
 
-    if ((pattern !== null) && (pattern !== EMPTY_STRING)) {
-      const subPatterns = pattern.split(VERTICAL_BAR);
+  const bnf = bnfs.join(EMPTY_STRING);
 
-      subPatterns.forEach((subPattern) => {
-        const pattern = (patternName === TYPE_PATTERN_NAME) ?
-                          `${subPattern}(?!\\w)` :
-                             subPattern; ///
+  return bnf;
+}
+
+function entryFromCustomGrammars(customGrammars, vocabularyName) {
+  const expressions = [];
 
-        patterns.push(pattern);
-      });
+  backwardsForEach(customGrammars, (customGrammar) => {
+    const vocabulary = customGrammar.getVocabulary(vocabularyName),
+          customGrammarDefaultCustomGrammar = customGrammar.isDefaultCustomGrammar();
+
+    if (!customGrammarDefaultCustomGrammar) {
+      validateVocabulary(vocabulary);
     }
+
+    expressionsFromVocabulary(vocabulary, expressions);
   });
 
-  const patternsString = patterns.join(VERTICAL_BAR),
-        entryName = patternName,  ///
-        entryValue = `^(?:${patternsString})`,
+  const pattern = expressions.join(VERTICAL_BAR),
+        entryName = vocabularyName,  ///
+        entryValue = `^(?:${pattern})`,
         entry = {
           [entryName]: entryValue
         };

package/src/customGrammar/default.js

@@ -62,17 +62,18 @@ statementSubstitution                ::=  "[" statement "for" statement "]";
 
 referenceSubstitution                ::=  "[" reference "for" reference "]";`;
 
-export const typePattern = "_";
+export const typeVocabulary = `_
+`;
 
-export const symbolPattern = "";
+export const symbolVocabulary = "";
 
 const name = DEFAULT_CUSTOM_GRAMMAR_NAME,
       json = {
         name,
         termBNF,
         statementBNF,
-        typePattern,
-        symbolPattern
+        typeVocabulary,
+        symbolVocabulary
       };
 
 const defaultCustomGrammar = CustomGrammar.fromJSON(json);

package/src/customGrammar.js

@@ -1,16 +1,17 @@
 "use strict";
 
 import { EMPTY_STRING } from "./constants";
+import { DEFAULT_CUSTOM_GRAMMAR_NAME } from "./grammarNames";
 import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
-import { TYPE_PATTERN_NAME, SYMBOL_PATTERN_NAME } from "./patternNames";
+import { TYPE_VOCABULARY_NAME, SYMBOL_VOCABULARY_NAME } from "./vocabularyNames";
 
 export default class CustomGrammar {
-  constructor(name, termBNF, statementBNF, typePattern, symbolPattern) {
+  constructor(name, termBNF, statementBNF, typeVocabulary, symbolVocabulary) {
     this.name = name;
     this.termBNF = termBNF;
     this.statementBNF = statementBNF;
-    this.typePattern = typePattern;
-    this.symbolPattern = symbolPattern;
+    this.typeVocabulary = typeVocabulary;
+    this.symbolVocabulary = symbolVocabulary;
   }
   
   getName() {
@@ -25,65 +26,49 @@ export default class CustomGrammar {
     return this.statementBNF;
   }
 
-  getTypePattern() {
-    return this.typePattern;
+  getTypeVocabulary() {
+    return this.typeVocabulary;
   }
 
-  getSymbolPattern() {
-    return this.symbolPattern;
+  getSymbolVocabulary() {
+    return this.symbolVocabulary;
   }
 
-  getBNF(ruleName = null) {
+  getBNF(ruleName) {
     let bnf;
 
     switch (ruleName) {
       case TERM_RULE_NAME: bnf = this.termBNF; break;
       case STATEMENT_RULE_NAME: bnf = this.statementBNF; break;
-
-      default: {
-        const ruleNames = [
-                TERM_RULE_NAME,
-                STATEMENT_RULE_NAME
-              ],
-              combinedBNF = ruleNames.reduce((combinedBNF, ruleName) => {
-                const bnf = this.getBNF(ruleName);
-
-                if (bnf !== EMPTY_STRING) {
-                  combinedBNF = `${combinedBNF}
-            
-${bnf}`;
-                }
-
-                return combinedBNF;
-              }, EMPTY_STRING);
-
-        bnf = combinedBNF;  ///
-
-        break;
-      }
     }
 
     return bnf;
   }
 
-  getPattern(patternName) {
-    let pattern;
+  getVocabulary(vocabularyName) {
+    let vocabulary;
 
-    switch (patternName) {
-      case TYPE_PATTERN_NAME: pattern = this.typePattern; break;
-      case SYMBOL_PATTERN_NAME: pattern = this.symbolPattern; break;
+    switch (vocabularyName) {
+      case TYPE_VOCABULARY_NAME: vocabulary = this.typeVocabulary; break;
+      case SYMBOL_VOCABULARY_NAME: vocabulary = this.symbolVocabulary; break;
     }
 
-    return pattern;
+    return vocabulary;
   }
 
-  getPatterns() {
-    const patterns = [
-      this.typePattern,
-      this.symbolPattern
+  getVocabularies() {
+    const vocabularies = [
+      this.typeVocabulary,
+      this.symbolVocabulary
     ];
 
-    return patterns;
+    return vocabularies;
+  }
+
+  isDefaultCustomGrammar() {
+    const defaultCustomGrammar = (this.name === DEFAULT_CUSTOM_GRAMMAR_NAME);
+
+    return defaultCustomGrammar;
   }
 
   setName(name) {
@@ -104,15 +89,15 @@ ${bnf}`;
     }
   }
 
-  setPattern(patternName, pattern) {
-    switch (patternName) {
-      case TYPE_PATTERN_NAME:
-        this.typePattern = pattern;
+  setVocabulary(vocabularyName, vocabulary) {
+    switch (vocabularyName) {
+      case TYPE_VOCABULARY_NAME:
+        this.typeVocabulary = vocabulary;
 
         break;
 
-      case SYMBOL_PATTERN_NAME:
-        this.symbolPattern = pattern;
+      case SYMBOL_VOCABULARY_NAME:
+        this.symbolVocabulary = vocabulary;
 
         break;
     }
@@ -124,38 +109,38 @@ ${bnf}`;
     this.setBNF(ruleName, bnf);
   }
 
-  resetPattern(patternName) {
-    const pattern = EMPTY_STRING;
+  resetVocabulary(vocabularyName) {
+    const vocabulary = EMPTY_STRING;
 
-    this.setPattern(patternName, pattern);
+    this.setVocabulary(vocabularyName, vocabulary);
   }
 
-  update(ruleName, bnf, patternName, pattern) {
+  update(ruleName, bnf, vocabularyName, vocabulary) {
     this.setBNF(ruleName, bnf);
 
-    this.setPattern(patternName, pattern);
+    this.setVocabulary(vocabularyName, vocabulary);
   }
 
   toJSON() {
     const name = this.name,
           termBNF = this.termBNF,
           statementBNF = this.statementBNF,
-          typePattern = this.typePattern,
-          symbolPattern = this.symbolPattern,
+          typeVocabulary = this.typeVocabulary,
+          symbolVocabulary = this.symbolVocabulary,
           json = {
             name,
             termBNF,
             statementBNF,
-            typePattern,
-            symbolPattern
+            typeVocabulary,
+            symbolVocabulary
           };
     
     return json;
   }
 
   static fromJSON(json) {
-    const { name, termBNF, statementBNF, typePattern, symbolPattern } = json,
-          customGrammar = new CustomGrammar(name, termBNF, statementBNF, typePattern, symbolPattern);
+    const { name, termBNF, statementBNF, typeVocabulary, symbolVocabulary } = json,
+          customGrammar = new CustomGrammar(name, termBNF, statementBNF, typeVocabulary, symbolVocabulary);
 
     return customGrammar;
   }
@@ -163,15 +148,15 @@ ${bnf}`;
   static fromName(name) {
     const termBNF = EMPTY_STRING,
           statementBNF = EMPTY_STRING,
-          typePattern = EMPTY_STRING,
-          symbolPattern = EMPTY_STRING,
-          customGrammar = new CustomGrammar(name, termBNF, statementBNF, typePattern, symbolPattern);
+          typeVocabulary = EMPTY_STRING,
+          symbolVocabulary = EMPTY_STRING,
+          customGrammar = new CustomGrammar(name, termBNF, statementBNF, typeVocabulary, symbolVocabulary);
 
     return customGrammar;
   }
 
-  static fromNameTermBNFStatementBNFTypePatternAndSymbolPattern(name, termBNF, statementBNF, typePattern, symbolPattern) {
-    const customGrammar = new CustomGrammar(name, termBNF, statementBNF, typePattern, symbolPattern);
+  static fromNameTermBNFStatementBNFTypeVocabularyAndSymbolVocabulary(name, termBNF, statementBNF, typeVocabulary, symbolVocabulary) {
+    const customGrammar = new CustomGrammar(name, termBNF, statementBNF, typeVocabulary, symbolVocabulary);
 
     return customGrammar;
   }

package/src/example/customGrammar/userDefined1.js

@@ -5,16 +5,20 @@ import { CustomGrammar } from "../../index"; ///
 import { USER_DEFINED_CUSTOM_GRAMMAR_NAME_1 } from "../grammarNames";
 
 const name = USER_DEFINED_CUSTOM_GRAMMAR_NAME_1,
-      termBNF = ``,
-      statementBNF = ``,
-      typePattern = "Group",
-      symbolPattern = "",
+      termBNF = `
+
+        term  ::=  [type] "stuff" ;
+        
+      `,
+      statementBNF = "",
+      typeVocabulary = "",
+      symbolVocabulary = "",
       json = {
         name,
         termBNF,
         statementBNF,
-        typePattern,
-        symbolPattern
+        typeVocabulary,
+        symbolVocabulary
       },
       userDefinedCustomGrammar1 = CustomGrammar.fromJSON(json);
 

package/src/example/customGrammar/userDefined2.js

@@ -5,16 +5,16 @@ import { CustomGrammar } from "../../index"; ///
 import { USER_DEFINED_CUSTOM_GRAMMAR_NAME_2 } from "../grammarNames";
 
 const name = USER_DEFINED_CUSTOM_GRAMMAR_NAME_2,
-      termBNF = ``,
-      statementBNF = ``,
-      typePattern = "",
-      symbolPattern = "",
+      termBNF = "",
+      statementBNF = "",
+      typeVocabulary = "",
+      symbolVocabulary = "",
       json = {
         name,
         termBNF,
         statementBNF,
-        typePattern,
-        symbolPattern
+        typeVocabulary,
+        symbolVocabulary
       },
       userDefinedCustomGrammar2 = CustomGrammar.fromJSON(json);
 

package/src/example/grammarNames.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export { DEFAULT_CUSTOM_GRAMMAR_NAME } from "../grammarNames";
+export { DEFAULT_CUSTOM_GRAMMAR_NAME } from "../index"; ///
 
 export const USER_DEFINED_CUSTOM_GRAMMAR_NAME_1 = "User defined 1";
 export const USER_DEFINED_CUSTOM_GRAMMAR_NAME_2 = "User defined 2";

package/src/example/select/vocabularyName.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import Select from "../select";
+
+import { TYPE_VOCABULARY_NAME, SYMBOL_VOCABULARY_NAME }  from "../../vocabularyNames";
+
+export default class VocabularyNameSelect extends Select {
+  getVocabularyName() {
+    const value = this.getValue(),
+          vocabularyName = value; ///
+
+    return vocabularyName;
+  }
+
+  childElements() {
+    const vocabularyNames = [
+            TYPE_VOCABULARY_NAME,
+            SYMBOL_VOCABULARY_NAME
+          ],
+          options  = vocabularyNames.map((vocabularyName, index) => {
+            const value = vocabularyName,
+                  selected = (index === 0);
+
+            return (
+
+              <option value={value} selected={selected} >
+                {vocabularyName}
+              </option>
+
+            );
+          }),
+          childElements = [
+            ...options
+          ];
+
+
+    return childElements;
+  }
+
+  parentContext() {
+    const getVocabularyName = this.getVocabularyName.bind(this); ///
+
+    return ({
+      getVocabularyName
+    });
+  }
+
+  static defaultProperties = {
+    className: "rule-name",
+    spellCheck: "false"
+  }
+}

package/src/example/textarea/vocabulary.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import Textarea from "../textarea";
+
+export default class VocabularyTextarea extends Textarea {
+  getVocabulary() {
+    const value = this.getValue(),
+          vocabulary = value; ///
+
+    return vocabulary;
+  }
+
+  setVocabulary(vocabulary) {
+    const value = vocabulary; ///
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const getVocabulary = this.getVocabulary.bind(this),
+          setVocabulary = this.setVocabulary.bind(this);
+
+    return ({
+      getVocabulary,
+      setVocabulary
+    });
+  }
+
+  static defaultProperties = {
+    className: "vocabulary",
+    spellCheck: "false"
+  };
+}