occam-verify-cli 1.0.388 → 1.0.404

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.388",
+  "version": "1.0.404",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -11,15 +11,15 @@
   },
   "dependencies": {
     "argumentative": "^2.0.36",
-    "necessary": "^15.0.6",
-    "occam-custom-grammars": "^5.0.1317",
-    "occam-entities": "^1.0.430",
-    "occam-file-system": "^6.0.445",
-    "occam-furtle": "^2.0.263",
-    "occam-grammars": "^1.3.410",
-    "occam-lexers": "^23.1.15",
-    "occam-parsers": "^23.1.18",
-    "occam-query": "^4.1.124"
+    "necessary": "^16.0.3",
+    "occam-custom-grammars": "^5.0.1322",
+    "occam-entities": "^1.0.431",
+    "occam-file-system": "^6.0.446",
+    "occam-furtle": "^2.0.265",
+    "occam-grammars": "^1.3.414",
+    "occam-lexers": "^23.1.22",
+    "occam-parsers": "^23.1.25",
+    "occam-query": "^4.1.131"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",

package/src/action/verify.js

@@ -51,9 +51,9 @@ export default function verifyAction(argument, log) {
 
     const dependentName = null,
           dependentReleased = false,
-          releaseVerified = verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap);
+          releaseVerifies = verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap);
 
