occam-furtle 2.0.71 → 2.0.73

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;
+}

package/src/dom/parameters.js

@@ -8,7 +8,6 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const parameterNodesQuery = nodesQuery("/parameters/parameter"),
       arrayAssignmentParametersNodeQuery = nodeQuery("/arrayAssignment/parameters"),
-      objectAssignmentParametersNodeQuery = nodeQuery("/objectAssignment/parameters"),
       anonymousProcedureParametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
       procedureDeclarationParametersNodeQuery = nodeQuery("/procedureDeclaration/parameters");
 
@@ -38,8 +37,6 @@ export default domAssigned(class Parameters {
     return parameter;
   }
 
-  someParameter(callback) { return this.array.some(callback); }
-
   forEachParameter(callback) { this.array.forEach(callback); }
 
   matchValues(values, context) {
@@ -69,42 +66,6 @@ export default domAssigned(class Parameters {
     context.debug(`...matched the ${valuesString} values against the '${parametersString}' parameters.`);
   }
 
-  matchParameter(parameter, context) {
-    const parameterString = parameter.getString(),
-          parametersString = this.string; ///
-
-    context.trace(`Matching the '${parameterString}' parameter against the '${parametersString}' parameters...`);
-
-    const parameterA = parameter, ///
-          parameterMatches = this.someParameter((parameter) => {
-            if (parameter !== null) {
-              const parameterB = parameter, ///
-                    parameterBMatchesParameterA = parameterA.matchParameter(parameterB, context);
-
-              if (parameterBMatchesParameterA) {
-                return true;
-              }
-            }
-          });
-
-    if (!parameterMatches) {
-      const message = `The '${parameterString}' parameter does not match any of the '${parametersString}' parameters.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
-    context.debug(`...matched the '${parameterString}' parameter against the '${parametersString}' parameters.`);
-  }
-
-  matchParameters(parameters, context) {
-    parameters.forEachParameter((parameter) => {
-      if (parameter !== null) {
-        this.matchParameter(parameter, context);
-      }
-    });
-  }
-
   static name = "Parameters";
 
   static fromStringAndArray(string, array) {
@@ -125,18 +86,6 @@ export default domAssigned(class Parameters {
     return parameters;
   }
 
-  static fromObjectAssignmentNode(objectAssignmentNode, context) {
-    const objectAssignmentParametersNode = objectAssignmentParametersNodeQuery(objectAssignmentNode),
-          parametersNode = objectAssignmentParametersNode,  ///
-          node = parametersNode,  ///
-          string = context.nodeAsString(node),
-          parameterNodes = parameterNodesQuery(parametersNode),
-          array = arrayFromParameterNodes(parameterNodes, context),
-          parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
   static fromAnonymousProcedureNode(anonymousProcedureNode, context) {
     const { Parameter } = dom,
           anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),

package/src/dom/some.js

@@ -4,8 +4,8 @@ import dom from "../dom";
 import Exception from "../exception";
 
 import { nodeQuery } from "../utilities/query";
-import { NODES_TYPE } from "../types";
 import { domAssigned } from "../dom";
+import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
 const variableNodeQuery = nodeQuery("/some/variable"),
       valueSomeNodeQuery = nodeQuery("/value/some"),
@@ -49,11 +49,29 @@ export default domAssigned(class Some {
     const nodes = value.getNodes();
 
     nodes.some((node) => {
-      const { Value, Values } = dom,
-            value = Value.fromNode(node, context),
-            values = Values.fromValue(value, context);
+      let value;
 
-      this.anonymousProcedure.call(values, context);
+      const { Value, Values } = dom;
+
+      value = Value.fromNode(node, context);
+
+      const values = Values.fromValue(value, context);
+
+      value = this.anonymousProcedure.call(values, context);
+
+      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);
+
+        throw exception;
+      }
+
+      const boolean = value.getBoolean();
+
+      return boolean;
     });
 
     context.trace(`...evaluated the '${someString}' some.`);

package/src/dom/step.js

@@ -34,7 +34,6 @@ export default domAssigned(class Step {
   }
 
   evaluate(context) {
-
     if (false) {
       ///
     } else if (this.arrayAssignment !== null) {

package/src/dom/variable.js

@@ -217,6 +217,19 @@ export default domAssigned(class Variable {
     return variable;
   }
 
+  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;
+  }
+
   static fromTypeVariableNodeAndAssignmentNode(type, variableNode, assignmentNode, context) {
     const { Assignment } = dom,
           node = variableNode,  ///

package/src/index.js

@@ -21,9 +21,11 @@ import ReturnBlock from "./dom/block/return";
 import NegatedValue from "./dom/value/negated";
 import BitwiseValue from "./dom/value/bitwise";
 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 NamedParameters from "./dom/parameters/named";
 import ObjectAssignment from "./dom/assignment/object";
 import ConditionalBlocks from "./dom/conditionalBlocks";
 import AnonymousProcedure from "./dom/procedure/anonymous";

package/src/nodeProperties.js

@@ -0,0 +1,84 @@
+"use strict";
+
+import Exception from "./exception";
+import NodeProperty from "./nodeProperty";
+
+import { stringFromArray } from "./dom/parameters";
+import { NODES_TYPE, STRING_TYPE, BOOLEAN_TYPE } from "./types";
+import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME } from "./parameterNames";
+
+const types = [
+        STRING_TYPE,
+        BOOLEAN_TYPE,
+        NODES_TYPE,
+      ],
+      names = [
+        CONTENT_PARAMETER_NAME,
+        TERMINAL_PARAMETER_NAME,
+        CHILD_NODES_PARAMETER_NAME
+      ];
+
+class NodeProperties {
+  constructor(string, array) {
+    this.string = string;
+    this.array = array;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  someNodeProperty(callback) { return this.array.some(callback); }
+
+  matchNamedParameter(namedParameter, context) {
+    const nodePropertiesString = this.string, ///
+          namedParameterString = namedParameter.getString();
+
+    context.trace(`Matching the '${namedParameterString}' named parameter against the '${nodePropertiesString}' node properties...`);
+
+    const namedParameterMatches = this.someNodeProperty((nodeProperty) => {
+      const namedParameterMatchesNodeProperty = nodeProperty.matchNamedParameter(namedParameter, context);
+
+      if (namedParameterMatchesNodeProperty) {
+        return true;
+      }
+    });
+
+    if (!namedParameterMatches) {
+      const message = `The '${namedParameterString}' named parameter does not match any of the '${nodePropertiesString}' node properties.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...matched the '${namedParameterString}' named parameter against the '${nodePropertiesString}' node properties.`);
+  }
+
+  matchNamedParameters(namedParameters, context) {
+    namedParameters.forEachNamedParameter((namedParameter) => {
+      this.matchNamedParameter(namedParameter, context);
+    });
+  }
+
+  static fromNothing() {
+    const context = null,
+          array = names.map((name, index) => {
+            const type = types[index],
+                  nodeProperty = NodeProperty.fromNameAndType(name, type, context);
+
+            return nodeProperty;
+          }),
+          string = stringFromArray(array, context),
+          nodeProperties = new NodeProperties(string, array);
+
+    return nodeProperties;
+  }
+}
+
+const nodeProperties = NodeProperties.fromNothing();
+
+export default nodeProperties;

package/src/nodeProperty.js

@@ -0,0 +1,56 @@
+"use strict";
+
+export default class NodeProperty {
+  constructor(string, type, name) {
+    this.string = string;
+    this.type = type;
+    this.name = name;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  matchNamedParameter(namedParameter, context) {
+    let namedParameterMatches;
+
+    const nodePropertyString = this.string, ///
+          namedParameterString = namedParameter.getString();
+
+    context.trace(`Matching the '${nodePropertyString}' node property against the '${namedParameterString}' named parameter...`);
+
+    const name = namedParameter.getName(),
+          type = namedParameter.getType();
+
+    namedParameterMatches = ((this.name === name) && (this.type === type));
+
+    if (namedParameterMatches) {
+      context.debug(`...matched the '${nodePropertyString}' node property against the '${namedParameterString}' named parameter.`);
+    }
+
+    return namedParameterMatches;
+  }
+
+  static name = "Parameter";
+
+  static fromNameAndType(name, type, context) {
+    const string = stringFromNameAndType(name, type, context),
+          nodeProperty = new NodeProperty(string, type, name);
+
+    return nodeProperty;
+  }
+};
+
+function stringFromNameAndType(name, type) {
+  const string = `${type} ${name}`;
+
+  return string;
+}

package/lib/parameters/node.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _parameter = /*#__PURE__*/ _interop_require_default(require("../dom/parameter"));
-var _parameters = /*#__PURE__*/ _interop_require_wildcard(require("../dom/parameters"));
-var _types = require("../types");
-var _parameterNames = require("../parameterNames");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-var types = [
-    _types.STRING_TYPE,
-    _types.BOOLEAN_TYPE,
-    _types.NODES_TYPE
-], names = [
-    _parameterNames.CONTENT_PARAMETER_NAME,
-    _parameterNames.TERMINAL_PARAMETER_NAME,
-    _parameterNames.CHILD_NODES_PARAMETER_NAME
-];
-var context = null, array = names.map(function(name, index) {
-    var type = types[index], parameter = _parameter.default.fromNameAndType(name, type, context);
-    return parameter;
-}), string = (0, _parameters.stringFromArray)(array, context), parameters = _parameters.default.fromStringAndArray(string, array, context), nodeParameters = parameters; ///
-var _default = nodeParameters;
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/parameters/node.js

@@ -1,32 +0,0 @@
-"use strict";
-
-import Parameter from "../dom/parameter";
-import Parameters from "../dom/parameters";
-
-import { stringFromArray } from "../dom/parameters";
-import { NODES_TYPE, STRING_TYPE, BOOLEAN_TYPE } from "../types";
-import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME } from "../parameterNames";
-
-const types = [
-        STRING_TYPE,
-        BOOLEAN_TYPE,
-        NODES_TYPE,
-      ],
-      names = [
-        CONTENT_PARAMETER_NAME,
-        TERMINAL_PARAMETER_NAME,
-        CHILD_NODES_PARAMETER_NAME
-      ];
-
-const context = null,
-      array = names.map((name, index) => {
-        const type = types[index],
-              parameter = Parameter.fromNameAndType(name, type, context);
-
-        return parameter;
-      }),
-      string = stringFromArray(array, context),
-      parameters = Parameters.fromStringAndArray(string, array, context),
-      nodeParameters = parameters;  ///
-
-export default nodeParameters;