occam-verify-cli 0.0.1010 → 0.0.1012

package/src/declaration/constructor.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import Constructor from "../constructor";
+
+export default class ConstructorDeclaration {
+  constructor(fileContext, constructor) {
+    this.fileContext = fileContext;
+    this.constructor = constructor;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getConstructor() {
+    return this.constructor;
+  }
+
+  getString() { return this.constructor.getString(); }
+
+  verify() {
+    let verified;
+
+    const constructorDeclarationString = this.getString(); ///
+
+    this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+
+    const constructorVerified = this.constructor.verify(this.fileContext);
+
+    if (constructorVerified) {
+      this.fileContext.addConstructor(this.constructor);
+
+      verified = true;
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+    const constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+          constructorDeclaration = new ConstructorDeclaration(fileContext, constructor);
+
+    return constructorDeclaration;
+  }
+}

package/src/declaration/metavariable.js

@@ -8,11 +8,16 @@ import { nodeQuery } from "../utilities/query";
 const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
 
 export default class MetavariableDeclaration {
-  constructor(string, metavariable) {
+  constructor(fileContext, string, metavariable) {
+    this.fileContext = fileContext;
     this.string = string;
     this.metavariable = metavariable;
   }
 
+  getFileContext() {
+    return this.fileContext;
+  }
+
   getString() {
     return this.string;
   }
@@ -21,23 +26,23 @@ export default class MetavariableDeclaration {
     return this.metavariable;
   }
 
-  verify(fileContext) {
+  verify() {
     let verified;
 
     const metavariableDeclarationString = this.string; ///
 
-    fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
+    this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerified = this.metavariable.verify(fileContext);
+    const metavariableVerified = this.metavariable.verify(this.fileContext);
 
     if (metavariableVerified) {
-      fileContext.addMetavariable(this.metavariable);
+      this.fileContext.addMetavariable(this.metavariable);
 
       verified = true;
     }
 
     if (verified) {
-      fileContext.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
+      this.fileContext.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
     }
 
     return verified;
@@ -50,7 +55,7 @@ export default class MetavariableDeclaration {
           metavariableString = metavariable.getString(),
           metaTypeString = metaType.getString(),
           string = `${metavariableString}:${metaTypeString}`,
-          metavariableDeclaration = new MetavariableDeclaration(string, metavariable);
+          metavariableDeclaration = new MetavariableDeclaration(fileContext, string, metavariable);
 
     return metavariableDeclaration;
   }

package/src/declaration/type.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import Type from "../type";
+
+export default class TypeDeclaration {
+  constructor(fileContext, type) {
+    this.fileContext = fileContext;
+    this.type = type;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getString() { return this.type.getString(); }
+
+  verify() {
+    let verified = false;
+
+    const typeDeclarationString = this.getString(); ///
+
+    this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
+
+    const typeVerified = this.type.verify(this.fileContext);
+
+    if (typeVerified) {
+      this.fileContext.addType(this.type);
+
+      verified = true;
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
+    const type = Type.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
+          typeDeclaration = new TypeDeclaration(fileContext, type);
+
+    return typeDeclaration;
+  }
+}

package/src/error.js

@@ -0,0 +1,35 @@
+"use strict";
+
+export default class Error {
+  constructor(fileContext, string) {
+    this.fileContext = fileContext;
+    this.string = string;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  verify(errorNode) {
+    let verified = false;
+
+    const errorString = this.string;  ///
+
+    this.fileContext.debug(`The '${errorString}' error cannot be verified.`, errorNode);
+
+    return verified;
+  }
+
+  static fromErrorNode(errorNode, fileContext) {
+    const node = errorNode, ///
+          string = fileContext.nodeAsString(node),
+          error = new Error(fileContext, string);
+
+    return error;
+  }
+}
+

package/src/rule.js

@@ -90,15 +90,15 @@ export default class Rule {
     return proofStepsUnified;
   }
 
-  verify(fileContext) {
+  verify() {
     let verified = false;
 
     const labelsString = labelsStringFromLabels(this.labels);
 
-    fileContext.trace(`Verifying the '${labelsString}' rule...`);
+    this.fileContext.trace(`Verifying the '${labelsString}' rule...`);
 
     const labelsVerified = this.labels.every((label) => {
-      const labelVVerified = label.verify(fileContext);
+      const labelVVerified = label.verify(this.fileContext);
 
       if (labelVVerified) {
         return true;
@@ -106,7 +106,7 @@ export default class Rule {
     });
 
     if (labelsVerified) {
-      const localContext = LocalContext.fromFileContext(fileContext),
+      const localContext = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
               const premiseVerified = premise.verify(localContext);
 
@@ -130,7 +130,7 @@ export default class Rule {
           if (proofVerified) {
             const rule = this;  ///
 
-            fileContext.addRule(rule);
+            this.fileContext.addRule(rule);
 
             verified = true;
           }
@@ -139,7 +139,7 @@ export default class Rule {
     }
 
     if (verified) {
-      fileContext.debug(`...verified the '${labelsString}' rule.`);
+      this.fileContext.debug(`...verified the '${labelsString}' rule.`);
     }
 
     return verified;

package/src/ruleNames.js

@@ -3,3 +3,4 @@
 export const TERM_RULE_NAME = "term";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
+export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/statement.js

@@ -75,18 +75,18 @@ class Statement {
     return unifiedWithMetaType;
   }
 
-  verifyAsCombinator(localContext) {
+  verifyAsCombinator(fileContext) {
     let verifiedAsCombinator;
 
     const statementNode = this.node,  ///
           statementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${statementString}' statement as a combinator...`);
+    fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`);
 
-    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, localContext);
+    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
     if (verifiedAsCombinator) {
-      localContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
+      fileContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
     }
 
     return verifiedAsCombinator;

package/src/term.js

@@ -1,16 +1,25 @@
 "use strict";
 
+import shim from "./shim";
+import termAsConstructorVerifier from "./verifier/termAsConstructor";
+
 import { filter } from "./utilities/array";
 import { nodesQuery } from "./utilities/query"
+import { termNodeFromTermString } from "./utilities/node";
 
 const variableNodesQuery = nodesQuery("//variable");
 
-export default class Term {
-  constructor(node, type) {
+class Term {
+  constructor(string, node, type) {
+    this.string = string;
     this.node = node;
     this.type = type;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getNode() {
     return this.node;
   }
@@ -81,10 +90,116 @@ export default class Term {
     return implicitlyGrounded;
   }
 
-  static fromTermNodeAndType(termNode, type) {
+  verify(localContext, verifyAhead) {
+    let verified = false;
+
+    debugger
+
+    return verified;
+  }
+
+  verifyType(fileContext) {
+    let typeVerified;
+
+    if (this.type === null) {
+      typeVerified = true;
+    } else {
+      const typeName = this.type.getName();
+
+      fileContext.trace(`Verifying the '${typeName}' type...`);
+
+      const type = fileContext.findTypeByTypeName(typeName);
+
+      if (type === null) {
+        fileContext.debug(`The '${typeName}' type is missing.`);
+      } else {
+        this.type = type; ///
+
+        typeVerified = true;
+      }
+
+      if (typeVerified) {
+        fileContext.debug(`...verified the '${typeName}' type.`);
+      }
+    }
+
+    return typeVerified;
+  }
+
+  verifyAsConstructor(fileContext) {
+    let verifiedAsConstructor;
+
+    const termNode = this.node,  ///
+          termString = this.string;  ///
+
+    fileContext.trace(`Verifying the '${termString}' term as a constructor...`);
+
+    verifiedAsConstructor = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
+
+    if (verifiedAsConstructor) {
+      fileContext.debug(`...verified the '${termString}' term as a constructor.`, termNode);
+    }
+
+    return verifiedAsConstructor;
+  }
+
+  toJSON() {
+    const typeJSON = (this.type !== null) ?
+                       this.type.toJSON() :
+                         null,
+          string = this.string,
+          type = typeJSON,  ///
+          json = {
+            string,
+            type
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json,
+          termString = string,  ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          termNode = termNodeFromTermString(termString, lexer, parser),
+          node = termNode;
+
+    let { type } = json;
+
+    const typeJSON = type;  ///
+
+    json = typeJSON;  ///
+
+    type = (json !== null) ?
+            Type.fromJSON(json, fileContext) :
+              null;
+
+    const term = new Term(string, node, type);
+
+    return term;
+  }
+
+  static fromTermNode(termNode, fileContext) {
+    const node = termNode,  ///
+          string = fileContext.nodeAsString(node),
+          type = null,
+          term = new Term(string, node, type);
+
+    return term;
+  }
+
+  static fromTermNodeAndType(termNode, type, fileContext) {
     const node = termNode,  ///
-          term = new Term(node, type);
+          string = fileContext.nodeAsString(node),
+          term = new Term(string, node, type);
 
     return term;
   }
 }
+
+Object.assign(shim, {
+  Term
+});
+
+export default Term;

package/src/type.js

@@ -1,15 +1,25 @@
 "use strict";
 
-import { OBJECT_TYPE_NAME } from "./typeNames";
+import shim from "./shim";
 
+import { nodeQuery } from "./utilities/query";
+import { OBJECT_TYPE_NAME } from "./typeNames";
 import { typeNameFromTypeNode } from "./utilities/name";
 
-export default class Type {
-  constructor(name, superType) {
+const typeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
+      superTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
+
+class Type {
+  constructor(string, name, superType) {
+    this.string = string;
     this.name = name;
     this.superType = superType;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getName() {
     return this.name;
   }
@@ -111,36 +121,122 @@ export default class Type {
     return typeNodeMatches;
   }
 
-  asString(tokens, noSuperType = false) {
-    let string;
+  verify(fileContext) {
+    let verified = false;
 
-    if (noSuperType) {
-      string = `${this.name}`;
+    const typeString = this.string; ///
+
+    fileContext.trace(`Verifying the '${typeString}' type...`);
+
+    const typePresent = fileContext.isTypePresentByTypeName(this.name);
+
+    if (typePresent) {
+      fileContext.debug(`The type '${typeString}' is already present.`);
     } else {
-      const superTypeName = this.superType.getName();
+      if (this.superType === null) {
+        verified = true;
+      } else {
+        const name = this.superType.getName(),
+              superTypePresent = fileContext.isTypePresentByTypeName(name);
+
+        if (superTypePresent) {
+          verified = true;
+        } else {
+          const superTypeString = this.superType.getString();
+
+          fileContext.debug(`The super-type '${superTypeString}' is not present.`);
+        }
+      }
+    }
 
-      string = `${this.name}:${superTypeName}`;
+    if (verified) {
+      fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
-    return string;
+    return verified;
+  }
+
+  toJSON() {
+    const superTypeJSON = (this.superType !== null) ?
+                            this.superType.toJSON() :
+                              null,
+          name = this.name,
+          superType = superTypeJSON,  ///
+          json = {
+            name,
+            superType
+          };
+
+    return json;
   }
 
-  static fromTypeName(typeName) {
-    const name = typeName,  ///
-          superType = objectType, ///
-          type = new Type(name, superType);
+  static fromJSON(json, fileContext) {
+    const { name } = json;
+
+    let { superType } = json;
+
+    const superTypeJSON = superType;  ///
+
+    json = superTypeJSON; ///
+
+    superType = (json !== null) ?
+                   Type.fromJSON(json, fileContext) :
+                      null;
+
+    const typeName = name,  ///
+          string = stringFromTypeNameAndSuperType(typeName, superType),
+          type = new Type(string, name, superType);
+
+    return type;
+  }
+
+  static fromTypeNode(typeNode) {
+    let type = null;
+
+    if (typeNode !== null) {
+      const typeName = typeNameFromTypeNode(typeNode),
+            name = typeName,  ///
+            string = name,  ///
+            superType = null;
+
+      type = new Type(string, name, superType);
+    }
 
     return type;
   }
 
-  static fromTypeNameAndSuperType(typeName, superType) {
-    const name = typeName,  ///
-          type = new Type(name, superType);
+  static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
+    const typeNode = typeNodeQuery(typeDeclarationNode),
+          superTypeNode = superTypeNodeQuery(typeDeclarationNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          superType = Type.fromTypeNode(superTypeNode),
+          string = stringFromTypeNameAndSuperType(typeName, superType),
+          name = typeName,  ///
+          type = new Type(string, name, superType);
 
     return type;
   }
 }
 
+function stringFromTypeNameAndSuperType(typeName, superType) {
+  let string = typeName;  ///
+
+  if (superType !== null) {
+    const typeString = string,  ///
+          superTypeString = superType.getString();
+
+    string = `${typeString}:${superTypeString}`;
+  }
+
+  return string;
+}
+
+Object.assign(shim, {
+  Type
+});
+
+export default Type;
+
 class ObjectType extends Type {
   static fromNothing() {
     const name = OBJECT_TYPE_NAME,

package/src/utilities/node.js

@@ -6,21 +6,26 @@ import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { TERM_RULE_NAME,
          METAVARIABLE_RULE_NAME,
-         UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
-import { termTokensFromTermString,
-         metavariableTokensFromMetavariableString,
-         unqualifiedStatementTokensFromUnqualifiedStatementString } from "../utilities/tokens";
+         UNQUALIFIED_STATEMENT_RULE_NAME,
+         CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
+import { metavariableTokensFromMetavariableString,
+         unqualifiedStatementTokensFromUnqualifiedStatementString,
+         constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
 const { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
+const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
 export function termNodeFromTermString(termString, lexer, parser) {
-  const termTokens = termTokensFromTermString(termString, lexer),
-        termNode = termNodeFromTermTokens(termTokens, parser);
+  const constructorDeclarationString = `Constructor ${termString}
+`,
+        constructorDeclarationTokens = constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer),
+        constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
+        termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
 
   return termNode;
 }
@@ -72,6 +77,14 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifi
   return unqualifiedStatementNode;
 }
 
+export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
+  const tokens = constructorDeclarationTokens,  ///
+        ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
+        constructorDeclarationNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
+
+  return constructorDeclarationNode;
+}
+
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = nominalParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],

package/src/utilities/releaseContext.js

@@ -86,8 +86,6 @@ export function createReleaseContext(dependency, dependentNames, context, callba
 }
 
 export function initialiseReleaseContext(dependency, context) {
-  let releaseContextInitialised = false;
-
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
         releaseName = dependencyName, ///
@@ -98,7 +96,7 @@ export function initialiseReleaseContext(dependency, context) {
 
     log.warning(`Unable to initialise the '${dependencyName}' context because it has not been created.`);
   } else {
-    releaseContextInitialised = releaseContext.isInitialised();
+    const releaseContextInitialised = releaseContext.isInitialised();
 
     if (!releaseContextInitialised) {
       initialiseDependencyReleaseContexts(dependency, releaseContext, context);
@@ -113,8 +111,6 @@ export function initialiseReleaseContext(dependency, context) {
       log.info(`...initialised the '${dependencyName}' context.`);
     }
   }
-
-  return releaseContextInitialised;
 }
 
 export default {
@@ -277,14 +273,9 @@ function createDependencyReleaseContexts(dependency, releaseContext, dependentNa
 }
 
 function initialiseDependencyReleaseContexts(dependency, releaseContext, context) {
-  const dependencies = releaseContext.getDependencies(),
-        dependencyReleaseContextsInitialised = dependencies.everyDependency((dependency) => {  ///
-          const releaseContextInitialised = initialiseReleaseContext(dependency, context);
-
-          if (releaseContextInitialised) {
-            return true;
-          }
-        });
+  const dependencies = releaseContext.getDependencies();
 
-  return dependencyReleaseContextsInitialised;
+  dependencies.forEachDependency((dependency) => {  ///
+    initialiseReleaseContext(dependency, context);
+  });
 }

package/src/utilities/tokens.js

@@ -30,6 +30,13 @@ export function unqualifiedStatementTokensFromUnqualifiedStatementString(unquali
   return unqualifiedStatementTokens;
 }
 
+export function constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer) {
+  const content = constructorDeclarationString,  ///
+        constructorDeclarationTokens = tokensFromContentAndLexer(content, lexer);
+
+  return constructorDeclarationTokens;
+}
+
 function tokensFromContentAndLexer(content, lexer = nominalLexer) {
   const tokens = lexer.tokenise(content);