occam-verify-cli 1.0.220 → 1.0.224

package/src/context/release.js

@@ -447,20 +447,20 @@ export default class ReleaseContext {
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
     const verifiedFileContexts = [],
-          fileContextsVerified = verifyFileContexts(this.fileContexts, verifiedFileContexts);
+          fileContextsVerify = verifyFileContexts(this.fileContexts, verifiedFileContexts);
 
-    if (fileContextsVerified) {
+    if (fileContextsVerify) {
       this.fileContexts = verifiedFileContexts; ///
 
       this.verified = true;
 
-      verified = true;
+      verifies = true;
     }
 
-    return verified;
+    return verifies;
   }
 
   toJSON() {
@@ -477,12 +477,12 @@ export default class ReleaseContext {
   static fromLogNameJSONAndEntries(log, name, json, entries) {
     const lexer = null,
           parser = null,
-          verified = false,
+          verifies = false,
           initialised = false,
           fileContexts = [],
           customGrammar = customGrammarFromNameAndEntries(name, entries),
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verifies, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
 
     return releaseContext;
   }
@@ -490,15 +490,15 @@ export default class ReleaseContext {
 
 function verifyFileContexts(fileContexts, verifiedFileContexts) {
   const resolved = resolve(fileContexts, verifiedFileContexts, (fileContext) => {
-          const fileContextVerified = fileContext.verify();
+          const fileContextVerifies = fileContext.verify();
 
-          if (fileContextVerified) {
+          if (fileContextVerifies) {
             return true;
           }
         }),
-        fileContextsVerified = resolved;  ///
+        fileContextsVerify = resolved;  ///
 
-  return fileContextsVerified;
+  return fileContextsVerify;
 }
 
 function fileContextsFromJSON(json,fileContexts, releaseContext) {

package/src/dom/assertion/contained.js

@@ -46,40 +46,40 @@ export default domAssigned(class ContainedAssertion {
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const containedAssertionString = this.string; ///
 
     context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
-    const termVerified = this.verifyTerm(assignments, stated, context),
-          frameVerified = this.verifyFrame(assignments, stated, context),
-          statementVerified = this.verifyStatement(assignments, stated, context)
+    const termVerifies = this.verifyTerm(assignments, stated, context),
+          frameVerifies = this.verifyFrame(assignments, stated, context),
+          statementVerifies = this.verifyStatement(assignments, stated, context)
 
-    if (termVerified || frameVerified || statementVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+    if (termVerifies || frameVerifies || statementVerifies) {
+      let verifiesWhenStated = false,
+          verifiesWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, context);
+        verifiesWhenStated = this.verifyWhenStated(assignments, context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(context);
+        verifiesWhenDerived = this.verifyWhenDerived(context);
       }
 
-      if (verifiedWhenStated || verifiedWhenDerived) {
-        verified = true;
+      if (verifiesWhenStated || verifiesWhenDerived) {
+        verifies = true;
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${containedAssertionString}' contained assertion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyTerm(assignments, stated, context) {
-    let termVerified = false;
+    let termVerifies = false;
 
     if (this.term !== null) {
       const termString = this.term.getString();
@@ -91,23 +91,23 @@ export default domAssigned(class ContainedAssertion {
       if (!termSimple) {
         context.debug(`The '${termString}' term is not simple.`);
       } else {
-        termVerified = this.term.verify(context, () => {
-          const verifiedAhead = true;
+        termVerifies = this.term.verify(context, () => {
+          const verifiesAhead = true;
 
-          return verifiedAhead;
+          return verifiesAhead;
         });
 
-        if (termVerified) {
+        if (termVerifies) {
           context.debug(`...verified the '${termString}' term.`);
         }
       }
     }
 
-    return termVerified;
+    return termVerifies;
   }
 
   verifyFrame(assignments, stated, context) {
-    let frameVerified = false;
+    let frameVerifies = false;
 
     if (this.frame !== null) {
       const frameString = this.frame.getString();
@@ -123,19 +123,19 @@ export default domAssigned(class ContainedAssertion {
 
         assignments = null; ///
 
-        frameVerified = this.frame.verify(assignments, stated, context);
+        frameVerifies = this.frame.verify(assignments, stated, context);
 
-        if (frameVerified) {
+        if (frameVerifies) {
           context.debug(`...verified the '${frameString}' frame.`);
         }
       }
     }
 
-    return frameVerified;
+    return frameVerifies;
   }
 
   verifyStatement(assignments, stated, context) {
-    let statementVerified = false;
+    let statementVerifies = false;
 
     if (this.statement !== null) {
       const statementString = this.statement.getString();
@@ -146,50 +146,50 @@ export default domAssigned(class ContainedAssertion {
 
       assignments = null; ///
 
-      statementVerified = this.statement.verify(assignments, stated, context);
+      statementVerifies = this.statement.verify(assignments, stated, context);
 
-      if (statementVerified) {
+      if (statementVerifies) {
         context.debug(`...verified the '${statementString}' statement.`);
       }
     }
 
-    return statementVerified;
+    return statementVerifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated;
+    let verifiesWhenStated;
 
     const containedAssertionString = this.string; ///
 
     context.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);
 
-    verifiedWhenStated = true;
+    verifiesWhenStated = true;
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const containedAssertionString = this.string; ///
 
     context.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
 
-    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, context);
+    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, context);
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiedIndependently;
+    let unifiesIndependently;
 
     const containedAssertionString = this.string; ///
 
@@ -202,15 +202,15 @@ export default domAssigned(class ContainedAssertion {
     const term = termFromTermAndSubstitutions(this.term, substitutions, context),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),
           statement = statementFromStatementAndSubstitutions(this.statement, substitutions, context),
-          verifiedWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, context);
+          verifiesWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, context);
 
-    unifiedIndependently = verifiedWhenDerived; ///
+    unifiesIndependently = verifiesWhenDerived; ///
 
-    if (unifiedIndependently) {
+    if (unifiesIndependently) {
       context.debug(`...unified the '${containedAssertionString}' contained assertion independently.`);
     }
 
-    return unifiedIndependently;
+    return unifiesIndependently;
   }
 
   static name = "ContainedAssertion";
@@ -238,18 +238,18 @@ export default domAssigned(class ContainedAssertion {
 });
 
 function verifyWhenDerived(term, frame, statement, negated, context) {
-  let verifiedWhenDerived = false;
+  let verifiesWhenDerived = false;
 
   if (statement !== null) {
     if (term !== null) {
       const termContained = statement.isTermContained(term, context);
 
       if (!negated && termContained) {
-        verifiedWhenDerived = true;
+        verifiesWhenDerived = true;
       }
 
       if (negated && !termContained) {
-        verifiedWhenDerived = true;
+        verifiesWhenDerived = true;
       }
     }
 
@@ -257,14 +257,14 @@ function verifyWhenDerived(term, frame, statement, negated, context) {
       const frameContained = statement.isFrameContained(frame, context);
 
       if (!negated && frameContained) {
-        verifiedWhenDerived = true;
+        verifiesWhenDerived = true;
       }
 
       if (negated && !frameContained) {
-        verifiedWhenDerived = true;
+        verifiesWhenDerived = true;
       }
     }
   }
 
-  return verifiedWhenDerived;
+  return verifiesWhenDerived;
 }

package/src/dom/assertion/defined.js

@@ -41,39 +41,39 @@ export default domAssigned(class DefinedAssertion {
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const definedAssertionString = this.string; ///
 
     context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
 
-    const termVerified = this.verifyTerm(assignments, stated, context),
-          frameVerified = this.verifyFrame(assignments, stated, context);
+    const termVerifies = this.verifyTerm(assignments, stated, context),
+          frameVerifies = this.verifyFrame(assignments, stated, context);
 
-    if (termVerified || frameVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+    if (termVerifies || frameVerifies) {
+      let verifiesWhenStated = false,
+          verifiesWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, context);
+        verifiesWhenStated = this.verifyWhenStated(assignments, context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(context);
+        verifiesWhenDerived = this.verifyWhenDerived(context);
       }
 
-      if (verifiedWhenStated || verifiedWhenDerived) {
-        verified = true;
+      if (verifiesWhenStated || verifiesWhenDerived) {
+        verifies = true;
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${definedAssertionString}' defined assertion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyTerm(assignments, stated, context) {
-    let termVerified = false;
+    let termVerifies = false;
 
     if (this.term !== null) {
       const termString = this.term.getString(); ///
@@ -85,23 +85,23 @@ export default domAssigned(class DefinedAssertion {
       if (!termSimple) {
         context.debug(`The '${termString}' term is not simple.`);
       } else {
-        termVerified = this.term.verify(context, () => {
-          const verifiedAhead = true;
+        termVerifies = this.term.verify(context, () => {
+          const verifiesAhead = true;
 
-          return verifiedAhead;
+          return verifiesAhead;
         });
 
-        if (termVerified) {
+        if (termVerifies) {
           context.debug(`...verified the '${termString}' term.`);
         }
       }
     }
 
-    return termVerified;
+    return termVerifies;
   }
 
   verifyFrame(assignments, stated, context) {
-    let frameVerified = false;
+    let frameVerifies = false;
 
     if (this.frame !== null) {
       const frameString = this.frame.getString(); ///
@@ -117,51 +117,51 @@ export default domAssigned(class DefinedAssertion {
 
         assignments = null; ///
 
-        frameVerified = this.frame.verify(assignments, stated, context);
+        frameVerifies = this.frame.verify(assignments, stated, context);
 
-        if (frameVerified) {
+        if (frameVerifies) {
           context.debug(`...verified the '${frameString}' frame.`);
         }
       }
     }
 
-    return frameVerified;
+    return frameVerifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated;
+    let verifiesWhenStated;
 
     const definedAssertionString = this.string; ///
 
     context.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);
 
-    verifiedWhenStated = true;
+    verifiesWhenStated = true;
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const definedAssertionString = this.string; ///
 
     context.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
 
-    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, context);
+    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, context);
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiedIndependently;
+    let unifiesIndependently;
 
     const definedAssertionString = this.string; ///
 
@@ -173,15 +173,15 @@ export default domAssigned(class DefinedAssertion {
 
     const term = termFromTermAndSubstitutions(this.term, substitutions, context),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),
-          verifiedWhenDerived = verifyWhenDerived(term, frame, this.negated, context);
+          verifiesWhenDerived = verifyWhenDerived(term, frame, this.negated, context);
 
-    unifiedIndependently = verifiedWhenDerived; ///
+    unifiesIndependently = verifiesWhenDerived; ///
 
-    if (unifiedIndependently) {
+    if (unifiesIndependently) {
       context.debug(`...unified the '${definedAssertionString}' defined assertion independently.`);
     }
 
-    return unifiedIndependently;
+    return unifiesIndependently;
   }
 
   static name = "DefinedAssertion";
@@ -208,7 +208,7 @@ export default domAssigned(class DefinedAssertion {
 });
 
 function verifyWhenDerived(term, frame, negated, context) {
-  let verifiedWhenDerived = false;
+  let verifiesWhenDerived = false;
 
   if (term !== null) {
     const { Variable } = dom,
@@ -218,11 +218,11 @@ function verifyWhenDerived(term, frame, negated, context) {
           variableDefined = generalContext.isVariableDefined(variable);
 
     if (!negated && variableDefined) {
-      verifiedWhenDerived = true;
+      verifiesWhenDerived = true;
     }
 
     if (negated && !variableDefined) {
-      verifiedWhenDerived = true;
+      verifiesWhenDerived = true;
     }
   }
 
@@ -233,13 +233,13 @@ function verifyWhenDerived(term, frame, negated, context) {
           metavariableDefined = context.isMetavariableDefined(metavariable);
 
     if (!negated && metavariableDefined) {
-      verifiedWhenDerived = true;
+      verifiesWhenDerived = true;
     }
 
     if (negated && !metavariableDefined) {
-      verifiedWhenDerived = true;
+      verifiesWhenDerived = true;
     }
   }
 
-  return verifiedWhenDerived;
+  return verifiesWhenDerived;
 }

package/src/dom/assertion/property.js

@@ -36,7 +36,7 @@ export default domAssigned(class PropertyAssertion {
   }
 
   matchTermAndPropertyRelation(term, propertyRelation, context) {
-    let verifiedAsPropertyAssertion = false;
+    let verifiesAsPropertyAssertion = false;
 
     const termString = term.getString(),
           propertyRelationString = propertyRelation.getString(),
@@ -51,121 +51,123 @@ export default domAssigned(class PropertyAssertion {
     if (termAEqualToTermB) {
       const propertyRelationEqualToPropertyRelation = this.propertyRelation.isEqualTo(propertyRelation);
 
-      verifiedAsPropertyAssertion = propertyRelationEqualToPropertyRelation;  ///
+      verifiesAsPropertyAssertion = propertyRelationEqualToPropertyRelation;  ///
     }
 
-    if (verifiedAsPropertyAssertion) {
+    if (verifiesAsPropertyAssertion) {
       context.debug(`...matched the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion.`);
     }
 
-    return verifiedAsPropertyAssertion;
+    return verifiesAsPropertyAssertion;
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const propertyAssertionString = this.string; ///
 
     context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);
 
-    const termVerified = this.verifyTerm(assignments, stated, context);
+    const termVerifies = this.verifyTerm(assignments, stated, context);
 
-    if (termVerified) {
-      const propertyRelationVerified = this.verifyPropertyRelation(assignments, stated, context);
+    if (termVerifies) {
+      const propertyRelationVerifies = this.verifyPropertyRelation(assignments, stated, context);
 
-      if (propertyRelationVerified) {
-        let verifiedWhenStated = false,
-            verifiedWhenDerived = false;
+      if (propertyRelationVerifies) {
+        let verifiesWhenStated = false,
+            verifiesWhenDerived = false;
 
         if (stated) {
-          verifiedWhenStated = this.verifyWhenStated(assignments, context);
+          verifiesWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(context);
+          verifiesWhenDerived = this.verifyWhenDerived(context);
         }
 
-        verified = verifiedWhenStated || verifiedWhenDerived;
+        if (verifiesWhenStated || verifiesWhenDerived) {
+          verifies = true;
+        }
       }
     }
 
-    if (verified) {
+    if (verifies) {
       if (stated) {
         this.assign(assignments, context);
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${propertyAssertionString}' property assertion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyTerm(assignments, stated, context) {
-    let termVerified;
+    let termVerifies;
 
     const termString = this.term.getString();
 
     context.trace(`Verifying the '${termString}' term...`);
 
-    termVerified = this.term.verify(context, () => {
-      const verifiedAhead = true;
+    termVerifies = this.term.verify(context, () => {
+      const verifiesAhead = true;
 
-      return verifiedAhead;
+      return verifiesAhead;
     });
 
-    if (termVerified) {
+    if (termVerifies) {
       context.debug(`...verified the '${termString}' term.`);
     }
 
-    return termVerified;
+    return termVerifies;
   }
 
   verifyPropertyRelation(assignments, stated, context) {
-    let propertyRelationVerified;
+    let propertyRelationVerifies;
 
     const propertyRelationString = this.propertyRelation.getString();
 
     context.trace(`Verifying the '${propertyRelationString}' property relation...`);
 
-    propertyRelationVerified = this.propertyRelation.verify(context);
+    propertyRelationVerifies = this.propertyRelation.verify(context);
 
-    if (propertyRelationVerified) {
+    if (propertyRelationVerifies) {
       context.debug(`...verified the '${propertyRelationString}' property relation.`);
     }
 
-    return propertyRelationVerified;
+    return propertyRelationVerifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated;
+    let verifiesWhenStated;
 
     const propertyAssertionString = this.string; ///
 
     context.trace(`Verifying the '${propertyAssertionString}' stated property assertion...`);
 
-    verifiedWhenStated = true;
+    verifiesWhenStated = true;
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${propertyAssertionString}' stated property assertion.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const propertyAssertionString = this.string; ///
 
     context.trace(`Verifying the '${propertyAssertionString}' derived property assertion...`);
 
-    verifiedWhenDerived = true;
+    verifiesWhenDerived = true;
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${propertyAssertionString}' derived property assertion.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   assign(assignments, context) {