occam-verify-cli 0.0.1006 → 0.0.1007

package/src/log.js

@@ -25,37 +25,37 @@ export default class Log {
     return this.follow;
   }
 
-  trace(message, node, tokens, filePath) {
+  trace(message, filePath) {
     const level = TRACE_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  debug(message, node, tokens, filePath) {
+  debug(message, filePath) {
     const level = DEBUG_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  info(message, node, tokens, filePath) {
+  info(message, filePath) {
     const level = INFO_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  warning(message, node, tokens, filePath) {
+  warning(message, filePath) {
     const level = WARNING_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  error(message, node, tokens, filePath) {
+  error(message, filePath) {
     const level = ERROR_LEVEL;
 
-    this.write(level, message, node, tokens, filePath);
+    this.write(level, message, filePath);
   }
 
-  write(level, message, node, tokens, filePath) {
+  write(level, message, filePath) {
     const levels = [
             TRACE_LEVEL,
             DEBUG_LEVEL,
@@ -70,7 +70,7 @@ export default class Log {
       return;
     }
 
-    message = formatMessage(level, message, node, tokens, filePath);  ///
+    message = formatMessage(level, message, filePath);  ///
 
     this.follow ?
       console.log(message) :
@@ -96,27 +96,12 @@ export default class Log {
   }
 }
 
-function formatMessage(level, message, node = null, tokens = null, filePath = null) {
+function formatMessage(level, message, filePath = null) {
   const upperCaseLevel = level.toUpperCase();
 
-  if ((node === null) || (tokens === null)) {
-    message = (filePath !== null) ?
-              `${upperCaseLevel}: ${filePath} - ${message}`:
-                `${upperCaseLevel}: ${message}`;
-  } else {
-    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
-          leastLineNumber = leastLineIndex, ///
-          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, tokens),
-          greatestLineNumber = greatestLineIndex; ///
-
-    if (leastLineNumber === greatestLineNumber) {
-      const lineNumber = leastLineNumber; ///
-
-      message = `${upperCaseLevel}: ${filePath} (${lineNumber}) - ${message}`;
-    } else {
-      message = `${upperCaseLevel}: ${filePath} (${leastLineNumber}-${greatestLineNumber}) - ${message}`;
-    }
-  }
+  message = (filePath !== null) ?
+            `${upperCaseLevel}: ${filePath} - ${message}`:
+              `${upperCaseLevel}: ${message}`;
 
   return message;
 }

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

@@ -9,6 +9,7 @@ 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");
 
@@ -152,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/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

@@ -101,18 +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...`);
 
-        releaseContext.initialise(releaseContexts);
+      releaseContext.initialise(releaseContexts);
 
-        log.info(`...initialised 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;