occam-verify-cli 0.0.272 → 0.0.274

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.272",
+  "version": "0.0.274",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,13 +12,29 @@
   "dependencies": {
     "argumentative": "^2.0.15",
     "necessary": "^11.0.40",
-    "occam-custom-grammars": "^5.0.353",
+    "occam-custom-grammars": "^5.0.355",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.320",
+    "occam-grammars": "^1.0.322",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },
-  "devDependencies": {},
-  "scripts": {}
+  "devDependencies": {
+    "@swc/core": "^1.2.51",
+    "watchful-cli": "^1.7.13"
+  },
+  "scripts": {
+    "clean": "rm -rf ./lib",
+    "watchful": "watchful -m --transpiler=swc --source-directory=./src --lib-directory=./lib --pause=100",
+    "batch": "npm run watchful batch --",
+    "batch-debug": "npm run watchful batch -- --debug",
+    "incremental": "npm run watchful incremental --",
+    "incremental-debug": "npm run watchful incremental -- --debug",
+    "build": "npm run clean && npm run batch",
+    "build-debug": "npm run clean && npm run batch-debug",
+    "watch": "npm run clean && npm run batch && npm run incremental",
+    "watch-debug": "npm run clean && npm run batch-debug && npm run incremental-debug"
+  },
+  "browser": "./lib/browser.js",
+  "main": "./lib/main.js"
 }

package/{bin → src}/assertion.js

@@ -1,10 +1,10 @@
 "use strict";
 
-const { nodeQuery } = require("./utilities/query");
+import { nodeQuery } from "./utilities/query";
 
 const statementNodeQuery = nodeQuery("/*/statement!");
 
