occam-verify-cli 1.0.911 → 1.0.913

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.911",
+  "version": "1.0.913",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,14 +12,14 @@
   "dependencies": {
     "argumentative": "^2.0.47",
     "necessary": "^17.1.7",
-    "occam-furtle": "^3.0.194",
-    "occam-grammars": "^1.3.520",
-    "occam-languages": "^0.0.198",
+    "occam-furtle": "^3.0.195",
+    "occam-grammars": "^1.3.524",
+    "occam-languages": "^0.0.199",
     "occam-lexers": "^23.1.44",
-    "occam-model": "^1.0.505",
-    "occam-nominal": "^1.0.102",
+    "occam-model": "^1.0.506",
+    "occam-nominal": "^1.0.103",
     "occam-parsers": "^23.1.50",
-    "occam-server": "^7.0.6"
+    "occam-server": "^7.0.7"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",

package/src/element/assertion/signature.js

@@ -5,7 +5,7 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateSignatureAssertion } from "../../process/instantiate";
-import { signatureFromJSignatureAssertionNode, referenceFromJSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
+import { signatureFromSignatureAssertionNode, referenceFromSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SignatureAssertion extends Assertion {
   constructor(context, string, node, lineIndex, signature, reference) {
@@ -201,8 +201,8 @@ export default define(class SignatureAssertion extends Assertion {
         const { string, lineIndex } = json,
               definedAssertionNode = instantiateSignatureAssertion(string, context),
               node = definedAssertionNode,  ///
-              signature = signatureFromJSignatureAssertionNode(definedAssertionNode, context),
-              reference = referenceFromJSignatureAssertionNode(definedAssertionNode, context);
+              signature = signatureFromSignatureAssertionNode(definedAssertionNode, context),
+              reference = referenceFromSignatureAssertionNode(definedAssertionNode, context);
 
         context = null;
 

package/src/element/signature.js

@@ -5,8 +5,8 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { instantiateSignature } from "../process/instantiate";
-import { termsFromSignatureNode } from "../utilities/element";
-import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
+import { signatureFromSignatureNode } from "../utilities/element";
+import { attempt, reconcile, serialise, unserialise, instantiate, ablate } from "../utilities/context";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -41,6 +41,22 @@ export default define(class Signature extends Element {
     return term;
   }
 
+  isEqualTo(signature) {
+    const signatureNode = signature.getNode(),
+          signatureNodeMatches = this.matchSignatureNode(signatureNode),
+          equalTo = signatureNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchSignatureNode(signatureNode) {
+    const node = signatureNode, ///
+          nodeMatches = this.matchNode(node),
+          signatureNodeMatches = nodeMatches; ///
+
+    return signatureNodeMatches;
+  }
+
   findValidSignature(context) {
     const signatureNode = this.getSignatureNode(),
           signature = context.findSignatureBySignatureNode(signatureNode),
@@ -299,4 +315,30 @@ export default define(class Signature extends Element {
 
     return signature;
   }
+
+  static fromSignatureString(signatureString, context) {
+    let signature;
+
+    ablate((context) => {
+      instantiate((context) => {
+        const string = signatureString,  ///
+              signatureNode = instantiateSignature(string, context);
+
+        signature = signatureFromSignatureNode(signatureNode, context);
+      }, context);
+    }, context);
+
+    return signature;
+  }
 });
+
+function termsFromSignatureNode(signatureNode, context) {
+  const termNodes = signatureNode.getTermNodes(),
+        terms = termNodes.map((termNode) => {
+          const term = context.findTermByTermNode(termNode);
+
+          return term;
+        });
+
+  return terms;
+}

package/src/process/instantiate.js

@@ -14,6 +14,7 @@ import { TERM_RULE_NAME,
          PARAMETER_RULE_NAME,
          STATEMENT_RULE_NAME,
          REFERENCE_RULE_NAME,
+         SIGNATURE_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONCLUSION_RULE_NAME,
          HYPOTHESIS_RULE_NAME,
@@ -51,6 +52,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       parameterPlaceholderRule = ruleFromRuleName(PARAMETER_RULE_NAME),
       statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
       referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
+      signaturePlaceholderRule = ruleFromRuleName(SIGNATURE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
       conclusionPlaceholderRule = ruleFromRuleName(CONCLUSION_RULE_NAME),
       hypothesisPlaceholderRule = ruleFromRuleName(HYPOTHESIS_RULE_NAME),
@@ -125,6 +127,8 @@ export function instantiateStatement(string, context) { return instantiate(state
 
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
+export function instantiateSignature(string, context) { return instantiate(signaturePlaceholderRule, string, context); }
+
 export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
 
 export function instantiateHypothesis(string, context) { return instantiate(hypothesisPlaceholderRule, string, context); }

package/src/utilities/element.js

@@ -1763,7 +1763,10 @@ export function signatureFromTopLevelAssertionNode(topLevelAsssertionNode, conte
   const signatureNode = topLevelAsssertionNode.getSignatureNode();
 
   if (signatureNode !== null) {
-    signature = signatureFromSignatureNode(signatureNode, context);
+    const { Signature } = elements,
+          signatureString = context.nodeAsString(signatureNode);
+
+    signature = Signature.fromSignatureString(signatureString, context);
   }
 
   return signature;
@@ -1862,8 +1865,10 @@ export function statementFromContainedAssertionNode(containedAssertionNode, cont
 }
 
 export function signatureFromSignatureAssertionNode(signatureAssertionNode, context) {
-  const signatureNode = signatureAssertionNode.getSignatureNode(),
-        signature = signatureFromSignatureNode(signatureNode, context);
+  const { Signature } = elements,
+        signatureNode = signatureAssertionNode.getSignatureNode(),
+        signatureString = context.nodeAsString(signatureNode),
+        signature = Signature.fromSignatureString(signatureString, context);
 
   return signature;
 }
@@ -1902,22 +1907,6 @@ export function statementFromBracketedCombinatorNode(bracketedCombinatorNode, co
   return statement;
 }
 
-export function signatureFromJSignatureAssertionNode(sasisfiesAssertionNode, context) {
-  const signatureNode = sasisfiesAssertionNode.getSignatureNode(),
-        signature = signatureFromSignatureNode(signatureNode, context);
-
-  return signature;
-}
-
-export function referenceFromJSignatureAssertionNode(sasisfiesAssertionNode, context) {
-  const { Reference } = elements,
-        referenceNode = sasisfiesAssertionNode.getReferenceNode(),
-        referenceString = context.nodeAsString(referenceNode),
-        reference = Reference.fromReferenceString(referenceString, context);
-
-  return reference;
-}
-
 export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
         targetFrame = frameFromFrameNode(targetFrameNode, context);