occam-verify-cli 1.0.457 → 1.0.473

package/src/context/file.js

@@ -1,11 +1,12 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
+import { contextUtilities } from "occam-furtle";
 
 import elements from "../elements";
 
+import { LEVELS } from "../constants";
 import { verifyFile } from "../process/verify";
-import { chainContext } from "../utilities/context";
 import { baseTypeFromNothing } from "../types";
 import { nodeAsString, nodesAsString } from "../utilities/node";
 import { typesFromJSON,
@@ -33,7 +34,9 @@ import { typesFromJSON,
          metatheoremsToMetatheoremsJSON,
          metavariablesToMetavariablesJSON } from "../utilities/json";
 
-const { push, filter } = arrayUtilities;
+const { push, filter } = arrayUtilities,
+      { chainContext, lineIndexFromNodeAndTokens } = contextUtilities,
+      [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;
 
 export default class FileContext {
   constructor(context, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables) {
@@ -87,7 +90,7 @@ export default class FileContext {
 
   getEquivalences() {
     const { Equivalences } = elements,
-          equivalences = Equivalences.fromNothing();
+          equivalences = Equivalences.fromNothing(context);
 
     return equivalences;
   }
@@ -250,12 +253,6 @@ export default class FileContext {
     return this.metavariables;
   }
 
-  getFileContext() {
-    const fileContext = this; ///
-
-    return fileContext;
-  }
-
   addType(type) {
     this.types.push(type);
   }
@@ -496,12 +493,9 @@ export default class FileContext {
           specificMetavariable = metavariable;  ///
 
     metavariable = metavariables.find((metavariable) => {
-      const generalMetavariable = metavariable; ///
-
-      metavariable = specificMetavariable;  ///
-
       const context = this, ///
-            metavariableUnifies = generalMetavariable.unifyMetavariable(metavariable, context);
+            generalMetavariable = metavariable, ///
+            metavariableUnifies = generalMetavariable.unifyMetavariable(specificMetavariable, context);
 
       if (metavariableUnifies) {
         return true;
@@ -737,10 +731,8 @@ export default class FileContext {
   isLabelPresentByReference(reference) {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
-            const { Substitutions } = elements,
-                  context = this, ///
-                  substitutions = Substitutions.fromNothing(),
-                  labelUnifies = reference.unifyLabel(label, substitutions, context);
+            const context = this, ///
+                  labelUnifies = reference.unifyLabel(label, context);
 
             if (labelUnifies) {
               return true;
@@ -778,6 +770,20 @@ export default class FileContext {
     return topLevelMetaAssertionPresent;
   }
 
+  getFileContext() {
+    const fileContext = this; ///
+
+    return fileContext;
+  }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
   nodeAsString(node) {
     const string = nodeAsString(node, this.tokens);
 
@@ -791,33 +797,44 @@ export default class FileContext {
   }
 
   trace(message, node = null) {
-    this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
+    const level = TRACE_LEVEL;
 
-    this.context.trace(message, this.filePath, this.lineIndex);
+    this.writeToLog(level, message, node);
   }
 
   debug(message, node = null) {
-    this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
+    const level = DEBUG_LEVEL;
 
-    this.context.debug(message, this.filePath, this.lineIndex);
+    this.writeToLog(level, message, node);
   }
 
   info(message, node = null) {
-    this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
+    const level = INFO_LEVEL;
 
-    this.context.info(message, this.filePath, this.lineIndex);
+    this.writeToLog(level, message, node);
   }
 
   warning(message, node = null) {
-    this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
+    const level = WARNING_LEVEL;
 
-    this.context.warning(message, this.filePath, this.lineIndex);
+    this.writeToLog(level, message, node);
   }
 
   error(message, node = null) {
-    this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
+    const level = ERROR_LEVEL;
 
-    this.context.error(message, this.filePath, this.lineIndex);
+    this.writeToLog(level, message, node);
+  }
+
+  writeToLog(level, message, node) {
+    const lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex),
+          filePath = (lineIndex === null) ?
+                        this.filePath :
+                          null;
+
+    this.context.writeToLog(level, message, filePath, lineIndex);
+
+    this.lineIndex = lineIndex;
   }
 
   verify() {
@@ -835,9 +852,9 @@ export default class FileContext {
 
       verifies = verifyFile(fileNode, context);
 
-      if (!verifies) {
-        this.clear();
-      }
+      verifies ?
+        this.complete() :
+          this.clear();
 
       if (verifies) {
         this.info(`...verified the '${this.filePath}' file.`);
@@ -847,7 +864,24 @@ export default class FileContext {
     return verifies;
   }
 
+  prepare() {
+    if (this.tokens !== null) {
+      return;
+    }
+
+    const file = this.findFile(this.filePath),
+          lexer = this.getLexer(),
+          parser = this.getParser(),
+          content = file.getContent();
+
+    this.tokens = lexer.tokenise(content);
+
+    this.node = parser.parse(this.tokens);
+  }
+
   clear() {
+    this.lineIndex = null;
+
     this.types = [];
     this.rules = [];
     this.axioms = [];
@@ -863,21 +897,8 @@ export default class FileContext {
     this.metavariables = [];
   }
 
-  prepare() {
+  complete() {
     this.lineIndex = null;
-
-    if (this.tokens !== null) {
-      return;
-    }
-
-    const file = this.findFile(this.filePath),
-          lexer = this.getLexer(),
-          parser = this.getParser(),
-          content = file.getContent();
-
-    this.tokens = lexer.tokenise(content);
-
-    this.node = parser.parse(this.tokens);
   }
 
   initialise(json) {
@@ -999,25 +1020,3 @@ export default class FileContext {
     return fileContext;
   }
 }
-
-function lineIndexFromNodeAndTokens(node, tokens, lineIndex) {
-  if (node !== null) {
-    lineIndex = 0;
-
-    const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens);
-
-    tokens.some((token, tokenIndex) => {
-      const tokenEndOfLineToken = token.isEndOfLineToken();
-
-      if (tokenEndOfLineToken) {
-        lineIndex += 1;
-      }
-
-      if (tokenIndex === firstSignificantTokenIndex) {
-        return true;
-      }
-    });
-  }
-
-  return lineIndex;
-}

package/src/context/liminal.js

@@ -0,0 +1,67 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+import { contextUtilities } from "occam-furtle";
+
+const { extract } = arrayUtilities,
+      { chainContext } = contextUtilities;
+
+export default class LiminalContext {
+  constructor(context, substitutions) {
+    this.context = context;
+    this.substitutions = substitutions;
+
+    return chainContext(this);
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getSubstitutions() {
+    let substitutions = this.context.getSubstitutions();
+
+    substitutions = [ ///
+      ...this.substitutions,
+      ...substitutions
+    ]
+
+    return substitutions;
+  }
+
+  addSubstitution(substitution) {
+    const context = this, ///
+          substitutionA = substitution, ///
+          substitutionString = substitution.getString();
+
+    extract(this.substitutions, (substitution) => {
+      const substitutionB = substitution, ///
+            substitutionAEqualToAssertionB = substitutionA.isEqualTo(substitutionB);
+
+      if (substitutionAEqualToAssertionB) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${substitutionString}' substitution to the context.`);
+
+    this.substitutions.push(substitution);
+  }
+
+  getFileContext() { return this.context.getFileContext(); }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
+  static fromNothing(context) {
+    const substitutions = [],
+          emphemeralContext = new LiminalContext(context, substitutions);
+
+    return emphemeralContext;
+  }
+}

package/src/context/{fragment.js → literal.js}

@@ -1,9 +1,12 @@
 "use strict";
 
+import { contextUtilities } from "occam-furtle";
+
 import { nodeAsString } from "../utilities/node";
-import { chainContext } from "../utilities/context";
 
-export default class FragmentContext {
+const { chainContext } = contextUtilities;
+
+export default class LiteralContext {
   constructor(context, tokens) {
     this.context = context;
     this.tokens = tokens;
@@ -29,10 +32,20 @@ export default class FragmentContext {
     return string;
   }
 
+  getFileContext() { return this.context.getFileContext(); }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
   static fromNothing(context) {
     const tokens = null,
-          fragmentContext = new FragmentContext(context, tokens);
+          literalContext = new LiteralContext(context, tokens);
 
-    return fragmentContext;
+    return literalContext;
   }
 }

package/src/context/nominal.js

@@ -16,6 +16,18 @@ class NominalContext {
     return this.parser;
   }
 
+  getFileContext() {
+    const fileContext = null;
+
+    return fileContext;
+  }
+
+  getDepth() {
+    const depth = -1;
+
+    return depth;
+  }
+
   static fromNothing() {
     const lexer = nominalLexer, ///
           parser = nominalParser, ///

package/src/context/release.js

@@ -10,13 +10,15 @@ import FileContext from "../context/file";
 import NominalLexer from "../nominal/lexer";
 import NominalParser from "../nominal/parser";
 
+import { LEVELS } from "../constants";
 import { getMetaTypes } from "../metaTypes";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities,
       { tail, push, first, clear, filter, resolve, compress } = arrayUtilities,
-      { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities;
+      { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities,
+      [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;
 
 export default class ReleaseContext {
   constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
@@ -430,15 +432,51 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  trace(message, filePath = null, lineIndex = null) { this.log.trace(message, filePath, lineIndex); }
+  trace(message, filePath = null, lineIndex = null) {
+    const level = TRACE_LEVEL;
 
-  debug(message, filePath = null, lineIndex = null) { this.log.debug(message, filePath, lineIndex); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  debug(message, filePath = null, lineIndex = null) {
+    const level = DEBUG_LEVEL
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  info(message, filePath = null, lineIndex = null) {
+    const level = INFO_LEVEL;
 
-  info(message, filePath = null, lineIndex = null) { this.log.info(message, filePath, lineIndex); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  warning(message, filePath = null, lineIndex = null) {
+    const level = WARNING_LEVEL;
 
-  warning(message, filePath = null, lineIndex = null) { this.log.warning(message, filePath, lineIndex); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
 
-  error(message, filePath = null, lineIndex = null) { this.log.error(message, filePath, lineIndex); }
+  error(message, filePath = null, lineIndex = null) {
+    const level = ERROR_LEVEL;
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  writeToLog(level, message, filePath, lineIndex) {
+    this.log.write(level, message, filePath, lineIndex);
+  }
+
+  getFileContext() {
+    const fileContext = null;
+
+    return fileContext;
+  }
+
+  getDepth() {
+    const depth = -1;
+
+    return depth;
+  }
 
   initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),

package/src/context/scoped.js

@@ -1,12 +1,12 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
+import { contextUtilities } from "occam-furtle";
 
 import elements from "../elements";
 
-import { chainContext } from "../utilities/context";
-
-const { last } = arrayUtilities;
+const { last } = arrayUtilities,
+      { chainContext } = contextUtilities;
 
 class ScopedContext {
   constructor(context, variables, judgements, equivalences, subproofOrProofAssertions) {
@@ -54,7 +54,9 @@ class ScopedContext {
   getEquivalences() {
     let equivalences = this.context.getEquivalences();
 
-    equivalences = this.equivalences.mergedWith(equivalences);  ///
+    const context = this; ///
+
+    equivalences = this.equivalences.mergedWith(equivalences, context);  ///
 
     return equivalences;
   }
@@ -169,18 +171,7 @@ class ScopedContext {
     this.subproofOrProofAssertions.push(subproofOrProofAssertion);
   }
 
-  findVariableByVariableIdentifier(variableIdentifier, nested = true) {
-    const variables = this.getVariables(nested),
-          variable = variables.find((variable) => {
-            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
-
-            if (variableComparesToVariableIdentifier) {
-              return true;
-            }
-          }) || null;
-
-    return variable;
-  }
+  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
   findJudgementByMetavariable(metavariable) {
     const judgements = this.getJudgements(),
@@ -200,22 +191,17 @@ class ScopedContext {
     return judgement;
   }
 
-  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
-
-  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }
-
-  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
-          variablePresent = (variable !== null);
-
-    return variablePresent;
-  }
+  findVariableByVariableIdentifier(variableIdentifier, nested = true) {
+    const variables = this.getVariables(nested),
+          variable = variables.find((variable) => {
+            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
-  isJudgementPresentByMetavariable(metavariable) {
-    const judgement = this.findJudgementByMetavariable(metavariable),
-          judgementPresent = (judgement !== null);
+            if (variableComparesToVariableIdentifier) {
+              return true;
+            }
+          }) || null;
 
-    return judgementPresent;
+    return variable;
   }
 
   isTermGrounded(term) {
@@ -266,6 +252,20 @@ class ScopedContext {
     return metavariableDefined
   }
 
+  isJudgementPresentByMetavariable(metavariable) {
+    const judgement = this.findJudgementByMetavariable(metavariable),
+          judgementPresent = (judgement !== null);
+
+    return judgementPresent;
+  }
+
+  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
+    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
   compareTermAndPropertyRelation(term, propertyRelation) {
     const context = this, ///
           proofAssertions = this.getProofAssertions(),
@@ -280,11 +280,21 @@ class ScopedContext {
     return comparesToTermAndPropertyRelation;
   }
 
+  getFileContext() { return this.context.getFileContext(); }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
   static fromNothing(context) {
     const { Equivalences } = elements,
           variables = [],
           judgements = [],
-          equivalences = Equivalences.fromNothing(),
+          equivalences = Equivalences.fromNothing(context),
           subproofOrProofAssertions = [],
           scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
 

package/src/context/synthetic.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { contextUtilities } from "occam-furtle";
+
+const { chainContext } = contextUtilities;
+
+export default class SyntheticContext {
+  constructor(context, generalContext, specificContext) {
+    this.context = context;
+    this.generalContext = generalContext;
+    this.specificContext = specificContext;
+
+    return chainContext(this);
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getGeneralContext() {
+    return this.generalContext;
+  }
+
+  getSpecificContext() {
+    return this.specificContext;
+  }
+
+  findTermByTermNode(termNode) { return this.specificContext.findTermByTermNode(termNode); }
+
+  findFrameByFrameNode(frameNode) { return this.specificContext.findFrameByFrameNode(frameNode); }
+
+  findTypeByNominalTypeName(nominalTypeName) { return this.specificContext.findTypeByNominalTypeName(nominalTypeName); }
+
+  isTypePresentByNominalTypeName(nominalTypeName) { return this.specificContext.isTypePresentByNominalTypeName(nominalTypeName); }
+
+  findVariableByVariableIdentifier(variableIdentifier) { return this.generalContext.findVariableByVariableIdentifier(variableIdentifier); }
+
+  findMetavariableByMetavariableName(metavariableName) { return this.generalContext.findMetavariableByMetavariableName(metavariableName); }
+
+  isVariablePresentByVariableIdentifier(variableIdentifier) { this.generalContext.isVariablePresentByVariableIdentifier(variableIdentifier); }
+
+  isMetavariablePresentByMetavariableName(metavariableName) { this.generalContext.isMetavariablePresentByMetavariableName(metavariableName); }
+
+  getFileContext() { return this.context.getFileContext(); }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
+  static fromNothing(generalContext, specificContext) {
+    const context = specificContext,  ///
+          syntheticContext = new SyntheticContext(context, generalContext, specificContext);
+
+    return syntheticContext;
+  }
+}