occam-verify-cli 0.0.959 → 0.0.960

package/lib/verify/term.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, "default", {
 var _shim = /*#__PURE__*/ _interop_require_default(require("../shim"));
 var _term = /*#__PURE__*/ _interop_require_default(require("../term"));
 var _bracketed = /*#__PURE__*/ _interop_require_default(require("../constructor/bracketed"));
-var _termAgainstConstructor = /*#__PURE__*/ _interop_require_default(require("../unifier/termAgainstConstructor"));
+var _termWithConstructor = /*#__PURE__*/ _interop_require_default(require("../unifier/termWithConstructor"));
 var _query = require("../utilities/query");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -25,8 +25,8 @@ function verifyTerm(termNode, terms, localContext, verifyAhead) {
     localContext.trace("Verifying the '".concat(termString, "' term..."), termNode);
     var verifyTermFunctions = [
         verifyTermAsVariable,
-        unifyTermAgainstConstructors,
-        unifyTermAgainstBracketedConstructor
+        unifyTermWithConstructors,
+        unifyTermWithBracketedConstructor
     ];
     termVerified = verifyTermFunctions.some(function(verifyTermFunction) {
         var termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);
@@ -64,25 +64,25 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
     }
     return termVerifiedAsVariable;
 }
-function unifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {
-    var termUnifiedAgainstConstructors = false;
+function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
+    var termUnifiedWithConstructors = false;
     var variableNode = variableNodeQuery(termNode);
     if (variableNode === null) {
         var constructors = localContext.getConstructors();
-        termUnifiedAgainstConstructors = constructors.some(function(constructor) {
-            var termUnifiedAgainstConstructor = unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead);
-            if (termUnifiedAgainstConstructor) {
+        termUnifiedWithConstructors = constructors.some(function(constructor) {
+            var termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
+            if (termUnifiedWithConstructor) {
                 return true;
             }
         });
     }
-    return termUnifiedAgainstConstructors;
+    return termUnifiedWithConstructors;
 }
-function unifyTermAgainstBracketedConstructor(termNode, terms, localContext, verifyAhead) {
-    var termUnifiedAgainstBracketedConstructor;
+function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
+    var termUnifiedWithBracketedConstructor;
     var termString = localContext.nodeAsString(termNode), bracketedTerms = [];
-    localContext.trace("Unifying the '".concat(termString, "' term against the bracketed constructor..."), termNode);
-    termUnifiedAgainstBracketedConstructor = unifyTermAgainstConstructor(termNode, bracketedTerms, _bracketed.default, localContext, function() {
+    localContext.trace("Unifying the '".concat(termString, "' term with the bracketed constructor..."), termNode);
+    termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, _bracketed.default, localContext, function() {
         var verifiedAhead;
         var bracketedTermNode = termNode; ///
         termNode = termNodeQuery(bracketedTermNode); ///
@@ -90,28 +90,28 @@ function unifyTermAgainstBracketedConstructor(termNode, terms, localContext, ver
         verifiedAhead = termVVerified; ///
         return verifiedAhead;
     });
-    if (termUnifiedAgainstBracketedConstructor) {
-        localContext.debug("...unified the '".concat(termString, "' term against the bracketed constructor."), termNode);
+    if (termUnifiedWithBracketedConstructor) {
+        localContext.debug("...unified the '".concat(termString, "' term with the bracketed constructor."), termNode);
     }
-    return termUnifiedAgainstBracketedConstructor;
+    return termUnifiedWithBracketedConstructor;
 }
-function unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-    var termUnifiedAgainstConstructor = false;
+function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
+    var termUnifiedWithConstructor = false;
     var termString = localContext.nodeAsString(termNode), constructorString = constructor.getString(), constructorTermNode = constructor.getTermNode();
-    localContext.trace("Unifying the '".concat(termString, "' term against the '").concat(constructorString, "' constructor..."), termNode);
-    var termNodeA = termNode, constructorTermNodeB = constructorTermNode, unified = _termAgainstConstructor.default.unify(termNodeA, constructorTermNodeB, localContext);
+    localContext.trace("Unifying the '".concat(termString, "' term with the '").concat(constructorString, "' constructor..."), termNode);
+    var termNodeA = termNode, constructorTermNodeB = constructorTermNode, unified = _termWithConstructor.default.unify(termNodeA, constructorTermNodeB, localContext);
     if (unified) {
         var verifiedAhead;
         var type = constructor.getType(), term = _term.default.fromTermNodeAndType(termNode, type);
         terms.push(term);
         verifiedAhead = verifyAhead();
         terms.pop();
-        termUnifiedAgainstConstructor = verifiedAhead; ///
+        termUnifiedWithConstructor = verifiedAhead; ///
     }
-    if (termUnifiedAgainstConstructor) {
-        localContext.debug("...unified the '".concat(termString, "' term against the '").concat(constructorString, "' constructor."), termNode);
+    if (termUnifiedWithConstructor) {
+        localContext.debug("...unified the '".concat(termString, "' term with the '").concat(constructorString, "' constructor."), termNode);
     }
-    return termUnifiedAgainstConstructor;
+    return termUnifiedWithConstructor;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\nimport Term from \"../term\";\nimport bracketedConstructor from \"../constructor/bracketed\";\nimport termAgainstConstructorUnifier from \"../unifier/termAgainstConstructor\";\n\nimport { nodeQuery } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/term/argument/term\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nfunction verifyTerm(termNode, terms, localContext, verifyAhead) {\n  let termVerified;\n\n  const termString = localContext.nodeAsString(termNode);\n\n  localContext.trace(`Verifying the '${termString}' term...`, termNode);\n\n  const verifyTermFunctions = [\n    verifyTermAsVariable,\n    unifyTermAgainstConstructors,\n    unifyTermAgainstBracketedConstructor\n  ];\n\n  termVerified = verifyTermFunctions.some((verifyTermFunction) => {\n    const termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);\n\n    if (termVerified) {\n      return true;\n    }\n  });\n\n  if (termVerified) {\n    localContext.debug(`...verified the '${termString}' term.`, termNode);\n  }\n\n  return termVerified;\n}\n\nObject.assign(shim, {\n  verifyTerm\n});\n\nexport default verifyTerm;\n\nfunction verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {\n  let termVerifiedAsVariable = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode !== null) {\n    const termString = localContext.nodeAsString(termNode);\n\n    localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);\n\n    const variable = localContext.findVariableByVariableNode(variableNode);\n\n    if (variable !== null) {\n      let verifiedAhead;\n\n      const type = variable.getType(),\n            term = Term.fromTermNodeAndType(termNode, type);\n\n      terms.push(term);\n\n      verifiedAhead = verifyAhead();\n\n      terms.pop();\n\n      termVerifiedAsVariable = verifiedAhead; ///\n    }\n\n    if (termVerifiedAsVariable) {\n      localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);\n    }\n  }\n\n  return termVerifiedAsVariable;\n}\n\nfunction unifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {\n  let termUnifiedAgainstConstructors = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode === null) {\n    const constructors = localContext.getConstructors();\n\n    termUnifiedAgainstConstructors = constructors.some((constructor) => {\n      const termUnifiedAgainstConstructor = unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead);\n\n      if (termUnifiedAgainstConstructor) {\n        return true;\n      }\n    });\n  }\n\n  return termUnifiedAgainstConstructors;\n}\n\nfunction unifyTermAgainstBracketedConstructor(termNode, terms, localContext, verifyAhead) {\n  let termUnifiedAgainstBracketedConstructor;\n\n  const termString = localContext.nodeAsString(termNode),\n        bracketedTerms = [];\n\n  localContext.trace(`Unifying the '${termString}' term against the bracketed constructor...`, termNode);\n\n  termUnifiedAgainstBracketedConstructor = unifyTermAgainstConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {\n    let verifiedAhead;\n\n    const bracketedTermNode = termNode; ///\n\n    termNode = termNodeQuery(bracketedTermNode); ///\n\n    const termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);\n\n    verifiedAhead = termVVerified;  ///\n\n    return verifiedAhead;\n  });\n\n  if (termUnifiedAgainstBracketedConstructor) {\n    localContext.debug(`...unified the '${termString}' term against the bracketed constructor.`, termNode);\n  }\n\n  return termUnifiedAgainstBracketedConstructor;\n}\n\nfunction unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {\n  let termUnifiedAgainstConstructor = false;\n\n  const termString = localContext.nodeAsString(termNode),\n        constructorString = constructor.getString(),\n        constructorTermNode = constructor.getTermNode();\n\n  localContext.trace(`Unifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);\n\n  const termNodeA = termNode,  ///\n        constructorTermNodeB = constructorTermNode,  ///\n        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);\n\n  if (unified) {\n    let verifiedAhead;\n\n    const type = constructor.getType(),\n          term = Term.fromTermNodeAndType(termNode, type);\n\n    terms.push(term);\n\n    verifiedAhead = verifyAhead();\n\n    terms.pop();\n\n    termUnifiedAgainstConstructor = verifiedAhead;  ///\n  }\n\n  if (termUnifiedAgainstConstructor) {\n    localContext.debug(`...unified the '${termString}' term against the '${constructorString}' constructor.`, termNode);\n  }\n\n  return termUnifiedAgainstConstructor;\n}\n\n"],"names":["termNodeQuery","nodeQuery","variableNodeQuery","verifyTerm","termNode","terms","localContext","verifyAhead","termVerified","termString","nodeAsString","trace","verifyTermFunctions","verifyTermAsVariable","unifyTermAgainstConstructors","unifyTermAgainstBracketedConstructor","some","verifyTermFunction","debug","Object","assign","shim","termVerifiedAsVariable","variableNode","variable","findVariableByVariableNode","verifiedAhead","type","getType","term","Term","fromTermNodeAndType","push","pop","termUnifiedAgainstConstructors","constructors","getConstructors","constructor","termUnifiedAgainstConstructor","unifyTermAgainstConstructor","termUnifiedAgainstBracketedConstructor","bracketedTerms","bracketedConstructor","bracketedTermNode","termVVerified","constructorString","getString","constructorTermNode","getTermNode","termNodeA","constructorTermNodeB","unified","termAgainstConstructorUnifier","unify"],"mappings":"AAAA;;;;+BA4CA;;;eAAA;;;2DA1CiB;2DACA;gEACgB;6EACS;qBAEhB;;;;;;AAE1B,IAAMA,gBAAgBC,IAAAA,gBAAS,EAAC,wBAC1BC,oBAAoBD,IAAAA,gBAAS,EAAC;AAEpC,SAASE,WAAWC,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAAEC,WAAW;IAC5D,IAAIC;IAEJ,IAAMC,aAAaH,aAAaI,YAAY,CAACN;IAE7CE,aAAaK,KAAK,CAAC,AAAC,kBAA4B,OAAXF,YAAW,cAAYL;IAE5D,IAAMQ,sBAAsB;QAC1BC;QACAC;QACAC;KACD;IAEDP,eAAeI,oBAAoBI,IAAI,CAAC,SAACC;QACvC,IAAMT,eAAeS,mBAAmBb,UAAUC,OAAOC,cAAcC;QAEvE,IAAIC,cAAc;YAChB,OAAO;QACT;IACF;IAEA,IAAIA,cAAc;QAChBF,aAAaY,KAAK,CAAC,AAAC,oBAA8B,OAAXT,YAAW,YAAUL;IAC9D;IAEA,OAAOI;AACT;AAEAW,OAAOC,MAAM,CAACC,aAAI,EAAE;IAClBlB,YAAAA;AACF;IAEA,WAAeA;AAEf,SAASU,qBAAqBT,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAAEC,WAAW;IACtE,IAAIe,yBAAyB;IAE7B,IAAMC,eAAerB,kBAAkBE;IAEvC,IAAImB,iBAAiB,MAAM;QACzB,IAAMd,aAAaH,aAAaI,YAAY,CAACN;QAE7CE,aAAaK,KAAK,CAAC,AAAC,kBAA4B,OAAXF,YAAW,4BAA0BL;QAE1E,IAAMoB,WAAWlB,aAAamB,0BAA0B,CAACF;QAEzD,IAAIC,aAAa,MAAM;YACrB,IAAIE;YAEJ,IAAMC,OAAOH,SAASI,OAAO,IACvBC,OAAOC,aAAI,CAACC,mBAAmB,CAAC3B,UAAUuB;YAEhDtB,MAAM2B,IAAI,CAACH;YAEXH,gBAAgBnB;YAEhBF,MAAM4B,GAAG;YAETX,yBAAyBI,eAAe,GAAG;QAC7C;QAEA,IAAIJ,wBAAwB;YAC1BhB,aAAaY,KAAK,CAAC,AAAC,oBAA8B,OAAXT,YAAW,0BAAwBL;QAC5E;IACF;IAEA,OAAOkB;AACT;AAEA,SAASR,6BAA6BV,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAAEC,WAAW;IAC9E,IAAI2B,iCAAiC;IAErC,IAAMX,eAAerB,kBAAkBE;IAEvC,IAAImB,iBAAiB,MAAM;QACzB,IAAMY,eAAe7B,aAAa8B,eAAe;QAEjDF,iCAAiCC,aAAanB,IAAI,CAAC,SAACqB;YAClD,IAAMC,gCAAgCC,4BAA4BnC,UAAUC,OAAOgC,aAAa/B,cAAcC;YAE9G,IAAI+B,+BAA+B;gBACjC,OAAO;YACT;QACF;IACF;IAEA,OAAOJ;AACT;AAEA,SAASnB,qCAAqCX,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAAEC,WAAW;IACtF,IAAIiC;IAEJ,IAAM/B,aAAaH,aAAaI,YAAY,CAACN,WACvCqC,iBAAiB,EAAE;IAEzBnC,aAAaK,KAAK,CAAC,AAAC,iBAA2B,OAAXF,YAAW,gDAA8CL;IAE7FoC,yCAAyCD,4BAA4BnC,UAAUqC,gBAAgBC,kBAAoB,EAAEpC,cAAc;QACjI,IAAIoB;QAEJ,IAAMiB,oBAAoBvC,UAAU,GAAG;QAEvCA,WAAWJ,cAAc2C,oBAAoB,GAAG;QAEhD,IAAMC,gBAAgBzC,WAAWC,UAAUC,OAAOC,cAAcC;QAEhEmB,gBAAgBkB,eAAgB,GAAG;QAEnC,OAAOlB;IACT;IAEA,IAAIc,wCAAwC;QAC1ClC,aAAaY,KAAK,CAAC,AAAC,mBAA6B,OAAXT,YAAW,8CAA4CL;IAC/F;IAEA,OAAOoC;AACT;AAEA,SAASD,4BAA4BnC,QAAQ,EAAEC,KAAK,EAAEgC,WAAW,EAAE/B,YAAY,EAAEC,WAAW;IAC1F,IAAI+B,gCAAgC;IAEpC,IAAM7B,aAAaH,aAAaI,YAAY,CAACN,WACvCyC,oBAAoBR,YAAYS,SAAS,IACzCC,sBAAsBV,YAAYW,WAAW;IAEnD1C,aAAaK,KAAK,CAAC,AAAC,iBAAiDkC,OAAjCpC,YAAW,wBAAwC,OAAlBoC,mBAAkB,qBAAmBzC;IAE1G,IAAM6C,YAAY7C,UACZ8C,uBAAuBH,qBACvBI,UAAUC,+BAA6B,CAACC,KAAK,CAACJ,WAAWC,sBAAsB5C;IAErF,IAAI6C,SAAS;QACX,IAAIzB;QAEJ,IAAMC,OAAOU,YAAYT,OAAO,IAC1BC,OAAOC,aAAI,CAACC,mBAAmB,CAAC3B,UAAUuB;QAEhDtB,MAAM2B,IAAI,CAACH;QAEXH,gBAAgBnB;QAEhBF,MAAM4B,GAAG;QAETK,gCAAgCZ,eAAgB,GAAG;IACrD;IAEA,IAAIY,+BAA+B;QACjChC,aAAaY,KAAK,CAAC,AAAC,mBAAmD2B,OAAjCpC,YAAW,wBAAwC,OAAlBoC,mBAAkB,mBAAiBzC;IAC5G;IAEA,OAAOkC;AACT"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\nimport Term from \"../term\";\nimport bracketedConstructor from \"../constructor/bracketed\";\nimport termWithConstructorUnifier from \"../unifier/termWithConstructor\";\n\nimport { nodeQuery } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/term/argument/term\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nfunction verifyTerm(termNode, terms, localContext, verifyAhead) {\n  let termVerified;\n\n  const termString = localContext.nodeAsString(termNode);\n\n  localContext.trace(`Verifying the '${termString}' term...`, termNode);\n\n  const verifyTermFunctions = [\n    verifyTermAsVariable,\n    unifyTermWithConstructors,\n    unifyTermWithBracketedConstructor\n  ];\n\n  termVerified = verifyTermFunctions.some((verifyTermFunction) => {\n    const termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);\n\n    if (termVerified) {\n      return true;\n    }\n  });\n\n  if (termVerified) {\n    localContext.debug(`...verified the '${termString}' term.`, termNode);\n  }\n\n  return termVerified;\n}\n\nObject.assign(shim, {\n  verifyTerm\n});\n\nexport default verifyTerm;\n\nfunction verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {\n  let termVerifiedAsVariable = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode !== null) {\n    const termString = localContext.nodeAsString(termNode);\n\n    localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);\n\n    const variable = localContext.findVariableByVariableNode(variableNode);\n\n    if (variable !== null) {\n      let verifiedAhead;\n\n      const type = variable.getType(),\n            term = Term.fromTermNodeAndType(termNode, type);\n\n      terms.push(term);\n\n      verifiedAhead = verifyAhead();\n\n      terms.pop();\n\n      termVerifiedAsVariable = verifiedAhead; ///\n    }\n\n    if (termVerifiedAsVariable) {\n      localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);\n    }\n  }\n\n  return termVerifiedAsVariable;\n}\n\nfunction unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {\n  let termUnifiedWithConstructors = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode === null) {\n    const constructors = localContext.getConstructors();\n\n    termUnifiedWithConstructors = constructors.some((constructor) => {\n      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);\n\n      if (termUnifiedWithConstructor) {\n        return true;\n      }\n    });\n  }\n\n  return termUnifiedWithConstructors;\n}\n\nfunction unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {\n  let termUnifiedWithBracketedConstructor;\n\n  const termString = localContext.nodeAsString(termNode),\n        bracketedTerms = [];\n\n  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);\n\n  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {\n    let verifiedAhead;\n\n    const bracketedTermNode = termNode; ///\n\n    termNode = termNodeQuery(bracketedTermNode); ///\n\n    const termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);\n\n    verifiedAhead = termVVerified;  ///\n\n    return verifiedAhead;\n  });\n\n  if (termUnifiedWithBracketedConstructor) {\n    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);\n  }\n\n  return termUnifiedWithBracketedConstructor;\n}\n\nfunction unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {\n  let termUnifiedWithConstructor = false;\n\n  const termString = localContext.nodeAsString(termNode),\n        constructorString = constructor.getString(),\n        constructorTermNode = constructor.getTermNode();\n\n  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);\n\n  const termNodeA = termNode,  ///\n        constructorTermNodeB = constructorTermNode,  ///\n        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);\n\n  if (unified) {\n    let verifiedAhead;\n\n    const type = constructor.getType(),\n          term = Term.fromTermNodeAndType(termNode, type);\n\n    terms.push(term);\n\n    verifiedAhead = verifyAhead();\n\n    terms.pop();\n\n    termUnifiedWithConstructor = verifiedAhead;  ///\n  }\n\n  if (termUnifiedWithConstructor) {\n    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);\n  }\n\n  return termUnifiedWithConstructor;\n}\n\n"],"names":["termNodeQuery","nodeQuery","variableNodeQuery","verifyTerm","termNode","terms","localContext","verifyAhead","termVerified","termString","nodeAsString","trace","verifyTermFunctions","verifyTermAsVariable","unifyTermWithConstructors","unifyTermWithBracketedConstructor","some","verifyTermFunction","debug","Object","assign","shim","termVerifiedAsVariable","variableNode","variable","findVariableByVariableNode","verifiedAhead","type","getType","term","Term","fromTermNodeAndType","push","pop","termUnifiedWithConstructors","constructors","getConstructors","constructor","termUnifiedWithConstructor","unifyTermWithConstructor","termUnifiedWithBracketedConstructor","bracketedTerms","bracketedConstructor","bracketedTermNode","termVVerified","constructorString","getString","constructorTermNode","getTermNode","termNodeA","constructorTermNodeB","unified","termWithConstructorUnifier","unify"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.959",
+  "version": "0.0.960",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/context/file.js

@@ -620,6 +620,45 @@ export default class FileContext {
 
   fatal(message, node) { this.releaseContext.fatal(message, node, this.tokens, this.filePath); }
 
+  reset() {
+    this.types = [];
+    this.rules = [];
+    this.axioms = [];
+    this.lemmas = [];
+    this.theorems = [];
+    this.variables = [];
+    this.metaLemmas = [];
+    this.conjectures = [];
+    this.combinators = [];
+    this.constructors = [];
+    this.metatheorems = [];
+    this.metavariables = [];
+  }
+
+  verify() {
+    let verified = false;
+
+    if (this.tokens === null) {
+      const lexer = this.getLexer(),
+            parser = this.getParser(),
+            content = this.fileContent; ///
+
+      this.tokens = lexer.tokenise(content);
+
+      this.node = parser.parse(this.tokens);
+    }
+
+    if (this.node !== null) {
+      this.reset();
+
+      const fileContext = this; ///
+
+      verified = topLevelVerifier.verify(this.node, fileContext);
+    }
+
+    return verified;
+  }
+
   toJSON() {
     const filePath =  this.filePath,
           fileContent = this.fileContent,
@@ -631,23 +670,9 @@ export default class FileContext {
     return json;
   }
 
-  verify() {
-    const lexer = this.getLexer(),
-          parser = this.getParser(),
-          content = this.fileContent,  ///
-          fileContext = this;
-
-    this.tokens = lexer.tokenise(content);
-
-    this.node = parser.parse(this.tokens);
-
-    const verified = topLevelVerifier.verify(this.node, fileContext);
-
-    return verified;
-  }
-
-  static fromJSONAndReleaseContext(json, releaseContext) {
-    const { fileContent, filePath } = json,
+  static fromFileAndReleaseContext(file, releaseContext) {
+    const fileContent = file.getContent(),
+          filePath = file.getPath(),
           tokens = null,
           node = null,
           types = [],

package/src/context/release.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { filePathUtilities } from "occam-entities";
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
 import FileContext from "./file";
@@ -8,18 +9,20 @@ import { objectType } from "../type";
 import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
-const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
+const { isFilePathFlorenceFilePath } = filePathUtilities,
+      { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, json, name, lexer, parser, entries, verified, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
+  constructor(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
     this.log = log;
-    this.json = json;
     this.name = name;
+    this.entries = entries;
+    this.released = released;
     this.lexer = lexer;
     this.parser = parser;
-    this.entries = entries;
     this.verified = verified;
+    this.initialised = initialised;
     this.fileContexts = fileContexts;
     this.customGrammar = customGrammar;
     this.loggingDisabled = loggingDisabled;
@@ -30,14 +33,18 @@ export default class ReleaseContext {
     return log;
   }
 
-  getJSON() {
-    return this.json;
-  }
-
   getName() {
     return this.name;
   }
 
+  getEntries() {
+    return this.entries;
+  }
+
+  isReleased() {
+    return this.released;
+  }
+
   getLexer() {
     return this.lexer;
   }
@@ -46,14 +53,14 @@ export default class ReleaseContext {
     return this.parser;
   }
 
-  getEntries() {
-    return this.entries;
-  }
-
   isVerified() {
     return this.verified;
   }
 
+  isInitialised() {
+    return this.initialised;
+  }
+
   getFileContexts() {
     return this.fileContexts;
   }
@@ -74,14 +81,18 @@ export default class ReleaseContext {
     this.log = log;
   }
 
-  setJSON(json) {
-    this.json = json;
-  }
-
   setName(name) {
     this.name = name;
   }
 
+  setEntries(entries) {
+    this.entries = entries;
+  }
+
+  setReleased(released) {
+    this.released = released;
+  }
+
   setLexer(lexer) {
     this.lexer = lexer;
   }
@@ -90,14 +101,14 @@ export default class ReleaseContext {
     this.parser = parser;
   }
 
-  setEntries(entries) {
-    this.entries = entries;
-  }
-
   setVerified(verified) {
     this.verified = verified;
   }
 
+  setInitialised(initialised) {
+    return this.initialised = initialised;
+  }
+
   setFileContexts(fileContexts) {
     this.fileContexts = fileContexts;
   }
@@ -376,12 +387,6 @@ export default class ReleaseContext {
     return type;
   }
 
-  isReleased() {
-    const released = (this.json !== null);
-
-    return released;
-  }
-
   getReleaseName() {
     const name = this.getName(),
           releaseName = name; ///
@@ -459,7 +464,9 @@ export default class ReleaseContext {
     this.log.fatal(message, node, tokens, filePath);
   }
 
-  verify(releaseContexts) {
+  initialise(releaseContexts) {
+    let initialised;
+
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
           florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar),
           florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
@@ -468,21 +475,39 @@ export default class ReleaseContext {
 
     this.parser = florenceParser; ///
 
-    this.dependencyReleaseContexts = tail(releaseContexts)
+    this.dependencyReleaseContexts = tail(releaseContexts);
 
-    if (this.json !== null) {
-      const releaseContext = this;
+    if (this.released) {
+      const verified = this.verify();
 
-      releaseContext.disableLogging();
+      initialised = verified;  ///
+    } else {
+      initialised = true;
+    }
 
-      this.fileContexts = fileContextsFromJSON(this.json, releaseContext);
+    this.initialised = initialised;
 
-      verifyFileContexts(this.fileContexts, releaseContext);
+    return initialised;
+  }
 
-      releaseContext.enableLogging();
+  verify() {
+    let verified;
 
-      this.verified = true;
-    }
+    const releaseContext = this;
+
+    releaseContext.disableLogging();
+
+    this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);
+
+    const fileContextsVerified = verifyFileContexts(this.fileContexts, releaseContext);
+
+    verified = fileContextsVerified;  ///
+
+    releaseContext.enableLogging();
+
+    this.verified = verified;
+
+    return verified;
   }
 
   toJSON() {
@@ -496,21 +521,24 @@ export default class ReleaseContext {
     return json;
   }
 
-  static fromLogJSONNameAndEntries(log, json, name, entries) {
+  static fromLogNameEntriesAndReleased(log, name, entries, released) {
     const lexer = null,
           parser = null,
           verified = false,
+          initialised = false,
           fileContexts = [],
           customGrammar = customGrammarFromNameAndEntries(name, entries),
           loggingDisabled = false,
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, json, name, lexer, parser, entries, verified, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
 
     return releaseContext;
   }
 }
 
 function verifyFileContexts(fileContexts, releaseContext) {
+  let fileContextsVerified;
+
   fileContexts = [  ///
     ...fileContexts
   ];
@@ -543,16 +571,27 @@ function verifyFileContexts(fileContexts, releaseContext) {
 
     leftDifference(fileContexts, verifiedFileContexts);
   }
+
+  const fileContextsLength = fileContexts.length;
+
+  fileContextsVerified = (fileContextsLength === 0);
+
+  return fileContextsVerified;
 }
 
-function fileContextsFromJSON(json, releaseContext) {
-  const fileContextsJSON = json, ///
-        fileContexts = fileContextsJSON.map((fileContextJSON) => {
-          const json = fileContextJSON, ///
-                fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
+function fileContextsFromEntries(entries, releaseContext) {
+  const fileContexts = [];
 
-          return fileContext;
-        });
+  entries.forEachFile((file) => {
+    const filePath = file.getPath(),
+          filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+
+    if (filePathFlorenceFilePath) {
+      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);
+
+      fileContexts.push(fileContext);
+    }
+  });
 
   return fileContexts;
 }

package/src/frame.js

@@ -38,9 +38,9 @@ export default class Frame {
 
   unifySubstitution(substitution) {
     const substitutionUnified = this.declarations.some((declaration) => {
-      const substitutionUnifiedAgainstDeclaration = declaration.unifySubstitution(substitution);
+      const substitutionUnifiedWithDeclaration = declaration.unifySubstitution(substitution);
 
-      if (substitutionUnifiedAgainstDeclaration) {
+      if (substitutionUnifiedWithDeclaration) {
         return true;
       }
     });

package/src/index.js

@@ -4,6 +4,6 @@ export { default as Log } from "./log";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
 export { default as createReleaseContext } from "./releaseContext/create";
-export { default as verifyReleaseContext } from "./releaseContext/verify";
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
+export { default as initialiseReleaseContext } from "./releaseContext/initialise";
 

package/src/metavariable.js

@@ -63,9 +63,9 @@ export default class Metavariable {
         } else if ((termNode === null) && (this.termType === null)) {
           matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
-          const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, this.termType, localContext);
+          const termUnifiedWithTermType = unifyTermWithTermType(termNode, this.termType, localContext);
 
-          matchesNode = termUnifiedAgainstTermType;  ///
+          matchesNode = termUnifiedWithTermType;  ///
         }
       }
     }
@@ -90,8 +90,8 @@ export default class Metavariable {
   }
 }
 
-export function unifyTermAgainstTermType(termNode, termType, localContext) {
-  let termUnifiedAgainstTermType;
+export function unifyTermWithTermType(termNode, termType, localContext) {
+  let termUnifiedWithTermType;
 
   const type = termType,  ///
         terms = [],
@@ -110,9 +110,9 @@ export function unifyTermAgainstTermType(termNode, termType, localContext) {
           return verifiedAhead;
         });
 
-  termUnifiedAgainstTermType = termVerified;  ///
+  termUnifiedWithTermType = termVerified;  ///
 
-  return termUnifiedAgainstTermType;
+  return termUnifiedWithTermType;
 }
 
 function termTypeFromMetavariableNode(metavariableNode, fileContext) {

package/src/proofStep.js

@@ -21,23 +21,23 @@ export default class ProofStep {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
-      let statementUnifiedAgainstStatement = false;
+      let statementUnifiedWithStatement = false;
 
-      if (!statementUnifiedAgainstStatement) {
+      if (!statementUnifiedWithStatement) {
         const statementNodeA = statementNode, ///
               statementNodeB = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
-      if (!statementUnifiedAgainstStatement) {
+      if (!statementUnifiedWithStatement) {
         const statementNodeA = statementNode, ///
               statementNodeB = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
-      statementUnified = statementUnifiedAgainstStatement;  ///
+      statementUnified = statementUnifiedWithStatement;  ///
     }
 
     return statementUnified;
@@ -58,13 +58,13 @@ export default class ProofStep {
   }
 }
 
-function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
-  let statementUnifiedAgainstStatement = false;
+function unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
+  let statementUnifiedWithStatement = false;
 
   const statementStringA = localContextA.nodeAsString(statementNodeA),
         statementStringB = localContextB.nodeAsString(statementNodeB);
 
-  localContextB.trace(`Unifying the '${statementStringB}' statement against the '${statementStringA}' statement...`, statementNodeB);
+  localContextB.trace(`Unifying the '${statementStringB}' statement with the '${statementStringA}' statement...`, statementNodeB);
 
   const substitutions = Substitutions.fromNothing(),
         nodeA = statementNodeA,  ///
@@ -72,14 +72,14 @@ function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivale
         unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
   if (unified) {
-    const substitutionsUnifiedAgainstEquivalences = substitutions.unifyAgainstEquivalences(equivalences, localContextA, localContextB);
+    const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
 
-    statementUnifiedAgainstStatement = substitutionsUnifiedAgainstEquivalences;  ///
+    statementUnifiedWithStatement = substitutionsUnifiedWithEquivalences;  ///
   }
 
-  if (statementUnifiedAgainstStatement) {
-    localContextB.debug(`...unified the '${statementStringB}' statement against the '${statementStringA}' statement.`, statementNodeB);
+  if (statementUnifiedWithStatement) {
+    localContextB.debug(`...unified the '${statementStringB}' statement with the '${statementStringA}' statement.`, statementNodeB);
   }
 
-  return statementUnifiedAgainstStatement;
+  return statementUnifiedWithStatement;
 }

package/src/releaseContext/create.js

@@ -12,11 +12,9 @@ export default function createReleaseContext(dependency, dependentNames, context
   log.debug(`Creating the '${releaseName}' context given the '${dependencyString}' dependency...`);
 
   if (releaseContext !== null) {
-    const error = null,
-          version = releaseContext.getVersion(),
-          versionString = version.toString();
+    const error = null;
 
-    log.debug(`...already created the '${releaseName}:${versionString}' context.`);
+    log.debug(`...already created the '${releaseName}' context.`);
 
     callback(error);
 
@@ -52,20 +50,17 @@ export default function createReleaseContext(dependency, dependentNames, context
       return;
     }
 
-    const version = releaseContext.getVersion(),
-          versionString = version.toString();
-
     releaseContextMap[releaseName] = releaseContext;
 
-    createDependencyReleaseContexts(dependency, dependentNames, context, (error) => {
+    log.info(`...created the '${releaseName}' context.`);
+
+    createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context, (error) => {
       if (error) {
         callback(error);
 
         return;
       }
 
-      log.info(`...created the '${releaseName}@${versionString}' context.`);
-
       callback(error);
     });
   }, context);
@@ -122,7 +117,7 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
             versionString = version.toString(),
             dependencyString = dependency.asString();
 
-      log.error(`Version mismatch: '${dependentName}' requires the '${dependencyString}' dependency but a context with version '${versionString}' was created.`);
+      log.warning(`Version mismatch: The '${dependentName}' dependent requires the '${dependencyString}' dependency but a context with version '${versionString}' was provided.`);
 
       releaseMatchesDependency = false;
     }
@@ -131,11 +126,8 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
   return releaseMatchesDependency;
 }
 
-function createDependencyReleaseContexts(dependency, dependentNames, context, callback) {
-  const { releaseContextMap } = context,
-        dependencyName = dependency.getName(),
-        releaseName = dependencyName, ///
-        releaseContext = releaseContextMap[releaseName],
+function createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context, callback) {
+  const dependencyName = dependency.getName(),
         dependencies = releaseContext.getDependencies();
 
   dependentNames = [ ...dependentNames, dependencyName ];  ///