occam-verify-cli 0.0.1068 → 0.0.1069

package/src/utilities/json.js

@@ -0,0 +1,551 @@
+"use strict";
+
+import shim from "../shim";
+
+export function termFromJSON(json, fileContext) {
+  let { term } = json;
+
+  const termJSON = term;  ///
+
+  json = termJSON;  ///
+
+  const { Term } = shim;
+
+  term = Term.fromJSON(json, fileContext);
+
+  return term;
+}
+
+export function typeFromJSON(json, fileContext) {
+  let { type } = json;
+
+  const { name } = type,
+        typeName = name;  ///
+
+  type = fileContext.findTypeByTypeName(typeName);
+
+  return type;
+}
+
+export function metaTypeFromJSON(json, fileContext) {
+  let { metaType } = json;
+
+  if (metaType !== null) {
+    const { name } = metaType,
+          metaTypeName = name;  ///
+
+    metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName);
+  }
+
+  return metaType;
+}
+
+export function superTypeFromJSON(json, fileContext) {
+  let { superType } = json;
+
+  const superTypeJSON = superType;  ///
+
+  json = superTypeJSON; ///
+
+  const { name } = json,
+        typeName = name,  ///
+        type = fileContext.findTypeByTypeName(typeName);
+
+  superType = type; ///
+
+  return superType;
+}
+
+export function statementFromJSON(json, fileContext) {
+  let { statement } = json;
+
+  const { Statement } = shim,
+        statementJSON = statement;  ///
+
+  json = statementJSON; ///
+
+  statement = Statement.fromJSON(json, fileContext);
+
+  return statement;
+}
+
+export function conclusionFromJSON(json, fileContext) {
+  let { conclusion } = json;
+
+  const { Conclusion } = shim,
+        conclusionJSON = conclusion;  ///
+
+  json = conclusionJSON;  ///
+
+  conclusion = Conclusion.fromJSON(json, fileContext);
+
+  return conclusion;
+}
+
+export function consequentFromJSON(json, fileContext) {
+  let { consequent } = json;
+
+  const { Consequent } = shim,
+        consequentJSON = consequent;  ///
+
+  json = consequentJSON;  ///
+
+  consequent = Consequent.fromJSON(json, fileContext);
+
+  return consequent;
+}
+
+export function metavariableFromJSON(json, fileContext) {
+  let { metavariable } = json;
+
+  const { Metavariable } = shim,
+        metavariableJSON = metavariable;  ///
+
+  json = metavariableJSON; ///
+
+  metavariable = Metavariable.fromJSON(json, fileContext);
+
+  return metavariable;
+}
+
+export function unqualifiedStatementFromJSON(json, fileContext) {
+  let { unqualifiedStatement } = json;
+
+  const { UnqualifiedStatement } = shim,
+        unqualifiedStatementJSON = unqualifiedStatement;  ///
+
+  json = unqualifiedStatementJSON; ///
+
+  unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
+
+  return unqualifiedStatement;
+}
+
+export function typesFromJSON(json, fileContext) {
+  let { types } = json;
+
+  const typesJSON = types; ///
+        types = typesJSON.map((typeJSON) => {
+          const { Type } = shim,
+                json = typeJSON,  ///
+                type = Type.fromJSON(json, fileContext);
+
+          return (type);
+        });
+
+  return types;
+}
+
+export function rulesFromJSON(json, fileContext) {
+  let { rules } = json;
+
+  const rulesJSON = rules; ///
+        rules = rulesJSON.map((ruleJSON) => {
+          const { Rule } = shim,
+                json = ruleJSON,  ///
+                rule = Rule.fromJSON(json, fileContext);
+
+          return (rule);
+        });
+
+  return rules;
+}
+
+export function labelsFromJSON(json, fileContext) {
+  let { labels } = json;
+
+  const { Label } = shim,
+        labelsJSON = labels;  ///
+
+  labels = labelsJSON.map((labelJSON) => {
+    const json = labelJSON, ///
+          label = Label.fromJSON(json, fileContext);
+
+    return label;
+  });
+
+  return labels;
+}
+
+export function axiomsFromJSON(json, fileContext) {
+  let { axioms } = json;
+
+  const axiomsJSON = axioms; ///
+        axioms = axiomsJSON.map((axiomJSON) => {
+          const { Axiom } = shim,
+                json = axiomJSON,  ///
+                axiom = Axiom.fromJSON(json, fileContext);
+
+          return (axiom);
+        });
+
+  return axioms;
+}
+
+export function premisesFromJSON(json, fileContext) {
+  let { premises } = json;
+
+  const { Premise } = shim,
+        premisesJSON = premises;  ///
+
+  premises = premisesJSON.map((premiseJSON) => {
+    const json = premiseJSON, ///
+          premise = Premise.fromJSON(json, fileContext);
+
+    return premise;
+  });
+
+  return premises;
+}
+
+export function theoremsFromJSON(json, fileContext) {
+  let { theorems } = json;
+
+  const theoremsJSON = theorems; ///
+        theorems = theoremsJSON.map((theoremJSON) => {
+          const { Theorem } = shim,
+                json = theoremJSON,  ///
+                theorem = Theorem.fromJSON(json, fileContext);
+
+          return (theorem);
+        });
+
+  return theorems;
+}
+
+export function variablesFromJSON(json, fileContext) {
+  let { variables } = json;
+
+  const variablesJSON = variables; ///
+        variables = variablesJSON.map((variableJSON) => {
+          const { Variable } = shim,
+                json = variableJSON,  ///
+                variable = Variable.fromJSON(json, fileContext);
+
+          return (variable);
+        });
+
+  return variables;
+}
+
+export function conjecturesFromJSON(json, fileContext) {
+  let { conjectures } = json;
+
+  const conjecturesJSON = conjectures; ///
+        conjectures = conjecturesJSON.map((conjectureJSON) => {
+          const { Conjecture } = shim,
+                json = conjectureJSON,  ///
+                conjecture = Conjecture.fromJSON(json, fileContext);
+
+          return (conjecture);
+        });
+
+  return conjectures;
+}
+
+export function combinatorsFromJSON(json, fileContext) {
+  let { combinators } = json;
+
+  const combinatorsJSON = combinators; ///
+        combinators = combinatorsJSON.map((combinatorJSON) => {
+          const { Combinator } = shim,
+                json = combinatorJSON,  ///
+                combinator = Combinator.fromJSON(json, fileContext);
+
+          return (combinator);
+        });
+
+  return combinators;
+}
+
+export function constructorsFromJSON(json, fileContext) {
+  let { constructors } = json;
+
+  const constructorsJSON = constructors; ///
+        constructors = constructorsJSON.map((constructorJSON) => {
+          const { Constructor } = shim,
+                json = constructorJSON,  ///
+                constructor = Constructor.fromJSON(json, fileContext);
+
+          return (constructor);
+        });
+
+  return constructors;
+}
+
+export function metatheoremsFromJSON(json, fileContext) {
+  let { metatheorems } = json;
+
+  const metatheoremsJSON = metatheorems; ///
+        metatheorems = metatheoremsJSON.map((metatheoremJSON) => {
+          const { Metatheorem } = shim,
+                json = metatheoremJSON,  ///
+                metatheorem = Metatheorem.fromJSON(json, fileContext);
+
+          return (metatheorem);
+        });
+
+  return metatheorems;
+}
+
+export function suppositionsFromJSON(json, fileContext) {
+  let { suppositions } = json;
+
+  const { Supposition } = shim,
+        suppositionsJSON = suppositions;  ///
+
+  suppositions = suppositionsJSON.map((suppositionJSON) => {
+    const json = suppositionJSON, ///
+          supposition = Supposition.fromJSON(json, fileContext);
+
+    return supposition;
+  });
+
+  return suppositions;
+}
+
+export function substitutionsFromJSON(json, fileContext) {
+  let { substitutions } = json;
+
+  const { Substitution } = shim,
+        substitutionsJSON = substitutions;  ///
+
+  substitutions = substitutionsJSON.map((substitutionJSON) => {
+    const json = substitutionJSON,  ///
+          substitution = Substitution.fromJSON(json, fileContext);
+
+    return substitution;
+  });
+
+  return substitutions;
+}
+
+export function metavariablesFromJSON(json, fileContext) {
+  let { metavariables } = json;
+
+  const metavariablesJSON = metavariables; ///
+        metavariables = metavariablesJSON.map((metavariableJSON) => {
+          const { Metavariable } = shim,
+                json = metavariableJSON,  ///
+                metavariable = Metavariable.fromJSON(json, fileContext);
+
+          return (metavariable);
+        });
+
+  return metavariables;
+}
+
+export function termToTermJSON(term) {
+  const termJSON = term.toJSON();
+
+  return termJSON;
+}
+
+export function typeToTypeJSON(type) {
+  const typeJSON = type.toJSON();
+
+  return typeJSON;
+}
+
+export function metaTypeToMetaTypeJSON(metaType) {
+  const metaTypeJSON = (metaType !== null) ?
+                         metaType.toJSON() :
+                           null;
+  return metaTypeJSON;
+}
+
+export function superTypeToSuperTypeJSON(superType) {
+  const superTypeJSON = superType.toJSON();
+
+  return superTypeJSON;
+}
+
+export function statementToStatementJSON(statement) {
+  const statementJSON = statement.toJSNO();
+
+  return statementJSON;
+}
+
+export function conclusionToConclusionJSON(conclusion) {
+  const conclusionJSON = conclusion.toJSON();
+
+  return conclusionJSON;
+}
+
+export function consequentToConsequentJSON(consequent) {
+  const consequentJSON = consequent.toJSON();
+
+  return consequentJSON;
+}
+
+export function metavariableToMetavariableJSON(metavariable) {
+  const metavariableJSON = metavariable.toJSNO();
+
+  return metavariableJSON;
+}
+
+export function unqualifiedStatementToUnqualifiedStatementJSON(unqualifiedStatement) {
+  const unqualifiedStatementJSON = unqualifiedStatement.toJSNO();
+
+  return unqualifiedStatementJSON;
+}
+
+export function typesToTypesJSON(types) {
+  const typesJSON = types.map((type) => {
+    const typeJSON = type.toJSON();
+
+    type = typeJSON; ///
+
+    return type;
+  });
+
+  return typesJSON;
+}
+
+export function rulesToRulesJSON(rules) {
+  const rulesJSON = rules.map((rule) => {
+    const ruleJSON = rule.toJSON();
+
+    rule = ruleJSON; ///
+
+    return rule;
+  });
+
+  return rulesJSON;
+}
+
+export function labelsToLabelsJSON(labels) {
+  const labelsJSON = labels.map((label) => {
+    const labelJSON = label.toJSON();
+
+    return labelJSON;
+  });
+
+  return labelsJSON;
+}
+
+export function axiomsToAxiomsJSON(axioms) {
+  const axiomsJSON = axioms.map((axiom) => {
+    const axiomJSON = axiom.toJSON();
+
+    axiom = axiomJSON; ///
+
+    return axiom;
+  });
+
+  return axiomsJSON;
+}
+
+export function premisesToPremisesJSON(premises) {
+  const premisesJSON = premises.map((premise) => {
+    const premiseJSON = premise.toJSON();
+
+    return premiseJSON;
+  });
+
+  return premisesJSON;
+}
+
+export function theoremsToTheoremsJSON(theorems) {
+  const theoremsJSON = theorems.map((theorem) => {
+    const theoremJSON = theorem.toJSON();
+
+    theorem = theoremJSON; ///
+
+    return theorem;
+  });
+
+  return theoremsJSON;
+}
+
+export function variablesToVariablesJSON(variables) {
+  const variablesJSON = variables.map((variable) => {
+    const variableJSON = variable.toJSON();
+
+    variable = variableJSON;  ///
+
+    return variable;
+  });
+
+  return variablesJSON;
+}
+
+export function conjecturesToConjecturesJSON(conjectures) {
+  const conjecturesJSON = conjectures.map((conjecture) => {
+    const conjectureJSON = conjecture.toJSON();
+
+    conjecture = conjectureJSON; ///
+
+    return conjecture;
+  });
+
+  return conjecturesJSON;
+}
+
+export function combinatorsToCombinatorsJSON(combinators) {
+  const combinatorsJSON = combinators.map((combinator) => {
+    const combinatorJSON = combinator.toJSON();
+
+    combinator = combinatorJSON; ///
+
+    return combinator;
+  });
+
+  return combinatorsJSON;
+}
+
+export function suppositionsToSuppositionsJSON(suppositions) {
+  const suppositionsJSON = suppositions.map((supposition) => {
+    const suppositionJSON = supposition.toJSON();
+
+    return suppositionJSON;
+  });
+
+  return suppositionsJSON;
+}
+
+export function constructorsToConstructorsJSON(constructors) {
+  const constructorsJSON = constructors.map((constructor) => {
+    const constructorJSON = constructor.toJSON();
+
+    constructor = constructorJSON;  ///
+
+    return constructor;
+  });
+
+  return constructorsJSON;
+}
+
+export function metatheoremsToMetatheoremsJSON(metatheorems) {
+  const metatheoremsJSON = metatheorems.map((metatheorem) => {
+    const metatheoremJSON = metatheorem.toJSON();
+
+    metatheorem = metatheoremJSON; ///
+
+    return metatheorem;
+  });
+
+  return metatheoremsJSON;
+}
+
+export function substitutionsToSubstitutionsJSON(substitutions) {
+  const substitutionsJSON = substitutions.mapSubstitution((substitution) => {
+    const substitutionJSON = substitution.toJSON();
+
+    return substitutionJSON;
+  });
+
+  return substitutionsJSON;
+}
+
+export function metavariablesToMetavariablesJSON(metavariables) {
+  const metavariablesJSON = metavariables.map((metavariable) => {
+    const metavariableJSON = metavariable.toJSON();
+
+    metavariable = metavariableJSON;  ///
+
+    return metavariable;
+  });
+
+  return metavariablesJSON;
+}

