occam-verify-cli 0.0.1003 → 0.0.1006

package/src/context/local.js

@@ -88,8 +88,6 @@ class LocalContext {
     return lastProofStep;
   }
 
-  getTokens() { return this.context.getTokens(); }
-
   getAxioms() { return this.context.getAxioms(); }
 
   getLemmas() { return this.context.getLemmas(); }
@@ -377,29 +375,29 @@ class LocalContext {
     return metavariable;
   }
 
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
+  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
 
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+
+  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-  findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
+  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
 
-  findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
+  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
 
-  findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
+  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
 
-  findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
+  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
 
-  findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
+  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
 
-  findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
+  findMetaLemmaByReference(reference) { return this.context.findMetaLemmaByReference(reference); }
 
-  findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
+  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
 
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+  findMetatheoremByReference(reference) { return this.context.findMetatheoremByReference(reference); }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -415,8 +413,6 @@ class LocalContext {
 
   error(message, node) { this.context.error(message, node); }
 
-  fatal(message, node) { this.context.fatal(node, message); }
-
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],

package/src/context/release.js

@@ -10,13 +10,14 @@ import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { isFilePathFlorenceFilePath } = filePathUtilities,
-      { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
-      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
+  constructor(log, name, json, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
+    this.json = json;
     this.entries = entries;
     this.released = released;
     this.lexer = lexer;
@@ -25,7 +26,6 @@ export default class ReleaseContext {
     this.initialised = initialised;
     this.fileContexts = fileContexts;
     this.customGrammar = customGrammar;
-    this.loggingDisabled = loggingDisabled;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
@@ -37,6 +37,10 @@ export default class ReleaseContext {
     return this.name;
   }
 
+  getJSON() {
+    return this.json;
+  }
+
   getEntries() {
     return this.entries;
   }
@@ -69,10 +73,6 @@ export default class ReleaseContext {
     return this.customGrammar;
   }
 
-  isLoggingDisabled() {
-    return this.loggingDisabled;
-  }
-
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
@@ -117,10 +117,6 @@ export default class ReleaseContext {
     this.customGrammar = customGrammar;
   }
 
-  setLoggingDisabled(loggingDisabled) {
-    this.loggingDisabled = loggingDisabled;
-  }
-
   setDependencyReleaseContexts(dependencyReleaseContexts) {
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
@@ -404,113 +400,49 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  disableLogging() {
-    const loggingDisabled = true;
-
-    this.setLoggingDisabled(loggingDisabled);
-  }
-
-  enableLogging() {
-    const loggingDisabled = false;
-
-    this.setLoggingDisabled(loggingDisabled);
-  }
-
-  trace(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.trace(message, node, tokens, filePath);
-  }
-
-  debug(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.debug(message, node, tokens, filePath);
-  }
-
-  info(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.info(message, node, tokens, filePath);
-  }
-
-  warning(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
+  trace(message, node = null, tokens = null, filePath = null) { this.log.trace(message, node, tokens, filePath); }
 
-    this.log.warning(message, node, tokens, filePath);
-  }
-
-  error(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.error(message, node, tokens, filePath);
-  }
+  debug(message, node = null, tokens = null, filePath = null) { this.log.debug(message, node, tokens, filePath); }
 
-  fatal(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
+  info(message, node = null, tokens = null, filePath = null) { this.log.info(message, node, tokens, filePath); }
 
-    this.log.fatal(message, node, tokens, filePath);
-  }
+  warning(message, node = null, tokens = null, filePath = null) { this.log.warning(message, node, tokens, filePath); }
 
-  initialise(releaseContexts, verbose) {
-    let initialised;
+  error(message, node = null, tokens = null, filePath = null) { this.log.error(message, node, tokens, filePath); }
 
+  initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
-          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar),
-          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+          nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar),
+          nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-    this.lexer = florenceLexer; ///
+    this.lexer = nominalLexer; ///
 
-    this.parser = florenceParser; ///
+    this.parser = nominalParser; ///
 
     this.dependencyReleaseContexts = tail(releaseContexts);
 
     if (this.released) {
-      const verified = this.verify(verbose);
-
-      initialised = verified;  ///
-    } else {
-      initialised = true;
+      debugger
     }
 
-    this.initialised = initialised;
-
-    return initialised;
+    this.initialised = true;
   }
 
-  verify(verbose = true) {
-    let verified;
+  verify() {
+    let verified = false;
 
-    const releaseContext = this;
+    const releaseContext = this,  ///
+          fileContexts = fileContextsFromEntries(this.entries, releaseContext),
+          fileContextsVerified = verifyFileContexts(fileContexts, releaseContext);
 
-    if (!verbose) {
-      releaseContext.disableLogging();
-    }
-
-    this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);
-
-    const fileContextsVerified = verifyFileContexts(this.fileContexts, releaseContext);
+    if (fileContextsVerified) {
+      this.fileContexts = fileContexts;
 
-    verified = fileContextsVerified;  ///
+      this.verified = true;
 
-    if (!verbose) {
-      releaseContext.enableLogging();
+      verified = true;
     }
 
-    this.verified = verified;
-
     return verified;
   }
 
@@ -525,16 +457,15 @@ export default class ReleaseContext {
     return json;
   }
 
-  static fromLogNameEntriesAndReleased(log, name, entries, released) {
+  static fromLogNameJSONEntriesAndReleased(log, name, json, entries, released) {
     const lexer = null,
           parser = null,
           verified = false,
           initialised = false,
           fileContexts = [],
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          loggingDisabled = false,
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, name, json, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
 
     return releaseContext;
   }

package/src/declaration/combinator.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import Combinator from "../combinator";
+
+export default class CombinatorDeclaration {
+  constructor(combinator) {
+    this.combinator = combinator;
+  }
+
+  getCombinator() {
+    return this.combinator;
+  }
+
+  getString() { return this.combinator.getString(); }
+
+  verify(fileContext) {
+    let verified;
+
+    const ocmbinatorDeclarationString = this.getString(); ///
+
+    fileContext.trace(`Verifying the '${ocmbinatorDeclarationString}' combinator declaration...`);
+
+    const combinatorVerified = this.combinator.verify(fileContext);
+
+    if (combinatorVerified) {
+      fileContext.addCombinator(this.combinator);
+
+      verified = true;
+    }
+
+    if (verified) {
+      fileContext.debug(`...verified the '${ocmbinatorDeclarationString}' combinator declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+    const combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+          combinatorDeclaration = new CombinatorDeclaration(combinator);
+
+    return combinatorDeclaration;
+  }
+}

package/src/derivation.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import ProofStep from "./proofStep";
+
+import { last } from "./utilities/array";
+import { nodesQuery } from "./utilities/query";
+
+const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
+
+export default class Derivation {
+  constructor(proofSteps) {
+    this.proofSteps = proofSteps;
+  }
+
+  getProofSteps() {
+    return this.proofSteps;
+  }
+
+  getLastProofStep() {
+    const lastProofStep = last(this.proofSteps);
+
+    return lastProofStep;
+  }
+
+  verify(substitutions, localContext) {
+    let verified;
+
+    verified = this.proofSteps.every((proofStep) => { ///
+      const proofStepVerified = proofStep.verify(substitutions, localContext);
+
+      if (proofStepVerified) {
+        return true;
+      }
+    });
+
+    return verified;
+  }
+
+  static fromDerivationNode(derivationNode, fileContext) {
+    const proofStepNodes = proofStepNodesQuery(derivationNode),
+          proofSteps = proofStepNodes.map((proofStepNode) => {
+            const proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
+
+            return proofStep;
+          }),
+          derivation = new Derivation(proofSteps);
+
+    return derivation;
+  }
+}

package/src/equality.js

@@ -5,16 +5,11 @@ import equalityUnifier from "./unifier/equality";
 import { first, second } from "./utilities/array";
 
 export default class Equality {
-  constructor(node, leftTerm, rightTerm) {
-    this.node = node;
+  constructor(leftTerm, rightTerm) {
     this.leftTerm = leftTerm;
     this.rightTerm = rightTerm;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getLeftTerm() {
     return this.leftTerm;
   }
@@ -67,9 +62,7 @@ export default class Equality {
           leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
 
     if (leftTermTypeComparableToRightTermType) {
-      const node = equalityNode;  ///
-
-      equality = new Equality(node, leftTerm, rightTerm);
+      equality = new Equality(leftTerm, rightTerm);
     }
 
     return equality;

package/src/index.js

@@ -5,4 +5,3 @@ 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";
-

package/src/judgement.js

@@ -1,16 +1,11 @@
 "use strict";
 
 export default class Judgement {
-  constructor(node, frame, declaration) {
-    this.node = node;
+  constructor(frame, declaration) {
     this.frame = frame;
     this.declaration = declaration;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getFrame() {
     return this.frame;
   }
@@ -24,8 +19,7 @@ export default class Judgement {
   matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
 
   static fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration) {
-    const node = judgementNode, ///
-          judgement = new Judgement(node, frame, declaration);
+    const judgement = new Judgement(frame, declaration);
 
     return judgement;
   }

package/src/label.js

@@ -1,30 +1,73 @@
 "use strict";
 
-import { nodeAsString } from "./utilities/string";
+import Metavariable from "./metavariable";
+
+import { nodeQuery } from "./utilities/query";
+
+const metavariableNodeQuery = nodeQuery("//label/metavariable");
 
 export default class Label {
-  constructor(metavariableNode) {
-    this.metavariableNode = metavariableNode;
+  constructor(metavariable) {
+    this.metavariable = metavariable;
+  }
+
+  getMetavariable() {
+    return this.metavariable;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
+  getString() { return this.metavariable.getString(); }
+
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+
+  verify(fileContext) {
+    let verified = false;
+
+    const labelString = this.getString(); ///
+
+    fileContext.trace(`Verifying the '${labelString}' label...`);
+
+    const metavariableNode = this.metavariable.getNode(),
+          labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
+
+    if (labelPresent) {
+      fileContext.debug(`The '${labelString}' label is already present.`);
+    } else {
+      verified = true;
+    }
+
+    if (verified) {
+      fileContext.debug(`...verified the '${labelString}' label.`);
+    }
+
+    return verified;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+  toJSON() {
+    const metavariableJSON = this.metavariable.toJSON(),
+          metavariable = metavariableJSON,  ///
+          json = {
+            metavariable
+          };
 
-    return metavariableNodeMatches;
+    return json;
   }
 
-  asString(tokens) {
-    const string = nodeAsString(this.metavariableNode, tokens);
+  static fromJSON(json, fileContext) {
+    let { metavariable } = json;
 
-    return string;
+    json = metavariable;  ///
+
+    metavariable = Metavariable.fromJSON(json, fileContext);
+
+    const label = new Label(metavariable);
+
+    return label;
   }
 
-  static fromMetavariableNode(metavariableNode) {
-    const label = new Label(metavariableNode);
+  static fromLabelNode(labelNode, fileContext) {
+    const metavariableNode = metavariableNodeQuery(labelNode),
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, fileContext),
+          label = new Label(metavariable);
 
     return label;
   }

package/src/log.js

@@ -4,7 +4,7 @@ import { levels } from "necessary";
 
 import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "./utilities/message";
 
-const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
+const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL } = levels;
 
 export default class Log {
   constructor(messages, logLevel, follow) {
@@ -55,20 +55,13 @@ export default class Log {
     this.write(level, message, node, tokens, filePath);
   }
 
-  fatal(message, node, tokens, filePath) {
-    const level = FATAL_LEVEL;
-
-    this.write(level, message, node, tokens, filePath);
-  }
-
   write(level, message, node, tokens, filePath) {
     const levels = [
             TRACE_LEVEL,
             DEBUG_LEVEL,
             INFO_LEVEL,
             WARNING_LEVEL,
-            ERROR_LEVEL,
-            FATAL_LEVEL,
+            ERROR_LEVEL
           ],
           levelIndex = levels.indexOf(level),
           logLevelIndex = levels.indexOf(this.logLevel);

package/src/metaType.js

@@ -1,8 +1,10 @@
 "use strict";
 
+import shim from "./shim";
+
 import { metaTypeNameFromMetaTypeNode } from "./utilities/name";
 
-export default class MetaType {
+class MetaType {
   constructor(name) {
     this.name = name;
   }
@@ -17,13 +19,6 @@ export default class MetaType {
     return equalTo;
   }
 
-  match(metaType) {
-    const equalToMetaType = this.isEqualTo(metaType),
-          matches = equalToMetaType;  ///
-
-    return matches;
-  }
-
   matchName(name) {
     const nameMatches = (this.name === name);
 
@@ -44,21 +39,38 @@ export default class MetaType {
     return metaTypeNodeMatches;
   }
 
-  asString(tokens) {
-    const string = `${this.name}`;
+  toJSON() {
+    const name = this.name,
+          json = {
+            name
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { name } = json,
+          metaType = new MetaType(name);
 
-    return string;
+    return metaType;
   }
 
-  static fromMetaTypeName(metaTypeName) {
-    const name = metaTypeName,  ///
+  static fromMetaTypeNode(metaTypeNode, localContext) {
+    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+          name = metaTypeName,  ///
           metaType = new MetaType(name);
 
     return metaType;
   }
 }
 
-export function metaTypeFromJSONAndFileContext(json, fileContext) {
+Object.assign(shim, {
+  MetaType
+});
+
+export default MetaType;
+
+export function metaTypeFromJSON(json, fileContext) {
   let metaType;
 
   const { name } = json;