occam-furtle 2.0.71 → 2.0.73

package/lib/nodeProperties.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _exception = /*#__PURE__*/ _interop_require_default(require("./exception"));
+var _nodeProperty = /*#__PURE__*/ _interop_require_default(require("./nodeProperty"));
+var _parameters = require("./dom/parameters");
+var _types = require("./types");
+var _parameterNames = require("./parameterNames");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 NodeProperties = /*#__PURE__*/ function() {
+    function NodeProperties(string, array) {
+        _class_call_check(this, NodeProperties);
+        this.string = string;
+        this.array = array;
+    }
+    _create_class(NodeProperties, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getArray",
+            value: function getArray() {
+                return this.array;
+            }
+        },
+        {
+            key: "someNodeProperty",
+            value: function someNodeProperty(callback) {
+                return this.array.some(callback);
+            }
+        },
+        {
+            key: "matchNamedParameter",
+            value: function matchNamedParameter(namedParameter, context) {
+                var nodePropertiesString = this.string, namedParameterString = namedParameter.getString();
+                context.trace("Matching the '".concat(namedParameterString, "' named parameter against the '").concat(nodePropertiesString, "' node properties..."));
+                var namedParameterMatches = this.someNodeProperty(function(nodeProperty) {
+                    var namedParameterMatchesNodeProperty = nodeProperty.matchNamedParameter(namedParameter, context);
+                    if (namedParameterMatchesNodeProperty) {
+                        return true;
+                    }
+                });
+                if (!namedParameterMatches) {
+                    var message = "The '".concat(namedParameterString, "' named parameter does not match any of the '").concat(nodePropertiesString, "' node properties."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                context.debug("...matched the '".concat(namedParameterString, "' named parameter against the '").concat(nodePropertiesString, "' node properties."));
+            }
+        },
+        {
+            key: "matchNamedParameters",
+            value: function matchNamedParameters(namedParameters, context) {
+                var _this = this;
+                namedParameters.forEachNamedParameter(function(namedParameter) {
+                    _this.matchNamedParameter(namedParameter, context);
+                });
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var context = null, array = names.map(function(name, index) {
+                    var type = types[index], nodeProperty = _nodeProperty.default.fromNameAndType(name, type, context);
+                    return nodeProperty;
+                }), string = (0, _parameters.stringFromArray)(array, context), nodeProperties = new NodeProperties(string, array);
+                return nodeProperties;
+            }
+        }
+    ]);
+    return NodeProperties;
+}();
+var nodeProperties = NodeProperties.fromNothing();
+var _default = nodeProperties;
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nodeProperty.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return NodeProperty;
+    }
+});
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var NodeProperty = /*#__PURE__*/ function() {
+    function NodeProperty(string, type, name) {
+        _class_call_check(this, NodeProperty);
+        this.string = string;
+        this.type = type;
+        this.name = name;
+    }
+    _create_class(NodeProperty, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "matchNamedParameter",
+            value: function matchNamedParameter(namedParameter, context) {
+                var namedParameterMatches;
+                var nodePropertyString = this.string, namedParameterString = namedParameter.getString();
+                context.trace("Matching the '".concat(nodePropertyString, "' node property against the '").concat(namedParameterString, "' named parameter..."));
+                var name = namedParameter.getName(), type = namedParameter.getType();
+                namedParameterMatches = this.name === name && this.type === type;
+                if (namedParameterMatches) {
+                    context.debug("...matched the '".concat(nodePropertyString, "' node property against the '").concat(namedParameterString, "' named parameter."));
+                }
+                return namedParameterMatches;
+            }
+        }
+    ], [
+        {
+            key: "fromNameAndType",
+            value: function fromNameAndType(name, type, context) {
+                var string = stringFromNameAndType(name, type, context), nodeProperty = new NodeProperty(string, type, name);
+                return nodeProperty;
+            }
+        }
+    ]);
+    return NodeProperty;
+}();
+_define_property(NodeProperty, "name", "Parameter");
+function stringFromNameAndType(name, type) {
+    var string = "".concat(type, " ").concat(name);
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-furtle",
   "author": "James Smith",
-  "version": "2.0.71",
+  "version": "2.0.73",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-furtle",
   "description": "Occam's Furtle language.",
@@ -11,12 +11,12 @@
   },
   "dependencies": {
     "necessary": "^14.3.2",
-    "occam-grammars": "^1.3.161"
+    "occam-grammars": "^1.3.163"
   },
   "devDependencies": {
     "@swc/core": "^1.5.6",
-    "occam-custom-grammars": "^5.0.1085",
-    "occam-entities": "^1.0.295",
+    "occam-custom-grammars": "^5.0.1086",
+    "occam-entities": "^1.0.296",
     "occam-query": "^4.1.30",
     "watchful-cli": "^1.7.56"
   },

