occam-verify-cli 1.0.405 → 1.0.415

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.405",
+  "version": "1.0.415",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -11,19 +11,19 @@
   },
   "dependencies": {
     "argumentative": "^2.0.36",
-    "necessary": "^16.0.3",
-    "occam-custom-grammars": "^5.0.1323",
-    "occam-entities": "^1.0.432",
-    "occam-file-system": "^6.0.447",
-    "occam-furtle": "^2.0.266",
-    "occam-grammars": "^1.3.415",
-    "occam-lexers": "^23.1.22",
-    "occam-parsers": "^23.1.25",
-    "occam-query": "^4.1.131"
+    "necessary": "^16.0.10",
+    "occam-custom-grammars": "^5.0.1326",
+    "occam-entities": "^1.0.434",
+    "occam-file-system": "^6.0.449",
+    "occam-furtle": "^2.0.268",
+    "occam-grammars": "^1.3.418",
+    "occam-lexers": "^23.1.25",
+    "occam-parsers": "^23.1.28",
+    "occam-query": "^4.1.134"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",
-    "watchful-cli": "^1.7.63"
+    "watchful-cli": "^1.7.67"
   },
   "scripts": {
     "clean": "rm -rf ./lib",

package/src/constants.js

@@ -4,7 +4,6 @@ export const S = "s";
 export const NOTHING = "";
 export const MISSING = "missing";
 export const FUNCTION = "function";
-export const TYPE_TYPE = "type";
 export const UNDEFINED = "undefined";
 export const PROVISIONAL = "Provisional";
 export const EMPTY_STRING = "";

package/src/context/file.js

@@ -3,9 +3,9 @@
 import { arrayUtilities } from "necessary";
 
 import ontology from "../ontology";
-import topLevelVerifier from "../verifier/topLevel";
 
 import { baseType } from "../ontology/type";
+import { verifyFile } from "../process/verify";
 import { nodeAsTokens, nodeAsString, nodesAsString, tokensAsString } from "../utilities/string";
 import { typesFromJSON,
          rulesFromJSON,
@@ -641,9 +641,9 @@ export default class FileContext {
   findJudgementByMetavariable(metavariable) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementSimple = judgement.isSimple();
+            const judgementSingular = judgement.isSingular();
 
-            if (judgementSimple) {
+            if (judgementSingular) {
               const judgementMetavariable = judgement.getMetavariable(),
                     judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);
 
@@ -861,12 +861,12 @@ export default class FileContext {
     } else {
       this.debug(`Verifying the '${this.filePath}' file...`);
 
-      const fileContext = this, ///
-            verifiesAtTopLevel = topLevelVerifier.verify(this.node, fileContext);
+      const context = this, ///
+            fileNode = this.node; ///
+
+      verifies = verifyFile(fileNode, context);
 
-      if (verifiesAtTopLevel) {
-        verifies = true;
-      } else {
+      if (!verifies) {
         this.clear();
       }
 

package/src/context/local.js

@@ -229,9 +229,9 @@ class LocalContext {
   findJudgementByMetavariable(metavariable) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementSimple = judgement.isSimple();
+            const judgementSingular = judgement.isSingular();
 
-            if (judgementSimple) {
+            if (judgementSingular) {
               const judgementMetavariable = judgement.getMetavariable(),
                     judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);
 

package/src/context/release.js

@@ -526,7 +526,7 @@ function verifyTypePrefixes(typePrefixes, releaseContext) {
     const typePrefixAName = typePrefixA.getName(),
           typePrefixBName = typePrefixB.getName();
 
-    if (typePrefixAName === typePrefixBName) {
+    if (typePrefixAName !== typePrefixBName) {
       return true;
     }
   });

package/src/context/temporary.js

@@ -5,15 +5,15 @@ import { arrayUtilities } from "necessary";
 const { extract, compress } = arrayUtilities;
 
 export default class TemporaryContext {
-  constructor(context, tokens, terms, frames, statements, assertions, substitutions, reference) {
+  constructor(context, tokens, terms, frames, statements, assertions, references, substitutions) {
     this.context = context;
     this.tokens = tokens;
     this.terms = terms;
     this.frames = frames;
     this.statements = statements;
     this.assertions = assertions;
+    this.references = references;
     this.substitutions = substitutions;
-    this.reference = reference;
   }
 
   getContext() {
@@ -40,111 +40,126 @@ export default class TemporaryContext {
     return this.assertions;
   }
 
-  getSubstitutions() {
-    return this.substitutions;
+  getReferences() {
+    return this.references;
   }
 
-  getReference() {
-    return this.reference;
+  getSubstitutions() {
+    return this.substitutions;
   }
 
   addTerm(term) {
-    const context = this, ///
-          termNode = term.getNode(),
+    const termA = term, ///
+          context = this, ///
           termString = term.getString();
 
     extract(this.terms, (term) => {
-      const termMatchesTermNode = term.matchTermNode(termNode);
+      const termB = term, ///
+            termAEqualToTermB = termA.isEqualTo(termB);
 
-      if (termMatchesTermNode) {
+      if (termAEqualToTermB) {
         return true;
       }
     });
 
-    context.trace(`ADded the '${termString}' term.`);
+    context.trace(`ADded the '${termString}' term to the context.`);
 
     this.terms.push(term);
   }
 
   addFrame(frame) {
-    const context = this, ///
-          frameNode = frame.getNode(),
+    const frameA = frame, ///
+          context = this, ///
           frameString = frame.getString();
 
     extract(this.frames, (frame) => {
-      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+      const frameB = frame, ///
+            frameAEqualToFrameB = frameA.isEqualTo(frameB);
 
-      if (frameMatchesFrameNode) {
+      if (frameAEqualToFrameB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${frameString}' frame.`);
+    context.trace(`Added the '${frameString}' frame to the context.`);
 
     this.frames.push(frame);
   }
 
   addStatement(statement) {
     const context = this, ///
-          statementNode = statement.getNode(),
+          statementA = statement, ///
           statementString = statement.getString();
 
     extract(this.statements, (statement) => {
-      const statementMatchesFrameNode = statement.matchStatementNode(statementNode);
+      const statementB = statement, ///
+            statementAEqualToFrameB = statementA.isEqualTo(statementB);
 
-      if (statementMatchesFrameNode) {
+      if (statementAEqualToFrameB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${statementString}' statement.`);
+    context.trace(`Added the '${statementString}' statement to the context.`);
 
     this.statements.push(statement);
   }
 
   addAssertion(assertion) {
     const context = this, ///
-          assertionNode = assertion.getNode(),
+          assertionA = assertion, ///
           assertionString = assertion.getString();
 
     extract(this.assertions, (assertion) => {
-      const assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);
+      const assertionB = assertion, ///
+            assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
 
-      if (assertionMatchesFrameNode) {
+      if (assertionAEqualToAssertionB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${assertionString}' assertion.`);
+    context.trace(`Added the '${assertionString}' assertion to the context.`);
 
     this.assertions.push(assertion);
   }
 
-  addSubstitution(substitution) {
+  addReference(reference) {
     const context = this, ///
-          substitutionNode = substitution.getNode(),
-          substitutionString = substitution.getString();
+          referenceA = reference, ///
+          referenceString = reference.getString();
 
-    extract(this.substitutions, (substitution) => {
-      const substitutionMatchesFrameNode = substitution.matchSubstitutionNode(substitutionNode);
+    extract(this.references, (reference) => {
+      const referenceB = reference, ///
+            referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
 
-      if (substitutionMatchesFrameNode) {
+      if (referenceAEqualToReferenceB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${substitutionString}' substitution.`);
+    context.trace(`Added the '${referenceString}' reference to the context.`);
 
-    this.substitutions.push(substitution);
+    this.references.push(reference);
   }
 
-  addReference(reference) {
+  addSubstitution(substitution) {
     const context = this, ///
-      referenceString = reference.getString();
+          substitutionA = substitution, ///
+          substitutionString = substitution.getString();
 
-    this.reference = reference;
+    extract(this.substitutions, (substitution) => {
+      const substitutionB = substitution, ///
+            substituionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
 
-    context.trace(`Added the '${referenceString}' reference.`);
+      if (substituionAEqualToSubstitutionB) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${substitutionString}' substitution to the context.`);
+
+    this.substitutions.push(substitution);
   }
 
   findTermByTermNode(termNode) {
@@ -171,6 +186,18 @@ export default class TemporaryContext {
     return frame;
   }
 
+  findStatementByStatementNode(statementNode) {
+    const statement = this.statements.find((statement) => {
+      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+
+      if (statementMatchesStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statement;
+  }
+
   findAssertionByAssertionNode(assertionNode) {
     const assertion = this.assertions.find((assertion) => {
       const assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);
@@ -183,21 +210,21 @@ export default class TemporaryContext {
     return assertion;
   }
 
-  findStatementByStatementNode(statementNode) {
-    const statement = this.statements.find((statement) => {
-      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+  findReferenceByMetavariableNode(metavariableNode) {
+    const reference = this.references.find((reference) => {
+      const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
 
-      if (statementMatchesStatementNode) {
+      if (referenceMatcheMetavariableNode) {
         return true;
       }
     }) || null;
 
-    return statement;
+    return reference;
   }
 
-  findSubtitutionBySubtitutionNode(substitutionNode) {
+  findSubstitutionBySubstitutionNode(substitutionNode) {
     const substitution = this.substitutions.find((substitution) => {
-      const substitutionMatchesSubtitutionNode = substitution.matchSubtitutionNode(substitutionNode);
+      const substitutionMatchesSubtitutionNode = substitution.matchSubstitutionNode(substitutionNode);
 
       if (substitutionMatchesSubtitutionNode) {
         return true;
@@ -381,11 +408,12 @@ export default class TemporaryContext {
 
   error(message, node = null) { this.context.error(message, node); }
 
-  marge(context) {
+  merge(context) {
     const terms = context.getTerms(),
           frames = context.getFrames(),
           statements = context.getStatements(),
           assertions = context.getAssertions(),
+          references = context.getReferences(),
           substitutions = context.getSubstitutions();
 
     this.terms = [
@@ -408,21 +436,63 @@ export default class TemporaryContext {
       ...assertions
     ];
 
+    this.references = [
+      ...this.references,
+      ...references
+    ];
+
     this.substitutions = [
       ...this.substitutions,
       ...substitutions
     ];
 
     compress(this.terms, (termA, termB) => {
-      const termANode = termA.getNode(),
-            termBNode = termB.getNode(),
-            termANodeMatchesTermBNode = termANode.match(termBNode);
+      const termAEqualToTermB = termA.isEqualTo(termB);
+
+      if (!termAEqualToTermB) {
+        return true;
+      }
+    });
+
+    compress(this.frames, (frameA, frameB) => {
+      const frameAEqualToFrameB = frameA.isEqualTo(frameB);
+
+      if (!frameAEqualToFrameB) {
+        return true;
+      }
+    });
+
+    compress(this.statements, (statementA, statementB) => {
+      const statementAEqualToStatementB = statementA.isEqualTo(statementB);
 
-      if (termAMatchesTermB) {
+      if (!statementAEqualToStatementB) {
         return true;
       }
     });
 
+    compress(this.assertions, (assertionA, assertionB) => {
+      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+
+      if (!assertionAEqualToAssertionB) {
+        return true;
+      }
+    });
+
+    compress(this.references, (referenceA, referenceB) => {
+      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+
+      if (!referenceAEqualToReferenceB) {
+        return true;
+      }
+    });
+
+    compress(this.substitutions, (substitutionA, substitutionB) => {
+      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+
+      if (!substitutionAEqualToSubstitutionB) {
+        return true;
+      }
+    });
   }
 
   static fromNothing(context) {
@@ -431,9 +501,9 @@ export default class TemporaryContext {
           tokens = null,
           statements = [],
           assertions = [],
+          references = [],
           substitutions = [],
-          reference = null,
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }
@@ -442,9 +512,9 @@ export default class TemporaryContext {
     const tokens = null,
           statements = [],
           assertions = [],
+          references = [],
           substitutions = [],
-          reference = null,
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }
@@ -454,9 +524,9 @@ export default class TemporaryContext {
           frames = [],
           statements = [],
           assertions = [],
+          references = [],
           substitutions = [],
-          reference = null,
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }

package/src/mixins/statement/verify.js

@@ -26,7 +26,9 @@ function verifyAsMetavariableAndSubstitution(statement, assignments, stated, con
 
     if (metavariableVerifies) {
       const { TermSubstitution, FrameSubstitution } = ontology,
-            substitution = TermSubstitution.fromStatement(statement, context) || FrameSubstitution.fromStatement(statement, context);
+            frameSubstitution = FrameSubstitution.fromStatement(statement, context),
+            termSubstitution = TermSubstitution.fromStatement(statement, context),
+            substitution = (termSubstitution || frameSubstitution);
 
       if (substitution !== null) {
         const substitutionVerifies = substitution.verify(context);

package/src/mixins/step/unify.js

@@ -54,7 +54,6 @@ function unifyWithReference(statement, reference, satisfiesAssertion, substituti
 
       const { StatementSubstitution } = ontology,
             metavariable = reference.getMetavariable(),
-            specificContext = context,  ///
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
             substitution = statementSubstitution; ///
 

package/src/node/argument.js

@@ -21,7 +21,7 @@ export default class ArgumentNode extends NonTerminalNode {
 
   getSingularTermNode() {
     const ruleName = TERM_RULE_NAME,
-          singularTermNode = this.getSingularTNodeByRuleName(ruleName);
+          singularTermNode = this.getSingularNodeByRuleName(ruleName);
 
     return singularTermNode;
   }

package/src/node/assumption.js

@@ -5,16 +5,16 @@ import DocumentNode from "../nonTerminalNode";
 import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class AssumptionpNode extends DocumentNode {
-  isSimple() {
-    let simple = false;
+  isSingular() {
+    let singular = false;
 
     const statementNode = this.getStatementNode();
 
     if (statementNode === null) {
-      simple = true;
+      singular = true;
     }
 
-    return simple;
+    return singular;
   }
 
   getStatementNode() {

package/src/node/frame.js

@@ -5,16 +5,16 @@ import NonTerminalNode from "../nonTerminalNode";
 import { ASSUMPTION_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class FrameNode extends NonTerminalNode {
-  isSimple() {
-    let simple = false;
+  isSingular() {
+    let singular = false;
 
     const singularAssumptionNode = this.getSingularAssumptionNode();
 
     if (singularAssumptionNode !== null) {
-      simple = singularAssumptionNode.isSimple();
+      singular = singularAssumptionNode.isSingular();
     }
 
-    return simple;
+    return singular;
   }
 
   getAssumptionNodes() {
@@ -24,6 +24,20 @@ export default class FrameNode extends NonTerminalNode {
     return declarationNodes;
   }
 
+  getMetavariableName() {
+    let metavariableName = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const singularMetavariableNode = this.getSingularMetavariableNode();
+
+      metavariableName = singularMetavariableNode.getMetavariableName();
+    }
+
+    return metavariableName;
+  }
+
   getMetavariableNodes() {
     const ruleName = METAVARIABLE_RULE_NAME,
           metavariableNodes = this.getNodesByRuleName(ruleName);
@@ -33,7 +47,7 @@ export default class FrameNode extends NonTerminalNode {
 
   getSingularAssumptionNode() {
     const ruleName = ASSUMPTION_RULE_NAME,
-          singularAssumptionNode = this.getSingularTNodeByRuleName(ruleName);
+          singularAssumptionNode = this.getSingularNodeByRuleName(ruleName);
 
     return singularAssumptionNode;
   }

package/src/node/judgement.js

@@ -5,6 +5,13 @@ import NonTerminalNode from "../nonTerminalNode";
 import { FRAME_RULE_NAME, ASSUMPTION_RULE_NAME } from "../ruleNames";
 
 export default class JudgementNode extends NonTerminalNode {
+  isSingular() {
+    const frameNode = this.getFrameNode(),
+          singular = frameNode.isSingular();
+
+    return singular;
+  }
+
   getFrameNode() {
     const ruleName = FRAME_RULE_NAME,
           frameNode = this.getNodeByRuleName(ruleName);

package/src/node/statement.js

@@ -19,16 +19,38 @@ import { TERM_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 export default class StatementNode extends NonTerminalNode {
-  isSimple() {
-    let simple = false;
+  getMetavariableName() {
+    let metavariableName = null;
 
-    const metavariableNode = this.getMetavariableNode();
+    const singular = this.isSingular();
 
-    if (metavariableNode !== null) {
-      simple = true;
+    if (singular) {
+      const singularMetavariableNode = this.getSingularMetavariableNode();
+
+      metavariableName = singularMetavariableNode.getMetavariableName();
+    }
+
+    return metavariableName;
+  }
+
+  getSubstitutionNode() {
+    const frameSubstitutionNode = this.getFrameSubstitutionNode(),
+          termSubstitutionNode = this.getTermSubstitutionNode(),
+          substitutionNode = (frameSubstitutionNode || termSubstitutionNode);
+
+    return substitutionNode;
+  }
+
+  isSingular() {
+    let singular = false;
+
+    const singularMetavariableNode = this.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      singular = true;
     }
 
-    return simple;
+    return singular;
   }
 
   getTermNodes() {
@@ -59,13 +81,6 @@ export default class StatementNode extends NonTerminalNode {
     return judgementNode;
   }
 
-  getMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          metavariableNode = this.getNodeByRuleName(ruleName);
-
-    return metavariableNode;
-  }
-
   getTypeAssertionNode() {
     const ruleName = TYPE_ASSERTION_RULE_NAME,
           typeAssertionNode = this.getNodeByRuleName(ruleName);
@@ -134,6 +149,13 @@ export default class StatementNode extends NonTerminalNode {
     return satisfiedAssertionNode;
   }
 
+  getSingularMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          singularMetavariableNode = this.getSingularNodeByRuleName(ruleName);
+
+    return singularMetavariableNode;
+  }
+
   getSingularMetaArgumentNode() {
     const ruleName = META_ARGUMENT_RULE_NAME,
           singularMetaArgumentNode = this.getNodeByRuleName(ruleName);

package/src/node/substitution/term.js

@@ -20,27 +20,17 @@ export default class TermSubstitutionNode extends SubstitutionNode {
   }
 
   getLastVariableNode() {
-    let lastVariableNode = null;
-
     const lastTermNode = this.getLastTermNode(),
-          singularVariableNode = lastTermNode.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      lastVariableNode = singularVariableNode;  ///
-    }
+          singularVariableNode = lastTermNode.getSingularVariableNode(),
+          lastVariableNode = singularVariableNode;  ///
 
     return lastVariableNode;
   }
 
   getFirstVariableNode() {
-    let firstVariableNode = null;
-
     const firstTermNode = this.getFirstTermNode(),
-          singularVariableNode = firstTermNode.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      firstVariableNode = singularVariableNode;  ///
-    }
+          singularVariableNode = firstTermNode.getSingularVariableNode(),
+          firstVariableNode = singularVariableNode;  ///
 
     return firstVariableNode;
   }