occam-furtle 2.0.74 → 2.0.76

package/src/dom/assignment/array.js

@@ -85,9 +85,10 @@ export default domAssigned(class ArrayAssigment {
       throw exception;
     }
 
-    const { Variable, Assignment } = dom,
-          assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+    debugger
+
+    const { Variable } = dom,
+          variable = Variable.fromValueAndParameter(value, parameter, context);
 
     context.addVariable(variable);
 
@@ -116,3 +117,17 @@ export default domAssigned(class ArrayAssigment {
     return arrayAssignment;
   }
 });
+
+/*
+  static fromParameterAndAssignment(parameter, assignment, context) {
+    const type = parameter.getType(),
+          name = parameter.getName(),
+          value = null,
+          string = name,  ///
+          variable = new Variable(string, type, name, value, assignment);
+
+    return variable;
+  }
+
+
+ */

package/src/dom/assignment/object.js

@@ -108,15 +108,16 @@ export default domAssigned(class ObjectAssigment {
       throw exception;
     }
 
-    const { Value, Variable, Assignment } = dom,
+    const { Value, Variable } = dom,
           terminalNode = node,  ///
           content = terminalNode.getContent(),
           string = content;  ///
 
     value = Value.fromString(string, context);  ///
 
-    const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
+    debugger
+
+    const variable = Variable.fromValueAndNamedParameter(value, namedParameter, context);
 
     context.addVariable(variable);
 
@@ -138,13 +139,14 @@ export default domAssigned(class ObjectAssigment {
           nodeTerminalNode = node.isTerminalNode(),
           terminal = nodeTerminalNode;  ///
 
-    const { Value, Variable, Assignment } = dom,
+    const { Value, Variable } = dom,
           boolean = terminal; ///
 
     value = Value.fromBoolean(boolean, context);  ///
 
-    const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
+    debugger
+
+    const variable = Variable.fromValueAndNamedParameter(value, namedParameter, context);
 
     context.addVariable(variable);
 
@@ -173,15 +175,16 @@ export default domAssigned(class ObjectAssigment {
       throw exception;
     }
 
-    const { Value, Variable, Assignment } = dom,
+    const { Value, Variable } = dom,
           nonTerminalNode = node,  ///
           childNodes = nonTerminalNode.getChildNodes(),
           nodes = childNodes;  ///
 
     value = Value.fromNodes(nodes, context);  ///
 
-    const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
+    debugger
+
+    const variable = Variable.fromValueAndNamedParameter(value, namedParameter, context);
 
     context.addVariable(variable);
 

package/src/dom/assignment/variable.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import dom from "../../dom";
+import Exception from "../../exception";
+
+import { domAssigned } from "../../dom";
+
+export default domAssigned(class VariableAssignment {
+  constructor(string, variable, value) {
+    this.string = string;
+    this.variable = variable;
+    this.value = value;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  getValue() {
+    return this.value;
+  }
+
+  evaluate(context) {
+    let value;
+
+    const variableAssignmentString = this.string; ///
+
+    context.trace(`Evaluating the '${variableAssignmentString}' variable assignment...`);
+
+    value = this.value.evaluate(context);
+
+    debugger
+
+    if (value === null) {
+      const variableAssignmentString = this.string, ///
+            message = `The '${variableAssignmentString}' variable assignment cannot be evaluated.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...evaluated the '${variableAssignmentString}' variable assignment.`);
+
+    return value;
+  }
+
+  static name = "VariableAssignment";
+
+  static fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
+    const variableAssignment = variableAssignmentFromTypeAndAssignmentNode(type, variableAssignmentNode, context);
+
+    return variableAssignment;
+  }
+});
+
+function variableAssignmentFromTypeAndAssignmentNode(type, variableAssignmentNode, context) {
+  const { Variable, Value, VariableAssignment } = dom,
+        node = variableAssignmentNode, ///
+        string = context.nodeAsString(node),
+        value = Value.fromVariableAssignmentNode(variableAssignmentNode, context),
+        variable = Variable.fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context),
+        assignment = new VariableAssignment(string, variable, value);
+
+  return assignment;
+}

package/src/dom/assignments/variable.js

@@ -0,0 +1,80 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { domAssigned } from "../../dom";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
+
+const typeTerminalNodeQuery = nodeQuery("/variableAssignments/@type"),
+      variableAssignmentsNodeQuery = nodeQuery("/step/variableAssignments"),
+      variableAssignmentNodesQuery = nodesQuery("/variableAssignments/variableAssignment");
+
+export default domAssigned(class VariableAssignments {
+  constructor(string, array) {
+    this.string = string;
+    this.array = array;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  evaluate(context) {
+    const variableAssignmentsString = this.string; ///
+
+    context.trace(`Evaluating the '${variableAssignmentsString}' variable assignments...`);
+
+    this.array.forEach((variableAssignment) => {
+      variableAssignment.evaluate(context);
+
+      // context.addVariable(variable);
+      //
+      // variable.assign(context);
+    });
+
+    context.debug(`...evaluated the '${variableAssignmentsString}' variable assignments.`);
+  }
+
+  static name = "VariableAssignments";
+
+  static fromStepNode(stepNode, context) {
+    let variableAssignments = null;
+
+    const variableAssignmentsNode = variableAssignmentsNodeQuery(stepNode);
+
+    if (variableAssignmentsNode !== null) {
+      const node = variableAssignmentsNode,  ////
+            string = context.nodeAsString(node),
+            type = typeFromVariableAssignmentsNode(variableAssignmentsNode, context),
+            array = arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context);
+
+      variableAssignments = new VariableAssignments(string, array);
+    }
+
+    return variableAssignments;
+  }
+});
+
+function typeFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+  const typeTerminalNode = typeTerminalNodeQuery(variableAssignmentsNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        type = typeTerminalNodeContent; ///
+
+  return type;
+}
+
+function arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context) {
+  const variableAssignmentNodes = variableAssignmentNodesQuery(variableAssignmentsNode),
+        array = variableAssignmentNodes.map((variableAssignmentNode) => {
+          const { VariableAssignment } = dom,
+                variableAssignment = VariableAssignment.fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context);
+
+          return variableAssignment;
+        });
+
+  return array;
+}

package/src/dom/{returnStatement.js → statement/return.js}

@@ -1,9 +1,9 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 
-import { nodeQuery } from "../utilities/query";
-import { domAssigned } from "../dom";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
 
 const returnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 

package/src/dom/value.js

@@ -15,11 +15,11 @@ const { match } = arrayUtilities;
 const ternaryValueNodeQuery = nodeQuery("/ternary/value"),
       numberTerminalNodeQuery = nodeQuery("/value/@number"),
       conditionValueNodeQuery = nodeQuery("/condition/value"),
-      assignmentValueNodeQuery = nodeQuery("/assignment/value"),
       primitiveTerminalNodeQuery = nodeQuery("/value/@primitive"),
       returnStatementValueNodeQuery = nodeQuery("/returnStatement/value"),
       stringLiteralTerminalNodeQuery = nodeQuery("/value/@string-literal"),
-      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value");
+      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value"),
+      variableAssignmentValueNodeQuery = nodeQuery("/variableAssignment/value");
 
 export default domAssigned(class Value {
   constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall) {
@@ -393,20 +393,6 @@ export default domAssigned(class Value {
     return value;
   }
 
-  static fromAssignmentNode(assigmentNode, context) {
-    let value = null;
-
-    const assignmentValueNode = assignmentValueNodeQuery(assigmentNode);
-
-    if (assignmentValueNode !== null) {
-      const valueNode = assignmentValueNode;  ///
-
-      value = valueFromValueNode(valueNode, context);
-    }
-
-    return value;
-  }
-
   static fromReturnStatementNode(returnStatementNode, context) {
     let value = null;
 
@@ -428,6 +414,20 @@ export default domAssigned(class Value {
 
     return value;
   }
+
+  static fromVariableAssignmentNode(variableAssigmentNode, context) {
+    let value = null;
+
+    const variableAssignmentValueNode = variableAssignmentValueNodeQuery(variableAssigmentNode);
+
+    if (variableAssignmentValueNode !== null) {
+      const valueNode = variableAssignmentValueNode;  ///
+
+      value = valueFromValueNode(valueNode, context);
+    }
+
+    return value;
+  }
 });
 
 function matchNode(nodeA, nodeB) {

package/src/dom/variable.js

@@ -12,15 +12,15 @@ const someVariableNodeQuery = nodeQuery("/some/variable"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       arrayAssignmentVariableNodeQuery = nodeQuery("/arrayAssignment/variable"),
-      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable");
+      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable"),
+      variableAssignmentVariableNodeQuery = nodeQuery("/variableAssignment/variable");
 
 export default domAssigned(class Variable {
-  constructor(string, type, name, value, assignment) {
+  constructor(string, type, name, value) {
     this.string = string;
     this.type = type;
     this.name = name;
     this.value = value;
-    this.assignment = assignment;
   }
 
   getString() {
@@ -39,41 +39,37 @@ export default domAssigned(class Variable {
     return this.value;
   }
 
-  getAssignment() {
-    return this.assignment;
-  }
+  matchVariableName(variableName) {
+    const nameMatches = (this.name === variableName);
 
-  setString(string) {
-    this.string = string;
+    return nameMatches;
   }
 
-  setType(type) {
-    this.type = type;
-  }
+  evaluate(context) {
+    const variableString = this.string; ///
 
-  setName(name) {
-    this.name = name;
-  }
+    context.trace(`Evaluating the '${variableString}' variable...`);
 
-  setValue(value) {
-    this.value = value;
-  }
+    const variableName = this.name, ///
+          variablePresent = context.isVariablePresentByVariableName(variableName);
 
-  setAssignment(assignment) {
-    this.assignment = assignment;
-  }
+    if (!variablePresent) {
+      const message = `The '${variableString}; variable is not present.'`,
+            exception = Exception.fromMessage(message);
 
-  matchVariableName(variableName) {
-    const nameMatches = (this.name === variableName);
+      throw exception;
+    }
 
-    return nameMatches;
+    const variable = context.findVariableByVariableName(variableName),
+          value = variable.getValue(),
+          valueString = value.asString(context);
+
+    context.debug(`...evaluated the '${variableString}' variable to the ${valueString} value.`);
+
+    return value;
   }
 
   assign(context) {
-    if (this.assignment === null) {
-      return;
-    }
-
     const variableName = this.name, ///
           variableString = this.string, ///
           variablePresent = context.isVariablePresentByVariableName(variableName);
@@ -87,10 +83,9 @@ export default domAssigned(class Variable {
       throw exception;
     }
 
-    const value = this.assignment.evaluate(context),
-          variable = context.findVariableByVariableName(variableName),
+    const value = this.value.evaluate(context),
           valueType = value.getType(),
-          variableType = variable.getType();
+          variableType = this.type;
 
     if (valueType !== variableType) {
       const message = `The '${variableString} variable's '${variableType}' type does not match the assigned value's '${valueType}' type.'`,
@@ -99,37 +94,13 @@ export default domAssigned(class Variable {
       throw exception;
     }
 
-    variable.setValue(value);
+    this.value = value;
 
     const valueString = value.asString(context);
 
     context.debug(`...assigned the ${valueString} value to the '${variableString}' variable.`);
   }
 
-  evaluate(context) {
-    const variableString = this.string; ///
-
-    context.trace(`Evaluating the '${variableString}' variable...`);
-
-    const variableName = this.name, ///
-          variablePresent = context.isVariablePresentByVariableName(variableName);
-
-    if (!variablePresent) {
-      const message = `The '${variableString}; variable is not present.'`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
-    const variable = context.findVariableByVariableName(variableName),
-          value = variable.getValue(),
-          valueString = value.asString(context);
-
-    context.debug(`...evaluated the '${variableString}' variable to the ${valueString} value.`);
-
-    return value;
-  }
-
   static name = "Variable";
 
   static fromSomeNode(someLoopNode, context) {
@@ -174,8 +145,7 @@ export default domAssigned(class Variable {
     const type = parameter.getType(),
           name = parameter.getName(),
           string = name,  ///
-          assignment = null,
-          variable = new Variable(string, type, name, value, assignment);
+          variable = new Variable(string, type, name, value);
 
     return variable;
   }
@@ -185,8 +155,7 @@ export default domAssigned(class Variable {
           string = context.nodeAsString(node),
           name = nameFromVariableNode(variableNode),
           value = null,
-          assignment = null,
-          variable = new Variable(string, type, name, value, assignment);
+          variable = new Variable(string, type, name, value);
 
     return variable;
   }
@@ -207,37 +176,22 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromParameterAndAssignment(parameter, assignment, context) {
-    const type = parameter.getType(),
-          name = parameter.getName(),
-          value = null,
-          string = name,  ///
-          variable = new Variable(string, type, name, value, assignment);
-
-    return variable;
-  }
-
-  static fromNamedParameterAndAssignment(namedParameter, assignment, context) {
+  static fromValueAndNamedParameter(value, namedParameter, context) {
     const asName = namedParameter.getAsName(),
           name = (asName !== null) ?
                    asName : ///
-                    namedParameter.getName(),
+                     namedParameter.getName(),
           type = namedParameter.getType(),
-          value = null,
           string = name,  ///
-          variable = new Variable(string, type, name, value, assignment);
+          variable = new Variable(string, type, name, value);
 
     return variable;
   }
 
-  static fromTypeVariableNodeAndAssignmentNode(type, variableNode, assignmentNode, context) {
-    const { Assignment } = dom,
-          node = variableNode,  ///
-          string = context.nodeAsString(node),
-          name = nameFromVariableNode(variableNode),
-          value = null,
-          assignment = Assignment.fromAssignmentNode(assignmentNode, context),
-          variable = new Variable(string, type, name, value, assignment);
+  static fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
+    const variableAssignmentVariableNode = variableAssignmentVariableNodeQuery(variableAssignmentNode),
+          variableNode = variableAssignmentVariableNode,  ///
+          variable = variableFromVariableNode(variableNode, context);
 
     return variable;
   }
@@ -250,8 +204,7 @@ function variableFromVariableNode(variableNode, context) {
         type = null,
         name = nameFromVariableNode(variableNode),
         value = null,
-        assignment = null,
-        variable = new Variable(string, type, name, value, assignment);
+        variable = new Variable(string, type, name, value);
 
   return variable;
 }
@@ -263,3 +216,20 @@ function nameFromVariableNode(variableNode) {
 
   return name;
 }
+
+/*
+
+  static fromNamedParameterAndAssignment(namedParameter, assignment, context) {
+    const asName = namedParameter.getAsName(),
+          name = (asName !== null) ?
+                   asName : ///
+                    namedParameter.getName(),
+          type = namedParameter.getType(),
+          value = null,
+          string = name,  ///
+          variable = new Variable(string, type, name, value, assignment);
+
+    return variable;
+  }
+
+ */

package/src/index.js

@@ -16,7 +16,6 @@ import Parameter from "./dom/parameter";
 import Parameters from "./dom/parameters";
 import NodesQuery from "./dom/query/nodes";
 import Comparison from "./dom/comparison";
-import Assignment from "./dom/assignment";
 import ReturnBlock from "./dom/block/return";
 import NegatedValue from "./dom/value/negated";
 import BitwiseValue from "./dom/value/bitwise";
@@ -24,13 +23,14 @@ import ProcedureCall from "./dom/procedureCall";
 import NamedParameter from "./dom/parameter/named";
 import BracketedValue from "./dom/value/bracketed";
 import ArrayAssigment from "./dom/assignment/array";
-import ReturnStatement from "./dom/returnStatement";
+import ReturnStatement from "./dom/statement/return";
 import NamedParameters from "./dom/parameters/named";
 import ObjectAssignment from "./dom/assignment/object";
 import ConditionalBlocks from "./dom/conditionalBlocks";
 import AnonymousProcedure from "./dom/procedure/anonymous";
+import VariableAssignment from "./dom/assignment/variable";
+import VariableAssignments from "./dom/assignments/variable";
 import ProcedureDeclaration from "./dom/declaration/procedure";
-import VariablesDeclaration from "./dom/declaration/variables";
 import AnonymousProcedureCall from "./dom/procedureCall/anonymous";
 
 export { default as Values } from "./dom/values";