occam-verify-cli 0.0.450 → 0.0.451

package/src/verify/lemma.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import Lemma from "../lemma";
+import verifyLabels from "../verify/labels";
+import ProofContext from "../context/proof";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyIndicativeConditional from "../verify/indicativeConditional";
+
+import { front, last } from "../utilities/array";
+import { nodesAsString } from "../utilities/string";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const labelNodesQuery = nodesQuery("/lemma/label"),
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      statementNodesQuery = nodesQuery("/indicativeConditional/unqualifiedStatement/statement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/lemma/unqualifiedStatement!"),
+      indicativeConditionalNodeQuery = nodeQuery("/lemma/indicativeConditional!");
+
+export default function verifyLemma(lemmaNode, fileContext) {
+  let lemmaVerified = false;
+
+  fileContext.begin(lemmaNode);
+
+  const labelNodes = labelNodesQuery(lemmaNode),
+        labelsString = nodesAsString(labelNodes),
+        proofContext = ProofContext.fromFileContext(fileContext);
+
+  (labelsString === null) ?
+    fileContext.debug(`Verifying an anonymous lemma...`) :
+      fileContext.debug(`Verifying the '${labelsString}' lemma...`);
+
+  const labels = [],
+        labelsLength = labels.length,
+        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+
+  if (labelsVerified) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(lemmaNode),
+          indicativeConditionalNode = indicativeConditionalNodeQuery(lemmaNode);
+
+    if (unqualifiedStatementNode !== null) {
+      const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+      if (unqualifiedStatementVerified) {
+        if (labelsLength > 0) {
+          const statementNode = statementNodeQuery(unqualifiedStatementNode),
+                lemma = Lemma.fromLabelsAndStatementNode(labels, statementNode);
+
+          fileContext.addLemma(lemma);
+        }
+
+        lemmaVerified = true;
+      }
+    }
+
+    if (indicativeConditionalNode !== null) {
+      const indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+
+      if (indicativeConditionalVerified !== null) {
+        if (labelsLength) {
+          const statementNodes = statementNodesQuery(indicativeConditionalNode),
+                lastStatementNode = last(statementNodes),
+                frontStatementNodes = front(statementNodes),
+                consequentStatementNode = lastStatementNode,  ///
+                suppositionStatementNodes = frontStatementNodes,  ///
+                lemma = Lemma.fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode);
+
+          fileContext.addLemma(lemma);
+        }
+
+        lemmaVerified = true;
+      }
+    }
+  }
+
+  if (lemmaVerified) {
+    (labelsString === null) ?
+      fileContext.info(`Verified an anonymous lemma.`) :
+        fileContext.info(`Verified the '${labelsString}' lemma.`);
+  }
+
+  lemmaVerified ?
+    fileContext.complete(lemmaNode) :
+      fileContext.halt(lemmaNode);
+
+  return lemmaVerified;
+}

package/src/verify/release.js

@@ -16,7 +16,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
       if (verified) {
         releaseVerified = true;
       } else {
-        releaseContext.debug(`Verifying the '${releaseName}' package...`);
+        releaseContext.debug(`Verifying '${releaseName}'...`);
 
         const releaseFilesVerified = verifyReleaseFiles(releaseContext);
 
@@ -27,11 +27,11 @@ export default function verifyRelease(releaseName, releaseContextMap) {
 
           releaseVerified = verified; ///
         }
-      }
-    }
 
-    if (releaseVerified) {
-      releaseContext.info(`Verified the '${releaseName}' package.`);
+        if (releaseVerified) {
+          releaseContext.info(`Verified  '${releaseName}'.`);
+        }
+      }
     }
   }
 

package/src/verify/term.js

@@ -1,52 +1,101 @@
 "use strict";
 
-import verifyTermAsVariable from "../verify/termAsVariable";
-
 import { first } from "../utilities/array";
 import { nodeAsString } from "../utilities/string";
 import { ARGUMENT_RULE_NAME } from "../ruleNames";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!")
