occam-furtle 2.0.69 → 2.0.73

package/src/dom/assignment/object.js

@@ -2,7 +2,7 @@
 
 import dom from "../../dom";
 import Exception from "../../exception";
-import nodeParameters from "../../parameters/node";
+import nodeProperties from "../../nodeProperties";
 
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
@@ -12,10 +12,10 @@ import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_
 const objectAssignmentNodeQuery = nodeQuery("/step/objectAssignment");
 
 export default domAssigned(class ObjectAssigment {
-  constructor(string, variable, parameters) {
+  constructor(string, variable, namedParameters) {
     this.string = string;
     this.variable = variable;
-    this.parameters = parameters;
+    this.namedParameters = namedParameters;
   }
 
   getString() {
@@ -26,8 +26,8 @@ export default domAssigned(class ObjectAssigment {
     return this.variable;
   }
 
-  getParameters() {
-    return this.parameters;
+  getNamedParameters() {
+    return this.namedParameters;
   }
 
   evaluate(context) {
@@ -46,54 +46,52 @@ export default domAssigned(class ObjectAssigment {
       throw exception;
     }
 
-    nodeParameters.matchParameters(this.parameters, context);
+    nodeProperties.matchNamedParameters(this.namedParameters, context);
 
-    this.parameters.forEachParameter((parameter) => {
-      if (parameter !== null) {
-        this.evaluateParameter(parameter, value, context);
-      }
+    this.namedParameters.forEachNamedParameter((namedParameter) => {
+      this.evaluateNamedParameter(namedParameter, value, context);
     });
 
     context.debug(`...evaluated the '${objectAssignmentString}' object assignment.`);
   }
 
-  evaluateParameter(parameter, value, context) {
+  evaluateNamedParameter(namedParameter, value, context) {
     const valueString = value.asString(context),
-          parameterString = parameter.getString();
+          namedParameterString = namedParameter.getString();
 
-    context.trace(`Evaluating the '${parameterString}' parameter against the ${valueString} value...`);
+    context.trace(`Evaluating the '${namedParameterString}' named parameter against the ${valueString} value...`);
 
-    const name = parameter.getName();
+    const name = namedParameter.getName();
 
     switch (name) {
       case CONTENT_PARAMETER_NAME: {
-        this.evaluateContentParameter(parameter, value, context);
+        this.evaluateContentNamedParameter(namedParameter, value, context);
 
         break;
       }
 
       case TERMINAL_PARAMETER_NAME: {
-        this.evaluateTerminalParameter(parameter, value, context);
+        this.evaluateTerminalNamedParameter(namedParameter, value, context);
 
         break;
       }
 
       case CHILD_NODES_PARAMETER_NAME: {
-        this.evaluateChildNodesParameter(parameter, value, context);
+        this.evaluateChildNodesNamedParameter(namedParameter, value, context);
 
         break;
       }
     }
 
-    context.debug(`...evaluated the '${parameterString}' parameter against the ${valueString} value.`);
+    context.debug(`...evaluated the '${namedParameterString}' parameter named against the ${valueString} value.`);
   }
 
-  evaluateContentParameter(parameter, value, context) {
-    const type = parameter.getType();
+  evaluateContentNamedParameter(namedParameter, value, context) {
+    const type = namedParameter.getType();
 
     if (type !== STRING_TYPE) {
-      const parameterString = parameter.getString(),
-            message = `The '${parameterString}' parameter's type should be '${STRING_TYPE}'.`,
+      const namedParameterString = namedParameter.getString(),
+            message = `The '${namedParameterString}' named parameter's type should be '${STRING_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -118,19 +116,19 @@ export default domAssigned(class ObjectAssigment {
     value = Value.fromString(string, context);  ///
 
     const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
 
     context.addVariable(variable);
 
     variable.assign(context);
   }
 
-  evaluateTerminalParameter(parameter, value, context) {
-    const type = parameter.getType();
+  evaluateTerminalNamedParameter(namedParameter, value, context) {
+    const type = namedParameter.getType();
 
     if (type !== BOOLEAN_TYPE) {
-      const parameterString = parameter.getString(),
-            message = `The '${parameterString}' parameter's type should be '${BOOLEAN_TYPE}'.`,
+      const namedParameterString = namedParameter.getString(),
+            message = `The '${namedParameterString}' named parameter's type should be '${BOOLEAN_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -146,19 +144,19 @@ export default domAssigned(class ObjectAssigment {
     value = Value.fromBoolean(boolean, context);  ///
 
     const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
 
     context.addVariable(variable);
 
     variable.assign(context);
   }
 
-  evaluateChildNodesParameter(parameter, value, context) {
-    const type = parameter.getType();
+  evaluateChildNodesNamedParameter(namedParameter, value, context) {
+    const type = namedParameter.getType();
 
     if (type !== NODES_TYPE) {
-      const parameterString = parameter.getString(),
-            message = `The '${parameterString}' parameter's type should be '${NODES_TYPE}'.`,
+      const namedParameterString = namedParameter.getString(),
+            message = `The '${namedParameterString}' named parameter's type should be '${NODES_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -183,7 +181,7 @@ export default domAssigned(class ObjectAssigment {
     value = Value.fromNodes(nodes, context);  ///
 
     const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
 
     context.addVariable(variable);
 
@@ -198,13 +196,13 @@ export default domAssigned(class ObjectAssigment {
     const objectAssignmentNode = objectAssignmentNodeQuery(stepNode);
 
     if (objectAssignmentNode !== null) {
-      const { Variable, Parameters } = dom,
+      const { Variable, NamedParameters } = dom,
             node = objectAssignmentNode,  ///
             string = context.nodeAsString(node),
             variable = Variable.fromObjectAssignmentNode(objectAssignmentNode, context),
-            parameters = Parameters.fromObjectAssignmentNode(objectAssignmentNode, context);
+            namedParameters = NamedParameters.fromObjectAssignmentNode(objectAssignmentNode, context);
 
-      objectAssignment = new ObjectAssigment(string, variable, parameters);
+      objectAssignment = new ObjectAssigment(string, variable, namedParameters);
     }
 
     return objectAssignment;

package/src/dom/assignment.js

@@ -3,11 +3,8 @@
 import dom from "../dom";
 import Exception from "../exception";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const assignmentNodeQuery = nodeQuery("/variableAssignment/assignment");
-
 export default domAssigned(class Assignment {
   constructor(string, value) {
     this.string = string;
@@ -67,13 +64,6 @@ export default domAssigned(class Assignment {
 
     return assignment;
   }
-
-  static fromVariableAssignmentNode(variableAssignmentNode, context) {
-    const assignmentNode = assignmentNodeQuery(variableAssignmentNode),
-          assignment = assignmentFromAssignmentNode(assignmentNode, context);
-
-    return assignment;
-  }
 });
 
 function stringFromValue(value, context) {

package/src/dom/block/return.js

@@ -1,17 +1,22 @@
 "use strict";
 
 import dom from "../../dom";
+import Exception from "../../exception";
 import BlockContext from "../../context/block";
 
-import { nodesQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
 
-const stepNodesQuery = nodesQuery("/procedureDeclaration/returnBlock/step");
+const stepNodesQuery = nodesQuery("/returnBlock/step"),
+      nonsenseNodesQuery = nodesQuery("/returnBlock/nonsense"),
+      anonymousProcedureReturnBlockNodeQuery = nodeQuery("/anonymousProcedure/returnBlock"),
+      procedureDeclarationReturnBlockNodeQuery = nodeQuery("/procedureDeclaration/returnBlock");
 
 export default domAssigned(class ReturnBlock {
-  constructor(string, steps, returnStatement) {
+  constructor(string, steps, nonsensical, returnStatement) {
     this.string = string;
     this.steps = steps;
+    this.nonsensical = nonsensical;
     this.returnStatement = returnStatement;
   }
 
@@ -23,11 +28,22 @@ export default domAssigned(class ReturnBlock {
     return this.steps;
   }
 
+  isNonsensical() {
+    return this.nonsensical;
+  }
+
   getReturnStatement() {
     return this.returnStatement;
   }
 
   evaluate(variables, context) {
+    if (this.nonsensical) {
+      const message = `The return block is nonsensical.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
     const blockContext = BlockContext.fromVariables(variables, context);
 
     context = blockContext; ///
@@ -44,13 +60,17 @@ export default domAssigned(class ReturnBlock {
   static name = "ReturnBlock";
 
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    const { ReturnStatement } = dom,
-          node = procedureDeclarationNode,  ///
-          string = context.nodeAsString(node),
-          stepNodes = stepNodesQuery(procedureDeclarationNode),
-          steps = stepsFromStepNodes(stepNodes, context),
-          returnStatement = ReturnStatement.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          returnBlock = new ReturnBlock(string, steps, returnStatement);
+    const procedureDeclarationReturnBlockNode = procedureDeclarationReturnBlockNodeQuery(procedureDeclarationNode),
+          returnBlockNode = procedureDeclarationReturnBlockNode,  ///
+          returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+
+    return returnBlock;
+  }
+
+  static fromAnonymousProcedureNode(anonymousProcedureNode, context) {
+    const anonymousProcedureReturnBlockNode = anonymousProcedureReturnBlockNodeQuery(anonymousProcedureNode),
+          returnBlockNode = anonymousProcedureReturnBlockNode,  ///
+          returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
 
     return returnBlock;
   }
@@ -66,3 +86,24 @@ function stepsFromStepNodes(stepNodes, context) {
 
   return steps;
 }
+
+function returnBlockFromReturnBlockNode(returnBlockNode, context) {
+  const { ReturnBlock, ReturnStatement } = dom,
+        node = returnBlockNode, ///
+        string = context.nodeAsString(node),
+        stepNodes = stepNodesQuery(returnBlockNode),
+        steps = stepsFromStepNodes(stepNodes, context),
+        nonsensical = nonsensicalFromReturnBlockNode(returnBlockNode, context),
+        returnStatement = ReturnStatement.fromReturnBlockNode(returnBlockNode, context),
+        returnBlock = new ReturnBlock(string, steps, nonsensical, returnStatement);
+
+  return returnBlock;
+}
+
+function nonsensicalFromReturnBlockNode(returnBlockNode, context) {
+  const nonsenseNodes = nonsenseNodesQuery(returnBlockNode),
+        nonsenseNodesLength = nonsenseNodes.length,
+        nonsensical = (nonsenseNodesLength > 0);
+
+  return nonsensical;
+}

package/src/dom/block.js

@@ -3,8 +3,8 @@
 import dom from "../dom";
 import BlockContext from "../context/block";
 
+import { nodesQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const stepNodesQuery = nodesQuery("/block/step");
 

package/src/dom/parameter/named.js

@@ -0,0 +1,119 @@
+"use strict";
+
+import Exception from "../../exception";
+
+import { domAssigned } from "../../dom";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
+
+const typeTerminalNodeQuery = nodeQuery("/namedParameter/@type"),
+      nameTerminalNodeQuery = nodeQuery("/namedParameter/@name[0]"),
+      asNameTerminalNodeQuery = nodeQuery("/namedParameter/@name[1]");
+
+export default domAssigned(class NamedParameter {
+  constructor(string, type, name, asName) {
+    this.string = string;
+    this.type = type;
+    this.name = name;
+    this.asName = asName;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getAsName() {
+    return this.asName;
+  }
+
+  matchValue(value, context) {
+    const valueString = value.asString(context),
+          namedParameterString = this.string;  ///
+
+    context.trace(`Matching the ${valueString} value against the '${namedParameterString}' named parameter...`);
+
+    const valueType = value.getType();
+
+    if (this.type !== valueType) {
+      const message = `The ${valueString} value's '${valueType}' type  and '${namedParameterString}' named parameter's '${this.type}' type do not match.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...matched the ${valueString} value against the '${namedParameterString}' named parameter.`);
+  }
+
+  matchNamedParameter(namedParameter, context) {
+    let namedParameterMatches;
+
+    const namedParameterA = this,  ///
+          namedParameterB = namedParameter; ///
+
+    const namedParameterAString = namedParameterA.getString(),
+          namedParameterBString = namedParameterB.getString();
+
+    context.trace(`Matching the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter...`);
+
+    const name = namedParameter.getName(),
+          type = namedParameter.getType();
+
+    namedParameterMatches = ((this.name === name) && (this.type === type));
+
+    if (namedParameterMatches) {
+      context.debug(`...matched the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter.`);
+    }
+
+    return namedParameterMatches;
+  }
+
+  static name = "NamedParameter";
+
+  static fromNamedParameterNode(namedParameterNode, context) {
+    const type = typeFromNamedParameterNode(namedParameterNode, context),
+          name = nameFromNamedParameterNode(namedParameterNode, context),
+          asName = asNameFromNamedParameterNode(namedParameterNode, context),
+          node = namedParameterNode, //
+          string = context.nodeAsString(node),
+          namedParameter = new NamedParameter(string, type, name, asName);
+
+    return namedParameter;
+  }
+});
+
+function typeFromNamedParameterNode(namedParameterNode, context) {
+  const typeTerminalNode = typeTerminalNodeQuery(namedParameterNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        type = typeTerminalNodeContent; ///
+
+  return type;
+}
+
+function nameFromNamedParameterNode(namedParameterNode, context) {
+  const nameTerminalNode = nameTerminalNodeQuery(namedParameterNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        name = nameTerminalNodeContent; ///
+
+  return name;
+}
+
+function asNameFromNamedParameterNode(namedParameterNode, context) {
+  let asName = null;
+
+  const asNameTerminalNode = asNameTerminalNodeQuery(namedParameterNode);
+
+  if (asNameTerminalNode !== null) {
+    const asNameTerminalNodeContent = asNameTerminalNode.getContent();
+
+    asName = asNameTerminalNodeContent; ///
+  }
+
+  return asName;
+}

package/src/dom/parameter.js

@@ -10,24 +10,24 @@ const terminalNodesQuery = nodesQuery("/parameter/@*"),
       typeTerminalNodeQuery = nodeQuery("/parameter/@type");
 
 export default domAssigned(class Parameter {
-  constructor(string, name, type) {
+  constructor(string, type, name) {
     this.string = string;
-    this.name = name;
     this.type = type;
+    this.name = name;
   }
 
   getString() {
     return this.string;
   }
 
-  getName() {
-    return this.name;
-  }
-
   getType() {
     return this.type;
   }
 
+  getName() {
+    return this.name;
+  }
+
   matchValue(value, context) {
     const valueString = value.asString(context),
           parameterString = this.string;  ///
@@ -46,38 +46,8 @@ export default domAssigned(class Parameter {
     context.debug(`...matched the ${valueString} value against the '${parameterString}' parameter.`);
   }
 
-  matchParameter(parameter, context) {
-    let parameterMatches;
-
-    const parameterA = this,  ///
-          parameterB = parameter; ///
-
-    const parameterAString = parameterA.getString(),
-          parameterBString = parameterB.getString();
-
-    context.trace(`Matching the '${parameterAString}' parameter against the '${parameterBString}' parameter...`);
-
-    const name = parameter.getName(),
-          type = parameter.getType();
-
-    parameterMatches = ((this.name === name) && (this.type === type));
-
-    if (parameterMatches) {
-      context.debug(`...matched the '${parameterAString}' parameter against the '${parameterBString}' parameter.`);
-    }
-
-    return parameterMatches;
-  }
-
   static name = "Parameter";
 
-  static fromNameAndType(name, type, context) {
-    const string = stringFromNameAndType(name, type, context),
-          parameter = new Parameter(string, name, type);
-
-    return parameter;
-  }
-
   static fromParameterNode(parameterNode, context) {
     let parameter = null;
 
@@ -90,19 +60,13 @@ export default domAssigned(class Parameter {
             node = parameterNode, //
             string = context.nodeAsString(node);
 
-      parameter = new Parameter(string, name, type);
+      parameter = new Parameter(string, type, name);
     }
 
     return parameter;
   }
 });
 
-function stringFromNameAndType(name, type) {
-  const string = `${type} ${name}`;
-
-  return string;
-}
-
 function nameFromParameterNode(parameterNode, context) {
   const nameTerminalNode = nameTerminalNodeQuery(parameterNode),
         nameTerminalNodeContent = nameTerminalNode.getContent(),

package/src/dom/parameters/named.js

@@ -0,0 +1,129 @@
+"use strict";
+
+import dom from "../../dom";
+import Exception from "../../exception";
+
+import { domAssigned } from "../../dom";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
+
+const namedParameterNodesQuery = nodesQuery("/namedParameters/namedParameter"),
+      objectAssignmentNamedParametersNodeQuery = nodeQuery("/objectAssignment/namedParameters");
+
+export default domAssigned(class NamedParameters {
+  constructor(string, array) {
+    this.string = string;
+    this.array = array;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getLength() {
+    const length = this.array.length;
+
+    return length;
+  }
+
+  getNamedParameter(index) {
+    const namedParameter = this.array[index] || null;
+
+    return namedParameter;
+  }
+
+  someNamedParameter(callback) { return this.array.some(callback); }
+
+  forEachNamedParameter(callback) { this.array.forEach(callback); }
+
+  matchValues(values, context) {
+    const valuesString = values.getString(),
+          namedParametersString = this.string; ///
+
+    context.trace(`Matching the ${valuesString} values against the '${namedParametersString}' named parameters...`);
+
+    const valuesLength = values.getLength(),
+          namedParametersLength = this.getLength();
+
+    if (valuesLength !== namedParametersLength) {
+      const message = `The ${valuesString} values and '${namedParametersString}' named parameters are not of the same length.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    this.forEachNamedParameter((namedParameter, index) => {
+      if (namedParameter !== null) {
+        const value = values.getValue(index);
+
+        namedParameter.matchValue(value, context);
+      }
+    });
+
+    context.debug(`...matched the ${valuesString} values against the '${namedParametersString}' named parameters.`);
+  }
+
+  matchNamedParameter(namedParameter, context) {
+    const namedParameterString = namedParameter.getString(),
+          namedParametersString = this.string; ///
+
+    context.trace(`Matching the '${namedParameterString}' namedParameter against the '${namedParametersString}' named parameters...`);
+
+    const namedParameterA = namedParameter, ///
+          namedParameterMatches = this.someNamedParameter((namedParameter) => {
+            if (namedParameter !== null) {
+              const namedParameterB = namedParameter, ///
+                    namedParameterBMatchesNamedParameterA = namedParameterA.matchNamedParameter(namedParameterB, context);
+
+              if (namedParameterBMatchesNamedParameterA) {
+                return true;
+              }
+            }
+          });
+
+    if (!namedParameterMatches) {
+      const message = `The '${namedParameterString}' namedParameter does not match any of the '${namedParametersString}' named parameters.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...matched the '${namedParameterString}' namedParameter against the '${namedParametersString}' named parameters.`);
+  }
+
+  matchNamedParameters(namedParameters, context) {
+    namedParameters.forEachNamedParameter((namedParameter) => {
+      if (namedParameter !== null) {
+        this.matchNamedParameter(namedParameter, context);
+      }
+    });
+  }
+
+  static name = "NamedParameters";
+
+  static fromObjectAssignmentNode(objectAssignmentNode, context) {
+    const objectAssignmentNamedParametersNode = objectAssignmentNamedParametersNodeQuery(objectAssignmentNode),
+          parametersNode = objectAssignmentNamedParametersNode,  ///
+          node = parametersNode,  ///
+          string = context.nodeAsString(node),
+          namedParameterNodes = namedParameterNodesQuery(parametersNode),
+          array = arrayFromNamedParameterNodes(namedParameterNodes, context),
+          namedParameters = new NamedParameters(string, array);
+
+    return namedParameters;
+  }
+});
+
+function arrayFromNamedParameterNodes(namedParameterNodes, context) {
+  const { NamedParameter } = dom,
+        array = namedParameterNodes.map((namedParameterNode) => { ///
+          const namedParameter = NamedParameter.fromNamedParameterNode(namedParameterNode, context);
+
+          return namedParameter;
+        });
+
+  return array;
+}