occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/conclusion.js

@@ -20,7 +20,7 @@ export  default domAssigned(class Conclusion {
   }
 
   verify(context) {
-    let verified = false;
+    let verifies = false;
 
     const conclusionString = this.string;  ///
 
@@ -29,23 +29,23 @@ export  default domAssigned(class Conclusion {
     if (this.statement !== null) {
       const stated = true,
             assignments = null,
-            statementVerified = this.statement.verify(assignments, stated, context);
+            statementVerifies = this.statement.verify(assignments, stated, context);
 
-      verified = statementVerified; ///
+      verifies = statementVerifies; ///
 
     } else {
       context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${conclusionString}' conclusion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
+    let statementUnifies;
 
     const conclusion = this,  ///
           statementString = statement.getString(),
@@ -53,13 +53,13 @@ export  default domAssigned(class Conclusion {
 
     specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
 
-    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+    statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    if (statementUnified) {
+    if (statementUnifies) {
       specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   toJSON() {

package/src/dom/conjecture.js

@@ -6,7 +6,7 @@ import { domAssigned } from "../dom";
 
 export default domAssigned(class Conjecture extends TopLevelAssertion {
   verify() {
-    let verified;
+    let verifies;
 
     const conjecture = this,  ///
           fileContext = this.getFileContext(),
@@ -14,9 +14,9 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
 
     fileContext.trace(`Verifying the '${conjectureString}' conjecture...`);
 
-    verified = super.verify();
+    verifies = super.verify();
 
-    if (verified) {
+    if (verifies) {
       const conjecture = this;  ///
 
       fileContext.addConjecture(conjecture);
@@ -24,7 +24,7 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
       fileContext.debug(`...verified the '${conjectureString}' conjecture.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   static name = "Conjecture";

package/src/dom/constructor/bracketed.js

@@ -8,14 +8,14 @@ import { domAssigned } from "../../dom";
 
 export default domAssigned(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
-    let termUnified;
+    let termUnifies;
 
     const termString = term.getString();
 
     context.trace(`Unifying the '${termString}' term with the bracketed constructor...`, term);
 
-    termUnified = super.unifyTerm(term, context, () => {
-      let verifiedAhead = false;
+    termUnifies = super.unifyTerm(term, context, () => {
+      let verifiesAhead = false;
 
       const { Term } = dom,
             bracketedTerm = term, ///
@@ -27,29 +27,29 @@ export default domAssigned(class BracketedConstructor extends Constructor {
 
         term = Term.fromTermNode(termNode, context);
 
-        const termVVerified = term.verify(context, () => {
-          let verifiedAhead;
+        const termVVerifies = term.verify(context, () => {
+          let verifiesAhead;
 
           const type = term.getType();
 
           bracketedTerm.setType(type);
 
-          verifiedAhead = verifyAhead();
+          verifiesAhead = verifyAhead();
 
-          return verifiedAhead;
+          return verifiesAhead;
         });
 
-        verifiedAhead = termVVerified;  ///
+        verifiesAhead = termVVerifies;  ///
       }
 
-      return verifiedAhead;
+      return verifiesAhead;
     });
 
-    if (termUnified) {
+    if (termUnifies) {
       context.debug(`...unified the '${termString}' term with the bracketed constructor.`, term);
     }
 
-    return termUnified;
+    return termUnifies;
   }
 
   static fromNothing() {

package/src/dom/constructor.js

@@ -28,7 +28,7 @@ export default domAssigned(class Constructor {
   setType(type) { this.term.setType(type); }
 
   unifyTerm(term, context, verifyAhead) {
-    let termUnified = false;
+    let termUnifies = false;
 
     const constructor = this, ///
           termString = term.getString(),
@@ -36,25 +36,25 @@ export default domAssigned(class Constructor {
 
     context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, term);
 
-    const termUnifiedWithConstructor = unifyTermWithConstructor(term, constructor, context);
+    const termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
 
-    if (termUnifiedWithConstructor) {
-      let verifiedAhead;
+    if (termUnifiesWithConstructor) {
+      let verifiesAhead;
 
       const type = constructor.getType();
 
       term.setType(type);
 
-      verifiedAhead = verifyAhead();
+      verifiesAhead = verifyAhead();
 
-      termUnified = verifiedAhead;  ///
+      termUnifies = verifiesAhead;  ///
     }
 
-    if (termUnified) {
+    if (termUnifies) {
       context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, term);
     }
 
-    return termUnified;
+    return termUnifies;
   }
 
   toJSON() {

package/src/dom/declaration/combinator.js

@@ -26,29 +26,29 @@ export default domAssigned(class CombinatorDeclaration {
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
     const combinatorDeclarationString = this.getString(); ///
 
     this.fileContext.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerified = this.verifyCombinator();
+    const combinatorVerifies = this.verifyCombinator();
 
-    if (combinatorVerified) {
+    if (combinatorVerifies) {
       this.fileContext.addCombinator(this.combinator);
 
-      verified = true;
+      verifies = true;
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyCombinator() {
-    let statementVerified;
+    let statementVerifies;
 
     const combinatorString = this.combinator.getString();
 
@@ -57,13 +57,13 @@ export default domAssigned(class CombinatorDeclaration {
     const statement = this.combinator.getStatement(),
           statementNode = statement.getNode();
 
-    statementVerified = combinatorVerifier.verifyStatement(statementNode, this.fileContext);
+    statementVerifies = combinatorVerifier.verifyStatement(statementNode, this.fileContext);
 
-    if (statementVerified) {
+    if (statementVerifies) {
       this.fileContext.debug(`...verified the '${combinatorString}' combinator.`);
     }
 
-    return statementVerified;
+    return statementVerifies;
   }
 
   static name = "CombinatorDeclaration";

package/src/dom/declaration/complexType.js

@@ -2,8 +2,9 @@
 
 import dom from "../../dom";
 
+import { objectType } from "../type";
 import { domAssigned } from "../../dom";
-import { superTypesStringFromSuperTypes, stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
+import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
   constructor(fileContext, string, type) {
@@ -24,61 +25,84 @@ export default domAssigned(class ComplexTypeDeclaration {
     return this.type;
   }
 
+  getReleaseContext() { return this.fileContext.getReleaseContext(); }
+
+  getReleaseTypes() {
+    const includeDependencies = false,
+          includeRelease = false,
+          releaseContext = this.getReleaseContext(),
+          fileContextTypes = this.fileContext.getTypes(includeRelease),
+          releaseContextTypes = releaseContext.getTypes(includeDependencies),
+          releaseTypes = [
+            ...fileContextTypes,
+            ...releaseContextTypes
+          ];
+
+    return releaseTypes;
+  }
+
   verify() {
-    let verified = false;
+    let verifies = false;
 
     const complexTypeDeclarationString = this.getString();
 
     this.fileContext.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
 
-    const typeVerified = this.verifyType();
+    const typeVerifies = this.verifyType();
 
-    if (typeVerified) {
-      const superTypesVerified = this.verifySuperTypes();
+    if (typeVerifies) {
+      const superTypesVerify = this.verifySuperTypes();
 
-      if (superTypesVerified) {
-        const propertiesVerified = this.verifyProperties();
+      if (superTypesVerify) {
+        const propertiesVerify = this.verifyProperties();
 
-        if (propertiesVerified) {
+        if (propertiesVerify) {
           this.fileContext.addType(this.type);
 
-          verified = true;
+          verifies = true;
         }
       }
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyType() {
-    let typeVerified = false;
+    let typeVerifies = false;
 
-    const typeName = this.type.getName(),
-          complexTypeString = this.type.getString();
+    const complexTypeString = this.type.getString();
 
     this.fileContext.trace(`Verifying the '${complexTypeString}' complex type...`);
 
-    const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+    const typeName = this.type.getName(),
+          releaseTypes = this.getReleaseTypes(),
+          typePresent = releaseTypes.some((releaseType) => {
+            const releaseTypeNameMatches = releaseType.matchTypeName(typeName);
+
+            if (releaseTypeNameMatches) {
+              return true;
+            }
+          });
 
     if (typePresent) {
-      this.fileContext.debug(`The type '${complexTypeString}' is already present.`);
+      this.fileContext.debug(`The type '${complexTypeString}' is already present in the package.`);
     } else {
-      typeVerified = true;
+      typeVerifies = true;
     }
 
-    if (typeVerified) {
+    if (typeVerifies) {
       this.fileContext.debug(`...verified the '${complexTypeString}' complex type.`);
     }
 
-    return typeVerified;
+    return typeVerifies;
   }
 
   verifySuperType(superType) {
-    let superTypeVerified;
+    let superTypeVerifies = false;
 
     const superTypeString = superType.getString();
 
@@ -87,59 +111,100 @@ export default domAssigned(class ComplexTypeDeclaration {
     const superTypeName = superType.getName(),
           superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
 
-    superTypeVerified = superTypePresent; ///
+    if (superTypePresent) {
+      superTypeVerifies = true;
+    }
 
-    if (superTypeVerified) {
+    if (superTypeVerifies) {
       this.fileContext.debug(`...verified the '${superTypeString}' super-type.`);
     }
 
-    return superTypeVerified;
+    return superTypeVerifies;
   }
 
   verifySuperTypes() {
-    let superTypesVerified;
+    let superTypesVerify = false;
+
+    this.fileContext.trace(`Verifying the super-types...`);
+
+    let superTypes;
+
+    superTypes = this.type.getSuperTypes();
+
+    const typeName = this.type.getName(),
+          superTypesLength = superTypes.length;
+
+    if (superTypesLength === 0) {
+      const type = this.fileContext.findTypeByTypeName(typeName);
 
-    const typeBasic = this.type.isBasic();
+      if (type === null) {
+        const superType = objectType; ///
+
+        superTypes.push(superType);
+      }
+    }
+
+    const typeBasic = this.type.isBasic(),
+          typeString = this.type.getString();
 
     if (typeBasic) {
-      superTypesVerified = true;
+      superTypesVerify = true;
+
+      this.fileContext.trace(`The '${typeString}' type is basic.`)
     } else {
-      let superTypes;
+      const superTypeNames = superTypes.map((superType) => {
+              const superTypeName = superType.getName();
 
-      superTypes = this.type.getSuperTypes();
+              return superTypeName;
+            }),
+            superTypeNamesIncludesTypeName = superTypeNames.includes(typeName);
 
-      const superTypesString = superTypesStringFromSuperTypes(superTypes);
+      if (superTypeNamesIncludesTypeName) {
+        this.fileContext.trace(`The '${typeName}' type cannot be a super-type `);
+      } else {
+        if (superTypesLength === 0) {
+          const type = this.fileContext.findTypeByTypeName(typeName),
+                superType = type; ///
 
-      this.fileContext.trace(`Verifying the '${superTypesString} super-types...`);
+          superTypes.push(superType);
+        }
 
-      superTypesVerified = superTypes.every((superType) => {
-        const superTypeVerified = this.verifySuperType(superType);
+        superTypesVerify = superTypes.every((superType) => {
+          const superTypeVerifies = this.verifySuperType(superType);
 
-        if (superTypeVerified) {
-          return true;
-        }
-      });
+          if (superTypeVerifies) {
+            return true;
+          }
+        });
 
-      if (superTypesVerified) {
-        superTypes = superTypes.map((superType) => {
-          const superTypeName = superType.getName();
+        if (superTypesVerify) {
+          superTypes = superTypes.map((superType) => {
+            const superTypeName = superType.getName();
 
-          superType = this.fileContext.findTypeByTypeName(superTypeName);
+            superType = this.fileContext.findTypeByTypeName(superTypeName);
 
-          return superType;
-        });
+            return superType;
+          });
+
+          const typeName = this.type.getName(),
+            string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes);
 
-        this.type.setSuperTypes(superTypes);
+          this.type.setString(string);
 
-        this.fileContext.debug(`...verified the' '${superTypesString} super-types.`);
+          this.type.setSuperTypes(superTypes);
+        }
       }
     }
 
-    return superTypesVerified;
+    if (superTypesVerify) {
+      this.fileContext.debug(`...verified the super-types.`);
+    }
+
+    return superTypesVerify;
   }
 
   verifyProperty(property, properties, superTypeProperties) {
-    let propertyVerified = false;
+    let propertyVerifies = false;
 
     const propertyString = property.getString();
 
@@ -176,9 +241,9 @@ export default domAssigned(class ComplexTypeDeclaration {
 
         propertyType = property.getType();
 
-        const propertyTypeVerified = this.verifyPropertyType(propertyType);
+        const propertyTypeVerifies = this.verifyPropertyType(propertyType);
 
-        if (propertyTypeVerified) {
+        if (propertyTypeVerifies) {
           const propertyTypeName = propertyType.getName();
 
           propertyType = this.fileContext.findTypeByTypeName(propertyTypeName);
@@ -187,50 +252,50 @@ export default domAssigned(class ComplexTypeDeclaration {
 
           property.setType(type);
 
-          propertyVerified = true;
+          propertyVerifies = true;
         }
       }
     }
 
-    if (propertyVerified) {
-      this.fileContext.debug(`verified the '${propertyString}' property.`);
+    if (propertyVerifies) {
+      this.fileContext.debug(`verifies the '${propertyString}' property.`);
     }
 
-    return propertyVerified;
+    return propertyVerifies;
   }
 
   verifyProperties() {
-    let propertiesVerified;
+    let propertiesVerify;
 
     const includeSuperTypes = false,
           properties = this.type.getProperties(includeSuperTypes),
           superTypes = this.type.getSuperTypes()
 
-    propertiesVerified = superTypes.every((superType) => {
+    propertiesVerify = superTypes.every((superType) => {
       const superTypeProperties = superType.getProperties(),
-            propertiesVerified = properties.every((property) => {
-              const propertyVerified = this.verifyProperty(property, properties, superTypeProperties);
+            propertiesVerify = properties.every((property) => {
+              const propertyVerifies = this.verifyProperty(property, properties, superTypeProperties);
 
-              if (propertyVerified) {
+              if (propertyVerifies) {
                 return true;
               }
             });
 
-      if (propertiesVerified) {
+      if (propertiesVerify) {
         return true;
       }
     });
 
-    return propertiesVerified;
+    return propertiesVerify;
   }
 
   verifyPropertyType(propertyType) {
-    let propertyTypeVerified = false;
+    let propertyTypeVerifies = false;
 
     const typeEqualToPropertyType = this.type.isEqualTo(propertyType);
 
     if (typeEqualToPropertyType) {
-      propertyTypeVerified = true;
+      propertyTypeVerifies = true;
     } else  {
       const propertyTypeString = propertyType.getString(); ///
 
@@ -244,15 +309,15 @@ export default domAssigned(class ComplexTypeDeclaration {
 
         this.fileContext.debug(`The '${propertyTypeString}' property type is not present.`);
       } else {
-        propertyTypeVerified = true;
+        propertyTypeVerifies = true;
       }
 
-      if (propertyTypeVerified) {
+      if (propertyTypeVerifies) {
         this.fileContext.debug(`...verified the '${propertyTypeString}' property type.`);
       }
     }
 
-    return propertyTypeVerified;
+    return propertyTypeVerifies;
   }
 
   static name = "ComplexTypeDeclaration";

package/src/dom/declaration/constructor.js

@@ -26,33 +26,33 @@ export default domAssigned(class ConstructorDeclaration {
   }
 
   verify() {
-    let verified;
+    let verifies;
 
     const constructorDeclarationString = this.getString(); ///
 
     this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    const constructorTypeVerified = this.verifyConstructorType();
+    const constructorTypeVerifies = this.verifyConstructorType();
 
-    if (constructorTypeVerified) {
-      const constructorVerified = this.verifyConstructor();
+    if (constructorTypeVerifies) {
+      const constructorVerifies = this.verifyConstructor();
 
-      if (constructorVerified) {
+      if (constructorVerifies) {
         this.fileContext.addConstructor(this.constructor);
 
-        verified = true;
+        verifies = true;
       }
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyConstructor() {
-    let constructorVerified;
+    let constructorVerifies;
 
     const constructorString = this.constructor.getString();
 
@@ -61,17 +61,17 @@ export default domAssigned(class ConstructorDeclaration {
     const term = this.constructor.getTerm(),
           termNode = term.getNode();
 
-    constructorVerified = constructorVerifier.verifyTerm(termNode, this.fileContext);
+    constructorVerifies = constructorVerifier.verifyTerm(termNode, this.fileContext);
 
-    if (constructorVerified) {
+    if (constructorVerifies) {
       this.fileContext.debug(`...verified the '${constructorString}' constructor.`);
     }
 
-    return constructorVerified;
+    return constructorVerifies;
   }
 
   verifyConstructorType() {
-    let constructorTypeVerified = false;
+    let constructorTypeVerifies = false;
 
     let type;
 
@@ -101,15 +101,15 @@ export default domAssigned(class ConstructorDeclaration {
       } else {
         this.constructor.setType(type);
 
-        constructorTypeVerified = true;
+        constructorTypeVerifies = true;
       }
     }
 
-    if (constructorTypeVerified) {
+    if (constructorTypeVerifies) {
       this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
-    return constructorTypeVerified;
+    return constructorTypeVerifies;
   }
 
   static name = "ConstructorDeclaration";