occam-custom-grammars 5.0.1226 → 5.0.1228

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,12 +26,12 @@ 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) {
@@ -66,24 +67,30 @@ ${bnf}`;
     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 +111,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 +131,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 +170,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,16 @@ 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 = "",
+      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"
+  };
+}

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() {
@@ -138,10 +138,10 @@ class View extends Element {
             <RuleNameSelect onChange={changeHandler} />
             <BNFTextarea onKeyUp={keyUpHandler} />
             <SubHeading>
-              Pattern
+              Vocabulary
             </SubHeading>
-            <PatternNameSelect onChange={changeHandler} />
-            <PatternInput onKeyUp={keyUpHandler} />
+            <VocabularyNameSelect onChange={changeHandler} />
+            <VocabularyTextarea 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/utilities/bnf.js

@@ -0,0 +1,12 @@
+"use strict";
+
+
+import { EMPTY_STRING } from "../constants";
+
+export function validateBNf(buf) {
+  if ((buf === null) || (buf === EMPTY_STRING)) {
+    return;
+  }
+
+
+}

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,91 @@
+"use strict";
+
+import { CommonLexer } from "occam-lexers";
+import { NominalLexer } from "occam-grammars";
+import { arrayUtilities } from "necessary";
+import { CustomGrammarVocabularyLexer, CustomGrammarVocabularyParser } from "occam-grammars";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING, UNASSIGNED_TYPE, UNDERSCORE_CHARACTER } from "../constants";
+
+const errorNodesQuery = nodesQuery("//error"),
+      expressionNodesQuery = nodesQuery("//expression")
+
+const nominalLexer = CommonLexer.fromNothing(NominalLexer),
+      customGrammarVocabularyLexer = CustomGrammarVocabularyLexer.fromNothing(),
+      customGrammarVocabularyParser = CustomGrammarVocabularyParser.fromNothing();
+
+const { first, second } = arrayUtilities;
+
+export function validateVocabulary(vocabulary) {
+  if ((vocabulary === null) || (vocabulary === EMPTY_STRING)) {
+    return;
+  }
+
+  const content = vocabulary, ///
+        tokens = customGrammarVocabularyLexer.tokenise(content),
+        node = customGrammarVocabularyParser.parse(tokens);
+
+  if (node === null) {
+    throw new Error("The vocabulary cannot be parsed.");
+  }
+
+  const errorNodes = errorNodesQuery(node),
+        errorNodesLength = errorNodes.length;
+
+  if (errorNodesLength > 0) {
+    throw new Error("The vocabulary contains errors.");
+  }
+
+  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 '${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
-};