occam-verify-cli 1.0.984 → 1.0.986

package/src/element/judgement.js

@@ -1,303 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateJudgement } from "../process/instantiate";
-import { reconcile, instantiate,} from "../utilities/context";
-import { judgementFromStatementNode } from "../utilities/element";
-import { judgementAssignmentFromJudgement } from "../process/assign";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class Judgement extends Element {
-  constructor(context, string, node, breakPoint, frame, assumption) {
-    super(context, string, node, breakPoint);
-
-    this.frame = frame;
-    this.assumption = assumption;
-  }
-
-  getFrame() {
-    return this.frame;
-  }
-
-  getAssumption() {
-    return this.assumption;
-  }
-
-  getJudgementNode() {
-    const node = this.getNode(),
-          judgementNode = node; ///
-
-    return judgementNode;
-  }
-
-  isSingular() {
-    const judgementNode = this.getJudgementNode(),
-          singular = judgementNode.isSingular();
-
-    return singular;
-  }
-
-  isEqualTo(judgement) {
-    const judgementNode = judgement.getNode(),
-          judgementNodeMatches = this.matchJudgementNode(judgementNode),
-          equalTo = judgementNodeMatches;  ///
-
-    return equalTo;
-  }
-
-  getAssumptions() { return this.frame.getAssumptions(); }
-
-  getMetavariable() { return this.frame.getMetavariable(); }
-
-  getMetavariableNode() { return this.frame.getMetavariableNode(); }
-
-  getTopLevelMetaAssertion() { return this.assumption.getTopLevelMetaAssertion(); }
-
-  matchJudgementNode(judgementNode) {
-    const node = judgementNode, ///
-          nodeMatches = this.matchNode(node),
-          judgementNodeMatches = nodeMatches; ///
-
-    return judgementNodeMatches;
-  }
-
-  matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
-
-  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
-
-  findValidJudgement(context) {
-    const judgementNode = this.getJudgementNode(),
-          judgement = context.findJudgementByJudgementNode(judgementNode),
-          validJudgemenet = judgement;  ///
-
-    return validJudgemenet;
-  }
-
-  validate(context) {
-    let judgement = null;
-
-    const judgementString = this.getString();  ///
-
-    context.trace(`Validating the '${judgementString}' judgement...`);
-
-    let validates = false;
-
-    const validJudgement = this.findValidJudgement(context);
-
-    if (validJudgement !== null) {
-      validates = true;
-
-      judgement = validJudgement; ///
-
-      context.debug(`...the '${judgementString}' judgement is already valid.`);
-    } else {
-      const frameValidates = this.validateFrame(context);
-
-      if (frameValidates) {
-        const assumptionValidates = this.validateAssumption(context);
-
-        if (assumptionValidates) {
-          const stated = context.isStated();
-
-          let validatesWhenStated = false,
-              validatesWhenDerived = false;
-
-          if (stated) {
-            validatesWhenStated = this.validateWhenStated(context);
-          } else {
-            validatesWhenDerived = this.validateWhenDerived(context);
-          }
-
-          if (validatesWhenStated || validatesWhenDerived) {
-            validates = true;
-          }
-        }
-      }
-
-      if (validates) {
-        judgement = this; ///
-
-        this.assign(context);
-
-        context.addJudgement(judgement);
-      }
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${judgementString}' judgement.`);
-    }
-
-    return judgement;
-  }
-
-  validateFrame(context) {
-    let frameValidates = false;
-
-    const judgementString = this.getString(); ///
-
-    context.trace(`Validating the '${judgementString}' judgement's frame...`);
-
-    const frame = this.frame.validate(context);
-
-    if (frame !== null) {
-      this.frame = frame;
-
-      frameValidates = true;
-    }
-
-    if (frameValidates) {
-      context.trace(`...validated the '${judgementString}' judgement's frame.`);
-    }
-
-    return frameValidates;
-  }
-
-  validateAssumption(context) {
-    let assumptionValidates = false;
-
-    const judgementString = this.getString(); ///
-
-    context.trace(`Validating the '${judgementString}' judgement's assumption...`);
-
-    const assumption = this.assumption.validate(context);
-
-    if (assumption !== null) {
-      this.assumption = assumption;
-
-      assumptionValidates = true;
-    }
-
-    if (assumptionValidates) {
-      context.debug(`...validated the '${judgementString}' judgement's assumption.`);
-    }
-
-    return assumptionValidates;
-  }
-
-  validateWhenStated(context) {
-    let validatesWhenStated;
-
-    const judgementString = this.getString();  ///
-
-    context.trace(`Validating the '${judgementString}' stated judgement...`);
-
-    validatesWhenStated = true;
-
-    if (validatesWhenStated) {
-      context.debug(`...validated the '${judgementString}' stated judgement.`);
-    }
-
-    return validatesWhenStated;
-  }
-
-  validateWhenDerived(context) {
-    let validatesWhenDerived = false;
-
-    const judgementString = this.getString();  ///
-
-    context.trace(`Validating the '${judgementString}' derived judgement...`);
-
-    reconcile((context) => {
-      const assumptions = this.getAssumptions(),
-            topLevelMetaAssertion = this.getTopLevelMetaAssertion(),
-            metaLevelAssumptions = topLevelMetaAssertion.getMetaLevelAssumptions(),
-            metaLevelAssumptionsUnify = metaLevelAssumptions.every((metaLevelAssumption) => {
-              const assumptionUnifies = assumptions.some((assumption) => {
-                const assumptionUnifies = metaLevelAssumption.unifyAssumption(assumption, context);
-
-                if (assumptionUnifies) {
-                  return true;
-                }
-              });
-
-              if (assumptionUnifies) {
-                return true;
-              }
-            });
-
-      if (metaLevelAssumptionsUnify) {
-        validatesWhenDerived = true;
-      }
-    }, context);
-
-    if (validatesWhenDerived) {
-      context.debug(`...validated the '${judgementString}' derived judgement.`);
-    }
-
-    return validatesWhenDerived;
-  }
-
-  assign(context) {
-    const stated = context.isStated();
-
-    if (!stated) {
-      return;
-    }
-
-    const judgement = this, ///
-          judgementAssignment = judgementAssignmentFromJudgement(judgement, context);
-
-    context.addAssignment(judgementAssignment);
-  }
-
-  static name = "Judgement";
-
-  toJSON() {
-    const string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const json = {
-      string,
-      breakPoint
-    };
-
-    return json;
-  }
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            judgementNode = instantiateJudgement(string, context),
-            node = judgementNode,  ///
-            breakPoint = breakPointFromJSON(json),
-            frame = frameFromJudgementNode(judgementNode, context),
-            assumption = assumptionFromJudgementNode(judgementNode, context);
-
-      context = null;
-
-      const judgement = new Judgement(context, string, node, breakPoint, frame, assumption);
-
-      return judgement;
-    }, context);
-  }
-
-  static fromStatement(statement, context) {
-    const statementNode = statement.getNode(),
-          judgement = judgementFromStatementNode(statementNode, context);
-
-    return judgement;
-  }
-});
-
-function frameFromJudgementNode(judgementNode, context) {
-  const frameNode = judgementNode.getFrameNode(),
-        frame = context.findFrameByFrameNode(frameNode);
-
-  return frame;
-}
-
-function assumptionFromJudgementNode(judgementNode, context) {
-  const assumptionNode = judgementNode.getAssumptionNode(),
-        assumption = context.findAssumptionByAssumptionNode(assumptionNode);
-
-  return assumption;
-}