-    if (!releaseVerified) {
+    if (!releaseVerifies) {
       log.warning(`The '${name}' project or package cannot be verified.`);
 
       return;

package/src/assignment/equality.js

@@ -10,7 +10,7 @@ export default class EqualityAssignment {
   }
 
   assign(context) {
-    const equalityAdded = context.addEquality(this.equality, context),
+    const equalityAdded = context.addEquality(this.equality),
           equalityString = this.equality.getString(),
           equalityAssigned = equalityAdded; ///
 

package/src/context/file.js

@@ -2,8 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import Equivalences from "../equivalences";
-import Substitutions from "../substitutions";
+import ontology from "../ontology";
 import topLevelVerifier from "../verifier/topLevel";
 
 import { baseType } from "../ontology/type";
@@ -92,7 +91,8 @@ export default class FileContext {
   }
 
   getEquivalences() {
-    const equivalences = Equivalences.fromNothing();
+    const { Equivalences } = ontology,
+          equivalences = Equivalences.fromNothing();
 
     return equivalences;
   }
@@ -496,16 +496,17 @@ export default class FileContext {
     return axiomLemmaTheoremOrConjecture;
   }
 
-  findMetavariable(metavariable, generalContext, specificContext) {
-    const specificMetavariable = metavariable,  ///
-          metavariables = this.getMetavariables();
+  findMetavariable(metavariable) {
+    const metavariables = this.getMetavariables(),
+          specificMetavariable = metavariable;  ///
 
     metavariable = metavariables.find((metavariable) => {
       const generalMetavariable = metavariable; ///
 
       metavariable = specificMetavariable;  ///
 
-      const metavariableUnifies = generalMetavariable.unifyMetavariable(metavariable, generalContext, specificContext);
+      const context = this, ///
+            metavariableUnifies = generalMetavariable.unifyMetavariable(metavariable, context);
 
       if (metavariableUnifies) {
         return true;
@@ -627,7 +628,7 @@ export default class FileContext {
   findLabelByMetavariable(metavariable) {
     const labels = this.getLabels(),
           label = labels.find((label) => {
-            const metavariableEqualToLabelMetavariable = label.isMetavariableEqualTo(metavariable);
+            const metavariableEqualToLabelMetavariable = label.isMetavariableEqualToMetavariable(metavariable);
 
             if (metavariableEqualToLabelMetavariable) {
               return true;
@@ -668,8 +669,8 @@ export default class FileContext {
     return metavariable;
   }
 
-  isMetavariablePresent(metavariable, generalContext, specificContext) {
-    metavariable = this.findMetavariable(metavariable, generalContext, specificContext);  ///
+  isMetavariablePresent(metavariable) {
+    metavariable = this.findMetavariable(metavariable);
 
     const metavariablePresent = (metavariable !== null);
 
@@ -735,7 +736,8 @@ export default class FileContext {
   isLabelPresentByReference(reference) {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
-            const context = this, ///
+            const { Substitutions } = ontology,
+                  context = this, ///
                   substitutions = Substitutions.fromNothing(),
                   labelUnifies = reference.unifyLabel(label, substitutions, context);
 

package/src/context/local.js

@@ -2,15 +2,13 @@
 
 import { arrayUtilities } from "necessary";
 
-import Equivalence from "../equivalence";
-import Equivalences from "../equivalences";
+import ontology from "../ontology";
 
 const { last } = arrayUtilities;
 
 class LocalContext {
-  constructor(context, tokens, variables, judgements, equivalences, stepsOrSubproofs) {
+  constructor(context, variables, judgements, equivalences, stepsOrSubproofs) {
     this.context = context;
-    this.tokens = tokens;
     this.variables = variables;
     this.judgements = judgements;
     this.equivalences = equivalences;
@@ -21,10 +19,6 @@ class LocalContext {
     return this.context;
   }
 
-  getTokens() {
-    return this.tokens;
-  }
-
   getVariables(nested = true) {
     let variables;
 
@@ -124,19 +118,28 @@ class LocalContext {
 
   addTheorem(theorem) { this.context.addTheorem(theorem); }
 
-  addEquality(equality, context) {
+  addEquality(equality) {
     let equalityAdded;
 
     const equalityReflexive = equality.isReflexive();
 
     if (!equalityReflexive) {
-      const equivalence = Equivalence.fromEquality(equality);
+      const { Equivalence } = ontology,
+            equivalence = Equivalence.fromEquality(equality),
+            context = this; ///
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
     }
 
     equalityAdded = true;
 
+    if (equalityAdded) {
+      const context = this, ///
+            equalityString = equality.getString();
+
+      context.trace(`Added the '${equalityString}' equality.`)
+    }
+
     return equalityAdded;
   }
 
@@ -152,11 +155,14 @@ class LocalContext {
       variableAdded = true;
     }
 
-    return variableAdded;
-  }
+    if (variableAdded) {
+      const context = this,
+            variableString = variable.getString();
 
-  addStepOrSubproof(stepOrSubproof) {
-    this.stepsOrSubproofs.push(stepOrSubproof);
+      context.trace(`Added the '${variableString}' variable.`)
+    }
+
+    return variableAdded;
   }
 
   addJudgement(judgement) {
@@ -171,9 +177,20 @@ class LocalContext {
       judgementAdded = true;
     }
 
+    if (judgementAdded) {
+      const context = this, ///
+            judgementString = judgement.getString();
+
+      context.trace(`Added the '${judgementString}' judgement.`)
+    }
+
     return judgementAdded;
   }
 
+  addStepOrSubproof(stepOrSubproof) {
+    this.stepsOrSubproofs.push(stepOrSubproof);
+  }
+
   findProcedureByName(name) { return this.context.findProcedureByName(name); }
 
   findLabelByReference(reference, context) { return this.context.findLabelByReference(reference, context); }
@@ -229,7 +246,7 @@ class LocalContext {
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
-  findMetavariable(metavariable, generalContext, specificContext) { return this.context.findMetavariable(metavariable, generalContext, specificContext); }
+  findMetavariable(metavariable) { return this.context.findMetavariable(metavariable); }
 
   findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
 
@@ -249,7 +266,7 @@ class LocalContext {
 
   findAxiomLemmaTheoremOrConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference); }
 
-  isMetavariablePresent(metavariable, generalContext, specificContext) { return this.context.isMetavariablePresent(metavariable, generalContext, specificContext); }
+  isMetavariablePresent(metavariable) { return this.context.isMetavariablePresent(metavariable); }
 
   isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }
 
@@ -341,45 +358,13 @@ class LocalContext {
     return termAndPropertyRelationMatches;
   }
 
-  nodeAsString(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    const string = this.context.nodeAsString(node, tokens);
-
-    return string;
-  }
-
-  nodesAsString(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
+  nodeAsString(node, tokens) { return this.context.nodeAsString(node, tokens); }
 
-    const string = this.context.nodesAsString(node, tokens);
+  nodesAsString(node, tokens) { return this.context.nodesAsString(node, tokens); }
 
-    return string;
-  }
+  nodeAsTokens(node, tokens) { return this.context.nodeAsTokens(node, tokens); }
 
-  nodeAsTokens(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    tokens = this.context.nodeAsTokens(node, tokens); ///
-
-    return tokens;
-  }
-
-  nodesAsTokens(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    tokens = this.context.nodesAsTokens(node, tokens);  ///
-
-    return tokens;
-  }
+  nodesAsTokens(node, tokens) { return this.context.nodesAsTokens(node, tokens); }
 
   tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
 
@@ -393,23 +378,13 @@ class LocalContext {
 
   error(message, node = null) { this.context.error(message, node); }
 
-  static fromContext(context) {
-    const tokens = null,
+  static fromNothing(context) {
+    const { Equivalences } = ontology,
           variables = [],
           judgements = [],
           equivalences = Equivalences.fromNothing(),
           stepsOrSubproofs = [],
-          localContext = new LocalContext(context, tokens, variables, judgements, equivalences, stepsOrSubproofs);
-
-    return localContext;
-  }
-
-  static fromContextAndTokens(context, tokens) {
-    const variables = [],
-          judgements = [],
-          equivalences = Equivalences.fromNothing(),
-          stepsOrSubproofs = [],
-          localContext = new LocalContext(context, tokens, variables, judgements, equivalences, stepsOrSubproofs);
+          localContext = new LocalContext(context, variables, judgements, equivalences, stepsOrSubproofs);
 
     return localContext;
   }

package/src/context/partial.js

@@ -4,15 +4,11 @@ import { BNFLexer } from "occam-lexers";
 import { BNFParser } from "occam-parsers";
 import { arrayUtilities } from "necessary";
 
-import { nodeQuery } from "../utilities/query";
-
 const { first } = arrayUtilities;
 
 const bnfLexer = BNFLexer.fromNothing(),
       bnfParser = BNFParser.fromNothing();
 
-const childNodeQuery = nodeQuery("/*/*!");
-
 export default class PartialContext {
   constructor(node, tokens) {
     this.node = node;
@@ -29,25 +25,24 @@ export default class PartialContext {
 
   static fromStringLexerAndParser(Class, string, lexer, parser) {
     const { rule } = Class,
-          ruleMap = parser.getRuleMap(),
-          ruleName = rule.getName();
-
-    ruleMap[ruleName] = rule;
-
-    const startRule = rule, ///
+          startRule = rule, ///
           content = `${string}
 `;
 
     let tokens = lexer.tokenise(content),
         node = parser.parse(tokens, startRule);
 
-    delete  ruleMap[ruleName];
+    node.someChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
-    const childNode = childNodeQuery(node);
+      if (childNodeNonTerminalNode) {
+        node = childNode; ///
 
-    node = childNode; ///
+        tokens = tokensFromTokensAndNode(tokens, node);  ///
 
-    tokens = tokensFromTokensAndNode(tokens, node);  ///
+        return true;
+      }
+    })
 
     const partialContext = new Class(node, tokens);