occam-verify-cli 0.0.1005 → 0.0.1007

package/src/metaType.js

@@ -71,11 +71,13 @@ Object.assign(shim, {
 export default MetaType;
 
 export function metaTypeFromJSON(json, fileContext) {
-  let metaType;
+  let metaType = null;
 
-  const { name } = json;
+  if (json !== null) {
+    const { name } = json;
 
-  metaType = new MetaType(name);
+    metaType = new MetaType(name);
+  }
 
   return metaType;
 }

package/src/metavariable.js

@@ -2,13 +2,13 @@
 
 import { metaTypeFromJSON } from "./metaType";
 import { metavariableNameFromMetavariableNode } from "./utilities/name";
+import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
 export default class Metavariable {
-  constructor(string, node, name, termType, metaType) {
+  constructor(string, node, name, metaType) {
     this.string = string;
     this.node = node;
     this.name = name;
-    this.termType = termType;
     this.metaType = metaType;
   }
 
@@ -24,10 +24,6 @@ export default class Metavariable {
     return this.name;
   }
 
-  getTermType() {
-    return this.termType;
-  }
-
   getMetaType() {
     return this.metaType;
   }
@@ -80,8 +76,7 @@ export default class Metavariable {
 
     const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
           name = metavariableName,  ///
-          termType = termTypeFromMetavariableNode(metavariableNode, fileContext),
-          metavariable = new Metavariable(string, node, name, termType, metaType);
+          metavariable = new Metavariable(string, node, name, metaType);
 
     return metavariable;
   }
@@ -91,19 +86,18 @@ export default class Metavariable {
           name = metavariableName,  ///
           node = metavariableNode,  ///
           string = fileContext.nodeAsString(node),
-          termType = null,
           metaType = null,
-          metavariable = new Metavariable(string, node, name, termType, metaType);
+          metavariable = new Metavariable(string, node, name, metaType);
 
     return metavariable;
   }
 
-  static fromMetavariableNodeNameTermTypeAndMetaType(metavariableNode, termType, metaType, fileContext) {
+  static fromMetavariableNodeAndMetaType(metavariableNode, metaType, fileContext) {
     const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
           name = metavariableName,  ///
           node = metavariableNode,  ///
           string = fileContext.nodeAsString(node),
-          metavariable = new Metavariable(string, node, name, termType, metaType);
+          metavariable = new Metavariable(string, node, name, metaType);
 
     return metavariable;
   }

package/src/premise.js

@@ -6,8 +6,10 @@ import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
+import { trim } from "./utilities/string";
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
+import { unqualifiedStatementNodeFromUnqualifiedStatementString } from "./utilities/node";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
@@ -106,9 +108,10 @@ export default class Premise {
   }
 
   verify(localContext) {
-    let verified = false;
+    let verified = false,
+        premiseString = this.getString(); ///
 
-    const premiseString = this.getString(); ///
+    premiseString = trim(premiseString);  ///
 
     if (this.unqualifiedStatement !== null) {
       localContext.trace(`Verifying the '${premiseString}' premise...`);
@@ -150,7 +153,16 @@ export default class Premise {
   }
 
   static fromJSON(json, fileContext) {
-    let premise = null;
+    let { unqualifiedStatement } = json;
+
+    const lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          unqualifiedStatementString = unqualifiedStatement,  ///
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, lexer, parser);
+
+    unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext);
+
+    const premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise;
   }

package/src/ruleNames.js

@@ -1,4 +1,5 @@
 "use strict";
 
 export const TERM_RULE_NAME = "term";
+export const METAVARIABLE_RULE_NAME = "metavariable";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";

package/src/supposition.js

@@ -3,17 +3,11 @@
 import ProofStep from "./proofStep";
 import UnqualifiedStatement from "./statement/unqualified";
 
-import metaLevelUnifier from "./unifier/metaLevel";
-
-import { match } from "./utilities/array";
+import { trim } from "./utilities/string";
+import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
-import { nodeQuery, nodesQuery } from "./utilities/query";
 
-const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement"),
-      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
 export default class Supposition {
   constructor(fileContext, unqualifiedStatement) {
@@ -79,9 +73,10 @@ export default class Supposition {
   // }
 
   verify(localContext) {
-    let verified = false;
+    let verified = false,
+        suppositionString = this.getString(); ///
 
-    const suppositionString = this.getString(); ///
+    suppositionString = trim(suppositionString);  ///
 
     if (this.unqualifiedStatement !== null) {
       localContext.trace(`Verifying the '${suppositionString}' supposition...`);

package/src/utilities/node.js

@@ -4,8 +4,12 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { TERM_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
-import { termTokensFromTermString, unqualifiedStatementTokensFromUnqualifiedStatementString } from "../utilities/tokens";
+import { TERM_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
+import { termTokensFromTermString,
+         metavariableTokensFromMetavariableString,
+         unqualifiedStatementTokensFromUnqualifiedStatementString } from "../utilities/tokens";
 
 const { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
@@ -31,6 +35,20 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
+export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
+  const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
+        metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
+
+  return metavariableNode;
+}
+
+export function unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, lexer, parser) {
+  const unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+        unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
+
+  return unqualifiedStatementNode;
+}
+
 export function termNodeFromTermTokens(termTokens, parser) {
   const tokens = termTokens,  ///
         ruleName = TERM_RULE_NAME,
@@ -39,6 +57,13 @@ export function termNodeFromTermTokens(termTokens, parser) {
   return termNode;
 }
 
+export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
+  const ruleName = METAVARIABLE_RULE_NAME,
+        metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
+
+  return metavariableNode;
+}
+
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const tokens = unqualifiedStatementTokens,  ///
         ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,

package/src/utilities/releaseContext.js

@@ -9,9 +9,8 @@ export function createReleaseContext(dependency, dependentNames, context, callba
         releaseContext = releaseContextMap[releaseName] || null;
 
   if (releaseContext !== null) {
-    const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
-
-    const error = null;
+    const error = null,
+          releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
 
     let success;
 
@@ -102,20 +101,16 @@ export function initialiseReleaseContext(dependency, context) {
     releaseContextInitialised = releaseContext.isInitialised();
 
     if (!releaseContextInitialised) {
-      const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, context);
+      initialiseDependencyReleaseContexts(dependency, releaseContext, context);
 
-      if (dependencyReleaseContextsInitialised) {
-        const { log } = context,
-              releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
+      const { log } = context,
+            releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
-        log.debug(`Initialising the '${dependencyName}' context...`);
+      log.debug(`Initialising the '${dependencyName}' context...`);
 
-        releaseContextInitialised = releaseContext.initialise(releaseContexts);
+      releaseContext.initialise(releaseContexts);
 
-        releaseContextInitialised ?
-          log.info(`...initialised the '${dependencyName}' context.`) :
-            log.warning(`...unable to initialise the '${dependencyName}' context.`);
-      }
+      log.info(`...initialised the '${dependencyName}' context.`);
     }
   }
 

package/src/utilities/tokens.js

@@ -16,6 +16,13 @@ export function termTokensFromTermString(termString, lexer) {
   return termTokens;
 }
 
+export function metavariableTokensFromMetavariableString(metavariableString, lexer) {
+  const metavariableContent = `${metavariableString}`,
+        metavariableTokens = tokensFromContentAndLexer(metavariableContent, lexer);
+
+  return metavariableTokens;
+}
+
 export function unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer) {
   const content = unqualifiedStatementString,  ///
         unqualifiedStatementTokens = tokensFromContentAndLexer(content, lexer);

package/src/verify/declaration/metavariable.js

@@ -52,24 +52,13 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
           metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
 
     if (argumentVerified && metaTypeVerified) {
-      let termType,
-          metaType;
+      let metaType;
 
       const firstMetaType = first(metaTypes);
 
       metaType = firstMetaType; ///
 
-      const termTypesLength = termTypes.length;
-
-      if (termTypesLength === 0) {
-        termType = null;
-      } else {
-        const firstTermType = first(termTypes);
-
-        termType = firstTermType; ///
-      }
-
-      const metavariable = Metavariable.fromMetavariableNodeNameTermTypeAndMetaType(metavariableNode, termType, metaType, fileContext),
+      const metavariable = Metavariable.fromMetavariableNodeAndMetaType(metavariableNode, metaType, fileContext),
             metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
             metavariableAssigned = metavariableAssignment.assign(fileContext);
 

package/src/verify/files.js

@@ -19,7 +19,7 @@ export default function verifyFiles(releaseContext) {
     if (filePathNominalFilePath) {
       return true;
     }
-  })
+  });
 
   for (;;) {
     const filePathsLength = filePaths.length;

package/src/verify/release.js

@@ -2,34 +2,46 @@
 
 import verifyFiles from "../verify/files";
 
-export default function verifyRelease(releaseName, releaseContextMap) {
+export default function verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap) {
   let releaseVerified = false;
 
   const releaseContext = releaseContextMap[releaseName];
 
   if (releaseContext !== null) {
-    const dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, releaseContextMap);
+    const released = releaseContext.isReleased();
 
-    if (dependencyReleasesVVerified) {
-      const verified = releaseContext.isVerified();
-
-      if (verified) {
-        releaseVerified = true;
+    if (released) {
+      releaseVerified = true;
+    } else {
+      if (dependentReleased) {
+        releaseContext.warning(`The '${releaseName}' project cannot be verified because its '${dependentName}' dependent is a package.`);
       } else {
-        releaseContext.info(`Verifying the '${releaseName}' project...`);
+        const dependentName = releaseName,  ///
+              dependentReleased = released, ///
+              dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap);
 
-        const releaseFilesVerified = verifyReleaseFiles(releaseContext);
+        if (dependencyReleasesVVerified) {
+          const verified = releaseContext.isVerified();
 
-        if (releaseFilesVerified) {
-          const verified = true;
+          if (verified) {
+            releaseVerified = true;
+          } else {
+            releaseContext.info(`Verifying the '${releaseName}' project...`);
 
-          releaseContext.setVerified(verified);
+            const releaseFilesVerified = verifyReleaseFiles(releaseContext);
 
-          releaseVerified = verified; ///
-        }
+            if (releaseFilesVerified) {
+              const verified = true;
+
+              releaseContext.setVerified(verified);
 
-        if (releaseVerified) {
-          releaseContext.info(`...verified the '${releaseName}' project.`);
+              releaseVerified = verified; ///
+            }
+
+            if (releaseVerified) {
+              releaseContext.info(`...verified the '${releaseName}' project.`);
+            }
+          }
         }
       }
     }
@@ -45,12 +57,12 @@ function verifyReleaseFiles(releaseContext) {
   return releaseFilesVerified;
 }
 
-function verifyDependencyReleases(releaseContext, releaseContextMap) {
+function verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap) {
   const dependencies = releaseContext.getDependencies(),
         dependencyReleasesVVerified = dependencies.everyDependency((dependency) => {
           const name = dependency.getName(),
                 releaseName = name, ///
-                releaseVerified = verifyRelease(releaseName, releaseContextMap);
+                releaseVerified = verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap);
 
           if (releaseVerified) {
             return true;