package/src/element/label.js

@@ -1,186 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateLabel } from "../process/instantiate";
-import { labelFromLabelNode, metavariableFromLabelNode } from "../utilities/element";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { attempt, ablate, serialise, unserialise, instantiate } from "../utilities/context";
-
-export default define(class Label extends Element {
-  constructor(context, string, node, breakPoint, metavariable) {
-    super(context, string, node, breakPoint);
-
-    this.metavariable = metavariable;
-  }
-
-  getMetavariable() {
-    return this.metavariable;
-  }
-
-  getLabelNode() {
-    const node = this.getNode(),
-          labelNode = node; ///
-
-    return labelNode;
-  }
-
-  getMetavariableNode() { return this.metavariable.getNode(); }
-
-  matchLabelNode(labelNode) {
-    const node = labelNode, ///
-          nodeMatches = this.matchNode(node),
-          labelNodeMatches = nodeMatches; ///
-
-    return labelNodeMatches;
-  }
-
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
-
-  compareReference(reference) {
-    const metavariable = reference.getMetavariable(),
-          metavariableComparesToMetavariable = this.compareMetavariable(metavariable),
-          comparesToReference = metavariableComparesToMetavariable; ///
-
-    return comparesToReference;
-  }
-
-  compareMetavariable(metavariable) { return this.metavariable.compareMetavariable(metavariable); }
-
-  verify() {
-    let verifies = false;
-
-    const context = this.getContext(),
-          labelString = this.getString(); ///
-
-    context.trace(`Verifying the '${labelString}' label...`);
-
-    const labelNode = this.getLabelNode(),
-          labelPresent = context.isLabelPresentByLabelNode(labelNode);
-
-    if (!labelPresent) {
-      const validates = this.validate();
-
-      if (validates !== null) {
-        verifies = true;
-      }
-    } else {
-      context.debug(`The '${labelString}' label is already present.`);
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${labelString}' label.`);
-    }
-
-    return verifies;
-  }
-
-  validate() {
-    let validates = false;
-
-    const context = this.getContext(),
-          labelString = this.getString(); ///
-
-    context.trace(`Validating the '${labelString}' label...`);
-
-    attempt((context) => {
-      const metavariableValidates = this.validateMetavariable(context);
-
-      if (metavariableValidates) {
-        validates = true;
-      }
-
-      if (validates) {
-        this.commit(context);
-      }
-    }, context);
-
-    if (validates) {
-      context.debug(`...validated the '${labelString}' label.`);
-    }
-
-    return validates;
-  }
-
-  validateMetavariable(context) {
-    let metavariableValidates = false;
-
-    const labelString = this.getString(); ///
-
-    context.trace(`Validating the '${labelString}' label's metavariable...`);
-
-    const metavariable = this.metavariable.validate(context);
-
-    if (metavariable !== null) {
-      this.metavariable = metavariable;
-
-      metavariableValidates = true;
-    }
-
-    if (metavariableValidates) {
-      context.debug(`...validated the '${labelString}' label's metavariable.'`);
-    }
-
-    return metavariableValidates;
-  }
-
-  toJSON() {
-    const context = this.getContext();
-
-    return serialise((context) => {
-      const string = this.getString();
-
-      let breakPoint;
-
-      breakPoint = this.getBreakPoint();
-
-      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-      breakPoint = breakPointJSON;  ///
-
-      const json = {
-        context,
-        string,
-        breakPoint
-      };
-
-      return json;
-    }, context);
-  }
-
-  static name = "Label";
-
-  static fromJSON(json, context) {
-    let label;
-
-    instantiate((context) => {
-      unserialise((json, context) => {
-        const { string } = json,
-              labelNode = instantiateLabel(string, context),
-              node = labelNode, ///
-              breakPoint = breakPointFromJSON(json),
-              metavariable = metavariableFromLabelNode(labelNode, context);
-
-        label = new Label(context, string, node, breakPoint, metavariable);
-      }, json, context);
-    }, context);
-
-    return label;
-  }
-
-  static fromLabelString(labelString, context) {
-    let label;
-
-    ablate((context) => {
-      instantiate((context) => {
-        const string = labelString,  ///
-              labelNode = instantiateLabel(string, context);
-
-        label = labelFromLabelNode(labelNode, context);
-      }, context);
-    }, context);
-
-    return label;
-  }
-});

package/src/element/metaType.js

@@ -1,75 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class MetaType extends Element {
-  constructor(context, string, node, breakPoint, name) {
-    super(context, string, node, breakPoint);
-
-    this.name = name;
-  }
-
-  getName() {
-    return this.name;
-  }
-
-  getMetaTypeNode() {
-    const node = this.getNode(),
-          metaTypeNode = node;  ///
-
-    return metaTypeNode;
-  }
-
-  isEqualTo(metaType) {
-    const equalTo = (this === metaType);
-
-    return equalTo;
-  }
-
-  compareMetaTypeName(metaTypeName) {
-    const comparesToMetaTypeName = (metaTypeName === this.name);
-
-    return comparesToMetaTypeName;
-  }
-
-  static name = "MetaType";
-
-  toJSON() {
-    const string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const json = {
-      string,
-      breakPoint
-    };
-
-    return json;
-  }
-
-  static fromJSON(json, context) {
-    const { string } = json,
-          metaTypeName = string,  ///
-          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
-
-    return metaType;
-  }
-
-  static fromName(name, context) {
-    const string = name,  ///
-          node = null,
-          breakPoint = null,
-          metaType = new MetaType(context, string, node, breakPoint, name);
-
-    return metaType;
-  }
-});