occam-verify-cli 0.0.705 → 0.0.707

package/src/context/release.js

@@ -339,14 +339,14 @@ export default class ReleaseContext {
 
   fatal(message, node = null, tokens = null, filePath = null) { this.log.fatal(message, node, tokens, filePath); }
 
-  initialise(dependencyReleaseContexts) {
-    const releaseContext = this,  ///
-          releaseContexts = [
-            releaseContext,
-            ...dependencyReleaseContexts
-          ],
-          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
-          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
+  initialise(releaseContexts) {
+    releaseContexts = releaseContexts.slice();  ///
+
+    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
+          releaseContext = releaseContexts.shift(),
+          dependencyReleaseContexts = releaseContexts;  ///
+
+    const florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
           florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
     this.lexer = florenceLexer; ///

package/src/index.js

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

package/src/releaseContext/create.js

@@ -0,0 +1,154 @@
+"use strict";
+
+import { last } from "../utilities/array";
+
+export default function createReleaseContext(dependency, dependentNames, context, callback) {
+  const { log, releaseContextMap } = context,
+        dependencyName = dependency.getName(),
+        releaseName = dependencyName, ///
+        releaseContext = releaseContextMap[releaseName] || null;
+
+  if (releaseContext !== null) {
+    const error = null;
+
+    callback(error);
+
+    return;
+  }
+
+  log.info(`Creating the '${releaseName}' context.`)
+
+  const { releaseContextFromDependency } = context;
+
+  releaseContextFromDependency(dependency, context, (error, releaseContext) => {
+    if (error) {
+      callback(error);
+
+      return;
+    }
+
+    const releaseContextCreated = checkReleaseContextCreated(releaseContext, dependency, context);
+
+    if (!releaseContextCreated) {
+      const error = null;
+
+      callback(error);
+
+      return;
+    }
+
+    const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
+
+    if (!releaseMatchesDependency) {
+      const error = null;
+
+      callback(error);
+
+      return;
+    }
+
+    releaseContextMap[releaseName] = releaseContext;
+
+    createDependencyReleaseContexts(dependency, dependentNames, context, callback);
+  }, context);
+}
+
+function checkReleaseContextCreated(releaseContext, dependency, context) {
+  const releaseContextCreated = (releaseContext !== null);
+
+  if (!releaseContextCreated) {
+    const { log } = context,
+          dependencyName = dependency.getName(),
+          releaseName = dependencyName; ///
+
+    log.error(`The '${releaseName}' context could not be created.`);
+  }
+
+  return releaseContextCreated;
+}
+
+function checkCyclicDependencyExists(dependency, dependentNames, context) {
+  const dependencyName = dependency.getName(),
+        dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName),
+        cyclicDependencyExists = dependentNamesIncludesDependencyName;  ///
+
+  if (cyclicDependencyExists) {
+    const { log } = context,
+          firstDependentName = first(dependentNames),
+          dependencyNames = [  ///
+            ...dependentNames,
+            firstDependentName
+          ],
+          dependencyNamesString = dependencyNames.join(`' -> '`);
+
+    log.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);
+  }
+
+  return cyclicDependencyExists;
+}
+
+function checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context) {
+  let releaseMatchesDependency = true;
+
+  const entries = releaseContext.getEntries(),
+        shortenedVersion = dependency.getShortedVersion();
+
+  if (shortenedVersion !== null) {
+    const entriesMatchShortenedVersion = entries.matchShortenedVersion(shortenedVersion);
+
+    if (!entriesMatchShortenedVersion) {
+      const { log } = context,
+            version = releaseContext.getVersion(),
+            versionString = version.toString(),
+            lastDependentName = last(dependentNames),
+            dependentName = lastDependentName,  ///
+            dependencyName = dependency.getName(),
+            shortenedVersion = dependency.getShortedVersion(),
+            shortenedVersionString = shortenedVersion.toString();
+
+      log.error(`Version mismatch: '${dependentName}' requires '${dependencyName}' to be version ${shortenedVersionString}.0 or higher but version ${versionString} has been supplied.`);
+
+      releaseMatchesDependency = false;
+    }
+  }
+
+  return releaseMatchesDependency;
+}
+
+function createDependencyReleaseContexts(dependency, dependentNames, context, callback) {
+  const { releaseContextMap } = context,
+        dependencyName = dependency.getName(),
+        releaseName = dependencyName, ///
+        releaseContext = releaseContextMap[releaseName],
+        dependencies = releaseContext.getDependencies();
+
+  dependentNames = [ ...dependentNames, dependencyName ];  ///
+
+  dependencies.asynchronousForEachDependency((dependency, next, done) => {
+    const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames);
+
+    if (cyclicDependencyExists) {
+      const error = null;
+
+      callback(error);
+
+      return;
+    }
+
+    createReleaseContext(dependency, dependentNames, context, (error) => {
+      if (error) {
+        callback(error);
+
+        return;
+      }
+
+      next();
+    });
+  }, done);
+
+  function done() {
+    const error = null;
+
+    callback(error);
+  }
+}

