occam-grammars 1.3.168 → 1.3.170

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-grammars",
   "author": "James Smith",
-  "version": "1.3.168",
+  "version": "1.3.170",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-grammars",
   "description": "Occam's grammars.",
@@ -11,9 +11,10 @@
   },
   "dependencies": {
     "necessary": "^14.3.2",
-    "occam-grammar-utilities": "^8.0.256",
-    "occam-lexers": "^23.0.43",
-    "occam-parsers": "^23.0.48"
+    "occam-grammar-utilities": "^8.0.259",
+    "occam-lexers": "^23.0.47",
+    "occam-parsers": "^23.0.51",
+    "occam-query": "^4.1.33"
   },
   "devDependencies": {
     "@swc/core": "^1.5.6",

package/src/constants.js

@@ -1,3 +1,5 @@
 "use strict";
 
 export const EMPTY_STRING = "";
+export const ERROR_RULE_NAME = "error";
+export const EXPRESSION_RULE_NAME = "expression";

package/src/example/utilities/furtle.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { lexersUtilities, parsersUtilities } from "../../index";
+import { rulesUtilities as lexersRulesUtilities } from "occam-lexers";
+import { rulesUtilities as parsersRulesUtilities } from "occam-parsers";
+
+const { rulesAsEntries } = lexersRulesUtilities,
+      { rulesAsString, rulesFromStartRuleAndRuleMap } = parsersRulesUtilities;
+
+const { furtleLexerFromNothing } = lexersUtilities,
+      { furtleParserFromNothing } = parsersUtilities;
+
+export function bnfFromNothing() {
+  const furtleParser = furtleParserFromNothing(),
+        startRule = furtleParser.getStartRule(),
+        ruleMap = furtleParser.getRuleMap(),
+        rules = rulesFromStartRuleAndRuleMap(startRule, ruleMap),
+        multiline = true,
+        string = rulesAsString(rules, multiline),
+        bnf = string; ///
+
+  return bnf;
+}
+
+export function entriesFromNothing() {
+  const furtleLexer = furtleLexerFromNothing(),
+        rules = furtleLexer.getRules(),
+        entries = rulesAsEntries(rules);
+
+  return entries;
+}

package/src/example/view/furtle.js

@@ -1,9 +1,11 @@
 "use strict";
 
-import { FurtleLexer, FurtleParser, lexersUtilities, parsersUtilities } from "../../index";  ///
+import { lexersUtilities, parsersUtilities } from "../../index";  ///
 
 import View from "../view";
 
+import { bnfFromNothing, entriesFromNothing } from "../utilities/furtle";
+
 const { furtleLexerFromEntries } = lexersUtilities,
       { furtleParserFromBNFAndStartRuleName } = parsersUtilities;
 
@@ -36,9 +38,26 @@ export default class FurtleView extends View {
     return parseTree;
   }
 
-  static Lexer = FurtleLexer;
+  initialise() {
+    this.assignContext();
+
+    const { initialContent, initialRuleName } = this.constructor,
+          bnf = bnfFromNothing(),
+          entries = entriesFromNothing(),
+          content = initialContent, ///
+          ruleName = initialRuleName, ///
+          lexicalEntries = entries; ///
+
+    this.setBNF(bnf);
+
+    this.setContent(content);
 
-  static Parser = FurtleParser;
+    this.setRuleName(ruleName);
+
+    this.setLexicalEntries(lexicalEntries);
+
+    this.keyUpHandler();
+  }
 
   static readOnly = false;
 

package/src/example/view.js

@@ -16,20 +16,20 @@ import LexicalEntriesTextarea from "./view/textarea/lexicalEntries";
 
 class View extends Element {
   keyUpHandler = (event, element) => {
-    try {
+    // try {
       const tokens = this.getTokens(),
             parseTree = this.getParseTree(tokens);
 
       this.setTokens(tokens);
 
       this.setParseTree(parseTree);
-    } catch (error) {
-      console.log(error);
-
-      this.clearTokens();
-
-      this.clearParseTree();
-    }
+    // } catch (error) {
+    //   console.log(error);
+    //
+    //   this.clearTokens();
+    //
+    //   this.clearParseTree();
+    // }
   }
 
   getTokens() {

package/src/furtle/bnf.js

@@ -128,58 +128,6 @@ reference.              ::=  [name] ;
 
 
 
-nonsense.               ::=  [type] | [keyword] | [primitive] | [query] | [special] | [name] | [number] | [unassigned] ;
-    
-
-    
-expression              ::=  path spread? subExpression? ;
-
-path                    ::=  "/" infiniteDescent? selectors ;
-
-subExpression           ::=  path spread? subExpression?;
-
-infiniteDescent         ::=  "/" ;
-
-selectors               ::=  selector ( "|" selector )* ;
-
-spread                  ::=  unique
-
-                          |  "[" 
-      
-                             ( 
-                              
-                               ( startIndex "..." endIndex ) 
-                              
-                               | 
-                              
-                               ( startIndex "..." ) 
-                              
-                               | 
-                              
-                               ( "..." endIndex )
-                               
-                               | 
-                              
-                               index 
-                              
-                             )  
-                            
-                             "]" 
-                             
-                          ;
-
-selector                ::=  ruleName | tokenType ;
-                   
-ruleName                ::=  [name] | "*" ;
-                   
-tokenType               ::=  "@"<NO_WHITESPACE>( [name] | "*" ) ;
-                   
-startIndex              ::=  [number] ;
-                   
-endIndex                ::=  [number] ;
-                   
-index                   ::=  [number] ;
-                   
-unique                  ::=  "!" ;`;
+nonsense.               ::=  [type] | [keyword] | [primitive] | [query] | [special] | [name] | [number] | [unassigned] ;`;
 
 export default bnf;

package/src/furtle/entries.js

@@ -20,13 +20,7 @@ const entries = [
     "bracket": "^(?:\\{|\\})"
   },
   {
-    "special": "^(?:!=|!|==|=|,|;|_|&&|\\|\\||@|!|\\*|\\||\\/|\\(|\\)|\\[|\\]|\\.\\.\\.)"
-  },
-  {
-    "name": "^[a-zA-Z\-]+"
-  },
-  {
-    "number": "^[0-9]+"
+    "special": "^(?:!=|==|=|,|;|_|&&|\\|\\||\\(|\\))"
   },
   {
     "unassigned": "^."

package/src/index.js

@@ -5,7 +5,6 @@ export { default as parsersUtilities } from "./utilities/parsers";
 
 export { default as TeXLexer } from "./teX/lexer";
 export { default as JSONLexer } from "./json/lexer";
-export { default as FurtleLexer } from "./furtle/lexer";
 export { default as NominalLexer } from "./nominal/lexer";
 export { default as PlainTextLexer } from "./plainText/lexer";
 export { default as CustomGrammarBNFLexer } from "./customGrammarBNF/lexer";
@@ -13,7 +12,6 @@ export { default as CustomGrammarPatternLexer } from "./customGrammarPattern/lex
 
 export { default as TeXParser } from "./teX/parser";
 export { default as JSONParser } from "./json/parser";
-export { default as FurtleParser } from "./furtle/parser";
 export { default as NominalParser } from "./nominal/parser";
 export { default as PlainTextParser } from "./plainText/parser";
 export { default as CustomGrammarBNFParser } from "./customGrammarBNF/parser";

package/src/utilities/lexers.js

@@ -4,19 +4,36 @@ import { lexerUtilities } from "occam-lexers";
 
 import FurtleLexer from "../furtle/lexer";
 
+import { augmentLexicalRules } from "../utilities/query";
+
 const { lexerFromRules, rulesFromEntries } = lexerUtilities;
 
-export function furtleLexerFromEntries(entries) {
-  const rules = rulesFromEntries(entries),
-        furtleLexer = lexerFromRules(FurtleLexer, rules);
+export function furtleLexerFromEntries(entries, augmented = true) {
+  let rules;
+
+  rules = rulesFromEntries(entries);
+
+  if (augmented) {
+    rules = augmentRules(rules);
+  }
+
+  const furtleLexer = lexerFromRules(FurtleLexer, rules);
 
   return furtleLexer;
 }
 
-export function furtleLexerFromNothing() {
-  const { entries } = FurtleLexer,
-        rules = rulesFromEntries(entries),
-        furtleLexer = lexerFromRules(FurtleLexer, rules);
+export function furtleLexerFromNothing(augmented = true) {
+  const { entries } = FurtleLexer;
+
+  let rules;
+
+  rules = rulesFromEntries(entries);
+
+  if (augmented) {
+    rules = augmentRules(rules);
+  }
+
+  const furtleLexer = lexerFromRules(FurtleLexer, rules);
 
   return furtleLexer;
 }
@@ -25,3 +42,13 @@ export default {
   furtleLexerFromEntries,
   furtleLexerFromNothing
 };
+
+function augmentRules(rules) {
+  let lexicalRules = rules; ///
+
+  lexicalRules = augmentLexicalRules(lexicalRules);
+
+  rules = lexicalRules; ///
+
+  return rules;
+}

package/src/utilities/parsers.js

@@ -5,21 +5,27 @@ import { eliminateLeftRecursion } from "occam-grammar-utilities";
 
 import FurtleParser from "../furtle/parser";
 
+import { augmentBNFRules } from "../utilities/query";
+
 const { rulesFromBNF, parserFromRules, parserFromRulesAndStartRuleName } = parserUtilities;
 
-export function furtleParserFromBNF(bnf) {
+export function furtleParserFromBNF(bnf, augmented = true) {
   let rules;
 
   rules = rulesFromBNF(bnf);
 
   rules = eliminateLeftRecursion(rules);  ///
 
+  if (augmented) {
+    rules = augmentRules(rules);
+  }
+
   const furtleParser = parserFromRules(FurtleParser, rules);
 
   return furtleParser;
 }
 
-export function furtleParserFromNothing() {
+export function furtleParserFromNothing(augmented = true) {
   const { bnf } = FurtleParser;
 
   let rules;
@@ -28,18 +34,26 @@ export function furtleParserFromNothing() {
 
   rules = eliminateLeftRecursion(rules);  ///
 
+  if (augmented) {
+    rules = augmentRules(rules);
+  }
+
   const furtleParser = parserFromRules(FurtleParser, rules);
 
   return furtleParser;
 }
 
-export function furtleParserFromBNFAndStartRuleName(bnf, startRuleName) {
+export function furtleParserFromBNFAndStartRuleName(bnf, startRuleName, augmented = true) {
   let rules;
 
   rules = rulesFromBNF(bnf);
 
   rules = eliminateLeftRecursion(rules);  ///
 
+  if (augmented) {
+    rules = augmentRules(rules);
+  }
+
   const furtleParser = parserFromRulesAndStartRuleName(FurtleParser, rules, startRuleName);
 
   return furtleParser;
@@ -50,3 +64,13 @@ export default {
   furtleParserFromNothing,
   furtleParserFromBNFAndStartRuleName
 };
+
+function augmentRules(rules) {
+  let bnfRules = rules; ///
+
+  bnfRules = augmentBNFRules(bnfRules);
+
+  rules = bnfRules; ///
+
+  return rules;
+}

package/src/utilities/query.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import { Rule } from "occam-parsers";
+import { arrayUtilities } from "necessary";
+import { ExpressionLexer, ExpressionParser } from "occam-query";
+
+import { ERROR_RULE_NAME, EXPRESSION_RULE_NAME } from "../constants";
+
+const { first, extract } = arrayUtilities;
+
+const expressionBNFRules = expressionBNFRulesFromNothing(),
+      expressionLexicalRules = expressionLexicalRulesFromNothing();
+
+export function augmentLexicalRules(lexicalRules) {
+  lexicalRules = [  ///
+    ...lexicalRules
+  ];
+
+  const unassignedLexicalRule = lexicalRules.pop(); ///
+
+  lexicalRules = [  ///
+    ...lexicalRules,
+    ...expressionLexicalRules
+  ];
+
+  return lexicalRules;
+}
+
+export function augmentBNFRules(bnrRules) {
+  bnrRules = [ ///
+    ...bnrRules,
+    ...expressionBNFRules
+  ];
+
+  return bnrRules;
+}
+
+function expressionLexicalRulesFromNothing() {
+  const expressionLexer = ExpressionLexer.fromNothing(),
+        rules = expressionLexer.getRules(),
+        expressionLexicalRules = [  ///
+          ...rules
+        ];
+
+  return expressionLexicalRules;
+}
+
+function expressionBNFRulesFromNothing() {
+  const expressionParser = ExpressionParser.fromNothing(),
+        ruleMap = expressionParser.getRuleMap(),
+        rules = Object.values(ruleMap);
+
+  extract(rules, (rule) => {
+    const ruleName = rule.getName();
+
+    if (ruleName === ERROR_RULE_NAME) {
+      return true;
+    }
+  });
+
+  const expressionRule = extract(rules, (rule) => {
+    const ruleName = rule.getName();
+
+    if (ruleName === EXPRESSION_RULE_NAME) {
+      return true;
+    }
+  });
+
+  let rule = expressionRule,  ///
+      definitions = rule.getDefinitions();
+
+  const name = rule.getName(),
+        opacity = rule.getOpacity(),
+        NonTerminalNode = rule.getNonTerminalNode(),
+        firstDefinition = first(definitions),
+        definition = firstDefinition; ///
+
+  definitions = [
+    definition
+  ];
+
+  rule = Rule.fromNameOpacityDefinitionsAndNonTerminalNode(name, opacity, definitions, NonTerminalNode);
+
+  rules.unshift(rule);
+
+  const expressionBNFRules = rules;  ///
+
+  return expressionBNFRules;
+}