occam-verify-cli 1.0.396 → 1.0.404

package/src/ontology/declaration/simpleType.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 SimpleTypeDeclaration {
+export default define(class SimpleTypeDeclaration 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 SimpleTypeDeclaration {
   verify() {
     let verifies = false;
 
-    const simpleTypeDeclarationString = this.string;  ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          simpleTypeDeclarationString = this.getString();  ///
 
-    this.context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`, this.node);
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple 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();
 
@@ -52,7 +42,7 @@ export default define(class SimpleTypeDeclaration {
         const superTypesVerify = this.verifySuperTypes();
 
         if (superTypesVerify) {
-          const typePrefix = this.context.getTypePrefix();
+          const typePrefix = context.getTypePrefix();
 
           if (typePrefix !== null) {
             const typePrefixName = typePrefix.getName(),
@@ -61,7 +51,7 @@ export default define(class SimpleTypeDeclaration {
             this.type.setPrefixName(prefixName);
           }
 
-          this.context.addType(this.type);
+          context.addType(this.type);
 
           verifies = true;
         }
@@ -69,7 +59,7 @@ export default define(class SimpleTypeDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration.`, this.node);
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration.`, node);
     }
 
     return verifies;
@@ -78,30 +68,32 @@ export default define(class SimpleTypeDeclaration {
   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}' simple type...`, this.node);
+    context.trace(`Verifying the '${typeString}' simple 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}' simple type.`, this.node);
+      context.trace(`...verified the '${typeString}' simple type.`, node);
     }
 
     return typeVerifies;
@@ -110,20 +102,22 @@ export default define(class SimpleTypeDeclaration {
   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}' simple type's name.`, this.node);
+      context.trace(`The super-type's name matches the ${typeName}' simple type's name.`, node);
     } else {
       const oldSuperType = superType;
 
-      superType = this.context.findTypeByNominalTypeName(nominalTypeName);
+      superType = context.findTypeByNominalTypeName(nominalTypeName);
 
       const superTypePresent = (superType !== null);
 
@@ -137,7 +131,7 @@ export default define(class SimpleTypeDeclaration {
     }
 
     if (superTypeVerifies) {
-      this.context.debug(`...verified the '${superTypeString}' super-type.`, this.node);
+      context.debug(`...verified the '${superTypeString}' super-type.`, node);
     }
 
     return superTypeVerifies;
@@ -146,16 +140,18 @@ export default define(class SimpleTypeDeclaration {
   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}' simple type's super-types...`, this.node);
+    context.trace(`Verifying the '${typeString}' simple type's super-types...`, node);
 
     const typeBasic = this.type.isBasic();
 
     if (typeBasic) {
       superTypesVerify = true;
 
-      this.context.trace(`The '${typeString}' simple type is basic.`, this.node)
+      context.trace(`The '${typeString}' simple type is basic.`, node)
     } else  {
       const superTypes = this.type.getSuperTypes();
 
@@ -169,7 +165,7 @@ export default define(class SimpleTypeDeclaration {
     }
 
     if (superTypesVerify) {
-      this.context.debug(`...verified the '${typeString}' simple type's super-types.`, this.node);
+      context.debug(`...verified the '${typeString}' simple type's super-types.`, node);
     }
 
     return superTypesVerify;

package/src/ontology/declaration/typePrefix.js

@@ -1,27 +1,15 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Declaration from "../declaration";
 
 import { define } from "../../ontology";
 
-export default define(class TypePrefixDeclaration {
+export default define(class TypePrefixDeclaration extends Declaration {
   constructor(context, node, string, typePrefix) {
-    this.context = context;
-    this.node = node;
-    this.string = string;
-    this.typePrefix = typePrefix;
-  }
-
-  getContext() {
-    return this.context;
-  }
+    super(context, node, string);
 
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
+    this.typePrefix = typePrefix;
   }
 
   getTypePrefix() {
@@ -31,29 +19,31 @@ export default define(class TypePrefixDeclaration {
   verify() {
     let verifies = false;
 
-    const typePrefixDeclarationString = this.string;  ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          typePrefixDeclarationString = this.getString();  ///
 
-    this.context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`, this.node);
+    context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`, node);
 
     const includeRelease = true,
           includeDependencies = false,
-          types = this.context.getTypes(includeRelease, includeDependencies),
+          types = context.getTypes(includeRelease, includeDependencies),
           typesLength = types.length;
 
     if (typesLength > 0) {
-      this.context.debug(`Cannot verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, this.node);
+      context.debug(`Cannot verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, node);
     } else {
       const typePrefixVerifies = this.verifyTypePrefix();
 
       if (typePrefixVerifies) {
-        this.context.addTypePrefix(this.typePrefix);
+        context.addTypePrefix(this.typePrefix);
 
         verifies = true;
       }
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`, this.node);
+      context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`, node);
     }
 
     return verifies;
@@ -62,27 +52,29 @@ export default define(class TypePrefixDeclaration {
   verifyTypePrefix() {
     let typePrefixVerifies = false;
 
-    const typePrefixString = this.typePrefix.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          typePrefixString = this.typePrefix.getString();
 
-    this.context.trace(`Verifying the '${typePrefixString}' type prefix...`, this.node);
+    context.trace(`Verifying the '${typePrefixString}' type prefix...`, node);
 
-    const typePrefix = this.context.getTypePrefix();
+    const typePrefix = context.getTypePrefix();
 
     if (typePrefix !== null) {
-      this.context.trace(`The package already has a '${typePrefixString}' type prefix.`, this.node);
+      context.trace(`The package already has a '${typePrefixString}' type prefix.`, node);
     } else {
 
       const typePrefixName = this.typePrefix.getName(),
-            typePrefixPresent = this.context.isTypePrefixPresentByTypePrefixName(typePrefixName);
+            typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
 
       if (typePrefixPresent) {
-        this.context.trace(`The '${typePrefixString}' type prefix is already present.`, this.node);
+        context.trace(`The '${typePrefixString}' type prefix is already present.`, node);
       } else {
         const nominalTypeName = typePrefixName,  ///
-              typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
-          this.context.trace(`The '${typePrefixString}' type is already present.`, this.node);
+          context.trace(`The '${typePrefixString}' type is already present.`, node);
         } else {
           typePrefixVerifies = true;
         }
@@ -90,7 +82,7 @@ export default define(class TypePrefixDeclaration {
     }
 
     if (typePrefixVerifies) {
-      this.context.debug(`...verified the '${typePrefixString}' type prefix.`, this.node);
+      context.debug(`...verified the '${typePrefixString}' type prefix.`, node);
     }
 
     return typePrefixVerifies;

package/src/ontology/declaration/variable.js

@@ -1,27 +1,15 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Declaration from "../declaration";
 
 import { define } from "../../ontology";
 
-export default define(class VariableDeclaration {
+export default define(class VariableDeclaration extends Declaration {
   constructor(context, node, string, variable) {
-    this.context = context;
-    this.node = node;
-    this.string = string;
-    this.variable = variable;
-  }
-
-  getContext() {
-    return this.context;
-  }
+    super(context, node, string);
 
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
+    this.variable = variable;
   }
 
   getVariable() {
@@ -31,9 +19,11 @@ export default define(class VariableDeclaration {
   verify() {
     let verifies = false;
 
-    const variableDeclarationString = this.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          variableDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`, this.node);
+    context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`, node);
 
     const variableTypeVerifies = this.verifyVariableType();
 
@@ -41,14 +31,14 @@ export default define(class VariableDeclaration {
       const variableVerifies = this.verifyVariable();
 
       if (variableVerifies) {
-        this.context.addVariable(this.variable);
+        context.addVariable(this.variable);
 
         verifies = true;
       }
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${variableDeclarationString}' variable declaration.`, this.node);
+      context.debug(`...verified the '${variableDeclarationString}' variable declaration.`, node);
     }
 
     return verifies;
@@ -57,21 +47,23 @@ export default define(class VariableDeclaration {
   verifyVariable() {
     let  variableVerifies = false;
 
-    const variableString = this.variable.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          variableString = this.variable.getString();
 
-    this.context.trace(`Verifying the '${variableString}' variable...`, this.node);
+    context.trace(`Verifying the '${variableString}' variable...`, node);
 
     const variableIdentifier = this.variable.getIdentifier(),
-          variablePresent = this.context.isVariablePresentByVariableIdentifier(variableIdentifier);
+          variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
     if (variablePresent) {
-      this.context.debug(`The '${variableName}' variable is already present.`, this.node);
+      context.debug(`The '${variableName}' variable is already present.`, node);
     } else {
       variableVerifies = true;
     }
 
     if ( variableVerifies) {
-      this.context.debug(`...verified the '${variableString}' variable.`, this.node);
+      context.debug(`...verified the '${variableString}' variable.`, node);
     }
 
     return  variableVerifies;
@@ -80,22 +72,25 @@ export default define(class VariableDeclaration {
   verifyVariableType() {
     let variableTypeVerifies = false;
 
+    const node = this.getNode(),
+          context = this.getContext();
+
     let type;
 
     type = this.variable.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),
@@ -103,8 +98,8 @@ export default define(class VariableDeclaration {
 
       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.variable.setType(type);
 
@@ -113,7 +108,7 @@ export default define(class VariableDeclaration {
     }
 
     if (variableTypeVerifies) {
-      this.context.debug(`...verified the '${typeString}' type.`, this.node);
+      context.debug(`...verified the '${typeString}' type.`, node);
     }
 
     return variableTypeVerifies;