occam-verify-cli 0.0.526 → 0.0.529

package/src/context/proof.js

@@ -1,10 +1,11 @@
 "use strict";
 
+import Equality from "../equality";
 import fileMixins from "../mixins/file";
 import loggingMixins from "../mixins/logging";
-import callbacksMixins from "../mixins/callbacks";
 
 import { push, last } from "../utilities/array";
+import { MAXIMUM_INDEXES_LENGTH } from "../constants";
 
 class ProofContext {
   constructor(context, variables, proofSteps) {
@@ -17,6 +18,18 @@ class ProofContext {
     return this.context;
   }
 
+  getVariables() {
+    const variables = [];
+
+    push(variables, this.variables);
+
+    const contextVariables = this.context.getVariables();
+
+    push(variables, contextVariables);
+
+    return variables;
+  }
+
   getProofSteps() {
     let proofSteps = this.context.getProofSteps();
 
@@ -28,34 +41,34 @@ class ProofContext {
     return proofSteps;
   }
 
-  getTypes() { return this.context.getTypes(); }
-
-  getAxioms() { return this.context.getAxioms(); }
-
-  getLemmas() { return this.context.getLemmas(); }
-
-  getTheorems() { return this.context.getTheorems(); }
-
-  getCombinators() { return this.context.getCombinators(); }
+  getLastProofStep() {
+    let lastProofStep = null;
 
-  getConstructors() { return this.context.getConstructors(); }
+    const proofStepsLength = this.proofSteps.length;
 
-  getVariables() {
-    const variables = [];
+    if (proofStepsLength > 0) {
+      lastProofStep = last(this.proofSteps);
+    }
 
-    push(variables, this.variables);
+    return lastProofStep;
+  }
 
-    const contextVariables = this.context.getVariables();
+  getMetavariables() { return this.context.getMetavariables(); }
 
-    push(variables, contextVariables);
+  getEqualities() {
+    const equalities = [],
+          start = -MAXIMUM_INDEXES_LENGTH,  ///
+          proofSteps = this.proofSteps.slice(start); ///
 
-    return variables;
-  }
+    proofSteps.forEach((proofStep) => {
+      const equality = Equality.fromProofStep(proofStep);
 
-  getLastProofStep() {
-    const lastProofStep = last(this.proofSteps);
+      if (equality !== null) {
+        equalities.push(equality);
+      }
+    });
 
-    return lastProofStep;
+    return equalities;
   }
 
   addVariable(variable) {
@@ -67,15 +80,19 @@ class ProofContext {
   }
 
   matchStatement(statementNode) {
-    let statementMatches;
+    let statementMatches = false;
 
-    statementMatches = this.proofSteps.some((proofStep) => {
-      statementMatches = proofStep.matchStatement(statementNode);
+    if (!statementMatches) {
+      const proofStepMatchesStatement = this.proofSteps.some((proofStep) => {
+        const proofStepMatchesStatement = proofStep.match(statementNode);
 
-      if (statementMatches) {
-        return true;
-      }
-    });
+        if (proofStepMatchesStatement) {
+          return true;
+        }
+      });
+
+      statementMatches = proofStepMatchesStatement; ///
+    }
 
     if (!statementMatches) {
       statementMatches = this.context.matchStatement(statementNode);
@@ -100,31 +117,11 @@ class ProofContext {
 
   isVariablePresentByVariableName(variableName) {
     const variable = this.findVariableByVariableName(variableName),
-        variablePresent = (variable !== null);
+          variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findLabelByTypeName(labelName) { return this.context.findLabelByTypeName(labelName); }
-
-  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
-
-  findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
-
-  findLemmaByReferenceName(referenceName) { return this.context.findLemmaByReferenceName(referenceName); }
-
-  findTheoremByReferenceName(referenceName) { return this.context.findTheoremByReferenceName(referenceName); }
-
-  isLabelPresentByLabelName(labelName) { return this.context.isLabelPresentByLabelName(labelName); }
-
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
-
-  nodeAsString(node) { return this.context.nodeAsString(node); }
-
-  nodesAsString(node) { return this.context.nodesAsString(node); }
-
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],
@@ -147,6 +144,12 @@ class ProofContext {
 
 Object.assign(ProofContext.prototype, fileMixins);
 Object.assign(ProofContext.prototype, loggingMixins);
-Object.assign(ProofContext.prototype, callbacksMixins);
 
 export default ProofContext;
+
+function equalitiesFromProofSteps(proofSteps, context) {
+  let equalities = [];
+
+
+  return equalities;
+}

package/src/context/release/directory.js

@@ -6,8 +6,8 @@ import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
 
 export default class DirectoryReleaseContext extends ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, fileContexts) {
-    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
+  constructor(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts, fileContexts) {
+    super(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts);
 
     this.fileContexts = fileContexts;
   }
@@ -149,6 +149,30 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return theorems;
   }
 
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConjectures = fileContext.getConjectures(includeRelease);
+
+      push(conjectures, fileContextConjectures);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 
@@ -213,14 +237,14 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return json;
   }
 
-  static fromLogNameEntriesAndCallbacks(log, name, entries, callbacks) {
-    const verified = false,
+  static fromLogNameAndEntries(log, name, entries) {
+    const lexer = null,
+          parser = null,
+          verified = false,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          florenceLexer = null,
-          florenceParser = null,
           dependencyReleaseContexts = null,
           fileContexts = [],
-          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, fileContexts);
+          directoryReleaseContext = new DirectoryReleaseContext(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts, fileContexts);
 
     return directoryReleaseContext;
   }

package/src/context/release/file.js

@@ -2,29 +2,29 @@
 
 import ReleaseContext from "../../context/release";
 
-import { rewriteNodes } from "occam-grammar-utilities";
-
 import Rule from "../../rule";
 import Type from "../../type";
 import Axiom from "../../axiom";
 import Lemma from "../../lemma";
 import Theorem from "../../theorem";
+import Conjecture from "../../conjecture";
 import Combinator from "../../combinator";
 import Constructor from "../../constructor";
 
 import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
-import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, THEOREM_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
+import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, THEOREM_KIND, CONJECTURE_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
 
 export default class FileReleaseContext extends ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors) {
-    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
+  constructor(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, contextJSON) {
+    super(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts);
 
     this.types = types;
     this.rules = rules;
     this.axioms = axioms;
     this.lemmas = lemmas;
     this.theorems = theorems;
+    this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
     this.contextJSON = contextJSON;
@@ -153,6 +153,25 @@ export default class FileReleaseContext extends ReleaseContext {
     return theorems;
   }
 
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
+
+    push(conjectures, this.conjectures);
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 
@@ -191,29 +210,17 @@ export default class FileReleaseContext extends ReleaseContext {
     return constructors;
   }
 
-  nodeFromContentAndRuleName(content, ruleName) {
-    const ruleMap = this.florenceParser.getRuleMap(),
-          rule = ruleMap[ruleName],
-          tokens = this.florenceLexer.tokenise(content),
-          node = this.florenceParser.parse(tokens, rule);
-
-    if (node !== null) {
-      rewriteNodes(node);
-    }
-
-    return node;
-  }
-
   fromJSON() {
     const jsonArray = this.contextJSON,
-          releaseContext = this;  ///
+          lexer = this.getLexer(),
+          parser = this.getParser();
 
     jsonArray.forEach((json) => {
       const { kind } = json;
 
       switch (kind) {
         case TYPE_KIND: {
-          const type = Type.fromJSON(json, releaseContext);
+          const type = Type.fromJSON(json, lexer, parser);
 
           this.types.push(type);
 
@@ -221,7 +228,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case RULE_KIND: {
-          const rule = Rule.fromJSON(json, releaseContext);
+          const rule = Rule.fromJSON(json, lexer, parser);
 
           this.rules.push(rule);
 
@@ -229,7 +236,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case AXIOM_KIND: {
-          const axiom = Axiom.fromJSON(json, releaseContext);
+          const axiom = Axiom.fromJSON(json, lexer, parser);
 
           this.axioms.push(axiom);
 
@@ -237,7 +244,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case LEMMA_KIND: {
-          const lemma = Lemma.fromJSON(json, releaseContext);
+          const lemma = Lemma.fromJSON(json, lexer, parser);
 
           this.lemmas.push(lemma);
 
@@ -245,15 +252,23 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case THEOREM_KIND: {
-          const theorem = Theorem.fromJSON(json, releaseContext);
+          const theorem = Theorem.fromJSON(json, lexer, parser);
 
           this.theorems.push(theorem);
 
           break;
         }
 
+        case CONJECTURE_KIND: {
+          const conjecture = Conjecture.fromJSON(json, lexer, parser);
+
+          this.conjectures.push(conjecture);
+
+          break;
+        }
+
         case COMBINATOR_KIND: {
-          const combinator = Combinator.fromJSON(json, releaseContext);
+          const combinator = Combinator.fromJSON(json, lexer, parser);
 
           this.combinators.push(combinator);
 
@@ -261,7 +276,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case CONSTRUCTOR_KIND: {
-          const constructor = Constructor.fromJSON(json, releaseContext);
+          const constructor = Constructor.fromJSON(json, lexer, parser);
 
           this.constructors.push(constructor);
 
@@ -277,20 +292,21 @@ export default class FileReleaseContext extends ReleaseContext {
     this.fromJSON();
   }
 
-  static fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {
-    const verified = true,
+  static fromLogNameEntriesAndContextJSON(log, name, entries, contextJSON) {
+    const lexer = null,
+          parser = null,
+          verified = true,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          florenceLexer = null,
-          florenceParser = null,
           dependencyReleaseContexts = null,
           types = [],
           rules = [],
           axioms = [],
           lemmas = [],
           theorems = [],
+          conjectures = [],
           combinators = [],
           constructors = [],
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors);
+          releaseContext = new FileReleaseContext(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, contextJSON);
 
     return releaseContext;
   }

package/src/context/release.js

@@ -8,20 +8,19 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts) {
+  constructor(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
     this.entries = entries;
-    this.callbacks = callbacks;
+    this.lexer = lexer;
+    this.parser = parser;
     this.verified = verified;
     this.customGrammar = customGrammar;
-    this.florenceLexer = florenceLexer;
-    this.florenceParser = florenceParser;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
   getLog() {
-    return this.log;
+    return log;
   }
 
   getName() {
@@ -32,8 +31,12 @@ export default class ReleaseContext {
     return this.entries;
   }
 
-  getCallbacks() {
-    return this.callbacks;
+  getLexer() {
+    return this.lexer;
+  }
+
+  getParser() {
+    return this.parser;
   }
 
   isVerified() {
@@ -44,14 +47,6 @@ export default class ReleaseContext {
     return this.customGrammar;
   }
 
-  getFlorenceLexer() {
-    return this.florenceLexer;
-  }
-
-  getFlorenceParser() {
-    return this.florenceParser;
-  }
-
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
@@ -96,27 +91,21 @@ export default class ReleaseContext {
     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); }
+  tokenise(content) { return this.lexer.tokenise(content); }
 
-  info(message) { this.log.info(message); }
+  parse(tokens) { return this.parser.parse(tokens); }
 
-  warning(message) { this.log.warning(message); }
+  trace(message, node = null, tokens = null, filePath = null) { this.log.trace(message, node, tokens, filePath); }
 
-  error(message) { this.log.error(message); }
+  debug(message, node = null, tokens = null, filePath = null) { this.log.debug(message, node, tokens, filePath); }
 
-  fatal(message) { this.log.fatal(message); }
+  info(message, node = null, tokens = null, filePath = null) { this.log.info(message, node, tokens, filePath); }
 
-  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }
+  warning(message, node = null, tokens = null, filePath = null) { this.log.warning(message, node, tokens, filePath); }
 
-  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }
+  error(message, node = null, tokens = null, filePath = null) { this.log.error(message, node, tokens, filePath); }
 
-  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
+  fatal(message, node = null, tokens = null, filePath = null) { this.log.fatal(message, node, tokens, filePath); }
 
   initialise(dependencyReleaseContexts) {
     const releaseContext = this,  ///
@@ -124,11 +113,13 @@ export default class ReleaseContext {
             releaseContext,
             ...dependencyReleaseContexts
           ],
-          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
+          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
+          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
+          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+    this.lexer = florenceLexer; ///
 
-    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+    this.parser = florenceParser; ///
 
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }