occam-verify-cli 1.0.340 → 1.0.342

package/src/dom/declaration/complexType.js

@@ -34,8 +34,6 @@ export default domAssigned(class ComplexTypeDeclaration {
     return this.prefixed;
   }
 
-  getReleaseContext() { return this.context.getReleaseContext(); }
-
   verify() {
     let verifies = false;
 
@@ -57,22 +55,18 @@ export default domAssigned(class ComplexTypeDeclaration {
           const propertiesVerify = this.verifyProperties();
 
           if (propertiesVerify) {
-            const propertyTypesVerify = this.verifyPropertyTypes();
-
-            if (propertyTypesVerify) {
-              const typePrefix = this.context.getTypePrefix();
+            const typePrefix = this.context.getTypePrefix();
 
-              if (typePrefix !== null) {
-                const typePrefixName = typePrefix.getName(),
-                      prefixName = typePrefixName;  ///
+            if (typePrefix !== null) {
+              const typePrefixName = typePrefix.getName(),
+                    prefixName = typePrefixName;  ///
 
-                this.type.setPrefixName(prefixName);
-              }
+              this.type.setPrefixName(prefixName);
+            }
 
-              this.context.addType(this.type);
+            this.context.addType(this.type);
 
-              verifies = true;
-            }
+            verifies = true;
           }
         }
       }
@@ -192,40 +186,14 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     this.context.trace(`Verifying the '${propertyString}' property...`, this.node);
 
-    const propertyName = property.getName(),
-          count = properties.reduce((count, property) => {
-            const propertyNameMatches = property.matchPropertyName(propertyName);
-
-            if (propertyNameMatches) {
-              count++;
-            }
+    const propertyNameVerifies = this.verifyPropertyName(property, properties);
 
-            return count;
-          }, 0);
+    if (propertyNameVerifies) {
+      const propertyNominalTypeNameVerifies = this.verifyPropertyNominalTypeName(property, properties);
 
-    if (count > 1) {
-      this.context.debug(`The '${propertyString}' property appears more than once.`, this.node);
-    } else {
-      const superTypes = this.type.getSuperTypes();
-
-      propertyVerifies = superTypes.every((superType) => {
-        const superTypeProperties = superType.getProperties(),
-              superTypeProperty = superTypeProperties.find((superTypeProperty) => {
-                const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
-
-                if (propertyNameMatches) {
-                  return true;
-                }
-              }) || null;
-
-        if (superTypeProperty !== null) {
-          const superTypePropertyString = superTypeProperty.getString();
-
-          this.context.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`, this.node);
-        } else {
-          return true;
-        }
-      });
+      if (propertyNominalTypeNameVerifies) {
+        propertyVerifies = true;
+      }
     }
 
     if (propertyVerifies) {
@@ -260,68 +228,84 @@ export default domAssigned(class ComplexTypeDeclaration {
     return propertiesVerify;
   }
 
-  verifyPropertyType(property) {
-    let propertyTypeVerifies = false;
+  verifyPropertyName(property, properties) {
+    let propertyNameVerifies = false;
 
-    let propertyType = property.getType();
+    const propertyString = property.getString();
 
-    const propertyTypeString = propertyType.getString();
+    this.context.trace(`Verifying the '${propertyString}' property's name...`, this.node);
 
-    this.context.trace(`Verifying the '${propertyTypeString}' property type...`, this.node);
+    const propertyName = property.getName(),
+          count = properties.reduce((count, property) => {
+            const propertyNameMatches = property.matchPropertyName(propertyName);
 
-    const typeName = this.type.getName(),
-          typeNameMatches = propertyType.matchTypeName(typeName);
+            if (propertyNameMatches) {
+              count++;
+            }
 
-    if (typeNameMatches) {
-      propertyTypeVerifies = true;
+            return count;
+          }, 0);
 
-      property.setType(this.type);
+    if (count > 1) {
+      this.context.debug(`The '${propertyString}' property appears more than once.`, this.node);
     } else {
-      const nominalTypeName = propertyType.getNominalTypeName();
-
-      propertyType = this.context.findTypeByNominalTypeName(nominalTypeName);
-
-      const propertyTypePresent = (propertyType !== null);
-
-      if (propertyTypePresent) {
-        const type = propertyType;  ///
+      const superTypes = this.type.getSuperTypes(),
+            superType = superTypes.find((superType) => {
+              const superTypeProperties = superType.getProperties(),
+                    propertyNameMatches = superTypeProperties.some((superTypeProperty) => {
+                      const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
+
+                      if (propertyNameMatches) {
+                        return true;
+                      }
+                    });
+
+              if (propertyNameMatches) {
+                return true;
+              }
+            }) || null;
 
-        property.setType(type);
+      if (superType !== null) {
+        const superTypeString = superType.getString();
 
-        propertyTypeVerifies = true;
+        this.context.debug(`The '${superTypeString}' super-type has the same property.`, this.node);
+      } else {
+        propertyNameVerifies = true;
       }
     }
 
-    if (propertyTypeVerifies) {
-      this.context.debug(`...verified the '${propertyTypeString}' property type.`, this.node);
+    if (propertyNameVerifies) {
+      this.context.debug(`...verified the '${propertyString}' property's name.`, this.node);
     }
 
-    return propertyTypeVerifies;
+    return propertyNameVerifies;
   }
 
-  verifyPropertyTypes() {
-    let propertyTypesVerify;
+  verifyPropertyNominalTypeName(property) {
+    let propertyNominalTypeNameVerifies = false;
 
-    const typeString = this.type.getString();
+    const propertyString = property.getString(),
+          nominalTypeName = property.getNominalTypeName();
 
-    this.context.trace(`Verifying the '${typeString}' complex type's property types...`, this.node);
+    this.context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`, this.node);
 
-    const includeSuperTypes = false,
-          properties = this.type.getProperties(includeSuperTypes);
+    const nominalTypeNameMatches = this.type.matchNominalTypeName(nominalTypeName);
 
-    propertyTypesVerify = properties.every((property) => {
-      const propertyVerifies = this.verifyPropertyType(property);
+    if (nominalTypeNameMatches) {
+      propertyNominalTypeNameVerifies = true;
+    } else {
+      const typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
 
-      if (propertyVerifies) {
-        return true;
+      if (typePresent) {
+        propertyNominalTypeNameVerifies = true;
       }
-    });
+    }
 
-    if (propertyTypesVerify) {
-      this.context.debug(`...verified the '${typeString}' complex type's property types.`, this.node);
+    if (propertyNominalTypeNameVerifies) {
+      this.context.debug(`...verifies the '${propertyString}' property's '${nominalTypeName}' nominal type name.`, this.node);
     }
 
-    return propertyTypesVerify;
+    return propertyNominalTypeNameVerifies;
   }
 
   static name = "ComplexTypeDeclaration";

package/src/dom/property.js

@@ -3,46 +3,44 @@
 import dom from "../dom";
 
 import { domAssigned } from "../dom";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default domAssigned(class Property {
-  constructor(string, type, name) {
+  constructor(string, name, nominalTypeName) {
     this.string = string;
-    this.type = type;
     this.name = name;
+    this.nominalTypeName = nominalTypeName;
   }
 
   getString() {
     return this.string;
   }
 
-  getType() {
-    return this.type;
-  }
-
   getName() {
     return this.name;
   }
 
-  setType(type) {
-    this.type = type;
+  getNominalTypeName() {
+    return this.nominalTypeName;
   }
 
-  matchNominalTypeName(nominalTypeName) { return this.type.matchNominalTypeName(nominalTypeName); }
-
   matchPropertyName(propertyName) {
     const propertyNameMatches = (this.name === propertyName);
 
     return propertyNameMatches;
   }
 
+  matchNominalTypeName(nominalTypeName) {
+    const nominalTypeNameMatches = (this.nominalTypeName === nominalTypeName);
+
+    return nominalTypeNameMatches;
+  }
+
   toJSON() {
-    const typeJSON = typeToTypeJSON(this.type),
-          name = this.name, ///
-          type = typeJSON,  ///
+    const name = this.name, ///
+          nominalTypeName = this.nominalTypeName,  ///
           json = {
-            type,
-            name
+            name,
+            nominalTypeName
           };
 
     return json;
@@ -51,16 +49,9 @@ export default domAssigned(class Property {
   static name = "Property";
 
   static fromJSON(json, context) {
-    const { name } = json,
-          type = typeFromJSON(json, context),
+    const { name, nominalTypeName } = json,
           string = name, ///
-          property = new Property(string, type, name);
-
-    return property;
-  }
-
-  static fromPropertyNode(propertyNode, context) {
-    const property = propertyFromPropertyNode(propertyNode, context)
+          property = new Property(string, name, nominalTypeName);
 
     return property;
   }
@@ -73,12 +64,11 @@ export default domAssigned(class Property {
   }
 
   static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
-    const { Type } = dom,
-          type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
-          propertyName = propertyDeclarationNode.getPropertyName(),
+    const propertyName = propertyDeclarationNode.getPropertyName(),
+          nominalTypeName = propertyDeclarationNode.getNominalTypeName(),
           name = propertyName,  ///
           string = name,  ///
-          property = new Property(string, type, name);
+          property = new Property(string, name, nominalTypeName);
 
     return property;
   }
@@ -87,10 +77,10 @@ export default domAssigned(class Property {
 function propertyFromPropertyNode(propertyNode, context) {
   const { Property } = dom,
         propertyName = propertyNode.getPropertyName(),
+        nominalTypeName = null,
         name = propertyName,  ///
-        type = null,
         string = name,  ///
-        property = new Property(string, type, name);
+        property = new Property(string, name, nominalTypeName);
 
   return property;
 }

package/src/dom/propertyRelation.js

@@ -33,8 +33,6 @@ export default domAssigned(class PropertyRelation {
     return this.term;
   }
 
-  getType() { return this.property.getType(); }
-
   isEqualTo(propertyRelation) {
     const propertyRelationString = propertyRelation.getString(),
           equalTo = (propertyRelationString === this.string);
@@ -108,10 +106,6 @@ export default domAssigned(class PropertyRelation {
 
       context.debug(`The '${propertyName}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
     } else {
-      const type = termType;
-
-      this.property.setType(type);
-
       propertyVerifies = true;
     }
 

package/src/dom/type.js

@@ -2,9 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import dom from "../dom";
-
-import { domAssigned } from "../dom";
+import dom, { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../constants";
 import { typeFromTypeNode } from "../utilities/node";
 import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/type";
@@ -359,13 +357,13 @@ class Type {
   }
 
   static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-    const properties = [],
+    const typeName = simpleTypeDeclarationNode.getTypeName(),
           provisional = simpleTypeDeclarationNode.isProvisional(),
-          typeName = simpleTypeDeclarationNode.getTypeName(),
           typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
+          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
           name = typeName,  ///
           prefixName = typePrefixName,  ///
-          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
+          properties = [],
           string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
           type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
@@ -373,12 +371,12 @@ class Type {
   }
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-    const provisional = complexTypeDeclarationNode.isProvisional(),
-          typeName = complexTypeDeclarationNode.getTypeName(),
+    const typeName = complexTypeDeclarationNode.getTypeName(),
+          provisional = complexTypeDeclarationNode.isProvisional(),
           typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),
+          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           name = typeName,  ///
           prefixName = typePrefixName,  ///
-          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
           type = new Type(string, name, prefixName, superTypes, properties, provisional);

package/src/node/declaration/property.js

@@ -5,13 +5,6 @@ import NonTerminalNode from "../../node/nonTerminal";
 import { TYPE_RULE_NAME, PROPERTY_RULE_NAME } from "../../ruleNames";
 
 export default class PropertyDeclarationNode extends NonTerminalNode {
-  getPropertyName() {
-    const propertyNode = this.getPropertyNode(),
-          propertyName = propertyNode.getPropertyName();
-
-    return propertyName;
-  }
-
   getTypeNode() {
     const ruleName = TYPE_RULE_NAME,
           typeNode = this.getNodeByRuleName(ruleName);
@@ -26,5 +19,24 @@ export default class PropertyDeclarationNode extends NonTerminalNode {
     return propertyNode;
   }
 
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
+
+    return propertyName;
+  }
+
+  getNominalTypeName() {
+    let nominalTypeName = null;
+
+    const typeNode = this.getTypeNode();
+
+    if (typeNode !== null) {
+      nominalTypeName = typeNode.getNominalTypeName();
+    }
+
+    return nominalTypeName;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/utilities/json.js

@@ -496,7 +496,9 @@ export function termToTermJSON(term) {
 }
 
 export function typeToTypeJSON(type) {
-  const typeJSON = type.toJSON();
+  const typeJSON = (type !== null) ?
+                      type.toJSON() :
+                        null;
 
   return typeJSON;
 }