occam-custom-grammars 5.0.1227 → 5.0.1229

package/src/example/view.js

@@ -11,13 +11,13 @@ import SubHeading from "./subHeading";
 import NameSelect from "./select/name";
 import SizeableDiv from "./div/sizeable";
 import BNFTextarea from "./textarea/bnf";
-import PatternInput from "./input/pattern";
 import RuleNameSelect from "./select/ruleName";
 import ContentTextarea from "./textarea/content";
-import PatternNameSelect from "./select/patternName";
 import ParseTreeTextarea from "./textarea/parseTree";
 import StartRuleNameInput from "./input/startRuleName";
 import NominalBNFTextarea from "./textarea/nominalBNF";
+import VocabularyTextarea from "./textarea/vocabulary";
+import VocabularyNameSelect from "./select/vocabularyName";
 import userDefinedCustomGrammar1 from "./customGrammar/userDefined1";
 import userDefinedCustomGrammar2 from "./customGrammar/userDefined2";
 
@@ -31,22 +31,22 @@ const { rulesAsString } = rulesUtilities,
 class View extends Element {
   keyUpHandler = (event, element) => {
     try {
-      const name = this.getName(),
-            bnf = this.getBNF(),
-            pattern = this.getPattern(),
+      const bnf = this.getBNF(),
+            name = this.getName(),
             ruleName = this.getRuleName(),
-            patternName = this.getPatternName();
+            vocabulary = this.getVocabulary(),
+            vocabularyName = this.getVocabularyName();
 
       if (name === USER_DEFINED_CUSTOM_GRAMMAR_NAME_1) {
         userDefinedCustomGrammar1.setBNF(ruleName, bnf);
 
-        userDefinedCustomGrammar1.setPattern(patternName, pattern);
+        userDefinedCustomGrammar1.setVocabulary(vocabularyName, vocabulary);
       }
 
       if (name === USER_DEFINED_CUSTOM_GRAMMAR_NAME_2) {
         userDefinedCustomGrammar2.setBNF(ruleName, bnf);
 
-        userDefinedCustomGrammar2.setPattern(patternName, pattern);
+        userDefinedCustomGrammar2.setVocabulary(vocabularyName, vocabulary);
       }
 
       const customGrammars = [
@@ -92,7 +92,7 @@ class View extends Element {
 
     const name = this.getName(),
           ruleName = this.getRuleName(),
-          patternName = this.getPatternName();
+          vocabularyName = this.getVocabularyName();
 
     switch (name) {
       case DEFAULT_CUSTOM_GRAMMAR_NAME:
@@ -112,11 +112,11 @@ class View extends Element {
     }
 
     const bnf = customGrammar.getBNF(ruleName),
-          pattern = customGrammar.getPattern(patternName);
+          vocabulary = customGrammar.getVocabulary(vocabularyName);
 
     this.setBNF(bnf);
 
-    this.setPattern(pattern);
+    this.setVocabulary(vocabulary);
   }
 
   childElements() {
@@ -132,16 +132,16 @@ class View extends Element {
               Custom grammar
             </SubHeading>
             <NameSelect onChange={changeHandler} />
+            <SubHeading>
+              Vocabulary
+            </SubHeading>
+            <VocabularyNameSelect onChange={changeHandler} />
+            <VocabularyTextarea onKeyUp={keyUpHandler} />
             <SubHeading>
               BNF
             </SubHeading>
             <RuleNameSelect onChange={changeHandler} />
             <BNFTextarea onKeyUp={keyUpHandler} />
-            <SubHeading>
-              Pattern
-            </SubHeading>
-            <PatternNameSelect onChange={changeHandler} />
-            <PatternInput onKeyUp={keyUpHandler} />
             <SubHeading>
               Start rule
             </SubHeading>

package/src/index.js

@@ -3,7 +3,7 @@
 export { DEFAULT_CUSTOM_GRAMMAR_NAME } from "./grammarNames";
 
 export { default as ruleNames } from "./ruleNames";
-export { default as patternNames } from "./patternNames";
+export { default as vocabularyNames } from "./vocabularyNames";
 
 export { default as CustomGrammar } from "./customGrammar";
 export { default as lexersUtilities } from "./utilities/lexers";

package/src/typesMap.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { nominalParser } from "./utilities/nominal";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+import { STUFF_RULE_NAME, NONSENSE_RULE_NAME } from "./constants";
+
+const { first } = arrayUtilities;
+
+const ruleMap = nominalParser.getRuleMap(),
+      stuffRule = ruleMap[STUFF_RULE_NAME],
+      nonsenseRule = ruleMap[NONSENSE_RULE_NAME],
+      stuffTypes = typesFromRule(stuffRule),
+      nonsenseTypes = typesFromRule(nonsenseRule),
+      termTypes = stuffTypes, ///
+      statementTypes = nonsenseTypes,
+      typesMap = {
+        [TERM_RULE_NAME]: termTypes,
+        [STATEMENT_RULE_NAME]: statementTypes
+      };
+
+export default typesMap;
+
+function typesFromRule(rule) {
+  let parts;
+
+  const definitions = rule.getDefinitions(),
+        firstDDefinition = first(definitions),
+        definition = firstDDefinition;  ///
+
+  parts = definition.getParts();
+
+  const firstPart = first(parts),
+        oneOrMorePartsPart = firstPart, ///
+        part = oneOrMorePartsPart.getPart(),
+        choiceOrPartsPart = part; ///
+
+  parts = choiceOrPartsPart.getParts();
+
+  const types = parts.map((part) => {
+    const significantTokenTypePart = part,  ///
+          significantTokenType = significantTokenTypePart.getSignificantTokenType(),
+          type = significantTokenType;  ///
+
+    return type;
+  });
+
+  return types;
+}

package/src/utilities/bnf.js

@@ -0,0 +1,88 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import typesMap from "../typesMap";
+
+import { nodesQuery } from "../utilities/query";
+import { nominalLexer } from "../utilities/nominal";
+import { EMPTY_STRING, UNDERSCORE_CHARACTER } from "../constants";
+import { customGrammarBNFLexer, customGrammarBNFParser } from "../utilities/grammar";
+
+const { first, second } = arrayUtilities;
+
+const stringLiteralTerminalNodesQuery = nodesQuery("//stringLiteral/@*!"),
+      significantTokenTypeTerminalNodesQuery = nodesQuery("//significantTokenType/@*!");
+
+export function validateBNF(bnf, ruleName) {
+  if ((bnf === null) || (bnf === EMPTY_STRING)) {
+    return;
+  }
+
+  const content = bnf,
+        tokens = customGrammarBNFLexer.tokenise(content),
+        node = customGrammarBNFParser.parse(tokens);
+
+  const types = typesMap[ruleName],
+        significantTokenTypeTerminalNodes = significantTokenTypeTerminalNodesQuery(node);
+
+  significantTokenTypeTerminalNodes.forEach((significantTokenTypeTerminalNode) => {
+    const type = typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode),
+          typesIncludeType = types.includes(type);
+
+    if (!typesIncludeType) {
+      throw new Error(`The '${type}' type is not included in the '${ruleName}' rule's types.`)
+    }
+  });
+
+  const stringLiteralTerminalNodes = stringLiteralTerminalNodesQuery(node);
+
+  stringLiteralTerminalNodes.forEach((stringLiteralTerminalNode) => {
+    const content = contentFromStringLiteralTerminalNode(stringLiteralTerminalNode);
+
+    if (content === UNDERSCORE_CHARACTER) {
+      throw new Error(`The "${content}" string literal cannot be an underscore.`);
+    }
+
+    const tokens = nominalLexer.tokenise(content),
+          tokensLength = tokens.length;
+
+    if (tokensLength !== 1) {
+      throw new Error(`Tokenising the "${content}" string literal does not result in a single token.`);
+    }
+
+    const firstToken = first(tokens),
+          token = firstToken, ///
+          type = token.getType(),
+          typesIncludeType = types.includes(type);
+
+    if (!typesIncludeType) {
+      throw new Error(`The "${content}" string literal's token's '${type}' type is not included in the '${ruleName}' rule's types.`)
+    }
+  });
+}
+
+function contentFromStringLiteralTerminalNode(stringLiteralTerminalNode) {
+  let content;
+
+  content = stringLiteralTerminalNode.getContent();
+
+  const matches = content.match(/"([^"]+)"/),
+        secondMatch = second(matches);
+
+  content = secondMatch; ///
+
+  return content;
+}
+
+function typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode) {
+  let type;
+
+  const content = significantTokenTypeTerminalNode.getContent(),
+        matches = content.match(/\[([^\]]+)\]/),
+        secondMatch = second(matches);
+
+  type = secondMatch; ///
+
+  return type;
+}

package/src/utilities/grammar.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { CustomGrammarBNFLexer, CustomGrammarBNFParser } from "occam-grammars";
+import { CustomGrammarVocabularyLexer, CustomGrammarVocabularyParser } from "occam-grammars";
+
+export const customGrammarBNFLexer = CustomGrammarBNFLexer.fromNothing();
+
+export const customGrammarBNFParser = CustomGrammarBNFParser.fromNothing();
+
+export const customGrammarVocabularyLexer = CustomGrammarVocabularyLexer.fromNothing();
+
+export const customGrammarVocabularyParser = CustomGrammarVocabularyParser.fromNothing();

package/src/utilities/nominal.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { CommonLexer } from "occam-lexers";
+import { CommonParser } from "occam-parsers";
+import { NominalLexer, NominalParser } from "occam-grammars";
+
+export const nominalLexer = CommonLexer.fromNothing(NominalLexer);
+
+export const nominalParser = CommonParser.fromNothing(NominalParser);

package/src/utilities/query.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { Query } from "occam-query";
+
+export function nodeQuery(expressionString) {
+  const query = Query.fromExpressionString(expressionString);
+
+  return function(node) {
+    const nodes = query.execute(node);
+
+    node = nodes.shift() || null; ///
+
+    return node;
+  };
+}
+
+export function nodesQuery(expressionString) {
+  const query = Query.fromExpressionString(expressionString);
+
+  return function(node) {
+    const nodes = query.execute(node);
+
+    return nodes;
+  };
+}

package/src/utilities/vocabulary.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { nodesQuery } from "../utilities/query";
+import { nominalLexer } from "../utilities/nominal";
+import { EMPTY_STRING, UNASSIGNED_TYPE, UNDERSCORE_CHARACTER } from "../constants";
+import { customGrammarVocabularyLexer, customGrammarVocabularyParser } from "../utilities/grammar"
+
+const { first, second } = arrayUtilities;
+
+const expressionNodesQuery = nodesQuery("//expression")
+
+export function validateVocabulary(vocabulary) {
+  if ((vocabulary === null) || (vocabulary === EMPTY_STRING)) {
+    return;
+  }
+
+  const content = vocabulary, ///
+        tokens = customGrammarVocabularyLexer.tokenise(content),
+        node = customGrammarVocabularyParser.parse(tokens);
+
+  const expressionNodes = expressionNodesQuery(node);
+
+  expressionNodes.forEach((expressionNode) => {
+    const content = contentFromExpressionNode(expressionNode),
+          tokens = nominalLexer.tokenise(content),
+          tokensLength = tokens.length;
+
+    if (tokensLength > 1) {
+      throw new Error(`Tokenising the '${content}' content results in more than one token.`);
+    }
+
+    const firstToken = first(tokens),
+          token = firstToken,
+          type = token.getType();
+
+    if (type !== UNASSIGNED_TYPE) {
+      throw new Error(`The '${type}' type of the '${content}' token is not 'unassigned'.`);
+    }
+
+    if (content === UNDERSCORE_CHARACTER) {
+      throw new Error(`The '${content}' token cannot be an underscore.`);
+    }
+  });
+}
+
+export function expressionsFromVocabulary(vocabulary, expressions) {
+  if ((vocabulary === null) || (vocabulary === EMPTY_STRING)) {
+    return;
+  }
+
+  const content = vocabulary, ///
+        tokens = customGrammarVocabularyLexer.tokenise(content),
+        node = customGrammarVocabularyParser.parse(tokens),
+        expressionNodes = expressionNodesQuery(node);
+
+  expressionNodes.forEach((expressionNode) => {
+    const content = contentFromExpressionNode(expressionNode),
+          expression = content; ///
+
+    expressions.push(expression);
+  });
+}
+
+function contentFromExpressionNode(expressionNode) {
+  const nonTerminalNode = expressionNode, ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        secondChildNode = second(childNodes),
+        unassignedTerminalNode = secondChildNode,  ///
+        content = unassignedTerminalNode.getContent();
+
+  return content;
+}

package/src/vocabularyNames.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export const TYPE_VOCABULARY_NAME = "type";
+export const SYMBOL_VOCABULARY_NAME = "symbol";
+
+export default {
+  TYPE_VOCABULARY_NAME,
+  SYMBOL_VOCABULARY_NAME
+};

package/lib/patternNames.js

@@ -1,29 +0,0 @@
-"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_PATTERN_NAME () {
-        return SYMBOL_PATTERN_NAME;
-    },
-    get TYPE_PATTERN_NAME () {
-        return TYPE_PATTERN_NAME;
-    },
-    get default () {
-        return _default;
-    }
-});
-var TYPE_PATTERN_NAME = "type";
-var SYMBOL_PATTERN_NAME = "symbol";
-var _default = {
-    TYPE_PATTERN_NAME: TYPE_PATTERN_NAME,
-    SYMBOL_PATTERN_NAME: SYMBOL_PATTERN_NAME
-};
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9wYXR0ZXJuTmFtZXMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCBUWVBFX1BBVFRFUk5fTkFNRSA9IFwidHlwZVwiO1xuZXhwb3J0IGNvbnN0IFNZTUJPTF9QQVRURVJOX05BTUUgPSBcInN5bWJvbFwiO1xuXG5leHBvcnQgZGVmYXVsdCB7XG4gIFRZUEVfUEFUVEVSTl9OQU1FLFxuICBTWU1CT0xfUEFUVEVSTl9OQU1FXG59O1xuIl0sIm5hbWVzIjpbIlNZTUJPTF9QQVRURVJOX05BTUUiLCJUWVBFX1BBVFRFUk5fTkFNRSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O1FBR2FBO2VBQUFBOztRQURBQztlQUFBQTs7UUFHYjtlQUFBOzs7QUFITyxJQUFNQSxvQkFBb0I7QUFDMUIsSUFBTUQsc0JBQXNCO0lBRW5DLFdBQWU7SUFDYkMsbUJBQUFBO0lBQ0FELHFCQUFBQTtBQUNGIn0=

package/src/example/input/pattern.js

@@ -1,33 +0,0 @@
-"use strict";
-
-import Input from "../input";
-
-export default class PatternInput extends Input {
-  getPattern() {
-    const value = this.getValue(),
-          pattern = value; ///
-
-    return pattern;
-  }
-
-  setPattern(pattern) {
-    const value = pattern; ///
-
-    this.setValue(value);
-  }
-
-  parentContext() {
-    const getPattern = this.getPattern.bind(this),
-          setPattern = this.setPattern.bind(this);
-
-    return ({
-      getPattern,
-      setPattern
-    });
-  }
-
-  static defaultProperties = {
-    className: "pattern",
-    spellCheck: "false"
-  };
-}

package/src/example/select/patternName.js

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

package/src/patternNames.js

@@ -1,9 +0,0 @@
-"use strict";
-
-export const TYPE_PATTERN_NAME = "type";
-export const SYMBOL_PATTERN_NAME = "symbol";
-
-export default {
-  TYPE_PATTERN_NAME,
-  SYMBOL_PATTERN_NAME
-};