package/src/utilities/node.js

@@ -6,12 +6,10 @@ import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
-         SUBSTITUTION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { variableTokensFromVariableString,
          metavariableTokensFromMetavariableString,
-         substitutionTokensFromSubstitutionString,
          unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
@@ -21,7 +19,8 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
+      substitutionNodeQuery = nodeQuery("/unqualifiedStatement/statement/substitution");
 
 export function termNodeFromTermString(termString, lexer, parser) {
   const constructorDeclarationString = constructorDeclarationStringFromTermString(termString),
@@ -39,15 +38,6 @@ export function variableNodeFromVariableString(variableString, lexer, parser) {
   return variableNode;
 }
 
-export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const unqualifiedStatementString =unqualifiedStatementStringFromStatementString(statementString),
-        unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
-        unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-        statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
-
-  return statementNode;
-}
-
 export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
   const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
         metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
@@ -55,13 +45,6 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
-export function substitutionNodeFromSubstitutionString(substitutionString, lexer, parser) {
-  const substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString, lexer),
-        substitutionNode = substitutionNodeFromSubstitutionTokens(substitutionTokens, parser);
-
-  return substitutionNode;
-}
-
 export function constructorDeclarationStringFromTermString(termString) {
   const constructorDeclarationString = `Constructor ${termString}
 `;
@@ -76,6 +59,13 @@ export function unqualifiedStatementStringFromStatementString(statementString) {
   return unqualifiedStatementString;
 }
 
+export function unqualifiedStatementStringFromSubstitutionString(substitutionString) {
+  const unqualifiedStatementString = `a ${substitutionString}
+`;  ///
+
+  return unqualifiedStatementString;
+}
+
 export function termNodeFromConstructorDeclarationNode(constructorDeclarationNode) {
   const termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
 
@@ -88,6 +78,12 @@ export function statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNo
   return statementNode;
 }
 
+export function substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode) {
+  const substitutionNode = substitutionNodeQuery(unqualifiedStatementNode);
+
+  return substitutionNode;
+}
+
 export function variableNodeFromVariableTokens(variableTokens, parser) {
   const ruleName = VARIABLE_RULE_NAME,
         variableNode = nodeFromTokensRuleNameAndParser(variableTokens, ruleName, parser);
@@ -102,13 +98,6 @@ export function metavariableNodeFromMetavariableTokens(metavariableTokens, parse
   return metavariableNode;
 }
 
-export function substitutionNodeFromSubstitutionTokens(substitutionTokens, parser) {
-  const ruleName = SUBSTITUTION_RULE_NAME,
-        substitutionNode = nodeFromTokensRuleNameAndParser(substitutionTokens, ruleName, parser);
-
-  return substitutionNode;
-}
-
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const tokens = unqualifiedStatementTokens,  ///
         ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,

package/src/{verify → utilities}/release.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export default function verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap) {
+function verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap) {
   let releaseVerified = false;
 
   const releaseContext = releaseContextMap[releaseName];
@@ -42,6 +42,10 @@ export default function verifyRelease(releaseName, dependentName, dependentRelea
   return releaseVerified;
 }
 
+export default {
+  verifyRelease
+};
+
 function verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap) {
   const dependencies = releaseContext.getDependencies(),
         dependencyReleasesVVerified = dependencies.everyDependency((dependency) => {

package/src/utilities/releaseContext.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 const { last } = arrayUtilities;
 
-export function createReleaseContext(dependency, dependentNames, context, callback) {
+function createReleaseContext(dependency, dependentNames, context, callback) {
   const { log, releaseContextMap } = context,
         dependencyName = dependency.getName(),
         releaseName = dependencyName, ///
@@ -87,7 +87,7 @@ export function createReleaseContext(dependency, dependentNames, context, callba
   }, context);
 }
 
-export function initialiseReleaseContext(dependency, context) {
+function initialiseReleaseContext(dependency, context) {
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
         releaseName = dependencyName, ///

package/src/utilities/tokens.js

@@ -25,13 +25,6 @@ export function metavariableTokensFromMetavariableString(metavariableString, lex
   return metavariableTokens;
 }
 
-export function substitutionTokensFromSubstitutionString(substitutionString, lexer) {
-  const substitutionContent = `${substitutionString}`,
-        substitutionTokens = tokensFromContentAndLexer(substitutionContent, lexer);
-
-  return substitutionTokens;
-}
-
 export function unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer) {
   const content = unqualifiedStatementString,  ///
         unqualifiedStatementTokens = tokensFromContentAndLexer(content, lexer);
@@ -60,6 +53,16 @@ export function statementTokensFromUnqualifiedStatementTokens(unqualifiedStateme
   return statementTokens;
 }
 
+export function substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode) {
+  const lastSignificantTokenIndex = substitutionNode.getLastSignificantTokenIndex(unqualifiedStatementTokens),
+        firstSignificantTokenIndex = substitutionNode.getFirstSignificantTokenIndex(unqualifiedStatementTokens),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1,
+        substitutionTokens = unqualifiedStatementTokens.slice(start, end);
+
+  return substitutionTokens;
+}
+
 function tokensFromContentAndLexer(content, lexer = nominalLexer) {
   const tokens = lexer.tokenise(content);