occam-furtle 2.0.69 → 2.0.71

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/parameters.js

@@ -7,9 +7,9 @@ import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const parameterNodesQuery = nodesQuery("/parameters/parameter"),
-      someParametersNodeQuery = nodeQuery("/some/parameters"),
       arrayAssignmentParametersNodeQuery = nodeQuery("/arrayAssignment/parameters"),
       objectAssignmentParametersNodeQuery = nodeQuery("/objectAssignment/parameters"),
+      anonymousProcedureParametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
       procedureDeclarationParametersNodeQuery = nodeQuery("/procedureDeclaration/parameters");
 
 export default domAssigned(class Parameters {
@@ -107,22 +107,6 @@ export default domAssigned(class Parameters {
 
   static name = "Parameters";
 
-  static fromSomeNode(someNode, context) {
-    const { Parameter } = dom,
-          someParametersNode = someParametersNodeQuery(someNode),
-          parameterNode = someParametersNode, ///
-          parameterNodes = parameterNodesQuery(parameterNode),
-          array = parameterNodes.map((parameterNode) => {
-            const parameter = Parameter.fromParameterNode(parameterNode, context);
-
-            return parameter;
-          }),
-          string = stringFromArray(array, context),
-          parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
   static fromStringAndArray(string, array) {
     const parameters = new Parameters(string, array);
 
@@ -153,6 +137,22 @@ export default domAssigned(class Parameters {
     return parameters;
   }
 
+  static fromAnonymousProcedureNode(anonymousProcedureNode, context) {
+    const { Parameter } = dom,
+          anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),
+          parameterNode = anonymousProcedureParametersNode, ///
+          parameterNodes = parameterNodesQuery(parameterNode),
+          array = parameterNodes.map((parameterNode) => {
+            const parameter = Parameter.fromParameterNode(parameterNode, context);
+
+            return parameter;
+          }),
+          string = stringFromArray(array, context),
+          parameters = new Parameters(string, array);
+
+    return parameters;
+  }
+
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
     let parameters = null;
 

package/src/dom/procedure/anonymous.js

@@ -3,18 +3,19 @@
 import dom from "../../dom";
 import Exception from "../../exception";
 
+import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
-import { nodeQuery, nodesQuery } from "../../utilities/query";
 import { variablesFromValuesAndParameters } from "../procedure";
 
-const nonsenseNodesQuery = nodesQuery("/some/anonymousProcedure/returnBlock/nonsense"),
-      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
+const parametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
+      typeTerminalNodeQuery = nodeQuery("/anonymousProcedure/@type"),
+      somAnonymousProcedureNodeQuery = nodeQuery("/some/anonymousProcedure");
 
 export default domAssigned(class AnonymousProcedure {
-  constructor(string, parameters, nonsensical, returnBlock) {
+  constructor(string, type, parameters, returnBlock) {
     this.string = string;
+    this.type - type;
     this.parameters = parameters;
-    this.nonsensical = nonsensical;
     this.returnBlock = returnBlock;
   }
 
@@ -22,12 +23,12 @@ export default domAssigned(class AnonymousProcedure {
     return this.string;
   }
 
-  getParameters() {
-    return this.paramters;
+  getType() {
+    return this.type;
   }
 
-  isNonsensical() {
-    return this.nonsensical;
+  getParameters() {
+    return this.paramters;
   }
 
   getReturnBlock() {
@@ -35,54 +36,67 @@ export default domAssigned(class AnonymousProcedure {
   }
 
   call(values, context) {
-    debugger
-
     const anonymousProcedureString = this.string; ///
 
     context.trace(`Calling the '${anonymousProcedureString}' anonymous procedure...`);
 
-    if (this.nonsensical) {
-      const message = `The '${anonymousProcedureString}' anonymous procedure is nonsensical.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
     this.parameters.matchValues(values, context);
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context);
 
-    this.returnBlock.evaluate(variables, context);
+    const value = this.returnBlock.evaluate(variables, context),
+          valueType = value.getType();
+
+    if (this.type !== valueType) {
+      const valueString = value.asString(context),
+            message = `The ${valueString} value's '${valueType}' type and the '${anonymousProcedureString}' anonymous procedure's '${this.type}' type  do not match.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
 
     context.debug(`...called the '${anonymousProcedureString}' anonymous procedure.`);
+
+    return value;
   }
 
   static name = "AnonymousProcedure";
 
   static fromSomeNode(someNode, context) {
-    const { ReturnBlock, Parameters } = dom,
-          string = stringFromSomeNode(someNode, context),
-          parameters = Parameters.fromSomeNode(someNode, context),
-          nonsensical = nonsensicalFromSomeNode(someNode, context),
-          returnBlock = ReturnBlock.fromSomeNode(someNode, context),
-          anonymousProcedureDeclaration = new AnonymousProcedure(string, parameters, nonsensical, returnBlock);
-
-    return anonymousProcedureDeclaration;
+    const someAnonymousProcedureNode = somAnonymousProcedureNodeQuery(someNode),
+          anonymousProcedureNode = someAnonymousProcedureNode,  ///
+          anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
+
+    return anonymousProcedure;
   }
 });
 
-function stringFromSomeNode(someNode, context) {
-  const parametersNode = parametersNodeQuery(someNode),
-        parametersString = context.nodeAsString(parametersNode),
-        string = `(${parametersString}) { ... }`;
+function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {
+  const { Parameters, ReturnBlock, AnonymousProcedure } = dom,
+        string = stringFromAnonymousProcedureNode(anonymousProcedureNode, context),
+        type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),
+        parameters = Parameters.fromAnonymousProcedureNode(anonymousProcedureNode, context),
+        returnBlock = ReturnBlock.fromAnonymousProcedureNode(anonymousProcedureNode, context),
+        anonymousProcedure = new AnonymousProcedure(string, type, parameters, returnBlock);
 
-  return string;
+  return anonymousProcedure;
+}
+
+function typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context) {
+  const typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        type = typeTerminalNodeContent; ///
+
+  return type;
 }
 
-function nonsensicalFromSomeNode(someNode, context) {
-  const nonsenseNodes = nonsenseNodesQuery(someNode),
-        nonsenseNodesLength = nonsenseNodes.length,
-        nonsensical = (nonsenseNodesLength > 0);
+function stringFromAnonymousProcedureNode(anonymousProcedureNode, context) {
+  const parametersNode = parametersNodeQuery(anonymousProcedureNode),
+        typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),
+        parametersString = context.nodeAsString(parametersNode),
+        typeNode = typeTerminalNode,  ///
+        typeString = context.nodeAsString(typeNode),
+        string = `${typeString} (${parametersString}) { ... }`;
 
-  return nonsensical;
+  return string;
 }

package/src/dom/procedure.js

@@ -3,22 +3,20 @@
 import dom from "../dom";
 import Exception from "../exception";
 
+import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodeQuery = nodeQuery("/procedureDeclaration/label"),
-      nonsenseNodesQuery = nodesQuery("/procedureDeclaration/returnBlock/nonsense"),
       parametersNodeQuery = nodeQuery("/procedureDeclaration/parameters"),
       typeTerminalNodeQuery = nodeQuery("/procedureDeclaration/@type");
 
 export default domAssigned(class Procedure {
-  constructor(string, type, label, parameters, nonsensical, returnBlock) {
+  constructor(string, type, label, parameters, returnBlock) {
     this.string = string;
     this.type = type;
     this.label = label;
     this.parameters = parameters;
-    this.nonsensical = nonsensical;
     this.returnBlock = returnBlock;
   }
 
@@ -38,10 +36,6 @@ export default domAssigned(class Procedure {
     return this.parameters;
   }
 
-  isNonsensical() {
-    return this.nonsensical;
-  }
-
   getReturnBlock() {
     return this.returnBlock;
   }
@@ -64,13 +58,6 @@ export default domAssigned(class Procedure {
 
     context.trace(`Calling the '${procedureString}' procedure...`);
 
-    if (this.nonsensical) {
-      const message = `The '${procedureString}' procedure is nonsensical.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
     this.parameters.matchValues(values, context);
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context),
@@ -100,9 +87,8 @@ export default domAssigned(class Procedure {
           type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
           label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context),
           parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          nonsensical = nonsensicalFromProcedureDeclarationNode(procedureDeclarationNode, context),
           returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          procedureDeclaration = new Procedure(string, type, label, parameters, nonsensical, returnBlock);
+          procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);
 
     return procedureDeclaration;
   }
@@ -145,11 +131,3 @@ function stringFromProcedureDeclarationNode(procedureDeclarationNode, context) {
 
   return string;
 }
-
-function nonsensicalFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const nonsenseNodes = nonsenseNodesQuery(procedureDeclarationNode),
-        nonsenseNodesLength = nonsenseNodes.length,
-        nonsensical = (nonsenseNodesLength > 0);
-
-  return nonsensical;
-}

package/src/dom/returnStatement.js

@@ -5,7 +5,7 @@ import dom from "../dom";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const returnStatementNodeQuery = nodeQuery("/procedureDeclaration/returnBlock/returnStatement");
+const returnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 
 export default domAssigned(class ReturnStatement {
   constructor(string, value) {
@@ -37,19 +37,13 @@ export default domAssigned(class ReturnStatement {
 
   static name = "ReturnStatement";
 
-  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    let returnStatement = null;
-
-    const returnStatementNode = returnStatementNodeQuery(procedureDeclarationNode);
-
-    if (returnStatementNode !== null) {
-      const { Value } = dom,
-            node = returnStatementNode, ///
-            string = context.nodeAsString(node),
-            value = Value.fromReturnStatementNode(returnStatementNode, context);
-
-      returnStatement = new ReturnStatement(string, value);
-    }
+  static fromReturnBlockNode(returnBlockNode, context) {
+    const { Value } = dom,
+          returnStatementNode = returnStatementNodeQuery(returnBlockNode),
+          node = returnStatementNode, ///
+          string = context.nodeAsString(node),
+          value = Value.fromReturnStatementNode(returnStatementNode, context),
+          returnStatement = new ReturnStatement(string, value);
 
     return returnStatement;
   }

package/src/dom/some.js

@@ -31,11 +31,9 @@ export default domAssigned(class Some {
   }
 
   evaluate(context) {
-    debugger
-
     const someString = this.getString();
 
-    context.trace(`Evaluating the '${someString}' some loop...`);
+    context.trace(`Evaluating the '${someString}' some...`);
 
     const value = this.variable.evaluate(context),
           valueType = value.getType();
@@ -58,7 +56,7 @@ export default domAssigned(class Some {
       this.anonymousProcedure.call(values, context);
     });
 
-    context.trace(`...evaluated the '${someString}' some loop.`);
+    context.trace(`...evaluated the '${someString}' some.`);
   }
 
   static name = "Some";

package/src/dom/step.js

@@ -5,12 +5,11 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Step {
-  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration) {
+  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration) {
     this.string = string;
     this.arrayAssignment = arrayAssignment;
     this.objectAssigment = objectAssigment;
     this.conditionalBlocks = conditionalBlocks;
-    this.variableAssignment = variableAssignment;
     this.variablesDeclaration = variablesDeclaration;
   }
 
@@ -30,10 +29,6 @@ export default domAssigned(class Step {
     return this.conditionalBlocks;
   }
 
-  getVariableAssignment() {
-    return this.variableAssignment;
-  }
-
   getVariablesDeclaration() {
     return this.variablesDeclaration;
   }
@@ -48,8 +43,6 @@ export default domAssigned(class Step {
       this.objectAssigment.evaluate(context);
     } else if (this.conditionalBlocks !== null) {
       this.conditionalBlocks.evaluate(context);
-    } else if (this.variableAssignment !== null) {
-      this.variableAssignment.evaluate(context);
     } else if (this.variablesDeclaration !== null) {
       this.variablesDeclaration.evaluate(context);
     }
@@ -58,15 +51,14 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignment, VariablesDeclaration } = dom,
+    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariablesDeclaration } = dom,
           node = stepNode,  ///
           string = context.nodeAsString(node),
           arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
           objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
           conditionalBlocks = ConditionalBlocks.fromStepNode(stepNode, context),
-          variableAssignment = VariableAssignment.fromStepNode(stepNode, context),
           variablesDeclaration = VariablesDeclaration.fromStepNode(stepNode, context),
-          step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration);
+          step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration);
 
     return step;
   }

package/src/dom/value.js

@@ -19,7 +19,7 @@ const ternaryValueNodeQuery = nodeQuery("/ternary/value"),
       primitiveTerminalNodeQuery = nodeQuery("/value/@primitive"),
       returnStatementValueNodeQuery = nodeQuery("/returnStatement/value"),
       stringLiteralTerminalNodeQuery = nodeQuery("/value/@string-literal"),
-      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/vvalue");
+      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value");
 
 export default domAssigned(class Value {
   constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall) {

package/src/dom/variable.js

@@ -12,8 +12,7 @@ const someVariableNodeQuery = nodeQuery("/some/variable"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       arrayAssignmentVariableNodeQuery = nodeQuery("/arrayAssignment/variable"),
-      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable"),
-      variableAssignmentVariableNodeQuery = nodeQuery("/variableAssignment/variable");
+      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable");
 
 export default domAssigned(class Variable {
   constructor(string, type, name, value, assignment) {
@@ -218,21 +217,6 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromVariableAssignmentNode(variableAssignmentNode, context) {
-    const { Assignment } = dom,
-          variableAssignmentVariableNode = variableAssignmentVariableNodeQuery(variableAssignmentNode),
-          variableNode = variableAssignmentVariableNode, ///
-          node = variableNode,  ///
-          string = context.nodeAsString(node),
-          type = null,
-          name = nameFromVariableNode(variableNode),
-          value = null,
-          assignment = Assignment.fromVariableAssignmentNode(variableAssignmentNode, context),
-          variable = new Variable(string, type, name, value, assignment);
-
-    return variable;
-  }
-
   static fromTypeVariableNodeAndAssignmentNode(type, variableNode, assignmentNode, context) {
     const { Assignment } = dom,
           node = variableNode,  ///

package/src/index.js

@@ -27,7 +27,6 @@ import ReturnStatement from "./dom/returnStatement";
 import ObjectAssignment from "./dom/assignment/object";
 import ConditionalBlocks from "./dom/conditionalBlocks";
 import AnonymousProcedure from "./dom/procedure/anonymous";
-import VariableAssignment from "./dom/assignment/variable";
 import ProcedureDeclaration from "./dom/declaration/procedure";
 import VariablesDeclaration from "./dom/declaration/variables";