package/src/dom/assignment/object.js

@@ -2,7 +2,7 @@
 
 import dom from "../../dom";
 import Exception from "../../exception";
-import nodeParameters from "../../parameters/node";
+import nodeProperties from "../../nodeProperties";
 
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
@@ -12,10 +12,10 @@ import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_
 const objectAssignmentNodeQuery = nodeQuery("/step/objectAssignment");
 
 export default domAssigned(class ObjectAssigment {
-  constructor(string, variable, parameters) {
+  constructor(string, variable, namedParameters) {
     this.string = string;
     this.variable = variable;
-    this.parameters = parameters;
+    this.namedParameters = namedParameters;
   }
 
   getString() {
@@ -26,8 +26,8 @@ export default domAssigned(class ObjectAssigment {
     return this.variable;
   }
 
-  getParameters() {
-    return this.parameters;
+  getNamedParameters() {
+    return this.namedParameters;
   }
 
   evaluate(context) {
@@ -46,54 +46,52 @@ export default domAssigned(class ObjectAssigment {
       throw exception;
     }
 
-    nodeParameters.matchParameters(this.parameters, context);
+    nodeProperties.matchNamedParameters(this.namedParameters, context);
 
-    this.parameters.forEachParameter((parameter) => {
-      if (parameter !== null) {
-        this.evaluateParameter(parameter, value, context);
-      }
+    this.namedParameters.forEachNamedParameter((namedParameter) => {
+      this.evaluateNamedParameter(namedParameter, value, context);
     });
 
     context.debug(`...evaluated the '${objectAssignmentString}' object assignment.`);
   }
 
-  evaluateParameter(parameter, value, context) {
+  evaluateNamedParameter(namedParameter, value, context) {
     const valueString = value.asString(context),
-          parameterString = parameter.getString();
+          namedParameterString = namedParameter.getString();
 
-    context.trace(`Evaluating the '${parameterString}' parameter against the ${valueString} value...`);
+    context.trace(`Evaluating the '${namedParameterString}' named parameter against the ${valueString} value...`);
 
-    const name = parameter.getName();
+    const name = namedParameter.getName();
 
     switch (name) {
       case CONTENT_PARAMETER_NAME: {
-        this.evaluateContentParameter(parameter, value, context);
+        this.evaluateContentNamedParameter(namedParameter, value, context);
 
         break;
       }
 
       case TERMINAL_PARAMETER_NAME: {
-        this.evaluateTerminalParameter(parameter, value, context);
+        this.evaluateTerminalNamedParameter(namedParameter, value, context);
 
         break;
       }
 
       case CHILD_NODES_PARAMETER_NAME: {
-        this.evaluateChildNodesParameter(parameter, value, context);
+        this.evaluateChildNodesNamedParameter(namedParameter, value, context);
 
         break;
       }
     }
 
-    context.debug(`...evaluated the '${parameterString}' parameter against the ${valueString} value.`);
+    context.debug(`...evaluated the '${namedParameterString}' parameter named against the ${valueString} value.`);
   }
 
-  evaluateContentParameter(parameter, value, context) {
-    const type = parameter.getType();
+  evaluateContentNamedParameter(namedParameter, value, context) {
+    const type = namedParameter.getType();
 
     if (type !== STRING_TYPE) {
-      const parameterString = parameter.getString(),
-            message = `The '${parameterString}' parameter's type should be '${STRING_TYPE}'.`,
+      const namedParameterString = namedParameter.getString(),
+            message = `The '${namedParameterString}' named parameter's type should be '${STRING_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -118,19 +116,19 @@ export default domAssigned(class ObjectAssigment {
     value = Value.fromString(string, context);  ///
 
     const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
 
     context.addVariable(variable);
 
     variable.assign(context);
   }
 
-  evaluateTerminalParameter(parameter, value, context) {
-    const type = parameter.getType();
+  evaluateTerminalNamedParameter(namedParameter, value, context) {
+    const type = namedParameter.getType();
 
     if (type !== BOOLEAN_TYPE) {
-      const parameterString = parameter.getString(),
-            message = `The '${parameterString}' parameter's type should be '${BOOLEAN_TYPE}'.`,
+      const namedParameterString = namedParameter.getString(),
+            message = `The '${namedParameterString}' named parameter's type should be '${BOOLEAN_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -146,19 +144,19 @@ export default domAssigned(class ObjectAssigment {
     value = Value.fromBoolean(boolean, context);  ///
 
     const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
 
     context.addVariable(variable);
 
     variable.assign(context);
   }
 
-  evaluateChildNodesParameter(parameter, value, context) {
-    const type = parameter.getType();
+  evaluateChildNodesNamedParameter(namedParameter, value, context) {
+    const type = namedParameter.getType();
 
     if (type !== NODES_TYPE) {
-      const parameterString = parameter.getString(),
-            message = `The '${parameterString}' parameter's type should be '${NODES_TYPE}'.`,
+      const namedParameterString = namedParameter.getString(),
+            message = `The '${namedParameterString}' named parameter's type should be '${NODES_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -183,7 +181,7 @@ export default domAssigned(class ObjectAssigment {
     value = Value.fromNodes(nodes, context);  ///
 
     const assignment = Assignment.fromValue(value, context),
-          variable = Variable.fromParameterAndAssignment(parameter, assignment);
+          variable = Variable.fromNamedParameterAndAssignment(namedParameter, assignment);
 
     context.addVariable(variable);
 
@@ -198,13 +196,13 @@ export default domAssigned(class ObjectAssigment {
     const objectAssignmentNode = objectAssignmentNodeQuery(stepNode);
 
     if (objectAssignmentNode !== null) {
-      const { Variable, Parameters } = dom,
+      const { Variable, NamedParameters } = dom,
             node = objectAssignmentNode,  ///
             string = context.nodeAsString(node),
             variable = Variable.fromObjectAssignmentNode(objectAssignmentNode, context),
-            parameters = Parameters.fromObjectAssignmentNode(objectAssignmentNode, context);
+            namedParameters = NamedParameters.fromObjectAssignmentNode(objectAssignmentNode, context);
 
-      objectAssignment = new ObjectAssigment(string, variable, parameters);
+      objectAssignment = new ObjectAssigment(string, variable, namedParameters);
     }
 
     return objectAssignment;

package/src/dom/parameter/named.js

@@ -0,0 +1,119 @@
+"use strict";
+
+import Exception from "../../exception";
+
+import { domAssigned } from "../../dom";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
+
+const typeTerminalNodeQuery = nodeQuery("/namedParameter/@type"),
+      nameTerminalNodeQuery = nodeQuery("/namedParameter/@name[0]"),
+      asNameTerminalNodeQuery = nodeQuery("/namedParameter/@name[1]");
+
+export default domAssigned(class NamedParameter {
+  constructor(string, type, name, asName) {
+    this.string = string;
+    this.type = type;
+    this.name = name;
+    this.asName = asName;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getAsName() {
+    return this.asName;
+  }
+
+  matchValue(value, context) {
+    const valueString = value.asString(context),
+          namedParameterString = this.string;  ///
+
+    context.trace(`Matching the ${valueString} value against the '${namedParameterString}' named parameter...`);
+
+    const valueType = value.getType();
+
+    if (this.type !== valueType) {
+      const message = `The ${valueString} value's '${valueType}' type  and '${namedParameterString}' named parameter's '${this.type}' type do not match.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...matched the ${valueString} value against the '${namedParameterString}' named parameter.`);
+  }
+
+  matchNamedParameter(namedParameter, context) {
+    let namedParameterMatches;
+
+    const namedParameterA = this,  ///
+          namedParameterB = namedParameter; ///
+
+    const namedParameterAString = namedParameterA.getString(),
+          namedParameterBString = namedParameterB.getString();
+
+    context.trace(`Matching the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter...`);
+
+    const name = namedParameter.getName(),
+          type = namedParameter.getType();
+
+    namedParameterMatches = ((this.name === name) && (this.type === type));
+
+    if (namedParameterMatches) {
+      context.debug(`...matched the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter.`);
+    }
+
+    return namedParameterMatches;
+  }
+
+  static name = "NamedParameter";
+
+  static fromNamedParameterNode(namedParameterNode, context) {
+    const type = typeFromNamedParameterNode(namedParameterNode, context),
+          name = nameFromNamedParameterNode(namedParameterNode, context),
+          asName = asNameFromNamedParameterNode(namedParameterNode, context),
+          node = namedParameterNode, //
+          string = context.nodeAsString(node),
+          namedParameter = new NamedParameter(string, type, name, asName);
+
+    return namedParameter;
+  }
+});
+
+function typeFromNamedParameterNode(namedParameterNode, context) {
+  const typeTerminalNode = typeTerminalNodeQuery(namedParameterNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        type = typeTerminalNodeContent; ///
+
+  return type;
+}
+
+function nameFromNamedParameterNode(namedParameterNode, context) {
+  const nameTerminalNode = nameTerminalNodeQuery(namedParameterNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        name = nameTerminalNodeContent; ///
+
+  return name;
+}
+
+function asNameFromNamedParameterNode(namedParameterNode, context) {
+  let asName = null;
+
+  const asNameTerminalNode = asNameTerminalNodeQuery(namedParameterNode);
+
+  if (asNameTerminalNode !== null) {
+    const asNameTerminalNodeContent = asNameTerminalNode.getContent();
+
+    asName = asNameTerminalNodeContent; ///
+  }
+
+  return asName;
+}

package/src/dom/parameter.js

@@ -10,24 +10,24 @@ const terminalNodesQuery = nodesQuery("/parameter/@*"),
       typeTerminalNodeQuery = nodeQuery("/parameter/@type");
 
 export default domAssigned(class Parameter {
-  constructor(string, name, type) {
+  constructor(string, type, name) {
     this.string = string;
-    this.name = name;
     this.type = type;
+    this.name = name;
   }
 
   getString() {
     return this.string;
   }
 
-  getName() {
-    return this.name;
-  }
-
   getType() {
     return this.type;
   }
 
+  getName() {
+    return this.name;
+  }
+
   matchValue(value, context) {
     const valueString = value.asString(context),
           parameterString = this.string;  ///
@@ -46,38 +46,8 @@ export default domAssigned(class Parameter {
     context.debug(`...matched the ${valueString} value against the '${parameterString}' parameter.`);
   }
 
-  matchParameter(parameter, context) {
-    let parameterMatches;
-
-    const parameterA = this,  ///
-          parameterB = parameter; ///
-
-    const parameterAString = parameterA.getString(),
-          parameterBString = parameterB.getString();
-
-    context.trace(`Matching the '${parameterAString}' parameter against the '${parameterBString}' parameter...`);
-
-    const name = parameter.getName(),
-          type = parameter.getType();
-
-    parameterMatches = ((this.name === name) && (this.type === type));
-
-    if (parameterMatches) {
-      context.debug(`...matched the '${parameterAString}' parameter against the '${parameterBString}' parameter.`);
-    }
-
-    return parameterMatches;
-  }
-
   static name = "Parameter";
 
-  static fromNameAndType(name, type, context) {
-    const string = stringFromNameAndType(name, type, context),
-          parameter = new Parameter(string, name, type);
-
-    return parameter;
-  }
-
   static fromParameterNode(parameterNode, context) {
     let parameter = null;
 
@@ -90,19 +60,13 @@ export default domAssigned(class Parameter {
             node = parameterNode, //
             string = context.nodeAsString(node);
 
-      parameter = new Parameter(string, name, type);
+      parameter = new Parameter(string, type, name);
     }
 
     return parameter;
   }
 });
 
-function stringFromNameAndType(name, type) {
-  const string = `${type} ${name}`;
-
-  return string;
-}
-
 function nameFromParameterNode(parameterNode, context) {
   const nameTerminalNode = nameTerminalNodeQuery(parameterNode),
         nameTerminalNodeContent = nameTerminalNode.getContent(),