occam-verify-cli 1.0.396 → 1.0.404

package/src/ontology/declaration/complexType.js

@@ -1,31 +1,19 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Declaration from "../declaration";
 
 import { define } from "../../ontology";
 import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../../utilities/type";
 
-export default define(class ComplexTypeDeclaration {
+export default define(class ComplexTypeDeclaration extends Declaration {
   constructor(context, node, string, type, prefixed) {
-    this.context = context;
-    this.node = node;
-    this.string = string;
+    super(context, node, string);
+
     this.type = type;
     this.prefixed = prefixed;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getType() {
     return this.type;
   }
@@ -37,14 +25,16 @@ export default define(class ComplexTypeDeclaration {
   verify() {
     let verifies = false;
 
-    const complexTypeDeclarationString = this.string; ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          complexTypeDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`, this.node);
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`, node);
 
     if (this.prefixed) {
       const typeString = this.type.getString();
 
-      this.context.trace(`The '${typeString}' type is prefixed.`);
+      context.trace(`The '${typeString}' type is prefixed.`);
     } else {
       const typeVerifies = this.verifyType();
 
@@ -55,7 +45,7 @@ export default define(class ComplexTypeDeclaration {
           const propertiesVerify = this.verifyProperties();
 
           if (propertiesVerify) {
-            const typePrefix = this.context.getTypePrefix();
+            const typePrefix = context.getTypePrefix();
 
             if (typePrefix !== null) {
               const typePrefixName = typePrefix.getName(),
@@ -64,7 +54,7 @@ export default define(class ComplexTypeDeclaration {
               this.type.setPrefixName(prefixName);
             }
 
-            this.context.addType(this.type);
+            context.addType(this.type);
 
             verifies = true;
           }
@@ -73,7 +63,7 @@ export default define(class ComplexTypeDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`, this.node);
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`, node);
     }
 
     return verifies;
@@ -82,30 +72,32 @@ export default define(class ComplexTypeDeclaration {
   verifyType() {
     let typeVerifies = false;
 
-    const typeString = this.type.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          typeString = this.type.getString();
 
-    this.context.trace(`Verifying the '${typeString}' complex type...`, this.node);
+    context.trace(`Verifying the '${typeString}' complex type...`, node);
 
     const typeName = this.type.getName(),
           includeRelease = true,
           includeDependencies = false,
-          typePresent = this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
+          typePresent = context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
 
     if (typePresent) {
-      this.context.trace(`The '${typeString}' type is already present.`, this.node);
+      context.trace(`The '${typeString}' type is already present.`, node);
     } else {
       const prefixedTypeName = typeName, ///
-            typePresent = this.context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
 
       if (typePresent) {
-        this.context.trace(`The '${typeString}' type is already present.`, this.node);
+        context.trace(`The '${typeString}' type is already present.`, node);
       } else {
         typeVerifies = true;
       }
     }
 
     if (typeVerifies) {
-      this.context.trace(`...verified the '${typeString}' complex type.`, this.node);
+      context.trace(`...verified the '${typeString}' complex type.`, node);
     }
 
     return typeVerifies;
@@ -114,20 +106,22 @@ export default define(class ComplexTypeDeclaration {
   verifySuperType(superType) {
     let superTypeVerifies = false;
 
-    const superTypeString = superType.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          superTypeString = superType.getString();
 
-    this.context.trace(`Verifying the '${superTypeString}' super-type...`, this.node);
+    context.trace(`Verifying the '${superTypeString}' super-type...`, node);
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
           typeNameMatches = this.type.matchTypeName(typeName);
 
     if (typeNameMatches) {
-      this.context.trace(`The super-type's name matches the ${typeName}' complex type's name.`, this.node);
+      context.trace(`The super-type's name matches the ${typeName}' complex type's name.`, node);
     } else {
       const oldSuperType = superType;
 
-      superType = this.context.findTypeByNominalTypeName(nominalTypeName);
+      superType = context.findTypeByNominalTypeName(nominalTypeName);
 
       const superTypePresent = (superType !== null);
 
@@ -141,7 +135,7 @@ export default define(class ComplexTypeDeclaration {
     }
 
     if (superTypeVerifies) {
-      this.context.debug(`...verified the '${superTypeString}' super-type.`, this.node);
+      context.debug(`...verified the '${superTypeString}' super-type.`, node);
     }
 
     return superTypeVerifies;
@@ -150,16 +144,18 @@ export default define(class ComplexTypeDeclaration {
   verifySuperTypes() {
     let superTypesVerify;
 
-    const typeString = this.type.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          typeString = this.type.getString();
 
-    this.context.trace(`Verifying the '${typeString}' complex type's super-types...`, this.node);
+    context.trace(`Verifying the '${typeString}' complex type's super-types...`, node);
 
     const typeBasic = this.type.isBasic();
 
     if (typeBasic) {
       superTypesVerify = true;
 
-      this.context.trace(`The '${typeString}' complex type is basic.`, this.node)
+      context.trace(`The '${typeString}' complex type is basic.`, node)
     } else  {
       const superTypes = this.type.getSuperTypes();
 
@@ -173,7 +169,7 @@ export default define(class ComplexTypeDeclaration {
     }
 
     if (superTypesVerify) {
-      this.context.debug(`...verified the '${typeString}' complex type's super-types.`, this.node);
+      context.debug(`...verified the '${typeString}' complex type's super-types.`, node);
     }
 
     return superTypesVerify;
@@ -182,9 +178,11 @@ export default define(class ComplexTypeDeclaration {
   verifyProperty(property, properties) {
     let propertyVerifies = false;
 
-    const propertyString = property.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          propertyString = property.getString();
 
-    this.context.trace(`Verifying the '${propertyString}' property...`, this.node);
+    context.trace(`Verifying the '${propertyString}' property...`, node);
 
     const propertyNameVerifies = this.verifyPropertyName(property, properties);
 
@@ -197,7 +195,7 @@ export default define(class ComplexTypeDeclaration {
     }
 
     if (propertyVerifies) {
-      this.context.debug(`...verified the '${propertyString}' property.`, this.node);
+      context.debug(`...verified the '${propertyString}' property.`, node);
     }
 
     return propertyVerifies;
@@ -206,9 +204,11 @@ export default define(class ComplexTypeDeclaration {
   verifyProperties() {
     let propertiesVerify;
 
-    const typeString = this.type.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          typeString = this.type.getString();
 
-    this.context.trace(`Verifying the '${typeString}' complex type's properties...`, this.node);
+    context.trace(`Verifying the '${typeString}' complex type's properties...`, node);
 
     const includeSuperTypes = false,
           properties = this.type.getProperties(includeSuperTypes);
@@ -222,7 +222,7 @@ export default define(class ComplexTypeDeclaration {
     });
 
     if (propertiesVerify) {
-      this.context.debug(`...verified the '${typeString}' complex type's properties.`, this.node);
+      context.debug(`...verified the '${typeString}' complex type's properties.`, node);
     }
 
     return propertiesVerify;
@@ -231,9 +231,11 @@ export default define(class ComplexTypeDeclaration {
   verifyPropertyName(property, properties) {
     let propertyNameVerifies = false;
 
-    const propertyString = property.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          propertyString = property.getString();
 
-    this.context.trace(`Verifying the '${propertyString}' property's name...`, this.node);
+    context.trace(`Verifying the '${propertyString}' property's name...`, node);
 
     const propertyName = property.getName(),
           count = properties.reduce((count, property) => {
@@ -247,7 +249,7 @@ export default define(class ComplexTypeDeclaration {
           }, 0);
 
     if (count > 1) {
-      this.context.debug(`The '${propertyString}' property appears more than once.`, this.node);
+      context.debug(`The '${propertyString}' property appears more than once.`, node);
     } else {
       const superTypes = this.type.getSuperTypes(),
             superType = superTypes.find((superType) => {
@@ -268,14 +270,14 @@ export default define(class ComplexTypeDeclaration {
       if (superType !== null) {
         const superTypeString = superType.getString();
 
-        this.context.debug(`The '${superTypeString}' super-type has the same property.`, this.node);
+        context.debug(`The '${superTypeString}' super-type has the same property.`, node);
       } else {
         propertyNameVerifies = true;
       }
     }
 
     if (propertyNameVerifies) {
-      this.context.debug(`...verified the '${propertyString}' property's name.`, this.node);
+      context.debug(`...verified the '${propertyString}' property's name.`, node);
     }
 
     return propertyNameVerifies;
@@ -284,17 +286,19 @@ export default define(class ComplexTypeDeclaration {
   verifyPropertyNominalTypeName(property) {
     let propertyNominalTypeNameVerifies = false;
 
-    const propertyString = property.getString(),
+    const node = this.getNode(),
+          context = this.getContext(),
+          propertyString = property.getString(),
           nominalTypeName = property.getNominalTypeName();
 
-    this.context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`, this.node);
+    context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`, node);
 
     const nominalTypeNameMatches = this.type.matchNominalTypeName(nominalTypeName);
 
     if (nominalTypeNameMatches) {
       propertyNominalTypeNameVerifies = true;
     } else {
-      const typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
+      const typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
       if (typePresent) {
         propertyNominalTypeNameVerifies = true;
@@ -302,7 +306,7 @@ export default define(class ComplexTypeDeclaration {
     }
 
     if (propertyNominalTypeNameVerifies) {
-      this.context.debug(`...verifies the '${propertyString}' property's '${nominalTypeName}' nominal type name.`, this.node);
+      context.debug(`...verifies the '${propertyString}' property's '${nominalTypeName}' nominal type name.`, node);
     }
 
     return propertyNominalTypeNameVerifies;

package/src/ontology/declaration/constructor.js

@@ -1,29 +1,16 @@
 "use strict";
 
 import ontology from "../../ontology";
-
+import Declaration from "../declaration";
 import constructorVerifier from "../../verifier/constructor";
 
 import { define } from "../../ontology";
 
-export default define(class ConstructorDeclaration {
+export default define(class ConstructorDeclaration extends Declaration {
   constructor(context, node, string, constructor) {
-    this.context = context;
-    this.node = node;
-    this.string = string;
-    this.constructor = constructor;
-  }
-
-  getContext() {
-    return this.context;
-  }
+    super(context, node, string);
 
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
+    this.constructor = constructor;
   }
 
   getConstructor() {
@@ -33,9 +20,11 @@ export default define(class ConstructorDeclaration {
   verify() {
     let verifies;
 
-    const constructorDeclarationString = this.string; ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          constructorDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`, this.node);
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`, node);
 
     const constructorTypeVerifies = this.verifyConstructorType();
 
@@ -43,14 +32,14 @@ export default define(class ConstructorDeclaration {
       const constructorVerifies = this.verifyConstructor();
 
       if (constructorVerifies) {
-        this.context.addConstructor(this.constructor);
+        context.addConstructor(this.constructor);
 
         verifies = true;
       }
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`, this.node);
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`, node);
     }
 
     return verifies;
@@ -59,17 +48,19 @@ export default define(class ConstructorDeclaration {
   verifyConstructor() {
     let constructorVerifies;
 
-    const constructorString = this.constructor.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          constructorString = this.constructor.getString();
 
-    this.context.trace(`Verifying the '${constructorString}' constructor...`, this.node);
+    context.trace(`Verifying the '${constructorString}' constructor...`, node);
 
     const term = this.constructor.getTerm(),
           termNode = term.getNode();
 
-    constructorVerifies = constructorVerifier.verifyTerm(termNode, this.context);
+    constructorVerifies = constructorVerifier.verifyTerm(termNode, context);
 
     if (constructorVerifies) {
-      this.context.debug(`...verified the '${constructorString}' constructor.`, this.node);
+      context.debug(`...verified the '${constructorString}' constructor.`, node);
     }
 
     return constructorVerifies;
@@ -78,22 +69,25 @@ export default define(class ConstructorDeclaration {
   verifyConstructorType() {
     let constructorTypeVerifies = false;
 
+    const node = this.getNode(),
+          context = this.getContext();
+
     let type;
 
     type = this.constructor.getType();
 
     const typeString = type.getString();
 
-    this.context.trace(`Verifying the '${typeString}' type...`, this.node);
+    context.trace(`Verifying the '${typeString}' type...`, node);
 
     const nominalTypeName = type.getNominalTypeName();
 
-    type = this.context.findTypeByNominalTypeName(nominalTypeName);
+    type = context.findTypeByNominalTypeName(nominalTypeName);
 
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.context.debug(`The '${typeString}' type is not present.`, this.node);
+      context.debug(`The '${typeString}' type is not present.`, node);
     } else {
       const includeSupertypes = false,
             provisional = type.isProvisional(includeSupertypes),
@@ -101,8 +95,8 @@ export default define(class ConstructorDeclaration {
 
       if (!provisionalMatches) {
         provisional ?
-          this.context.debug(`The '${typeString}' type is present but not provisional.`, this.node) :
-            this.context.debug(`The '${typeString}' type is present but provisional.`, this.node);
+          context.debug(`The '${typeString}' type is present but not provisional.`, node) :
+            context.debug(`The '${typeString}' type is present but provisional.`, node);
       } else {
         this.constructor.setType(type);
 
@@ -111,7 +105,7 @@ export default define(class ConstructorDeclaration {
     }
 
     if (constructorTypeVerifies) {
-      this.context.debug(`...verified the '${typeString}' type.`, this.node);
+      context.debug(`...verified the '${typeString}' type.`, node);
     }
 
     return constructorTypeVerifies;

package/src/ontology/declaration/metavariable.js

@@ -1,27 +1,15 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Declaration from "../declaration";
 
 import { define } from "../../ontology";
 
-export default define(class MetavariableDeclaration {
+export default define(class MetavariableDeclaration extends Declaration {
   constructor(context, node, string, metavariable) {
-    this.context = context;
-    this.node = node;
-    this.string = string;
-    this.metavariable = metavariable;
-  }
-
-  getContext() {
-    return this.context;
-  }
+    super(context, node, string);
 
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
+    this.metavariable = metavariable;
   }
 
   getMetavariable() {
@@ -31,20 +19,22 @@ export default define(class MetavariableDeclaration {
   verify() {
     let verifies;
 
-    const metavariableDeclarationString = this.string; ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          metavariableDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`, this.node);
+    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`, node);
 
     const metavariableVerifies = this.verifyMetavariable(this.metavariable);
 
     if (metavariableVerifies) {
-      this.context.addMetavariable(this.metavariable);
+      context.addMetavariable(this.metavariable);
 
       verifies = true;
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`, this.node);
+      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`, node);
     }
 
     return verifies;
@@ -53,24 +43,27 @@ export default define(class MetavariableDeclaration {
   verifyType(type) {
     let typeVerifies;
 
+    const node = this.getNode(),
+          context = this.getContext();
+
     if (type === null) {
       typeVerifies = true;
     } else {
       const typeString = type.getString();
 
-      this.context.trace(`Verifying the '${typeString}' type...`, this.node);
+      context.trace(`Verifying the '${typeString}' type...`, node);
 
       const nominalTypeName = type.getNominalTypeName(),
-            typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
+            typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
       if (!typePresent) {
-        this.context.debug(`The '${typeString}' type is not present.`, this.node);
+        context.debug(`The '${typeString}' type is not present.`, node);
       } else {
         typeVerifies = true;
       }
 
       if (typeVerifies) {
-        this.context.debug(`...verified the '${typeString}' type.`, this.node);
+        context.debug(`...verified the '${typeString}' type.`, node);
       }
     }
 
@@ -80,21 +73,23 @@ export default define(class MetavariableDeclaration {
   verifyMetavariable(metavariable) {
     let metavariableVerifies = false;
 
-    const metavariableString = metavariable.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          metavariableString = metavariable.getString();
 
-    this.context.trace(`Verifying the '${metavariableString}' metavariable when declared...`, this.node);
+    context.trace(`Verifying the '${metavariableString}' metavariable when declared...`, node);
 
     const metavariableNode = metavariable.getNode(), ///
           termNode = metavariableNode.getTermNode();
 
     if (termNode !== null) {
-      this.context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`, this.node);
+      context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`, node);
     } else {
       const metavariableName = metavariable.getName(),
-            metavariablePresent = this.context.isMetavariablePresentByMetavariableName(metavariableName);
+            metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
 
       if (metavariablePresent) {
-        this.context.debug(`The '${metavariableName}' metavariable is already present.`, this.node);
+        context.debug(`The '${metavariableName}' metavariable is already present.`, node);
       } else {
         const type = metavariable.getType(),
               typeVerifies = this.verifyType(type);
@@ -104,7 +99,7 @@ export default define(class MetavariableDeclaration {
     }
 
     if (metavariableVerifies) {
-      this.context.debug(`...verified the '${metavariableString}' metavariable when declared.`, this.node);
+      context.debug(`...verified the '${metavariableString}' metavariable when declared.`, node);
     }
 
     return metavariableVerifies;