-class Assertion {
+export default class Assertion {
   constructor(subproofNode, statementNode) {
     this.subproofNode = subproofNode;
     this.statementNode = statementNode;
@@ -66,8 +66,6 @@ class Assertion {
   }
 }
 
-module.exports = Assertion;
-
 function matchAssertionNode(assertionNode, node) {
   let assertionNodeMatches = false;
 

package/src/axiom.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import { labelsAsString } from "./utilities/string";
+
+export default class Axiom {
+  constructor(labels, statementNode, suppositionStatementNode, consequentStatementNode) {
+    this.labels = labels;
+    this.statementNode = statementNode;
+    this.suppositionStatementNode = suppositionStatementNode;
+    this.consequentStatementNode = consequentStatementNode;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  getSuppositionStatementNode() {
+    return this.suppositionStatementNode;
+  }
+
+  getConsequentStatementNode() {
+    return this.consequentStatementNode;
+  }
+
+  asString() {
+    const string = labelsAsString(this.labels);
+
+    return string;
+  }
+
+  static fromStatementNodeAndLabels(statementNode, labels) {
+    const suppositionStatementNode = null,
+          consequentStatementNode = null,
+          axiom = new Axiom(labels, statementNode, suppositionStatementNode, consequentStatementNode);
+
+    return axiom;
+  }
+
+  static fromSuppositionStatementNodeConsequentStatementNodeAndLabels(suppositionStatementNode, consequentStatementNode, labels) {
+    const statementNode = null,
+          axiom = new Axiom(labels, statementNode, suppositionStatementNode, consequentStatementNode);
+
+    return axiom;
+  }
+}

package/src/browser.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { default as verifyRelease } from "./verify/release";
+export { default as ReleaseContext } from "./context/release";

package/{bin → src}/combinator.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const { nodeAsString } = require("./utilities/string");
+import { nodeAsString } from "./utilities/string";
 
-class Combinator {
+export default class Combinator {
   constructor(statementNode) {
     this.statementNode = statementNode;
   }
@@ -23,5 +23,3 @@ class Combinator {
     return combinator;
   }
 }
-
-module.exports = Combinator;

package/{bin → src}/conclusion.js

@@ -1,10 +1,10 @@
 "use strict";
 
-const { first } = require("./utilities/array"),
-      { metavariableNameFromMetavariableNode } = require("./utilities/query"),
-      { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } = require("./ruleNames");
+import { first } from "./utilities/array";
+import { metavariableNameFromMetavariableNode } from "./utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
 
-class Conclusion {
+export default class Conclusion {
   constructor(metastatementNode) {
     this.metastatementNode = metastatementNode;
   }
@@ -29,8 +29,6 @@ class Conclusion {
   }
 }
 
-module.exports = Conclusion;
-
 function matchConclusionNode(conclusionNode, node, metaSubstitutions) {
   let conclusionNodeMatches = false;
 

package/src/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export const COMMA = ',';
+export const EMPTY_STRING = "";
+export const LEFT_BRACKET = "(";
+export const RIGHT_BRACKET = ")";
+export const MAXIMUM_INDEXES_LENGTH = 10;
+export const MAXIMUM_PERMUTATION_LENGTH = 5;
+export const BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH = 3;

package/{bin → src}/constructor.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const { nodeAsString } = require("./utilities/string");
+import { nodeAsString } from "./utilities/string";
 
-class Constructor {
+export default class Constructor {
   constructor(termNode, type) {
     this.termNode = termNode;
     this.type = type;
@@ -39,5 +39,3 @@ class Constructor {
     return constructor;
   }
 }
-
-module.exports = Constructor;

package/{bin → src}/context/file.js

@@ -1,11 +1,11 @@
 "use strict";
 
-const { rewriteNodes } = require("occam-grammar-utilities");
+import { rewriteNodes } from "occam-grammar-utilities";
 
-const { push } = require("../utilities/array");
+import { push } from "../utilities/array";
 
-class FileContext {
-  constructor(tokens, node, rules, types, axioms, variables, combinators, constructors, packageContext) {
+export default class FileContext {
+  constructor(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext) {
     this.tokens = tokens;
     this.node = node;
     this.rules = rules;
@@ -14,7 +14,7 @@ class FileContext {
     this.variables = variables;
     this.combinators = combinators;
     this.constructors = constructors;
-    this.packageContext = packageContext;
+    this.releaseContext = releaseContext;
   }
 
   getTokens() {
@@ -31,9 +31,9 @@ class FileContext {
     ];
 
     if (bubble) {
-      const packageContextRules = this.packageContext.getRules();
+      const releaseContextRules = this.releaseContext.getRules();
 
-      push(rules, packageContextRules);
+      push(rules, releaseContextRules);
     }
 
     return rules;
@@ -45,9 +45,9 @@ class FileContext {
     ];
 
     if (bubble) {
-      const packageContextTypes = this.packageContext.getTypes();
+      const releaseContextTypes = this.releaseContext.getTypes();
 
-      push(types, packageContextTypes);
+      push(types, releaseContextTypes);
     }
 
     return types;
@@ -59,9 +59,9 @@ class FileContext {
     ];
 
     if (bubble) {
-      const packageContextAxioms = this.packageContext.getAxioms();
+      const releaseContextAxioms = this.releaseContext.getAxioms();
 
-      push(axioms, packageContextAxioms);
+      push(axioms, releaseContextAxioms);
     }
 
     return axioms;
@@ -90,9 +90,9 @@ class FileContext {
     ];
 
     if (bubble) {
-      const packageContextCombinators = this.packageContext.getCombinators();
+      const releaseContextCombinators = this.releaseContext.getCombinators();
 
-      push(combinators, packageContextCombinators);
+      push(combinators, releaseContextCombinators);
     }
 
     return combinators;
@@ -104,16 +104,16 @@ class FileContext {
     ];
 
     if (bubble) {
-      const packageContextConstructors = this.packageContext.getConstructors();
+      const releaseContextConstructors = this.releaseContext.getConstructors();
 
-      push(constructors, packageContextConstructors);
+      push(constructors, releaseContextConstructors);
     }
 
     return constructors;
   }
 
-  getPackageContext() {
-    return this.packageContext;
+  getReleaseContext() {
+    return this.releaseContext;
   }
 
   getMetaAssertions() {
@@ -236,11 +236,23 @@ class FileContext {
     this.constructors.push(constructor);
   }
 
-  static fromPackageContextAndFilePath(packageContext, filePath) {
-    const fileContent = packageContext.getFileContent(filePath),
+  trace(message) { this.releaseContext.trace(message); }
+
+  debug(message) { this.releaseContext.debug(message); }
+
+  info(message) { this.releaseContext.info(message); }
+
+  warning(message) { this.releaseContext.warning(message); }
+
+  error(message) { this.releaseContext.error(message); }
+
+  fatal(message) { this.releaseContext.fatal(message); }
+
+  static fromReleaseContextAndFilePath(releaseContext, filePath) {
+    const fileContent = releaseContext.getFileContent(filePath),
           content = fileContent,  ///
-          tokens = packageContext.tokenise(content),
-          node = packageContext.parse(tokens);
+          tokens = releaseContext.tokenise(content),
+          node = releaseContext.parse(tokens);
 
     rewriteNodes(node);
 
@@ -250,10 +262,8 @@ class FileContext {
           variables = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, packageContext);
+          fileContext = new FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext);
 
     return fileContext;
   }
 }
-
-module.exports = FileContext;

package/{bin → src}/context/metaproof.js

@@ -1,6 +1,6 @@
 "use strict";
 
-class MetaproofContext {
+export default class MetaproofContext {
   constructor(context, derived, metaAssertions) {
     this.context = context;
     this.derived = derived;
@@ -79,6 +79,18 @@ class MetaproofContext {
     this.metaAssertions.push(metaAssertion);
   }
 
+  trace(message) { this.context.trace(message); }
+
+  debug(message) { this.context.debug(message); }
+
+  info(message) { this.context.info(message); }
+
+  warning(message) { this.context.warning(message); }
+
+  error(message) { this.context.error(message); }
+
+  fatal(message) { this.context.fatal(message); }
+
   static fromContext(context) {
     const derived = false,
           metaAssertions = [],
@@ -87,5 +99,3 @@ class MetaproofContext {
     return metaproofContext;
   }
 }
-
-module.exports = MetaproofContext;

package/{bin → src}/context/proof.js

@@ -1,6 +1,6 @@
 "use strict";
 
-class ProofContext {
+export default class ProofContext {
   constructor(context, derived, variables, statementNodes) {
     this.context = context;
     this.derived = derived;
@@ -80,6 +80,18 @@ class ProofContext {
     this.statementNodes.push(statementNode);
   }
 
+  trace(message) { this.context.trace(message); }
+
+  debug(message) { this.context.debug(message); }
+
+  info(message) { this.context.info(message); }
+
+  warning(message) { this.context.warning(message); }
+
+  error(message) { this.context.error(message); }
+
+  fatal(message) { this.context.fatal(message); }
+
   static fromContext(context) {
     const derived = false,
           variables = [],
@@ -89,5 +101,3 @@ class ProofContext {
     return proofContext;
   }
 }
-
-module.exports = ProofContext;

package/src/context/release.js

@@ -0,0 +1,219 @@
+"use strict";
+
+import { CustomGrammar, lexersUtilities, parsersUtilities, CombinedCustomGrammar } from "occam-custom-grammars";
+
+import { push } from "../utilities/array";
+
+const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+
+export default class ReleaseContext {
+  constructor(releaseName, fileContexts, florenceLexer, florenceParser, releaseContexts, releaseVerified) {
+    this.releaseName = releaseName;
+    this.fileContexts = fileContexts;
+    this.florenceLexer = florenceLexer;
+    this.florenceParser = florenceParser;
+    this.releaseContexts = releaseContexts;
+    this.releaseVerified = releaseVerified;
+  }
+
+  getReleaseName() {
+    return this.releaseName;
+  }
+
+  getFileContexts() {
+    return this.fileContexts;
+  }
+
+  getFlorenceLexer() {
+    return this.florenceLexer;
+  }
+
+  getFlorenceParser() {
+    return this.florenceParser;
+  }
+
+  getReleaseContexts() {
+    return this.releaseContexts;
+  }
+
+  isReleaseVerified() {
+    return this.releaseVerified;
+  }
+
+  getRules(releaseNames = []) {
+    const rules = [],
+          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(this.releaseName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextRules = fileContext.getRules(bubble);
+
+        push(rules, fileContextRules);
+      });
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextRules = releaseContext.getRules(releaseNames);
+
+        push(rules, releaseContextRules);
+      });
+    }
+
+    return rules;
+  }
+
+  getTypes(releaseNames = []) {
+    const types = [],
+          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(this.releaseName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextTypes = fileContext.getTypes(bubble);
+
+        push(types, fileContextTypes);
+      });
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextTypes = releaseContext.getTypes(releaseNames);
+
+        push(types, releaseContextTypes);
+      });
+    }
+
+    return types;
+  }
+
+  getAxioms(releaseNames = []) {
+    const axioms = [],
+          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(this.releaseName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextAxioms = fileContext.getAxioms(bubble);
+
+        push(axioms, fileContextAxioms);
+      });
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+
+        push(axioms, releaseContextAxioms);
+      });
+    }
+
+    return axioms;
+  }
+
+  getCombinators(releaseNames = []) {
+    const combinators = [],
+          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(this.releaseName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextCombinators = fileContext.getCombinators(bubble);
+
+        push(combinators, fileContextCombinators);
+      });
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+
+        push(combinators, releaseContextCombinators);
+      });
+    }
+
+    return combinators;
+  }
+
+  getConstructors(releaseNames = []) {
+    const constructors = [],
+          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+
+    if (!releaseNamesIncludesReleaseName) {
+      releaseNames.push(this.releaseName);
+
+      const bubble = false;
+
+      this.fileContexts.forEach((fileContext) => {
+        const fileContextConstructors = fileContext.getConstructors(bubble);
+
+        push(constructors, fileContextConstructors);
+      });
+
+      this.releaseContexts.forEach((releaseContext) => {
+        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+
+        push(constructors, releaseContextConstructors);
+      });
+    }
+
+    return constructors;
+  }
+
+  getCustomGrammar() {
+    const name = this.releaseName, ///
+          termBNF = this.getTermBNF(),
+          statementBNF = this.getStatementBNF(),
+          metastatementBNF = this.getMetastatementBNF(),
+          typePattern = this.getTypePattern(),
+          symbolPattern = this.getSymbolPattern(),
+          operatorPattern = this.getOperatorPattern(),
+          customGrammar = new CustomGrammar(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+
+    return customGrammar;
+  }
+
+  addFileContext(fileContext) {
+    this.fileContexts.push(fileContext);
+  }
+
+  tokenise(content) { return this.florenceLexer.tokenise(content); }
+
+  parse(tokens) { return this.florenceParser.parse(tokens); }
+
+  initialise(releaseContexts, dependencyReleaseContexts) {
+    this.releaseContexts = releaseContexts;
+
+    const releaseContext = this;  ///
+
+    releaseContexts = [ releaseContext, ...dependencyReleaseContexts ]; ///
+
+    const customGrammars = releaseContexts.map((releaseContext) => {
+            const customGrammar = releaseContext.getCustomGrammar();
+
+            return customGrammar;
+          }),
+          combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+
+    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+
+    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+  }
+
+  static fromReleaseName(Class, releaseName, ...remainingArguments) {
+    const fileContexts = [],
+          florenceLexer = null,
+          florenceParser = null,
+          releaseContexts = [],
+          releaseVerified = false,
+          releaseContext = new Class(releaseName, fileContexts, florenceLexer, florenceParser, releaseContexts, releaseVerified, ...remainingArguments);
+
+    return releaseContext;
+  }
+}

package/src/main.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { default as verifyRelease } from "./verify/release";
+export { default as ReleaseContext } from "./context/release";

package/{bin → src}/metaAssertion.js

@@ -1,15 +1,15 @@
 "use strict";
 
-const { first, second } = require("./utilities/array"),
-      { nodeQuery, nodesQuery } = require("./utilities/query"),
-      { matchBracketedMetastatementChildNode } = require("./utilities/metastatement");
+import { first, second } from "./utilities/array";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { matchBracketedMetastatementChildNode } from "./utilities/metastatement";
 
 const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
       metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
       metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
-class MetaAssertion {
+export default class MetaAssertion {
   constructor(metaSubproofNode, metastatementNode) {
     this.metaSubproofNode = metaSubproofNode;
     this.metastatementNode = metastatementNode;
@@ -118,8 +118,6 @@ class MetaAssertion {
   }
 }
 
-module.exports = MetaAssertion;
-
 function matchMetaAssertionNode(metaAssertionNode, node) {
   let metaAssertionNodeMatches = false;
 

package/{bin → src}/metaSubstitution.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const { matchBracketedMetastatementChildNode } = require("./utilities/metastatement");
+import { matchBracketedMetastatementChildNode, bracketedMetastatementChildNodeFromChildNodes } from "./utilities/metastatement";
 
-class MetaSubstitution {
+export default class MetaSubstitution {
   constructor(metavariableName, nodes) {
     this.metavariableName = metavariableName;
     this.nodes = nodes;
@@ -43,14 +43,21 @@ class MetaSubstitution {
   }
 
   static fromMetavariableNameAndNodes(metavariableName, nodes) {
+    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(nodes);
+
+    if (bracketedMetastatementChildNode !== null) {
+      const nonTerminalNode = bracketedMetastatementChildNode,  ///
+            childNodes = nonTerminalNode.getChildNodes();
+
+      nodes = childNodes; ///
+    }
+
     const metaSubstitution = new MetaSubstitution(metavariableName, nodes);
 
     return metaSubstitution;
   }
 }
 
-module.exports = MetaSubstitution;
-
 function matchMetaSubstitutionNode(metaSubstitutionNode, node) {
   let metaSubstitutionNodeMatches = false;