occam-furtle 2.0.76 → 2.0.78

package/src/dom/procedure/anonymous.js

@@ -15,7 +15,7 @@ const parametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
 export default domAssigned(class AnonymousProcedure {
   constructor(string, type, parameters, returnBlock) {
     this.string = string;
-    this.type - type;
+    this.type = type;
     this.parameters = parameters;
     this.returnBlock = returnBlock;
   }

package/src/dom/some.js

@@ -31,12 +31,15 @@ export default domAssigned(class Some {
   }
 
   evaluate(context) {
+    let value;
+
     const someString = this.getString();
 
     context.trace(`Evaluating the '${someString}' some...`);
 
-    const value = this.variable.evaluate(context),
-          valueType = value.getType();
+    value = this.variable.evaluate(context);
+
+    const valueType = value.getType();
 
     if (valueType !== NODES_TYPE) {
       const valueString = value.asString(context),
@@ -46,35 +49,40 @@ export default domAssigned(class Some {
       throw exception;
     }
 
-    const nodes = value.getNodes();
+    const nodes = value.getNodes(),
+          boolean = nodes.some((node) => {
+            let value;
 
-    nodes.some((node) => {
-      let value;
+            const { Value, Values } = dom;
 
-      const { Value, Values } = dom;
+            value = Value.fromNode(node, context);
 
-      value = Value.fromNode(node, context);
+            const values = Values.fromValue(value, context);
 
-      const values = Values.fromValue(value, context);
+            value = this.anonymousProcedure.call(values, context);
 
-      value = this.anonymousProcedure.call(values, context);
+            const valueType = value.getType();
 
-      const valueType = value.getType();
+            if (valueType !== BOOLEAN_TYPE) {
+              const valueString = value.asString(context),
+                    message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+                    exception = Exception.fromMessage(message);
 
-      if (valueType !== BOOLEAN_TYPE) {
-        const valueString = value.asString(context),
-              message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
-              exception = Exception.fromMessage(message);
+              throw exception;
+            }
 
-        throw exception;
-      }
+            const boolean = value.getBoolean();
 
-      const boolean = value.getBoolean();
+            return boolean;
+          });
 
-      return boolean;
-    });
+    const { Value } = dom;
+
+    value = Value.fromBoolean(boolean, context);
 
     context.trace(`...evaluated the '${someString}' some.`);
+
+    return value;
   }
 
   static name = "Some";

package/src/dom/step.js

@@ -50,13 +50,13 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariablesDeclaration } = dom,
+    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignments } = dom,
           node = stepNode,  ///
           string = context.nodeAsString(node),
           arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
           objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
           conditionalBlocks = ConditionalBlocks.fromStepNode(stepNode, context),
-          variablesDeclaration = VariablesDeclaration.fromStepNode(stepNode, context),
+          variablesDeclaration = VariableAssignments.fromStepNode(stepNode, context),
           step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration);
 
     return step;

package/src/dom/value/negated.js

@@ -38,7 +38,7 @@ export default domAssigned(class NegatedValue {
 
     value = this.value.evaluate(context);
 
-    const valueType = value.getType;
+    const valueType = value.getType();
 
     if (valueType !== BOOLEAN_TYPE) {
       const valueString = value.asString(context),

package/src/dom/value.js

@@ -416,15 +416,9 @@ export default domAssigned(class Value {
   }
 
   static fromVariableAssignmentNode(variableAssigmentNode, context) {
-    let value = null;
-
-    const variableAssignmentValueNode = variableAssignmentValueNodeQuery(variableAssigmentNode);
-
-    if (variableAssignmentValueNode !== null) {
-      const valueNode = variableAssignmentValueNode;  ///
-
-      value = valueFromValueNode(valueNode, context);
-    }
+    const variableAssignmentValueNode = variableAssignmentValueNodeQuery(variableAssigmentNode),
+          valueNode = variableAssignmentValueNode,  ///
+          value = valueFromValueNode(valueNode, context);
 
     return value;
   }

package/src/dom/variable.js

@@ -69,26 +69,26 @@ export default domAssigned(class Variable {
     return value;
   }
 
-  assign(context) {
-    const variableName = this.name, ///
+  assign(value, context) {
+    const valueString = value.asString(context), ///
+          variableName = this.name, ///
           variableString = this.string, ///
           variablePresent = context.isVariablePresentByVariableName(variableName);
 
-    context.trace(`Assigning a value to the '${variableString}' variable...`);
+    context.trace(`Assigning the ${valueString} value to the '${variableString}' variable...`);
 
-    if (!variablePresent) {
-      const message = `The '${variableString}' variable is not present.`,
+    if (variablePresent) {
+      const message = `The '${variableString}' variable is already present.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const value = this.value.evaluate(context),
-          valueType = value.getType(),
+    const valueType = value.getType(),
           variableType = this.type;
 
     if (valueType !== variableType) {
-      const message = `The '${variableString} variable's '${variableType}' type does not match the assigned value's '${valueType}' type.'`,
+      const message = `The '${variableString} variable's '${variableType}' type does not match the value's '${valueType}' type.'`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -96,7 +96,9 @@ export default domAssigned(class Variable {
 
     this.value = value;
 
-    const valueString = value.asString(context);
+    const variable = this;  ///
+
+    context.addVariable(variable);
 
     context.debug(`...assigned the ${valueString} value to the '${variableString}' variable.`);
   }
@@ -125,6 +127,16 @@ export default domAssigned(class Variable {
     return variable;
   }
 
+  static fromParameter(parameter, context) {
+    const type = parameter.getType(),
+          name = parameter.getName(),
+          value = null,
+          string = name,  ///
+          variable = new Variable(string, type, name, value);
+
+    return variable;
+  }
+
   static fromNodeQueryNode(nodeQueryNode, context) {
     const nodeQueryVariableNode = nodeQueryVariableNodeQuery(nodeQueryNode),
           variableNode = nodeQueryVariableNode, ///
@@ -141,6 +153,19 @@ export default domAssigned(class Variable {
     return variable;
   }
 
+  static fromNamedParameter(namedParameter, context) {
+    const asName = namedParameter.getAsName(),
+          type = namedParameter.getType(),
+          name = (asName !== null) ?
+                   asName : ///
+                     namedParameter.getName(),
+          value = null,
+          string = name,  ///
+          variable = new Variable(string, type, name, value);
+
+    return variable;
+  }
+
   static fromValueAndParameter(value, parameter, context) {
     const type = parameter.getType(),
           name = parameter.getName(),
@@ -176,27 +201,26 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromValueAndNamedParameter(value, namedParameter, context) {
-    const asName = namedParameter.getAsName(),
-          name = (asName !== null) ?
-                   asName : ///
-                     namedParameter.getName(),
-          type = namedParameter.getType(),
-          string = name,  ///
-          variable = new Variable(string, type, name, value);
-
-    return variable;
-  }
-
   static fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
     const variableAssignmentVariableNode = variableAssignmentVariableNodeQuery(variableAssignmentNode),
           variableNode = variableAssignmentVariableNode,  ///
-          variable = variableFromVariableNode(variableNode, context);
+          variable = variableFromTypeAndVariableNode(type, variableNode, context);
 
     return variable;
   }
 });
 
+function variableFromTypeAndVariableNode(type, variableNode, context) {
+  const { Variable } = dom,
+        node = variableNode,  ///
+        string = context.nodeAsString(node),
+        name = nameFromVariableNode(variableNode),
+        value = null,
+        variable = new Variable(string, type, name, value);
+
+  return variable;
+}
+
 function variableFromVariableNode(variableNode, context) {
   const { Variable } = dom,
         node = variableNode,  ///
@@ -216,20 +240,3 @@ 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;
-  }
-
- */