package/src/releaseContext/initialise.js

@@ -0,0 +1,89 @@
+"use strict";
+
+export default function initialiseReleaseContext(dependency, dependentName, dependentReleased, context) {
+  let releaseContextInitialised = false;
+
+  const { releaseContextMap } = context,
+        dependencyName = dependency.getName(),
+        releaseName = dependencyName, ///
+        releaseContext = releaseContextMap[releaseName] || null;
+
+  if (releaseContext === null) {
+    const { log } = context;
+
+    log.error(`Unable to initialise the '${dependencyName}' dependency's context because it has not been created.`);
+  } else {
+    const initialised = releaseContext.isInitialised();
+
+    if (initialised) {
+      releaseContextInitialised = true;
+    } else {
+      const released = releaseContext.isReleased();
+
+      if (!released && dependentReleased) {
+        const { log } = context;
+
+        log.error(`Unable to initialise the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
+      } else {
+        const dependencies = releaseContext.getDependencies();
+
+        dependentName = dependencyName;  ///
+
+        dependentReleased = released;  ///
+
+        releaseContextInitialised = dependencies.everyDependency((dependency) => {  ///
+          const releaseContextInitialised = initialiseReleaseContext(dependency, dependentName, dependentReleased, context);
+
+          if (releaseContextInitialised) {
+            return true;
+          }
+        });
+
+        if (releaseContextInitialised) {
+          const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
+
+          releaseContext.initialise(releaseContexts);
+        }
+      }
+    }
+  }
+
+  return releaseContextInitialised;
+}
+
+function retrieveReleaseContexts(releaseContext, releaseContextMap) {
+  const releaseContexts = [],
+        remainingReleaseContext = releaseContext,  ///
+        remainingReleaseContexts = [
+          remainingReleaseContext
+        ];
+
+  let remainingReleaseContextsLength = remainingReleaseContexts.length;
+
+  while (remainingReleaseContextsLength > 0) {
+    const remainingReleaseContext = remainingReleaseContexts.shift(),
+          releaseContext = remainingReleaseContext;  ///
+
+    releaseContexts.push(releaseContext);
+
+    const dependencies = releaseContext.getDependencies();
+
+    dependencies.forEachDependency((dependency) => {
+      const dependencyName = dependency.getName(),
+            releaseName = dependencyName, ///
+            releaseContext = releaseContextMap[releaseName],
+            releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext),
+            remainingReleaseContextsIncludesReleaseContext = remainingReleaseContexts.includes(releaseContext);
+
+      if (!releaseContextsIncludesReleaseContext && !remainingReleaseContextsIncludesReleaseContext) {
+        const remainingReleaseContext = releaseContext; ///
+
+        remainingReleaseContexts.push(remainingReleaseContext);
+      }
+    });
+
+    remainingReleaseContextsLength = remainingReleaseContexts.length;
+  }
+
+  return releaseContexts;
+}

package/src/ruleNames.js

@@ -3,11 +3,9 @@
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
-export const VARIABLE_RULE_NAME = "variable";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
 export const STATEMENT_RULE_NAME = "statement";
-export const META_TYPE_RULE_NAME = "meta-type";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
@@ -17,5 +15,4 @@ export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
-export const METAVARIABLE_DECLARATION_RULE_NAME = "metavariableDeclaration";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/utilities/array.js

@@ -73,3 +73,31 @@ export function rightDifference(arrayA, arrayB) {
     }
   });
 }
+
+export function areArraysEqual(arrayA, arrayB, callback) {
+  if (callback === undefined) {
+    callback = (elementA, elementB) => {
+      if (elementA === elementB) {
+        return true;
+      }
+    };
+  }
+
+  let arraysEqual = false;
+
+  const arrayALength = arrayA.length,
+        arrayBLength = arrayB.length;
+
+  if (arrayALength === arrayBLength) {
+    arraysEqual = arrayA.every((elementA, index) => {
+      const elementB = arrayB[index],
+            result = callback(elementA, elementB);
+
+      if (result) {
+        return true;
+      }
+    })
+  }
+
+  return arraysEqual;
+}

package/src/utilities/terminalNodes.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { areArraysEqual } from "../utilities/array";
+
+export function terminalNodeMapFromNodes(nodes) {
+  const terminalNodeMap = {};
+
+  nodes.forEach((node, index) => {
+    const nodeTerminalNode = node.isTerminalNode();
+
+    if (nodeTerminalNode) {
+      const terminalNode = node;  //
+
+      terminalNodeMap[index] = terminalNode;
+    }
+  });
+
+  return terminalNodeMap;
+}
+
+export function areTerminalNodeMapsEqual(terminalNodeMapA, terminalNodeMapB) {
+  let terminalNodeMapsEqual = false;
+
+  const indexesA = Object.keys(terminalNodeMapA), ///
+        indexesB = Object.keys(terminalNodeMapB), ///
+        terminalNodeMapKeysEqual = areArraysEqual(indexesA, indexesB);
+
+  if (terminalNodeMapKeysEqual) {
+    const terminalNodesA = Object.keys(terminalNodeMapA), ///
+          terminalNodesB = Object.keys(terminalNodeMapB), ///
+          terminalNodeMapValuesEqual = areArraysEqual(terminalNodesA, terminalNodesB, (terminalNodeA, terminalNodeB) => {
+            const matches = terminalNodeA.match(terminalNodeB);
+
+            if (matches) {
+              return true;
+            }
+          });
+
+    terminalNodeMapsEqual = terminalNodeMapValuesEqual; ///
+  }
+
+  return terminalNodeMapsEqual;
+}

package/src/verifier/node.js

@@ -32,6 +32,28 @@ export default class NodeVerifier {
     return childNodesVerify;
   }
 
+  verifyTerminalNode(terminalNode, ...remainingArguments) {
+    let terminalNodeVerified;
+
+    const verifyAhead = remainingArguments.pop(), ///
+          verifiedAhead = verifyAhead();  ///
+
+    terminalNodeVerified = verifiedAhead; ///
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
+    let nonTerminalNodeVerified;
+
+    const childNodes = nonTerminalNode.getChildNodes(), ///
+          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+
+    nonTerminalNodeVerified = childNodesVerify; ///
+
+    return nonTerminalNodeVerified;
+  }
+
   verifyChildNodesAhead(index, childNodes, ...remainingArguments) {
     let childNodesVerify;
 
@@ -46,11 +68,10 @@ export default class NodeVerifier {
       const childNode = childNodes[index],
             node = childNode, ///
             nodeVerified = this.verifyNode(node, ...remainingArguments, () => {
-              index++;
-
               remainingArguments.push(verifyAhead);
 
-              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+              const aheadIndex = index + 1,
+                    childNodesVerifyAhead = this.verifyChildNodesAhead(aheadIndex, childNodes, ...remainingArguments);
 
               return childNodesVerifyAhead;
             });
@@ -60,26 +81,4 @@ export default class NodeVerifier {
 
     return childNodesVerify;
   }
-
-  verifyTerminalNode(terminalNode, ...remainingArguments) {
-    let terminalNodeVerified;
-
-    const verifyAhead = remainingArguments.pop(), ///
-          verifiedAhead = verifyAhead();  ///
-
-    terminalNodeVerified = verifiedAhead; ///
-
-    return terminalNodeVerified;
-  }
-
-  verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
-    let nonTerminalNodeVerified;
-
-    const childNodes = nonTerminalNode.getChildNodes(), ///
-          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
-
-    nonTerminalNodeVerified = childNodesVerify; ///
-
-    return nonTerminalNodeVerified;
-  }
 }

package/src/verifier/nodes/term.js

@@ -98,3 +98,4 @@ class TermNodesVerifier extends NodesVerifier {
 const termNodesVerifier = new TermNodesVerifier();
 
 export default termNodesVerifier;
+

package/src/verifier/nodes.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "../utilities/terminalNodes";
+
 export default class NodesVerifier {
   verifyNode(nodeA, nodeB, ...remainingArguments) {
     let nodeVerified = false;
@@ -35,15 +37,51 @@ export default class NodesVerifier {
           childNodesBLength = childNodesB.length;
 
     if (childNodesALength === childNodesBLength) {
-      const index = 0,
-            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+      const childTerminalNodeMapA = terminalNodeMapFromNodes(childNodesA),
+            childTerminalNodeMapB = terminalNodeMapFromNodes(childNodesB),
+            terminalNodeMapsEqual = areTerminalNodeMapsEqual(childTerminalNodeMapA, childTerminalNodeMapB);
+
+      if (terminalNodeMapsEqual) {
+        const index = 0,
+              childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
 
-      childNodesVerify = childNodesVerifyAhead; ///
+        childNodesVerify = childNodesVerifyAhead; ///
+      }
     }
 
     return childNodesVerify;
   }
 
+  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
+    let terminalNodeVerified;
+
+    const verifyAhead = remainingArguments.pop(),
+          verifiedAhead = verifyAhead();
+
+    terminalNodeVerified = verifiedAhead;  ///
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+
+      nonTerminalNodeVerified = childNodesVerify; ///
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
   verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
     let childNodesVerify;
 
@@ -60,11 +98,10 @@ export default class NodesVerifier {
             nodeA = childNodeA, ///
             nodeB = childNodeB, ///
             nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments, () => {
-              index++;
-
               remainingArguments.push(verifyAhead); ///
 
-              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+              const aheadIndex = index + 1,
+                    childNodesVerifyAhead = this.verifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
 
               return childNodesVerifyAhead;
             });
@@ -74,38 +111,4 @@ export default class NodesVerifier {
 
     return childNodesVerify;
   }
-
-  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
-    let terminalNodeVerified = false;
-
-    const matches = terminalNodeA.match(terminalNodeB);
-
-    if (matches) {
-      const verifyAhead = remainingArguments.pop(),
-            verifiedAhead = verifyAhead();
-
-      terminalNodeVerified = verifiedAhead;  ///
-    }
-
-    return terminalNodeVerified;
-  }
-
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
-    let nonTerminalNodeVerified = false;
-
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
-
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-            childNodesA = nonTerminalNodeAChildNodes, ///
-            childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
-
-      nonTerminalNodeVerified = childNodesVerify; ///
-    }
-
-    return nonTerminalNodeVerified;
-  }
 }

package/src/verify/givenVariable.js

@@ -0,0 +1,31 @@
+"use strict";
+
+export default function verifyGivenVariable(variableNode, variables, context, verifyAhead) {
+  let givenVariableVerified = false;
+
+  const variableString = context.nodeAsString(variableNode);
+
+  context.trace(`Verifying the '${variableString}' given variable...`, variableNode);
+
+  const variable = context.findVariableByVariableNode(variableNode);
+
+  if (variable !== null) {
+    let verifiedAhead;
+
+    variables.push(variable);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      variables.pop();
+    }
+
+    givenVariableVerified = verifiedAhead; ///
+  }
+
+  if (givenVariableVerified) {
+    context.debug(`...verified the '${variableString}' given variable.`, variableNode);
+  }
+
+  return givenVariableVerified;
+}