occam-verify-cli 1.0.256 → 1.0.259

package/src/context/local.js

@@ -141,8 +141,8 @@ class LocalContext {
   addVariable(variable, nested = true) {
     let variableAdded = false;
 
-    const variableName = variable.getNode(),
-          variablePresent = this.isVariablePresentByVariableName(variableName, nested);
+    const variableIdentifier = variable.getIdentifier(),
+          variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);
 
     if (!variablePresent) {
       this.variables.push(variable);
@@ -194,12 +194,12 @@ class LocalContext {
 
   findMetaLemmaMetatheoremsByReference(reference) { return this.context.findMetaLemmaMetatheoremsByReference(reference); }
 
-  findVariableByVariableName(variableName, nested = true) {
+  findVariableByVariableIdentifier(variableIdentifier, nested = true) {
     const variables = this.getVariables(nested),
           variable = variables.find((variable) => {
-            const variableNameMatches = variable.matchVariableName(variableName);
+            const variableIdentifierMatches = variable.matchVariableIdentifier(variableIdentifier);
 
-            if (variableNameMatches) {
+            if (variableIdentifierMatches) {
               return true;
             }
           }) || null;
@@ -251,8 +251,8 @@ class LocalContext {
 
   isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-  isVariablePresentByVariableName(variableName, nested = true) {
-    const variable = this.findVariableByVariableName(variableName, nested),
+  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
+    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
           variablePresent = (variable !== null);
 
     return variablePresent;

package/src/dom/assertion/property.js

@@ -183,9 +183,9 @@ export default domAssigned(class PropertyAssertion {
     variable = Variable.fromTermNode(termNode, context);
 
     if (variable !== null) {
-      const variableName = variable.getName();
+      const variableIdentifier = variable.getIdentifier();
 
-      variable = context.findVariableByVariableName(variableName);
+      variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
       variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
 

package/src/dom/declaration/complexType.js

@@ -210,11 +210,11 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     this.context.trace(`Verifying the '${propertyString}' property...`);
 
-    const propertyName = property.getName(),
+    const propertyIdentifier = property.getIdentifier(),
           count = properties.reduce((count, property) => {
-            const propertyNameMatches = property.matchPropertyName(propertyName);
+            const propertyIdentifierMatches = property.matchPropertyIdentifier(propertyIdentifier);
 
-            if (propertyNameMatches) {
+            if (propertyIdentifierMatches) {
               count++;
             }
 
@@ -225,9 +225,9 @@ export default domAssigned(class ComplexTypeDeclaration {
       this.context.debug(`The '${propertyString}' property appears more than once.`);
     } else {
       const superTypeProperty = superTypeProperties.find((superTypeProperty) => {
-        const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
+        const propertyIdentifierMatches = superTypeProperty.matchPropertyIdentifier(propertyIdentifier);
 
-        if (propertyNameMatches) {
+        if (propertyIdentifierMatches) {
           return true;
         }
       }) || null;

package/src/dom/declaration/variable.js

@@ -56,8 +56,8 @@ export default domAssigned(class VariableDeclaration {
 
     this.context.trace(`Verifying the '${variableString}' variable...`);
 
-    const variableName = this.variable.getName(),
-          variablePresent = this.context.isVariablePresentByVariableName(variableName);
+    const variableIdentifier = this.variable.getIdentifier(),
+          variablePresent = this.context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
     if (variablePresent) {
       this.context.debug(`The '${variableName}' variable is already present.`);

package/src/dom/metavariable.js

@@ -64,16 +64,12 @@ export default domAssigned(class Metavariable {
     this.metaType = metaType;
   }
 
-  matchName(name) {
-    const nameMatches = (name === this.name);
+  matchParameter(parameter) {
+    const name = parameter.getName(),
+          nameMatches = (name === this.name),
+          parameterMatches = nameMatches; ///
 
-    return nameMatches;
-  }
-
-  matchValue(value) {
-    const valueMatches = (value === this.name);
-
-    return valueMatches;
+    return parameterMatches;
   }
 
   matchMetavariableName(metavariableName) {

package/src/dom/parameter.js

@@ -3,16 +3,16 @@
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Parameter {
-  constructor(value) {
-    this.value = value;
+  constructor(name) {
+    this.name = name;
   }
 
-  getValue() {
-    return this.value;
+  getName() {
+    return this.name;
   }
 
   getString() {
-    const string = this.value; ///
+    const string = this.name; ///
 
     return string;
   }
@@ -20,13 +20,14 @@ export default domAssigned(class Parameter {
   findReplacementNode(substitutions) {
     let replacementNode = null;
 
-    const substitution = substitutions.findSubstitution((substitution) => {
-      const valueMatches = substitution.matchValue(this.value);
+    const parameter = this, ///
+          substitution = substitutions.findSubstitution((substitution) => {
+            const nameMatches = substitution.matchParameter(parameter);
 
-      if (valueMatches) {
-        return true;
-      }
-    });
+            if (nameMatches) {
+              return true;
+            }
+          });
 
     if (substitution !== null) {
       replacementNode = substitution.getReplacementNode();
@@ -36,9 +37,9 @@ export default domAssigned(class Parameter {
   }
 
   toJSON() {
-    const value = this.value,
+    const name = this.name,
           json = {
-            value
+            name
           };
 
     return json;
@@ -47,16 +48,16 @@ export default domAssigned(class Parameter {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    const { value } = json,
-          parameter = new Parameter(value);
+    const { name } = json,
+          parameter = new Parameter(name);
 
     return parameter;
   }
 
   static fromParameterNode(parameterNode, context) {
-    const parameterValue = parameterNode.getParameterValue(),
-          value = parameterValue, ///
-          parameter = new Parameter(value);
+    const parameterName = parameterNode.getParameterName(),
+          name = parameterName, ///
+          parameter = new Parameter(name);
 
     return parameter;
   }

package/src/dom/procedureCall.js

@@ -66,7 +66,7 @@ export default domAssigned(class ProcedureCall {
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiesIndependently = false;
+    let unifiesIndependently;
 
     const procedureCallString = this.string; ///
 

package/src/dom/propertyRelation.js

@@ -92,12 +92,12 @@ export default domAssigned(class PropertyRelation {
     context.trace(`Verifying the '${propertyString}' property...`);
 
     const termType = this.term.getType(),
-          propertyName = this.property.getName(),
+          propertyIdentifier = this.property.getIdentifier(),
           termTypeProperties = termType.getProperties(),
           variableTypeProperty = termTypeProperties.find((termTypeProperty) => {
-            const propertyNameMatches = termTypeProperty.matchPropertyName(propertyName);
+            const propertyIdentifierMatches = termTypeProperty.matchPropertyIdentifier(propertyIdentifier);
 
-            if (propertyNameMatches) {
+            if (propertyIdentifierMatches) {
               return true;
             }
           }) || null;
@@ -106,7 +106,7 @@ export default domAssigned(class PropertyRelation {
       const variableString = this.term.getString(),
             variableTypeString = termType.getString();
 
-      context.debug(`The '${propertyName}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
+      context.debug(`The '${propertyIdentifier}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
     } else {
       const type = termType;
 

package/src/dom/substitution/frame.js

@@ -26,7 +26,7 @@ export default domAssigned(class FrameSubstitution extends Substitution {
 
   isMetavariableEqualTo(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  matchValue(value) { return this.metavariable.matchValue(value); }
+  matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
 
   getReplacementNode() {
     const frameNode = this.frame.getNode(),

package/src/dom/substitution/statement.js

@@ -69,7 +69,7 @@ export default domAssigned(class StatementSubstitution extends Substitution {
     return simple;
   }
 
-  matchName(name) { return this.metavariable.matchName(name); }
+  matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
 
   getReplacementNode() {
     const statementNode = this.statement.getNode(),

package/src/dom/substitution/term.js

@@ -42,6 +42,8 @@ export default domAssigned(class TermSubstitution extends Substitution {
 
   isVariableEqualTo(variable) { return this.variable.isEqualTo(variable); }
 
+  matchParameter(parameter) { return this.variable.matchParameter(parameter); }
+
   getReplacementNode() {
     const termNode = this.term.getNode(),
           replacementNode = termNode; ///
@@ -49,8 +51,6 @@ export default domAssigned(class TermSubstitution extends Substitution {
     return replacementNode;
   }
 
-  matchValue(value) { return this.variable.matchValue(value); }
-
   static fromStatementNode(statementNode, context) {
     let termSubstitution = null;
 

package/src/dom/substitution.js

@@ -135,10 +135,10 @@ export default class Substitution {
     return resolved;
   }
 
-  matchName(name) {
-    const nameMatches = false;
+  matchParameter(parameter) {
+    const parameterMatches = false;
 
-    return nameMatches;
+    return parameterMatches;
   }
 
   getReplacementNode() {

package/src/dom/type.js

@@ -182,12 +182,6 @@ class Type {
     return equalToOrSuperTypeOf;
   }
 
-  matchName(name) {
-    const nodeMatches = (this.name === name);
-
-    return nodeMatches;
-  }
-
   matchTypeName(typeName) {
     const typeNameMatches = (this.name === typeName);
 

package/src/dom/variable.js

@@ -48,10 +48,12 @@ export default domAssigned(class Variable {
     return equalTo;
   }
 
-  mathValue(value) {
-    const valueMatches = (value === this.identifier);
+  matchParameter(parameter) {
+    const parameterName = parameter.getName(),
+          parameterNameMatchesIdentifier = (parameterName === this.identifier),
+          parameterMatches = parameterNameMatchesIdentifier;  ///
 
-    return valueMatches;
+    return parameterMatches;
   }
 
   matchVariableIdentifier(variableIdentifier) {
@@ -233,8 +235,8 @@ export default domAssigned(class Variable {
     let propertyRelations;
 
     const node = variable.getNode(),
-          identifier = variable.getName(),
-          type = variable.getType();
+          type = variable.getType(),
+          identifier = variable.getIdentifier();
 
     propertyRelations = variable.getPropertyRelations();
 

package/src/mixins/term/verify.js

@@ -37,9 +37,12 @@ function verifyTermAsVariable(term, context, verifyAhead) {
         singularVariableNode = termNode.getSingularVariableNode();
 
   if (singularVariableNode !== null) {
-    const variableNode = singularVariableNode,
-          variable = Variable.fromVariableNode(variableNode, context),
-          termString = term.getString();
+    let variable;
+
+    const termString = term.getString(),
+          variableNode = singularVariableNode;  ///
+
+    variable = Variable.fromVariableNode(variableNode, context);
 
     context.trace(`Verifying the '${termString}' term as a variable...`);
 
@@ -48,9 +51,9 @@ function verifyTermAsVariable(term, context, verifyAhead) {
     if (variableVerifies) {
       let verifiesAhead;
 
-      const variableName = variable.getName();
+      const variableIdentifier = variable.getIdentifier();
 
-      variable = context.findVariableByVariableName(variableName);
+      variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
       const type = variable.getType();
 

package/src/node/declaration/property.js

@@ -5,11 +5,11 @@ import NonTerminalNode from "../../node/nonTerminal";
 import { TYPE_RULE_NAME, PROPERTY_RULE_NAME } from "../../ruleNames";
 
 export default class PropertyDeclarationNode extends NonTerminalNode {
-  getPropertyName() {
+  getPropertyIdentifier() {
     const propertyNode = this.getPropertyNode(),
-          propertyName = propertyNode.getPropertyName();
+          propertyIdentifier = propertyNode.getPropertyIdentifier();
 
-    return propertyName;
+    return propertyIdentifier;
   }
 
   getTypeNode() {

package/src/node/declaration/variable.js

@@ -42,11 +42,11 @@ export default class VariableDeclarationNode extends NonTerminalNode {
     return variableNode;
   }
 
-  getVariableName() {
+  getVariableIdentifier() {
     const variableNode = this.getVariableNode(),
-          variableName = variableNode.getVariableName();
+          variableIdentifier = variableNode.getVariableIdentifier();
 
-    return variableName;
+    return variableIdentifier;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableDeclarationNode, ruleName, childNodes, opacity, precedence); }

package/src/node/parameter.js

@@ -3,21 +3,21 @@
 import NonTerminalNode from "../node/nonTerminal";
 
 export default class ParameterNode extends NonTerminalNode {
-  getParameterValue() {
-    let parameterValue;
+  getParameterName() {
+    let parameterName;
 
     this.someChildNode((childNode, index) => {
       const terminalNode = childNode, ///
             content = terminalNode.getContent();
 
-      parameterValue = content;  ///
+      parameterName = content;  ///
 
       if (index === 0) {
         return true;
       }
     });
 
-    return parameterValue;
+    return parameterName;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }

package/src/node/property.js

@@ -5,23 +5,23 @@ import NonTerminalNode from "../node/nonTerminal";
 import { SINGLE_SPACE } from "../constants";
 
 export default class PropertyNode extends NonTerminalNode {
-  getPropertyName() {
-    const names = this.getNames(),
-          propertyName = names.join(SINGLE_SPACE);
+  getPropertyIdentifiers() {
+    const identifiers = this.getIdentifiers(),
+          propertyIdentifiers = identifiers.join(SINGLE_SPACE);
 
-    return propertyName;
+    return propertyIdentifiers;
   }
 
-  getNames() {
-    const names = this.mapChildNode((childNode) => {
+  getIdentifiers() {
+    const identifiers = this.mapChildNode((childNode) => {
       const terminalNode = childNode, ///
             content = terminalNode.getContent(),
-            name = content; //
+            identifier = content; //
 
-      return name;
+      return identifier;
     });
 
-    return names;
+    return identifiers;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }

package/src/node/propertyRelation.js

@@ -19,11 +19,11 @@ export default class PropertyRelationNode extends NonTerminalNode {
     return propertyNode;
   }
 
-  getPropertyName() {
+  getPropertyIdentifier() {
     const propertyNode = this.getPropertyNode(),
-          propertyName = propertyNode.getPropertyName();
+          propertyIdentifier = propertyNode.getPropertyIdentifier();
 
-    return propertyName;
+    return propertyIdentifier;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }

package/src/node/variable.js

@@ -3,8 +3,8 @@
 import NonTerminalNode from "../node/nonTerminal";
 
 export default class VariableNode extends NonTerminalNode {
-  getVariableName() {
-    let variableName;
+  getVariableIdentifier() {
+    let variableIdentifier;
 
     this.someChildNode((childNode) => {
       const childNodeTerminalNode = childNode.isTerminalNode();
@@ -13,13 +13,13 @@ export default class VariableNode extends NonTerminalNode {
         const terminalNode = childNode, ///
               content = terminalNode.getContent();
 
-        variableName = content; ///
+        variableIdentifier = content; ///
 
         return true;
       }
     });
 
-    return variableName;
+    return variableIdentifier;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableNode, ruleName, childNodes, opacity, precedence); }