+      typeNodeQuery = nodeQuery("/argument/type!"),
+      variableNodeQuery = nodeQuery("/term/variable!");
 
 export default function verifyTerm(termNode, types, values, context) {
   let termVerified = false;
 
   context.begin(termNode);
 
-  const names = [],
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, types, names, values, context);
+  const termVerifiedAsVariable = verifyTermAsVariable(termNode, types, values, context);
 
   if (termVerifiedAsVariable) {
     termVerified = true;
   } else {
-    const constructors = context.getConstructors(),
-          constructor = constructors.find((constructor) => {
-            const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
+    const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
+
+    if (termVerifiedAgainstConstructors) {
+      termVerified = true;
+    }
+  }
+
+  termVerified ?
+    context.complete(termNode) :
+      context.halt(termNode);
 
-            if (termVerifiedAgainstConstructor) {
-              return true;
-            }
-          }) || null;
+  return termVerified;
+}
+
+export function verifyTermAsVariable(termNode, types, values, context) {
+  let termVerifiedAsVariable = false;
+
+  context.begin(termNode);
 
-    if (constructor !== null) {
-      const type = constructor.getType(),
-            value = termNode; ///
+  const variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    const variableName = variableNameFromVariableNode(variableNode),
+          variablePresent = context.isVariablePresentByVariableName(variableName);
+
+    if (!variablePresent) {
+      context.error(`The ${variableName} variable is not present.`)
+    } else {
+      const variable = context.findVariableByVariableName(variableName),
+        type = variable.getType(),
+        value = variable.getValue();
 
       types.push(type);
 
       values.push(value);
 
-      termVerified = true;
+      termVerifiedAsVariable = true;
     }
   }
 
-  termVerified ?
+  termVerifiedAsVariable ?
     context.complete(termNode) :
       context.halt(termNode);
 
-  return termVerified;
+  return termVerifiedAsVariable;
+}
+
+export function verifyTermAgainstConstructors(termNode, types, values, context) {
+  let termVerifiedAgainstConstructors = false;
+
+  context.begin(termNode);
+
+  const constructors = context.getConstructors(),
+        constructor = constructors.find((constructor) => {
+          const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
+
+          if (termVerifiedAgainstConstructor) {
+            return true;
+          }
+        }) || null;
+
+  if (constructor !== null) {
+    const type = constructor.getType(),
+          value = termNode; ///
+
+    types.push(type);
+
+    values.push(value);
+
+    termVerifiedAgainstConstructors = true;
+  }
+
+  termVerifiedAgainstConstructors ?
+    context.complete(termNode) :
+      context.halt(termNode);
+
+  return termVerifiedAgainstConstructors;
 }
 
 function verifyTermAgainstConstructor(termNode, constructor, context) {

package/lib/verify/termAsVariable.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyTermAsVariable;
-    }
-});
-var _query = require("../utilities/query");
-var variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
-function verifyTermAsVariable(termNode, types, names, values, context) {
-    var termVerifiedAsVariable = false;
-    context.begin(termNode);
-    var variableNode = variableNodeQuery(termNode);
-    if (variableNode !== null) {
-        var variableName = (0, _query.variableNameFromVariableNode)(variableNode), variablePresent = context.isVariablePresentByVariableName(variableName);
-        if (!variablePresent) {
-            context.error("The ".concat(variableName, " variable is not present."));
-        } else {
-            var variable = context.findVariableByVariableName(variableName), type = variable.getType(), name = variableName, value = variable.getValue();
-            types.push(type);
-            names.push(name);
-            values.push(value);
-            termVerifiedAsVariable = true;
-        }
-    }
-    termVerifiedAsVariable ? context.complete(termNode) : context.halt(termNode);
-    return termVerifiedAsVariable;
-}
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/verify/termAsVariable.js

@@ -1,41 +0,0 @@
-"use strict";
-
-import { nodeQuery, variableNameFromVariableNode} from "../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
-
-export default function verifyTermAsVariable(termNode, types, names, values, context) {
-  let termVerifiedAsVariable = false;
-
-  context.begin(termNode);
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const variableName = variableNameFromVariableNode(variableNode),
-          variablePresent = context.isVariablePresentByVariableName(variableName);
-
-    if (!variablePresent) {
-      context.error(`The ${variableName} variable is not present.`)
-    } else {
-      const variable = context.findVariableByVariableName(variableName),
-            type = variable.getType(),
-            name = variableName,  ///
-            value = variable.getValue();
-
-      types.push(type);
-
-      names.push(name);
-
-      values.push(value);
-
-      termVerifiedAsVariable = true;
-    }
-  }
-
-  termVerifiedAsVariable ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
-  return termVerifiedAsVariable;
-}