occam-custom-grammars 5.0.1228 → 5.0.1230

package/src/utilities/validate.js

@@ -0,0 +1,144 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import typesMap from "../typesMap";
+
+import { nominalLexer } from "../utilities/nominal";
+import { UNDERSCORE_CHARACTER } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { customGrammarBNFLexer, customGrammarBNFParser, customGrammarVocabularyLexer, customGrammarVocabularyParser } from "../utilities/grammar";
+
+const { first, second } = arrayUtilities;
+
+const expressionNodesQuery = nodesQuery("//expression"),
+      ruleNameTerminalNodeQuery = nodeQuery("/document/rule/name/@*!"),
+      stringLiteralTerminalNodesQuery = nodesQuery("//stringLiteral/@*!"),
+      significantTokenTypeTerminalNodesQuery = nodesQuery("//significantTokenType/@*!");
+
+export function validateBNF(bnf, ruleName) {
+  const content = bnf,
+        tokens = customGrammarBNFLexer.tokenise(content),
+        node = customGrammarBNFParser.parse(tokens);
+
+  if (node === null) {
+    return;
+  }
+
+  const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node);
+
+  if (ruleNameTerminalNode !== null) {
+    const name = nameFromRuleNameTerminalNode(ruleNameTerminalNode);
+
+    if (name !== ruleName) {
+      throw new Error(`The '${name}' rule should be named '${ruleName}'.`);
+    }
+  }
+
+  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.`)
+    }
+  });
+}
+
+export function validateVocabulary(vocabulary) {
+  const content = vocabulary, ///
+        tokens = customGrammarVocabularyLexer.tokenise(content),
+        node = customGrammarVocabularyParser.parse(tokens);
+
+  if (node === null) {
+    return;
+  }
+
+  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.`);
+    }
+  });
+}
+
+function nameFromRuleNameTerminalNode(ruleNameTerminalNode) {
+  let name;
+
+  const content = ruleNameTerminalNode.getContent();
+
+  name = content; ///
+
+  return name;
+}
+
+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/vocabulary.js

@@ -1,76 +1,24 @@
 "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";
+import { customGrammarVocabularyLexer, customGrammarVocabularyParser } from "../utilities/grammar"
 
-const errorNodesQuery = nodesQuery("//error"),
-      expressionNodesQuery = nodesQuery("//expression")
+const { second } = arrayUtilities;
 
-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 expressionNodesQuery = nodesQuery("//expression");
 
+export function expressionsFromVocabulary(vocabulary, expressions) {
   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);
+  const expressionNodes = expressionNodesQuery(node);
 
   expressionNodes.forEach((expressionNode) => {
     const content = contentFromExpressionNode(expressionNode),

package/lib/utilities/bnf.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "validateBNf", {
-    enumerable: true,
-    get: function() {
-        return validateBNf;
-    }
-});
-var _constants = require("../constants");
-function validateBNf(buf) {
-    if (buf === null || buf === _constants.EMPTY_STRING) {
-        return;
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvYm5mLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5cbmltcG9ydCB7IEVNUFRZX1NUUklORyB9IGZyb20gXCIuLi9jb25zdGFudHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHZhbGlkYXRlQk5mKGJ1Zikge1xuICBpZiAoKGJ1ZiA9PT0gbnVsbCkgfHwgKGJ1ZiA9PT0gRU1QVFlfU1RSSU5HKSkge1xuICAgIHJldHVybjtcbiAgfVxuXG5cbn1cbiJdLCJuYW1lcyI6WyJ2YWxpZGF0ZUJOZiIsImJ1ZiIsIkVNUFRZX1NUUklORyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBS2dCQTs7O2VBQUFBOzs7eUJBRmE7QUFFdEIsU0FBU0EsWUFBWUMsR0FBRztJQUM3QixJQUFJLEFBQUNBLFFBQVEsUUFBVUEsUUFBUUMsdUJBQVksRUFBRztRQUM1QztJQUNGO0FBR0YifQ==

package/src/utilities/bnf.js

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