occam-furtle 2.0.86 → 2.0.89

package/src/constants.js

@@ -5,6 +5,7 @@ export const TRUE = "true";
 export const FALSE = "false";
 export const FUNCTION = "function";
 export const EQUAL_TO = "==";
+export const UNDERSCORE = "_";
 export const CONJUNCTION = "&&";
 export const DISJUNCTION = "||";
 export const EMPTY_STRING = "";

package/src/context/block.js

@@ -16,12 +16,12 @@ export default class BlockContext {
     return this.context;
   }
 
-  getVariables(blocked = false) {
+  getVariables(nested = true) {
     const variables = [];
 
     push(variables, this.variables);
 
-    if (!blocked) {
+    if (nested) {
       const contextVariables = this.context.getVariables();
 
       push(variables, contextVariables);
@@ -36,8 +36,8 @@ export default class BlockContext {
 
   isProcedurePresentByReference(reference) { return this.context.isProcedurePresentByReference(reference); }
 
-  findVariableByVariableName(variableName, blocked = false) {
-    const variables = this.getVariables(blocked),
+  findVariableByVariableName(variableName, nested = true) {
+    const variables = this.getVariables(nested),
           variable = variables.find((variable) => {
             const variableNameMatches = variable.matchVariableName(variableName);
 
@@ -49,18 +49,18 @@ export default class BlockContext {
     return variable;
   }
 
-  isVariablePresentByVariableName(variableName, blocked = false) {
-    const variable = this.findVariableByVariableName(variableName, blocked),
+  isVariablePresentByVariableName(variableName, nested = true) {
+    const variable = this.findVariableByVariableName(variableName, nested),
           variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
   addVariable(variable) {
-    const blocked = true,
+    const nested = false,
           variableName = variable.getName(),
           variableString = variable.getString(),
-          variablePresent = this.isVariablePresentByVariableName(variableName, blocked);
+          variablePresent = this.isVariablePresentByVariableName(variableName, nested);
 
     if (variablePresent) {
       const message = `The '${variableString}' variable is already present.'`,

package/src/dom/assignment/array.js

@@ -7,7 +7,7 @@ import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 import { NODE_TYPE, NODES_TYPE } from "../../types";
 
-const arrayAssignmentNodeQuery = nodeQuery("/step/arrayAssignment");
+const stepArrayAssignmentNodeQuery = nodeQuery("/step/arrayAssignment");
 
 export default domAssigned(class ArrayAssigment {
   constructor(string, variable, parameters) {
@@ -98,21 +98,28 @@ export default domAssigned(class ArrayAssigment {
   static fromStepNode(stepNode, context) {
     let arrayAssignment = null;
 
-    const arrayAssignmentNode = arrayAssignmentNodeQuery(stepNode);
+    const stepArrayAssignmentNode = stepArrayAssignmentNodeQuery(stepNode);
 
-    if (arrayAssignmentNode !== null) {
-      const { Variable, Parameters } = dom,
-            parameters = Parameters.fromArrayAssignmentNode(arrayAssignmentNode, context),
-            variable = Variable.fromArrayAssignmentNode(arrayAssignmentNode, context),
-            string = stringFromVariableAndParameters(variable, parameters, context);
+    if (stepArrayAssignmentNode !== null) {
+      const arrayAssignmentNode = stepArrayAssignmentNode;  ///
 
-      arrayAssignment = new ArrayAssigment(string, variable, parameters);
+      arrayAssignment = arrayAssignmentFromArrayAssignmentNode(arrayAssignmentNode, context);
     }
 
     return arrayAssignment;
   }
 });
 
+function arrayAssignmentFromArrayAssignmentNode(arrayAssignmentNode, context) {
+  const { Variable, Parameters, ArrayAssignment } = dom,
+        parameters = Parameters.fromArrayAssignmentNode(arrayAssignmentNode, context),
+        variable = Variable.fromArrayAssignmentNode(arrayAssignmentNode, context),
+        string = stringFromVariableAndParameters(variable, parameters, context),
+        arrayAssignment = new ArrayAssignment(string, variable, parameters);
+
+  return arrayAssignment;
+}
+
 function stringFromVariableAndParameters(variable, parameters, context) {
   const variableString = variable.getString(),
         parametersString = parameters.getString(),

package/src/dom/assignment/object.js

@@ -9,7 +9,7 @@ import { domAssigned } from "../../dom";
 import { NODE_TYPE, NODES_TYPE, STRING_TYPE, BOOLEAN_TYPE } from "../../types";
 import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME } from "../../parameterNames";
 
-const objectAssignmentNodeQuery = nodeQuery("/step/objectAssignment");
+const stepObjectAssignmentNodeQuery = nodeQuery("/step/objectAssignment");
 
 export default domAssigned(class ObjectAssigment {
   constructor(string, variable, namedParameters) {
@@ -183,21 +183,28 @@ export default domAssigned(class ObjectAssigment {
   static fromStepNode(stepNode, context) {
     let objectAssignment = null;
 
-    const objectAssignmentNode = objectAssignmentNodeQuery(stepNode);
+    const stepObjectAssignmentNode = stepObjectAssignmentNodeQuery(stepNode);
 
-    if (objectAssignmentNode !== null) {
-      const { Variable, NamedParameters } = dom,
-            namedParameters = NamedParameters.fromObjectAssignmentNode(objectAssignmentNode, context),
-            variable = Variable.fromObjectAssignmentNode(objectAssignmentNode, context),
-            string = stringFromVariableAndNamesParameters(variable, namedParameters, context);
+    if (stepObjectAssignmentNode !== null) {
+      const objectAssignmentNode = stepObjectAssignmentNode;  ///
 
-      objectAssignment = new ObjectAssigment(string, variable, namedParameters);
+      objectAssignment = objectAssignmentFromObjectAssignmentNode(objectAssignmentNode, context);
     }
 
     return objectAssignment;
   }
 });
 
+function objectAssignmentFromObjectAssignmentNode(objectAssignmentNode, context) {
+  const { Variable, NamedParameters, ObjectAssigment } = dom,
+        namedParameters = NamedParameters.fromObjectAssignmentNode(objectAssignmentNode, context),
+        variable = Variable.fromObjectAssignmentNode(objectAssignmentNode, context),
+        string = stringFromVariableAndNamesParameters(variable, namedParameters, context),
+        objectAssignment = new ObjectAssigment(string, variable, namedParameters);
+
+  return objectAssignment;
+}
+
 function stringFromVariableAndNamesParameters(variable, namedParameters, context) {
   const namedParametersString = namedParameters.getString(),
         variableString = variable.getString(),

package/src/dom/assignment/variable.js

@@ -2,6 +2,7 @@
 
 import dom from "../../dom";
 
+import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class VariableAssignment {
@@ -60,7 +61,7 @@ function variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssig
 
 function stringFromValueAndVariable(value, variable, context) {
   const variableString = variable.getString(),
-        valueString = value.getString(),
+        valueString = value.asString(context),
         string = `${variableString} = ${valueString};`;
 
   return string;

package/src/dom/assignments/variable.js

@@ -6,8 +6,8 @@ import { domAssigned } from "../../dom";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const typeTerminalNodeQuery = nodeQuery("/variableAssignments/@type"),
-      variableAssignmentsNodeQuery = nodeQuery("/step/variableAssignments"),
-      variableAssignmentNodesQuery = nodesQuery("/variableAssignments/variableAssignment");
+      variableAssignmentNodesQuery = nodesQuery("/variableAssignments/variableAssignment"),
+      stepVariableAssignmentsNodeQuery = nodeQuery("/step/variableAssignments");
 
 export default domAssigned(class VariableAssignments {
   constructor(string, array) {
@@ -40,20 +40,28 @@ export default domAssigned(class VariableAssignments {
   static fromStepNode(stepNode, context) {
     let variableAssignments = null;
 
-    const variableAssignmentsNode = variableAssignmentsNodeQuery(stepNode);
+    const stepVariableAssignmentsNode = stepVariableAssignmentsNodeQuery(stepNode);
 
-    if (variableAssignmentsNode !== null) {
-      const type = typeFromVariableAssignmentsNode(variableAssignmentsNode, context),
-            array = arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context),
-            string = stringFromArray(array, context);
+    if (stepVariableAssignmentsNode !== null) {
+      const variableAssignmentsNode = stepVariableAssignmentsNode;  ///
 
-      variableAssignments = new VariableAssignments(string, array);
+      variableAssignments = variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context);
     }
 
     return variableAssignments;
   }
 });
 
+function variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+  const { VariableAssignments } = dom,
+        type = typeFromVariableAssignmentsNode(variableAssignmentsNode, context),
+        array = arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context),
+        string = stringFromArray(array, context),
+        variableAssignments = new VariableAssignments(string, array);
+
+  return variableAssignments;
+}
+
 function stringFromArray(array, context) {
   const variableAssignmentsString = array.reduce((variableAssignmentsString, variableAssignment) => {
           const variableAssignmentString = variableAssignment.getString();

package/src/dom/block/return.js

@@ -9,6 +9,7 @@ import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const stepNodesQuery = nodesQuery("/returnBlock/step"),
       nonsenseNodesQuery = nodesQuery("/returnBlock/nonsense"),
+      valueReturnBlockNodeQuery = nodeQuery("/value/returnBlock"),
       anonymousProcedureReturnBlockNodeQuery = nodeQuery("/anonymousProcedure/returnBlock"),
       procedureDeclarationReturnBlockNodeQuery = nodeQuery("/procedureDeclaration/returnBlock");
 
@@ -37,6 +38,12 @@ export default domAssigned(class ReturnBlock {
   }
 
   evaluate(variables, context) {
+    if (context === undefined) {
+      context = variables;  ///
+
+      variables = [];
+    }
+
     if (this.nonsensical) {
       const message = `The return block is nonsensical.`,
             exception = Exception.fromMessage(message);
@@ -59,10 +66,16 @@ export default domAssigned(class ReturnBlock {
 
   static name = "ReturnBlock";
 
-  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    const procedureDeclarationReturnBlockNode = procedureDeclarationReturnBlockNodeQuery(procedureDeclarationNode),
-          returnBlockNode = procedureDeclarationReturnBlockNode,  ///
-          returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+  static fromValueNode(valueNode, context) {
+    let returnBlock = null;
+
+    const valueReturnBlockNode = valueReturnBlockNodeQuery(valueNode);
+
+    if (valueReturnBlockNode !== null) {
+      const returnBlockNode = valueReturnBlockNode;  ///
+
+      returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+    }
 
     return returnBlock;
   }
@@ -74,6 +87,14 @@ export default domAssigned(class ReturnBlock {
 
     return returnBlock;
   }
+
+  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
+    const procedureDeclarationReturnBlockNode = procedureDeclarationReturnBlockNodeQuery(procedureDeclarationNode),
+          returnBlockNode = procedureDeclarationReturnBlockNode,  ///
+          returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+
+    return returnBlock;
+  }
 });
 
 function stringFromReturnStatement(returnStatement, context) {

package/src/dom/comparison.js

@@ -10,8 +10,7 @@ import { EQUAL_TO, NOT_EQUAL_TO } from "../constants";
 const terminalNodeQuery = nodeQuery("/comparison/@*"),
       leftValueNodeQuery = nodeQuery("/comparison/value[0]"),
       rightValueNodeQuery = nodeQuery("/comparison/value[1]"),
-      valueComparisonNodeQuery = nodeQuery("/value/comparison"),
-      conditionComparisonNodeQuery = nodeQuery("/condition/comparison");
+      valueComparisonNodeQuery = nodeQuery("/value/comparison");
 
 export default domAssigned(class Comparison {
   constructor(string, negated, leftValue, rightValue) {
@@ -90,20 +89,6 @@ export default domAssigned(class Comparison {
 
     return comparison;
   }
-
-  static fromConditionNode(conditionNode, context) {
-    let comparison = null;
-
-    const conditionComparisonNode = conditionComparisonNodeQuery(conditionNode);
-
-    if (conditionComparisonNode !== null) {
-      const comparisonNode = conditionComparisonNode; ///
-
-      comparison = comparisonFromComparisonNode(comparisonNode, context);
-    }
-
-    return comparison;
-  }
 });
 
 function negatedFromComparisonNode(comparisonNode) {

package/src/dom/declaration/procedure.js

@@ -21,15 +21,21 @@ export default domAssigned(class ProcedureDeclaration {
   static name = "ProcedureDeclaration";
 
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    const { Procedure } = dom,
-          procedure = Procedure.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          string = stringFromProcedure(procedure, context),
-          procedureDeclaration = new ProcedureDeclaration(string, procedure);
+    const procedureDeclaration = procedureFromProcedureDeclarationNode(procedureDeclarationNode, context);
 
     return procedureDeclaration;
   }
 });
 
+function procedureFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const { Procedure, ProcedureDeclaration } = dom,
+        procedure = Procedure.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+        string = stringFromProcedure(procedure, context),
+        procedureDeclaration = new ProcedureDeclaration(string, procedure);
+
+  return procedureDeclaration;
+}
+
 function stringFromProcedure(procedure, context) {
   const procedureString = procedure.getString(),
         string = `${procedureString};`;

package/src/dom/error.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import dom from "../dom";
+
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Error {
@@ -14,10 +16,17 @@ export default domAssigned(class Error {
   static name = "Error";
 
   static fromErrorNode(errorNode, context) {
-    const node = errorNode, ///
-          string = context.nodeAsString(node),
-          error = new Error(string);
+    const error = errorFromErrorNode(errorNode, context);
 
     return error;
   }
 });
+
+function errorFromErrorNode(errorNode, context) {
+  const {Error} = dom,
+        node = errorNode, ///
+        string = context.nodeAsString(node),
+        error = new Error(string);
+
+  return error;
+}

package/src/dom/every.js

@@ -91,19 +91,25 @@ export default domAssigned(class Every {
     const valueEveryNode = valueEveryNodeQuery(valueNode);
 
     if (valueEveryNode !== null) {
-      const { Variable, AnonymousProcedure } = dom,
-            everyNode = valueEveryNode, ///
-            anonymousProcedure = AnonymousProcedure.fromEveryNode(everyNode, context),
-            variable = Variable.fromEveryNode(everyNode, context),
-            string = stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context);
+      const everyNode = valueEveryNode; ///
 
-      every = new Every(string, variable, anonymousProcedure);
+      every = everyFromEveryNode(everyNode, context);
     }
 
     return every;
   }
 });
 
+function everyFromEveryNode(everyNode, context) {
+  const { Every, Variable, AnonymousProcedure } = dom,
+        anonymousProcedure = AnonymousProcedure.fromEveryNode(everyNode, context),
+        variable = Variable.fromEveryNode(everyNode, context),
+        string = stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context),
+        every = new Every(string, variable, anonymousProcedure);
+
+  return every;
+}
+
 function stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context) {
   const variableString = variable.getString(),
         anonymousProcedureString = anonymousProcedure.getString(),

package/src/dom/label.js

@@ -1,10 +1,12 @@
 "use strict";
 
+import dom from "../dom";
+
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const labelNodeQuery = nodeQuery("/procedureDeclaration/label"),
-      nameTerminalNodeQuery = nodeQuery("/label/@name");
+const nameTerminalNodeQuery = nodeQuery("/label/@name"),
+      procedureDeclarationLabelNodeQuery = nodeQuery("/procedureDeclaration/label");
 
 export default domAssigned(class Label {
   constructor(string, name) {
@@ -29,20 +31,21 @@ export default domAssigned(class Label {
   static name = "Label";
 
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    const labelNode = labelNodeQuery(procedureDeclarationNode),
-          name = nameFromLabelNode(labelNode, context),
-          string = stringFromName(name, context),
-          label = new Label(string, name);
+    const procedureDeclarationLabelNode = procedureDeclarationLabelNodeQuery(procedureDeclarationNode),
+          labelNode = procedureDeclarationLabelNode,  ///
+          label = labelFromLabelNode(labelNode, context);
 
     return label;
   }
 });
 
-function stringFromName(name, context) {
-  const nameString = name,  ///
-        string = nameString;  ///
+function labelFromLabelNode(labelNode, context) {
+  const { Label } = dom,
+        name = nameFromLabelNode(labelNode, context),
+        string = stringFromName(name, context),
+        label = new Label(string, name);
 
-  return string;
+  return label;
 }
 
 function nameFromLabelNode(labelNode, context) {
@@ -53,3 +56,10 @@ function nameFromLabelNode(labelNode, context) {
   return name;
 }
 
+function stringFromName(name, context) {
+  const nameString = name,  ///
+        string = nameString;  ///
+
+  return string;
+}
+

package/src/dom/parameter/named.js

@@ -1,9 +1,10 @@
 "use strict";
 
+import dom from "../../dom";
 import Exception from "../../exception";
 
+import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
-import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const typeTerminalNodeQuery = nodeQuery("/namedParameter/@type"),
       nameTerminalNodeQuery = nodeQuery("/namedParameter/@name[0]"),
@@ -77,16 +78,23 @@ export default domAssigned(class NamedParameter {
   static name = "NamedParameter";
 
   static fromNamedParameterNode(namedParameterNode, context) {
-    const type = typeFromNamedParameterNode(namedParameterNode, context),
-          name = nameFromNamedParameterNode(namedParameterNode, context),
-          asName = asNameFromNamedParameterNode(namedParameterNode, context),
-          string = stringFromTypeNameAndAsName(type, name, asName, context),
-          namedParameter = new NamedParameter(string, type, name, asName);
+    const namedParameter = namedParameterFromNamedParameterNode(namedParameterNode, context);
 
     return namedParameter;
   }
 });
 
+function namedParameterFromNamedParameterNode(namedParameterNode, context) {
+  const { NamedParameter } = dom,
+        type = typeFromNamedParameterNode(namedParameterNode, context),
+        name = nameFromNamedParameterNode(namedParameterNode, context),
+        asName = asNameFromNamedParameterNode(namedParameterNode, context),
+        string = stringFromTypeNameAndAsName(type, name, asName, context),
+        namedParameter = new NamedParameter(string, type, name, asName);
+
+  return namedParameter;
+}
+
 function stringFromTypeNameAndAsName(type, name, asName, context) {
   let string;
 

package/src/dom/parameter.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import dom from "../dom";
 import Exception from "../exception";
 
 import { domAssigned } from "../dom";
@@ -55,17 +56,23 @@ export default domAssigned(class Parameter {
           terminalNodesLength = terminalNodes.length;
 
     if (terminalNodesLength === 2) {
-      const name = nameFromParameterNode(parameterNode, context),
-            type = typeFromParameterNode(parameterNode, context),
-            string = stringFromNameAndType(name, type, context);
-
-      parameter = new Parameter(string, type, name);
+      parameter = parameterFromParameterNode(parameterNode, context);
     }
 
     return parameter;
   }
 });
 
+function parameterFromParameterNode(parameterNode, context) {
+  const { Parameter } = dom,
+        name = nameFromParameterNode(parameterNode, context),
+        type = typeFromParameterNode(parameterNode, context),
+        string = stringFromNameAndType(name, type, context),
+        parameter = new Parameter(string, type, name);
+
+  return parameter;
+}
+
 function stringFromNameAndType(name, type, context) {
   const nameString = name,  ///
         typeString = type,  ///

package/src/dom/parameters/named.js

@@ -106,16 +106,34 @@ export default domAssigned(class NamedParameters {
 
   static fromObjectAssignmentNode(objectAssignmentNode, context) {
     const objectAssignmentNamedParametersNode = objectAssignmentNamedParametersNodeQuery(objectAssignmentNode),
-          parametersNode = objectAssignmentNamedParametersNode,  ///
-          namedParameterNodes = namedParameterNodesQuery(parametersNode),
-          array = arrayFromNamedParameterNodes(namedParameterNodes, context),
-          string = stringFromArray(array, context),
-          namedParameters = new NamedParameters(string, array);
+          namedParametersNode = objectAssignmentNamedParametersNode,  ///
+          namedParameters = namedParametersFromNamedParametersNode(namedParametersNode, context);
 
     return namedParameters;
   }
 });
 
+function namedParametersFromNamedParametersNode(namedParametersNode, context) {
+  const { NamedParameters } = dom,
+        namedParameterNodes = namedParameterNodesQuery(namedParametersNode),
+        array = arrayFromNamedParameterNodes(namedParameterNodes, context),
+        string = stringFromArray(array, 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;
+}
+
 function stringFromArray(array, context) {
   const namedParametersSString = array.reduce((namedParametersSString, namedParameter) => {
           const namedParameterString = namedParameter.getString();
@@ -130,14 +148,3 @@ function stringFromArray(array, context) {
 
   return string;
 }
-
-function arrayFromNamedParameterNodes(namedParameterNodes, context) {
-  const { NamedParameter } = dom,
-        array = namedParameterNodes.map((namedParameterNode) => { ///
-          const namedParameter = NamedParameter.fromNamedParameterNode(namedParameterNode, context);
-
-          return namedParameter;
-        });
-
-  return array;
-}