occam-verify-cli 0.0.316 → 0.0.318

package/src/context/file.js

@@ -1,16 +1,16 @@
 "use strict";
 
-import { levels } from "necessary";
 import { rewriteNodes } from "occam-grammar-utilities";
 
+import loggingMixins from "../mixins/logging";
+
 import { push } from "../utilities/array";
 import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "../utilities/tokens";
 
-const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
-
-export default class FileContext {
-  constructor(filePath, tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext) {
+class FileContext {
+  constructor(filePath, context, tokens, node, rules, types, axioms, variables, combinators, constructors) {
     this.filePath = filePath;
+    this.context = context;
     this.tokens = tokens;
     this.node = node;
     this.rules = rules;
@@ -19,13 +19,16 @@ export default class FileContext {
     this.variables = variables;
     this.combinators = combinators;
     this.constructors = constructors;
-    this.releaseContext = releaseContext;
   }
 
   getFilePath() {
     return this.filePath;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getTokens() {
     return this.tokens;
   }
@@ -34,13 +37,17 @@ export default class FileContext {
     return this.node;
   }
 
+  getVariables() {
+    return this.variables;
+  }
+
   getRules(bubble = true) {
     const rules = [
       ...this.rules
     ];
 
     if (bubble) {
-      const releaseContextRules = this.releaseContext.getRules();
+      const releaseContextRules = this.context.getRules();
 
       push(rules, releaseContextRules);
     }
@@ -54,7 +61,7 @@ export default class FileContext {
     ];
 
     if (bubble) {
-      const releaseContextTypes = this.releaseContext.getTypes();
+      const releaseContextTypes = this.context.getTypes();
 
       push(types, releaseContextTypes);
     }
@@ -68,7 +75,7 @@ export default class FileContext {
     ];
 
     if (bubble) {
-      const releaseContextAxioms = this.releaseContext.getAxioms();
+      const releaseContextAxioms = this.context.getAxioms();
 
       push(axioms, releaseContextAxioms);
     }
@@ -76,30 +83,13 @@ export default class FileContext {
     return axioms;
   }
 
-  getLabels() {
-    const axioms = this.getAxioms(),
-          labels = axioms.reduce((labels, axiom) => {
-            const axiomLabels = axiom.getLabels();
-
-            push(labels, axiomLabels);
-
-            return labels;
-          }, []);
-
-    return labels;
-  }
-
-  getVariables() {
-    return this.variables;
-  }
-
   getCombinators(bubble = true) {
     const combinators = [
       ...this.combinators
     ];
 
     if (bubble) {
-      const releaseContextCombinators = this.releaseContext.getCombinators();
+      const releaseContextCombinators = this.context.getCombinators();
 
       push(combinators, releaseContextCombinators);
     }
@@ -113,7 +103,7 @@ export default class FileContext {
     ];
 
     if (bubble) {
-      const releaseContextConstructors = this.releaseContext.getConstructors();
+      const releaseContextConstructors = this.context.getConstructors();
 
       push(constructors, releaseContextConstructors);
     }
@@ -121,12 +111,14 @@ export default class FileContext {
     return constructors;
   }
 
-  getReleaseContext() {
-    return this.releaseContext;
+  getAssertions() {
+    const assertions = [];  ///
+
+    return assertions;
   }
 
   getMetaAssertions() {
-    const metaAssertions = [];
+    const metaAssertions = [];  ///
 
     return metaAssertions;
   }
@@ -164,7 +156,7 @@ export default class FileContext {
           axioms = this.getAxioms(),
           axiom = axioms.find((axiom) => {
             const axiomLabels = axiom.getLabels(),
-                  axiomLabelsIncludesLabel = axiomLabels.includes(label);
+                axiomLabelsIncludesLabel = axiomLabels.includes(label);
 
             if (axiomLabelsIncludesLabel) {
               return true;
@@ -176,7 +168,8 @@ export default class FileContext {
 
   findVariableByVariableName(variableName) {
     const name = variableName,  ///
-          variable = this.variables.find((variable) => {
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
             const matches = variable.matchName(name);
 
             if (matches) {
@@ -187,40 +180,41 @@ export default class FileContext {
     return variable;
   }
 
-  isDerived() {
-    const derived = false;
-
-    return derived;
-  }
-
   isLabelPresent(label) {
     const labels = this.getLabels(),
-          labelsIncludesLabel = labels.includes(label),
-          labelPresent = labelsIncludesLabel; ///
+        labelsIncludesLabel = labels.includes(label),
+        labelPresent = labelsIncludesLabel; ///
 
     return labelPresent;
   }
 
-  matchMetaAssertion(metaAssertion) {
-    const metaAssertionMatches = false;
-
-    return metaAssertionMatches;
-  }
-
   isTypePresentByTypeName(typeName) {
     const type = this.findTypeByTypeName(typeName),
-          typePresent = (type !== null);
+        typePresent = (type !== null);
 
     return typePresent;
   }
 
   isVariablePresentByVariableName(variableName) {
     const variable = this.findVariableByVariableName(variableName),
-          variablePresent = (variable !== null);
+        variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
+  getLabels() {
+    const axioms = this.getAxioms(),
+          labels = axioms.reduce((labels, axiom) => {
+            const axiomLabels = axiom.getLabels();
+
+            push(labels, axiomLabels);
+
+            return labels;
+          }, []);
+
+    return labels;
+  }
+
   addType(type) {
     this.types.push(type);
   }
@@ -245,23 +239,25 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
-  trace(message, node) { this.log(node, TRACE_LEVEL, message); }
-
-  debug(message, node) { this.log(node, DEBUG_LEVEL, message); }
-
-  info(message, node) { this.log(node, INFO_LEVEL, message); }
+  halt(node) {
+    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
+          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
 
-  warning(message, node) { this.log(node, WARNING_LEVEL, message); }
+    this.context.halt(this.filePath, leastLineIndex, greatestLineIndex);
+  }
 
-  error(message, node) { this.log(node, ERROR_LEVEL, message); }
+  begin(node) {
+    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
+          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
 
-  fatal(message, node) { this.log(node, FATAL_LEVEL, message); }
+    this.context.begin(this.filePath, leastLineIndex, greatestLineIndex);
+  }
 
-  log(node, level, message) {
+  complete(node) {
     const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
           greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
 
-    this.releaseContext.log(level, message, this.filePath, leastLineIndex, greatestLineIndex);
+    this.context.complete(this.filePath, leastLineIndex, greatestLineIndex);
   }
 
   static fromReleaseContextAndFilePath(releaseContext, filePath) {
@@ -272,14 +268,19 @@ export default class FileContext {
 
     rewriteNodes(node);
 
-    const rules = [],
+    const context = releaseContext, ///
+          rules = [],
           types = [],
           axioms = [],
           variables = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(filePath, tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext);
+          fileContext = new FileContext(filePath, context, tokens, node, rules, types, axioms, variables, combinators, constructors);
 
     return fileContext;
   }
 }
+
+Object.assign(FileContext.prototype, loggingMixins);
+
+export default FileContext;

package/src/context/metaproof.js

@@ -1,6 +1,10 @@
 "use strict";
 
-export default class MetaproofContext {
+import fileMixins from "../mixins/file";
+import loggingMixins from "../mixins/logging";
+import callbacksMixins from "../mixins/callbacks";
+
+class MetaproofContext {
   constructor(context, derived, metaAssertions) {
     this.context = context;
     this.derived = derived;
@@ -18,7 +22,7 @@ export default class MetaproofContext {
   getMetaAssertions() {
     let metaAssertions = this.context.getMetaAssertions();
 
-    metaAssertions = [
+    metaAssertions = [  ///
       ...metaAssertions,
       ...this.metaAssertions
     ];
@@ -26,25 +30,13 @@ export default class MetaproofContext {
     return metaAssertions;
   }
 
-  getRules() { return this.context.getRules(); }
-
-  getTypes() { return this.context.getTypes(); }
-
-  getAxioms() { return this.context.getAxioms(); }
-
-  getCombinators() { return this.context.getCombinators(); }
-
-  getConstructors() { return this.context.getConstructors(); }
-
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
-
-  findVariableByVariableName(variableName) { return this.context.findVariableByVariableName(variableName); }
-
-  isLabelPresent(label) { return this.context.isLabelPresent(label); }
+  setDerived(derived) {
+    this.derived = derived;
+  }
 
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+  addMetaAssertion(metaAssertion) {
+    this.metaAssertions.push(metaAssertion);
+  }
 
   matchMetaAssertion(metaAssertion) {
     let metaAssertionMatches;
@@ -67,35 +59,28 @@ export default class MetaproofContext {
     return metaAssertionMatches;
   }
 
-  isVariablePresentByVariableName(variableName) { return this.context.isVariablePresentByVariableName(variableName); }
-
-  setDerived(derived) {
-    this.derived = derived;
-  }
-
-  addRule(rule) { this.context.addRule(rule); }
+  static fromFileContext(fileContext) {
+    const context = fileContext,  ///
+          derived = false,
+          metaAssertions = [],
+          metaproofContext = new MetaproofContext(context, derived, metaAssertions);
 
-  addMetaAssertion(metaAssertion) {
-    this.metaAssertions.push(metaAssertion);
+    return metaproofContext;
   }
 
-  trace(message, node) { this.context.trace(message, node); }
-
-  debug(message, node) { this.context.debug(message, node); }
+  static fromMetaproofContext(metaproofContext) {
+    const context = metaproofContext,  ///
+          derived = false,
+          metaAssertions = [];
 
-  info(message, node) { this.context.info(message, node); }
-
-  warning(message, node) { this.context.warning(message, node); }
-
-  error(message, node) { this.context.error(message, node); }
-
-  fatal(message, node) { this.context.fatal(message, node); }
-
-  static fromContext(context) {
-    const derived = false,
-          metaAssertions = [],
-          metaproofContext = new MetaproofContext(context, derived, metaAssertions);
+    metaproofContext = new MetaproofContext(context, derived, metaAssertions);  ///
 
     return metaproofContext;
   }
 }
+
+Object.assign(MetaproofContext.prototype, fileMixins);
+Object.assign(MetaproofContext.prototype, loggingMixins);
+Object.assign(MetaproofContext.prototype, callbacksMixins);
+
+export default MetaproofContext;

package/src/context/proof.js

@@ -1,11 +1,14 @@
 "use strict";
 
-export default class ProofContext {
-  constructor(context, derived, variables, statementNodes) {
+import fileMixins from "../mixins/file";
+import loggingMixins from "../mixins/logging";
+import callbacksMixins from "../mixins/callbacks";
+
+class ProofContext {
+  constructor(context, derived, assertions) {
     this.context = context;
     this.derived = derived;
-    this.variables = variables;
-    this.statementNodes = statementNodes;
+    this.assertions = assertions;
   }
 
   getContext() {
@@ -16,50 +19,15 @@ export default class ProofContext {
     return this.derived;
   }
 
-  getVariables() {
-    return this.variables;
-  }
-
-  getStatementNodes() {
-    return this.statementNodes;
-  }
-
-  getRules() { return this.context.getRules(); }
-
-  getTypes() { return this.context.getTypes(); }
-
-  getAxioms() { return this.context.getAxioms(); }
+  getAssertions() {
+    let assertions = this.context.getAssertions();
 
-  getCombinators() { return this.context.getCombinators(); }
+    assertions = [
+      ...assertions,
+      ...this.assertions
+    ];
 
-  getConstructors() { return this.context.getConstructors(); }
-
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
-
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
-          variable = this.variables.find((variable) => {
-            const matches = variable.matchName(name);
-
-            if (matches) {
-              return true;
-            }
-          }) || this.context.findVariableByVariableName(variableName);  ///
-
-    return variable;
-  }
-
-  isLabelPresent(label) { return this.context.isLabelPresent(label); }
-
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
-
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
-          variablePresent = (variable !== null);
-
-    return variablePresent;
+    return assertions;
   }
 
   setDerived(derived) {
@@ -70,34 +38,53 @@ export default class ProofContext {
     this.derived = derived;
   }
 
-  addAxiom(axiom) { this.context.addAxiom(axiom); }
-
-  addVariable(variable) {
-    this.variables.push(variable);
+  addAssertion(assertion) {
+    this.assertions.push(assertion);
   }
 
-  addStatementNode(statementNode) {
-    this.statementNodes.push(statementNode);
-  }
+  matchAssertion(assertion) {
+    let assertionMatches;
 
-  trace(message, node) { this.context.trace(message, node); }
+    const assertionB = assertion; ///
 
-  debug(message, node) { this.context.debug(message, node); }
+    assertionMatches = this.assertions.some((assertion) => {
+      const assertionA = assertion, ///
+            matches = assertionA.match(assertionB);
 
-  info(message, node) { this.context.info(message, node); }
+      if (matches) {
+        return true;
+      }
+    });
 
-  warning(message, node) { this.context.warning(message, node); }
+    if (!assertionMatches) {
+      assertionMatches = this.context.matchAssertion(assertion);
+    }
 
-  error(message, node) { this.context.error(message, node); }
+    return assertionMatches;
+  }
 
-  fatal(message, node) { this.context.fatal(message, node); }
+  static fromFileContext(fileContext) {
+    const context = fileContext,  ///
+          derived = false,
+          assertions = [],
+          proofContext = new ProofContext(context, derived, assertions);
 
-  static fromContext(context) {
-    const derived = false,
-          variables = [],
-          statementNodes = [],
-          proofContext = new ProofContext(context, derived, variables, statementNodes);
+    return proofContext;
+  }
+
+  static fromProofContext(proofContext) {
+    const context = proofContext,  ///
+          derived = false,
+          assertions = [];
+
+    proofContext = new ProofContext(context, derived, assertions);  ///
 
     return proofContext;
   }
 }
+
+Object.assign(ProofContext.prototype, fileMixins);
+Object.assign(ProofContext.prototype, loggingMixins);
+Object.assign(ProofContext.prototype, callbacksMixins);
+
+export default ProofContext;

package/src/context/release.js

@@ -2,21 +2,19 @@
 
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-import logMixins from "../mixins/log";
-
 import { push } from "../utilities/array";
 import { customGrammarFromRelease, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
-class ReleaseContext {
-  constructor(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
+export default class ReleaseContext {
+  constructor(log, release, callbacks, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
     this.log = log;
     this.release = release;
+    this.callbacks = callbacks;
     this.verified = verified;
     this.customGrammar = customGrammar;
-
     this.fileContexts = fileContexts;
     this.florenceLexer = florenceLexer;
     this.florenceParser = florenceParser;
@@ -31,6 +29,10 @@ class ReleaseContext {
     return this.release;
   }
 
+  getCallbacks() {
+    return this.callbacks;
+  }
+
   isVerified() {
     return this.verified;
   }
@@ -65,6 +67,8 @@ class ReleaseContext {
 
   getDependencies() { return this.release.getDependencies(); }
 
+  matchShortenedVersion(shortenedVersion) { return this.release.matchShortenedVersion(shortenedVersion); }
+
   getRules(releaseNames = []) {
     const name = this.getName(),
           rules = [],
@@ -204,10 +208,32 @@ class ReleaseContext {
     this.fileContexts.push(fileContext);
   }
 
+  setVerified(verified) {
+    this.verified = verified;
+  }
+
   tokenise(content) { return this.florenceLexer.tokenise(content); }
 
   parse(tokens) { return this.florenceParser.parse(tokens); }
 
+  trace(message) { this.log.trace(message); }
+
+  debug(message) { this.log.debug(message); }
+
+  info(message) { this.log.info(message); }
+
+  warning(message) { this.log.warning(message); }
+
+  error(message) { this.log.error(message); }
+
+  fatal(message) { this.log.fatal(message); }
+
+  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }
+
+  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }
+
+  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
+
   initialise(releaseContexts, dependencyReleaseContexts) {
     const releaseContext = this;  ///
 
@@ -222,19 +248,15 @@ class ReleaseContext {
     this.releaseContexts = releaseContexts;
   }
 
-  static fromLogAndRelease(log, release, ...remainingArguments) {
+  static fromLogReleaseAndCallbacks(log, release, callbacks, ...remainingArguments) {
     const verified = false,
           customGrammar = customGrammarFromRelease(release),
           fileContexts = [],
           florenceLexer = null,
           florenceParser = null,
           releaseContexts = [],
-          releaseContext = new ReleaseContext(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
+          releaseContext = new ReleaseContext(log, release, callbacks, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
 
     return releaseContext;
   }
 }
-
-Object.assign(ReleaseContext.prototype, logMixins);
-
-export default ReleaseContext;

package/src/index.js

@@ -1,4 +1,5 @@
 "use strict";
 
+export { default as Callbacks } from "./callbacks";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";

package/src/mixins/callbacks.js

@@ -0,0 +1,15 @@
+"use strict";
+
+function halt(node) { this.context.halt(node); }
+
+function begin(node) { this.context.begin(node); }
+
+function complete(node) { this.context.complete(node); }
+
+const callbacksMixins = {
+  halt,
+  begin,
+  complete
+};
+
+export default callbacksMixins;

package/src/mixins/file.js

@@ -0,0 +1,12 @@
+"use strict";
+
+function findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
+
+function findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
+
+const fileMixins = {
+  findRuleByReferenceName,
+  findAxiomByReferenceName
+};
+
+export default fileMixins;

package/src/mixins/logging.js

@@ -0,0 +1,24 @@
+"use strict";
+
+function trace(message) { this.context.trace(message); }
+
+function debug(message) { this.context.debug(message); }
+
+function info(message) { this.context.info(message); }
+
+function warning(message) { this.context.warning(message); }
+
+function error(message) { this.context.error(message); }
+
+function fatal(message) { this.context.fatal(message); }
+
+const loggingMixins = {
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal
+};
+
+export default loggingMixins;