occam-verify-cli 1.0.457 → 1.0.473

package/src/element/substitution/frame.js

@@ -3,79 +3,134 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { withinFragment } from "../../utilities/fragment";
+import { literally } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
-import { frameSubstitutionFromFrameSubstitutionNode, frameSubstitutionFromStatementNode } from "../../utilities/element";
+import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
 export default define(class FrameSubstitution extends Substitution {
-  constructor(context, string, node, frame, metavariable) {
+  constructor(context, string, node, targetFrame, replacementFrame) {
     super(context, string, node);
 
-    this.frame = frame;
-    this.metavariable = metavariable;
+    this.targetFrame = targetFrame;
+    this.replacementFrame = replacementFrame;
   }
 
-  getFrame() {
-    return this.frame;
+  getTargetFrame() {
+    return this.targetFrame;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getReplacementFrame() {
+    return this.replacementFrame;
+  }
+
+  getTargetNode() {
+    const targetFrameNode = this.targetFrame.getNode(),
+          tergetNode = targetFrameNode; ///
+
+    return tergetNode;
   }
 
   getReplacementNode() {
-    const frameNode = this.frame.getNode(),
-          replacementNode = frameNode; ///
+    const replacementFrameNode = this.replacementFrame.getNode(),
+          replacementNode = replacementFrameNode; ///
 
     return replacementNode;
   }
 
-  isFrameEqualToFrame(frame) { return this.frame.isEqualTo(frame); }
+  isTrivial() {
+    const targetFrameEqualToReplacementFrame = this.targetFrame.isEqualTo(this.replacementFrame),
+          trivial = targetFrameEqualToReplacementFrame; ///
+
+    return trivial;
+  }
+
+  compareFrame(frame, context) {
+    const frameEqualToReplacementFrame = this.replacementFrame.isEqualTo(frame),
+          comparedToFrame = frameEqualToReplacementFrame; ///
+
+    return comparedToFrame;
+  }
 
-  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  compareParameter(parameter) {
+    const targetFrameComparesToParameter = this.targetFrame.compareParameter(parameter),
+          comparesToParameter = targetFrameComparesToParameter;  ///
 
-  verify(context) {
-    let verifies = false;
+    return comparesToParameter;
+  }
 
-    const frameSubstitutionString = this.string;  ///
+  validate(context) {
+    let validates = false;
 
-    context.trace(`Verifiying the '${frameSubstitutionString}' frame substitution...`);
+    const frameSubstitutionString = this.getString();  ///
 
-    const frameSingular = this.frame.isSingular();
+    context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
-    if (frameSingular) {
-      if (this.metavariable !== null) {
-        const metavariablePresent = context.isMetavariablePresent(this.metavariable);
+    const targetFrameValidates = this.validateTargetFrame(context);
 
-        if (metavariablePresent) {
-          const frameMetavariable = this.frame.getMetavariable(),
-                frameMetavariablePresent = context.isMetavariablePresent(frameMetavariable);
+    if (targetFrameValidates) {
+      const replacementFrameValidates = this.validateReplacementFrame(context);
 
-          if (frameMetavariablePresent) {
-            verifies = true;
-          } else {
-            context.debug(`The '${frameSubstitutionString}' frame substitution's general frame's metavariable is not present.`);
-          }
-        } else {
-          context.debug(`The '${frameSubstitutionString}' frame substitution's specific frame's metavariable is not present.`);
-        }
-      } else {
-        context.debug(`The '${frameSubstitutionString}' frame substitution's general frame is not singular.`);
+      if (replacementFrameValidates) {
+        validates = true;
       }
-    } else {
-      context.debug(`The '${frameSubstitutionString}' frame substitution's specific frame is not singular.`);
     }
 
-    if (verifies) {
+    if (validates) {
       const substititoin = this;  ///
 
       context.addSubstitution(substititoin);
 
-      context.debug(`...verified the '${frameSubstitutionString}' frame substitution.`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
+    }
+
+    return validates;
+  }
+
+  validateTargetFrame(context) {
+    let targetFrameValidates = false;
+
+    const targetFrameString = this.targetFrame.getString(),
+          frameSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
+
+    const targetFrameSingular = this.targetFrame.isSingular();
+
+    if (targetFrameSingular) {
+      const stated = true,
+            assignments = null;
+
+      targetFrameValidates = this.targetFrame.validate(assignments, stated, context);
+    } else {
+      context.debug(`The '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame is not singular.`);
+    }
+
+    if (targetFrameValidates) {
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
+    }
+
+    return targetFrameValidates;
+  }
+
+  validateReplacementFrame(context) {
+    let replacementFrameValidates;
+
+    const replacementFrameString = this.replacementFrame.getString(),
+          frameSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+
+    const stated = true,
+          assignments = null;
+
+    replacementFrameValidates = this.replacementFrame.validate(assignments, stated, context);
+
+    if (replacementFrameValidates) {
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
     }
 
-    return verifies;
+    return replacementFrameValidates;
   }
 
   static name = "FrameSubstitution";
@@ -88,12 +143,14 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    return withinFragment((context) => {
-      const frameAndMetavariableString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
-            string = frameAndMetavariableString,  ///
+    return literally((context) => {
+      const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+            string = frameSubstitutionString,  ///
             frameSubstitutionNode = instantiateFrameSubstitution(string, context),
             frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
+      frameSubstitution.validate(context);
+
       return frameSubstitution;
     }, context);
   }

package/src/element/substitution/reference.js

@@ -3,42 +3,142 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
+import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
 export default define(class ReferenceSubstitution extends Substitution {
-  constructor(context, string, node, reference, metavariable) {
+  constructor(context, string, node, targetReference, replacementReference) {
     super(context, string, node);
 
-    this.reference = reference;
-    this.metavariable = metavariable;
+    this.targetReference = targetReference;
+    this.replacementReference = replacementReference;
   }
 
-  getReference() {
-    return this.reference;
+  getTargetReference() {
+    return this.targetReference;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getReplacementReference() {
+    return this.replacementReference;
   }
 
-  isReferenceEqualToReference(reference) { return this.reference.isEqualTo(reference); }
+  getTargetNode() {
+    const targetReferenceNode = this.targetReference.getNode(),
+          tergetNode = targetReferenceNode; ///
+
+    return tergetNode;
+  }
+
+  getReplacementNode() {
+    const replacementReferenceNode = this.replacementReference.getNode(),
+          replacementNode = replacementReferenceNode; ///
+
+    return replacementNode;
+  }
+
+  isTrivial() {
+    const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),
+          trivial = targetReferenceEqualToReplacementReference; ///
+
+    return trivial;
+  }
+
+  compareReference(reference, context) {
+    const referenceEqualToReplacementReference = this.replacementReference.isEqualTo(reference),
+          comparedToReference = referenceEqualToReplacementReference; ///
+
+    return comparedToReference;
+  }
+
+  compareParameter(parameter) {
+    const targetReferenceComparesToParameter = this.targetReference.compareParameter(parameter),
+          comparesToParameter = targetReferenceComparesToParameter;  ///
+
+    return comparesToParameter;
+  }
+
+  validate(context) {
+    let validates = false;
+
+    const referenceSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution...`);
+
+    const targetReferenceValidates = this.validateTargetReference(context);
+
+    if (targetReferenceValidates) {
+      const replacementReferenceValidates = this.validateReplacementReference(context);
+
+      if (replacementReferenceValidates) {
+        validates = true;
+      }
+    }
+
+    if (validates) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
+
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
+    }
+
+    return validates;
+  }
+
+  validateTargetReference(context) {
+    let targetReferenceValidates = false;
+
+    const targetReferenceString = this.targetReference.getString(),
+          referenceSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
+
+    const targetReferenceSingular = this.targetReference.isSingular();
+
+    if (targetReferenceSingular) {
+      targetReferenceValidates = this.targetReference.validate(context);
+    } else {
+      context.debug(`The '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference is not singular.`);
+    }
+
+    if (targetReferenceValidates) {
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
+    }
+
+    return targetReferenceValidates;
+  }
+
+  validateReplacementReference(context) {
+    let replacementReferenceValidates;
+
+    const replacementReferenceString = this.replacementReference.getString(),
+          referenceSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+
+    replacementReferenceValidates = this.replacementReference.validate(context);
+
+    if (replacementReferenceValidates) {
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+    }
+
+    return replacementReferenceValidates;
+  }
 
   static name = "ReferenceSubstitution";
 
   static fromReferenceAndMetavariable(reference, metavariable, context) {
-    const string = stringFromReferenceAndMetavariable(reference, metavariable),
-          referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
-          referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    return literally((context) => {
+      const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+            string = referenceSubstitutionString,  ///
+            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
+            referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+
+      referenceSubstitution.validate(context);
 
-    return referenceSubstitution;
+      return referenceSubstitution;
+    }, context);
   }
 });
-
-function stringFromReferenceAndMetavariable(reference, metavariable) {
-  const referenceString = reference.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${referenceString} for ${metavariableString}]`;
-
-  return string;
-}