occam-verify-cli 1.0.696 → 1.0.702

package/src/element/metavariable.js

@@ -9,8 +9,9 @@ import { literally } from "../utilities/context";
 import { EMPTY_STRING } from "../constants";
 import { metaTypeToMetaTypeJSON } from "../utilities/json";
 import { instantiateMetavariable } from "../process/instantiate";
+import { nameFromMetavariableNode } from "../utilities/element";
+import { typeFromJSON, metaTypeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
-import { nameFromJSON, typeFromJSON, nameToNameJSON, metaTypeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Metavariable extends Element {
   constructor(context, string, node, name, type, metaType) {
@@ -439,15 +440,12 @@ export default define(class Metavariable extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          nameJSON = nameToNameJSON(this.name),
           metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
-          name = nameJSON,  ///
           type = typeJSON,  ///
           metaType = metaTypeJSON,  ///
           string = this.getString(), ///
           json = {
             string,
-            name,
             type,
             metaType
           };
@@ -462,13 +460,12 @@ export default define(class Metavariable extends Element {
       const { string } = json,
             metavariableNode = instantiateMetavariable(string, context),
             node = metavariableNode,  ///
-            name = nameFromJSON(json, context),
+            name = nameFromMetavariableNode(metavariableNode, context),
             type = typeFromJSON(json, context),
             metaType = metaTypeFromJSON(json, context),
             metavariable = new Metavariable(context, string, node, name, type, metaType);
 
       return metavariable;
-
     }, context);
 
     return metavariable;

package/src/element/parameter.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateParameter } from "../process/instantiate";
-import { nameFromJSON, nameToNameJSON, identifierFromJSON, identifierToIdentifierJSON } from "../utilities/json";
+import { nameFromParaneterNode, identifierFromParameterNode } from "../utilities/element";
 
 export default define(class Parameter extends Element {
   constructor(context, string, node, name, identifier) {
@@ -50,15 +50,9 @@ export default define(class Parameter extends Element {
   }
 
   toJSON() {
-    const nameJSON = nameToNameJSON(this.name),
-          identifierJSON = identifierToIdentifierJSON(this.identifier),
-          name = nameJSON,  ///
-          identifier = identifierJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            name,
-            identifier
+            string
           };
 
     return json;
@@ -71,9 +65,12 @@ export default define(class Parameter extends Element {
       const { string } = json,
             parameterNode = instantiateParameter(string, context),
             node = parameterNode,  ///
-            name = nameFromJSON(json, context),
-            identifier = identifierFromJSON(json, context),
-            parameter = new Parameter(context, string, node, name, identifier);
+            name = nameFromParaneterNode(parameterNode, context),
+            identifier = identifierFromParameterNode(parameterNode, context);
+
+      context = null;
+
+      const parameter = new Parameter(context, string, node, name, identifier);
 
       return parameter;
     }, context);

package/src/element/procedureCall.js

@@ -6,7 +6,7 @@ import { termsUtilities } from "occam-furtle";
 import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateProcedureCall } from "../process/instantiate";
-import { parametersFromJSON, parametersToParametersJSON, procedureReferenceFromJSON, procedureReferenceToProcedureReferenceJSON } from "../utilities/json";
+import { parametersFromProcedureCallNode, procedureReferenceFromProcedureCallNode } from "../utilities/element";
 
 const { termsFromPrimitives } = termsUtilities;
 
@@ -114,15 +114,9 @@ export default define(class ProcedureCall extends Element {
   }
 
   toJSON() {
-    const parametersJSON = parametersToParametersJSON(this.parameters),
-          procedureReferenceJSON = procedureReferenceToProcedureReferenceJSON(this.procedureReference),
-          parameters = parametersJSON,  ///
-          procedureReference = procedureReferenceJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            parameters,
-            procedureReference
+            string
           };
 
     return json;
@@ -135,9 +129,12 @@ export default define(class ProcedureCall extends Element {
       const { string } = json,
             procedureCallNode = instantiateProcedureCall(string, context),
             node = procedureCallNode,  ///
-            parameters = parametersFromJSON(json, context),
-            procedureReference = procedureReferenceFromJSON(json, context),
-            procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);
+            parameters = parametersFromProcedureCallNode(json, context),
+            procedureReference = procedureReferenceFromProcedureCallNode(json, context);
+
+      context = null;
+
+      const procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);
 
       return procedureCall;
     }, context);

package/src/element/procedureReference.js

@@ -4,8 +4,8 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { literally } from "../utilities/context";
-import { nameFromJSON, nameToNameJSON } from "../utilities/json";
 import { instantiateProcedureReference } from "../process/instantiate";
+import { nameFromProcedureReferenceNode } from "../utilities/element";
 
 export default define(class ProcedureReference extends Element {
   constructor(context, string, node, name) {
@@ -32,12 +32,9 @@ export default define(class ProcedureReference extends Element {
   }
 
   toJSON() {
-    const nameJSON = nameToNameJSON(this.name),
-          name = nameJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            name
+            string
           };
 
     return json;
@@ -50,8 +47,11 @@ export default define(class ProcedureReference extends Element {
       const { string } = json,
             procedureReferenceNode = instantiateProcedureReference(string, context),
             node = procedureReferenceNode,  ///
-            name = nameFromJSON(json, context),
-            procedureReference = new ProcedureReference(context, string, node, name);
+            name = nameFromProcedureReferenceNode(procedureReferenceNode, context);
+
+      context = null;
+
+      const procedureReference = new ProcedureReference(context, string, node, name);
 
       return procedureReference;
     }, context);

package/src/element/proofAssertion/premise.js

@@ -4,8 +4,9 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
+import { ephemeralContextFromJSON } from "../../utilities/json";
 import { attempt, liminally, literally } from "../../utilities/context";
-import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, ephemeralContextFromJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
+import { statementFromPremiseNode, procedureCallFromPremiseNode } from "../../utilities/element";
 
 export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -271,16 +272,10 @@ export default define(class Premise extends ProofAssertion {
 
     context = contextJSON;  ///
 
-    const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
-          statementJSON = statementToStatementJSON(this.statement),
-          procedureCall = procedureCallJSON,  ///
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement,
-            procedureCall
+            string
           };
 
     return json;
@@ -291,10 +286,10 @@ export default define(class Premise extends ProofAssertion {
   static fromJSON(json, context) {
     const premise = literally((context) => {
       const { string } = json,
-            prmiseNode = instantiatePremise(string, context),
-            node = prmiseNode,  ///
-            statement = statementFromJSON(json, context),
-            procedureCall = procedureCallFromJSON(json, context),
+            premiseNode = instantiatePremise(string, context),
+            node = premiseNode,  ///
+            statement = statementFromPremiseNode(premiseNode, context),
+            procedureCall = procedureCallFromPremiseNode(premiseNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///
@@ -302,7 +297,6 @@ export default define(class Premise extends ProofAssertion {
       const premise = new Premise(context, string, node, statement, procedureCall);
 
       return premise;
-
     }, context);
 
     return premise;

package/src/element/proofAssertion/supposition.js

@@ -4,8 +4,9 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { instantiateSupposition } from "../../process/instantiate";
+import { ephemeralContextFromJSON } from "../../utilities/json";
 import { attempt, liminally, literally } from "../../utilities/context";
-import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, ephemeralContextFromJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
+import { statementFromSuppositionNode, procedureCallFromSuppositionNode } from "../../utilities/element";
 
 export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -293,16 +294,10 @@ export default define(class Supposition extends ProofAssertion {
 
     context = contextJSON;  ///
 
-    const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
-          statementJSON = statementToStatementJSON(this.statement),
-          procedureCall = procedureCallJSON,  ///
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement,
-            procedureCall
+            string
           };
 
     return json;
@@ -315,8 +310,8 @@ export default define(class Supposition extends ProofAssertion {
       const { string } = json,
             suppositionNode = instantiateSupposition(string, context),
             node = suppositionNode,  ///
-            statement = statementFromJSON(json, context),
-            procedureCall = procedureCallFromJSON(json, context),
+            statement = statementFromSuppositionNode(suppositionNode, context),
+            procedureCall = procedureCallFromSuppositionNode(suppositionNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///
@@ -324,7 +319,6 @@ export default define(class Supposition extends ProofAssertion {
       const supposition = new Supposition(context, string, node, statement, procedureCall);
 
       return supposition;
-
     }, context);
 
     return supposition;

package/src/element/property.js

@@ -3,7 +3,10 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {nameToNameJSON} from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateProperty } from "../process/instantiate";
+import { nameFromPropertyNode } from "../utilities/element";
+import { nominalTypeNameFromJSON, nominalTypeNameToNominalTypeNameJSON } from "../utilities/json";
 
 export default define(class Property extends Element {
   constructor(context, string, node, name, nominalTypeName) {
@@ -41,14 +44,11 @@ export default define(class Property extends Element {
   }
 
   toJSON() {
-    const nominalTypeNameJSON = nameToNameJSON(this.nominalTypeName),
-          nameJSON = nameToNameJSON(this.name),
+    const nominalTypeNameJSON = nominalTypeNameToNominalTypeNameJSON(this.nominalTypeName),
           nominalTypeName = nominalTypeNameJSON,  ///
-          name = nameJSON,  ///
           string = this.getString(),
           json = {
             string,
-            name,
             nominalTypeName
           };
 
@@ -58,6 +58,20 @@ export default define(class Property extends Element {
   static name = "Property";
 
   static fromJSON(json, context) {
-    debugger
+    const property = literally((context) => {
+      const { string } = json,
+            propertyNode = instantiateProperty(string, context),
+            node = propertyNode,  ///
+            name = nameFromPropertyNode(propertyNode, context),
+            nominalTypeName = nominalTypeNameFromJSON(json);
+
+      context = null;
+
+      const property = new Property(context, string, node, name, nominalTypeName);
+
+      return property;
+    }, context);
+
+    return property;
   }
 });

package/src/element/propertyRelation.js

@@ -3,23 +3,26 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiatePropertyRelation } from "../process/instantiate";
+import { propertyFromPropertyRelationNode } from "../utilities/element";
 
 export default define(class PropertyRelation extends Element {
-  constructor(context, string, node, property, term) {
+  constructor(context, string, node, term, property) {
     super(context, string, node);
 
-    this.property = property;
     this.term = term;
-  }
-
-  getProperty() {
-    return this.property;
+    this.property = property;
   }
 
   getTerm() {
     return this.term;
   }
 
+  getProperty() {
+    return this.property;
+  }
+
   getPropertyRelationNode() {
     const node = this.getNode(),
           propertyRelationNode = node;  ///
@@ -110,4 +113,38 @@ export default define(class PropertyRelation extends Element {
   }
 
   static name = "PropertyRelation";
+
+  toJSON() {
+    const string = this.getString(),
+          json = {
+            string
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, context) {
+    const propertyRelation = literally((context) => {
+      const { string } = json,
+            propertyRelationNode = instantiatePropertyRelation(string, context),
+            node = propertyRelationNode,  ///
+            term = termFromPropertyRelationNode(propertyRelationNode, context),
+            property = propertyFromPropertyRelationNode(propertyRelationNode, context);
+
+      context = null;
+
+      const propertyRelation = new PropertyRelation(context, string, node, term, property);
+
+      return propertyRelation;
+    }, context);
+
+    return propertyRelation;
+  }
 });
+
+function termFromPropertyRelationNode(propertyRelationNode, context) {
+  const termNode = propertyRelationNode.getTermNode(),
+        term = context.findTermByTermNode(termNode);
+
+  return term;
+}

package/src/element/reference.js

@@ -3,10 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt } from "../utilities/context";
+import { attempt, literally } from "../utilities/context";
+import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
+import { metavariableFromReferenceNode } from "../utilities/element";
 import { unifyMetavariableIntrinsically } from "../process/unify";
-import { metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Reference extends Element {
   constructor(context, string, node, metavariable) {
@@ -26,7 +27,6 @@ export default define(class Reference extends Element {
     return referenceNode;
   }
 
-
   getName() { return this.metavariable.getName(); }
 
   getMetavariableName() {
@@ -291,12 +291,9 @@ export default define(class Reference extends Element {
   }
 
   toJSON() {
-    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
-          metavariable = metavariableJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            metavariable
+            string
           };
 
     return json;
@@ -305,6 +302,16 @@ export default define(class Reference extends Element {
   static name = "Reference";
 
   static fromJSON(json, context) {
-    debugger
+    const reference = literally((context) => {
+      const { string } = json,
+            referenceNode = instantiateReference(string, context),
+            node = referenceNode,  ///
+            metavariable = metavariableFromReferenceNode(referenceNode, context),
+            reference = new Reference(context, string, node, metavariable);
+
+      return reference;
+    }, context);
+
+    return reference;
   }
 });

package/src/element/rule.js

@@ -55,30 +55,6 @@ export default define(class Rule extends Element {
     return comparesToMetavariableName;
   }
 
-  verifyLabels() {
-    let labelsVerify;
-
-    const context = this.getContext(),
-          ruleString = this.getString();  ///
-
-    context.trace(`Verifying the '${ruleString}' rule's labels...`);
-
-    labelsVerify = this.labels.every((label) => {
-      const nameOnly = true,
-            labelVerifies = label.verify(nameOnly);
-
-      if (labelVerifies) {
-        return true;
-      }
-    });
-
-    if (labelsVerify) {
-      context.debug(`...verified the '${ruleString}' rule's labels.`);
-    }
-
-    return labelsVerify;
-  }
-
   unifyStatementWithConclusion(statement, context) {
     let statementUnifiesWithConclusion = false;
 
@@ -143,6 +119,47 @@ export default define(class Rule extends Element {
     return verifies;
   }
 
+  verifyLabel(label) {
+    let labelVerifies;
+
+    const context = this.getContext(),
+          ruleString = this.getString(),  ///
+          labelString = label.getString();
+
+    context.trace(`Verifying the '${ruleString}' rule's '${labelString}' label...`);
+
+    labelVerifies = label.verify();
+
+    if (labelVerifies) {
+      context.debug(`...verified the '${ruleString}' rule's '${labelString}' label.`);
+    }
+
+    return labelVerifies;
+  }
+
+  verifyLabels() {
+    let labelsVerify;
+
+    const context = this.getContext(),
+          ruleString = this.getString();  ///
+
+    context.trace(`Verifying the '${ruleString}' rule's labels...`);
+
+    labelsVerify = this.labels.every((label) => {
+      const labelVerifies = this.verifyLabel(label);
+
+      if (labelVerifies) {
+        return true;
+      }
+    });
+
+    if (labelsVerify) {
+      context.debug(`...verified the '${ruleString}' rule's labels.`);
+    }
+
+    return labelsVerify;
+  }
+
   async verifyProof(context) {
     let proofVerifies;
 

package/src/element/signature.js

@@ -4,8 +4,9 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { signatureStringFromTerms } from "../utilities/string";
-import { termsFromJSON, termsToTermsJSON } from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateSignature } from "../process/instantiate";
+import { termsFromSignatureNode } from "../utilities/element";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -34,34 +35,89 @@ export default define(class Signature extends Element {
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    const terms = [],
-          termsValidate = this.terms.every((term) => {
-            term = term.validate(context, () => { ///
-              const validatesForwards = true;
+    const validates = this.validate(context);
 
-              return validatesForwards;
-            });
+    if (validates) {
+      verifies = true;
+    }
 
-            const termValidates = (term !== null);
+    if (verifies) {
+      context.debug(`...verified the '${signatureString}' signature.`);
+    }
 
-            if (termValidates) {
-              terms.push(term);
+    return verifies;
+  }
 
-              return true;
-            }
-          });
+  validate(context) {
+    let validates = false;
+
+    const signatureString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureString}' signature...`);
+
+    const terms = [],
+          termsValidate = this.validateTerms(terms, context);
 
     if (termsValidate) {
       this.terms = terms;
 
-      verifies = true;
+      validates = true;
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${signatureString}' signature.`);
+    if (validates) {
+      context.debug(`...validated the '${signatureString}' signature.`);
     }
 
-    return verifies;
+    return validates
+  }
+
+  validateTerm(term, terms, context) {
+    let termValidates = false;
+
+    const termString = term.getString(),
+          signatureString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureString}' signature's '${termString}' term...`);
+
+    term = term.validate(context, () => { ///
+      const validatesForwards = true;
+
+      return validatesForwards;
+    });
+
+    if (term !== null) {
+      terms.push(term);
+
+      termValidates = true;
+    }
+
+    if (termValidates) {
+      context.debug(`...validated the '${signatureString}' signature's '${termString}' term.`);
+    }
+
+    return termValidates
+  }
+
+  validateTerms(terms, context) {
+    let termsValidate;
+
+    const signatureString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureString}' signature's terms...`);
+
+    termsValidate = terms.every((term) => {
+      const termValidates = this.validateTerm(term, terms, context);
+
+      if (termValidates) {
+        return true;
+      }
+    })
+
+    if (termsValidate){
+      context.debug(`...validated the '${signatureString}' signature's terms.`);
+    }
+
+    return termsValidate
   }
 
   compare(signature, substitutions, generalContext, specificContext) {
@@ -158,10 +214,9 @@ export default define(class Signature extends Element {
   }
 
   toJSON() {
-    const termsJSON = termsToTermsJSON(this.terms),
-          terms = termsJSON,  ///
+    const string = this.getString(),
           json = {
-            terms
+            string
           };
 
     return json;
@@ -170,6 +225,16 @@ export default define(class Signature extends Element {
   static name = "Signature";
 
   static fromJSON(json, context) {
-    debugger
+    const signature = literally((context) => {
+      const { string } = json,
+            signatureNode = instantiateSignature(string, context),
+            node = signatureNode,  ///
+            terms = termsFromSignatureNode(signatureNode, context),
+            signature = new Signature(context, string, node, terms);
+
+      return signature;
+    }, context);
+
+    return signature;
   }
 });