occam-furtle 3.0.378 → 3.0.381

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-furtle",
   "author": "James Smith",
-  "version": "3.0.378",
+  "version": "3.0.381",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-furtle",
   "description": "Occam's Furtle language.",
@@ -11,8 +11,8 @@
   },
   "dependencies": {
     "necessary": "^17.5.2",
-    "occam-grammars": "^1.3.630",
-    "occam-languages": "^1.0.33",
+    "occam-grammars": "^1.3.632",
+    "occam-languages": "^1.0.34",
     "occam-lexers": "^23.2.2",
     "occam-parsers": "^23.2.4",
     "occam-query": "^4.1.198"
@@ -28,8 +28,8 @@
     "juxtapose": "^4.0.143",
     "lively-cli": "^3.0.3",
     "occam-grammar-utilities": "^8.1.17",
-    "occam-model": "^1.0.560",
-    "occam-server": "^7.0.60",
+    "occam-model": "^1.0.561",
+    "occam-server": "^7.0.61",
     "watchful-cli": "^1.7.102"
   },
   "scripts": {

package/src/element/contains.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { Element } from "occam-languages";
+import { stringUtilities } from "necessary";
+
+import Exception from "../exception";
+
+import { define } from "../elements";
+import { STRING_TYPE_NAME } from "../typeNames";
+import { valueFromBoolean } from "../utilities/value";
+
+const { indexOf } = stringUtilities;
+
+export default define(class Contains extends Element {
+  constructor(context, string, node, breakPoint, variable, substring) {
+    super(context, string, node, breakPoint);
+
+    this.variable = variable;
+    this.substring = substring;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  getSubstring() {
+    return this.substring;
+  }
+
+  evaluate(context) {
+    let value;
+
+    const containsString = this.getString();  ///
+
+    context.trace(`Evaluating the '${containsString}' function...`);
+
+    value = this.variable.evaluate(context);
+
+    const valueType = value.getType(),
+          valueTypeStringType = valueType.isStringType();
+
+    if (!valueTypeStringType) {
+      const valueString = value.getString(),
+            message = `The '${valueString}' value's '${valueType}' type should be '${STRING_TYPE_NAME}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    const string = value.getString(),
+          boolean = string.contains(this.substring);
+
+    value = valueFromBoolean(boolean);
+
+    const valueString = value.getString();
+
+    context.debug(`...evaluated the '${containsString}' function as '${valueString}'.`);
+
+    return value;
+  }
+
+  static name = "Contains";
+});

package/src/element/endsWith.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { Element } from "occam-languages";
+
+import Exception from "../exception";
+
+import { define } from "../elements";
+import { STRING_TYPE_NAME } from "../typeNames";
+import { valueFromBoolean } from "../utilities/value";
+
+export default define(class EndsWith extends Element {
+  constructor(context, string, node, breakPoint, variable, substring) {
+    super(context, string, node, breakPoint);
+
+    this.variable = variable;
+    this.substring = substring;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  getSubstring() {
+    return this.substring;
+  }
+
+  evaluate(context) {
+    let value;
+
+    const endsWithString = this.getString();  ///
+
+    context.trace(`Evaluating the '${endsWithString}' function...`);
+
+    value = this.variable.evaluate(context);
+
+    const valueType = value.getType(),
+          valueTypeStringType = valueType.isStringType();
+
+    if (!valueTypeStringType) {
+      const valueString = value.getString(),
+            message = `The '${valueString}' value's '${valueType}' type should be '${STRING_TYPE_NAME}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    const string = value.getString(),
+          boolean = string.endsWith(this.substring);
+
+    value = valueFromBoolean(boolean);
+
+    const valueString = value.getString();
+
+    context.debug(`...evaluated the '${endsWithString}' function as '${valueString}'.`);
+
+    return value;
+  }
+
+  static name = "EndsWith";
+});

package/src/element/expression.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 
 export default define(class Expression extends Element {
-  constructor(context, string, node, breakPoint, term, some, every, reduce, ternary, nodeQuery, nodesQuery, lengthOf, toInteger, tryInteger, returnBlock, procedureCall) {
+  constructor(context, string, node, breakPoint, term, some, every, reduce, ternary, nodeQuery, nodesQuery, lengthOf, toInteger, tryInteger, contains, endsWith, startsWith, returnBlock, procedureCall) {
     super(context, string, node, breakPoint);
 
     this.term = term;
@@ -18,6 +18,9 @@ export default define(class Expression extends Element {
     this.lengthOf = lengthOf;
     this.toInteger = toInteger;
     this.tryInteger = tryInteger;
+    this.contains = contains;
+    this.endsWith = endsWith;
+    this.startsWith = startsWith;
     this.returnBlock = returnBlock;
     this.procedureCall = procedureCall;
   }
@@ -62,6 +65,18 @@ export default define(class Expression extends Element {
     return this.tryInteger;
   }
 
+  getContains() {
+    return this.contains;
+  }
+
+  getEndsWith() {
+    return this.endsWith;
+  }
+
+  getStartsWith() {
+    return this.startsWith;
+  }
+
   getReturnBlock() {
     return this.returnBlock;
   }
@@ -95,6 +110,12 @@ export default define(class Expression extends Element {
       type = this.toInteger.getType();
     } else if (this.tryInteger !== null) {
       type = this.tryInteger.getType();
+    } else if (this.contains !== null) {
+      type = this.contains.getType();
+    } else if (this.endsWith !== null) {
+      type = this.endsWith.getType();
+    } else if (this.startsWith !== null) {
+      type = this.startsWith.getType();
     } else if (this.returnBlock !== null) {
       type = this.returnBlock.getType();
     } else if (this.procedureCall !== null) {
@@ -121,6 +142,12 @@ export default define(class Expression extends Element {
       value = this.toInteger.evaluate(context);
     } else if (this.tryInteger !== null) {
       value = this.tryInteger.evaluate(context);
+    } else if (this.contains !== null) {
+      value = this.contains.evaluate(context);
+    } else if (this.endsWith !== null) {
+      value = this.endsWith.evaluate(context);
+    } else if (this.startsWith !== null) {
+      value = this.startsWith.evaluate(context);
     } else if (this.some !== null) {
       value = await this.some.evaluate(context);
     } else if (this.every !== null) {

package/src/element/startsWith.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { Element } from "occam-languages";
+
+import Exception from "../exception";
+
+import { define } from "../elements";
+import { STRING_TYPE_NAME } from "../typeNames";
+import { valueFromBoolean } from "../utilities/value";
+
+export default define(class StartsWith extends Element {
+  constructor(context, string, node, breakPoint, variable, substring) {
+    super(context, string, node, breakPoint);
+
+    this.variable = variable;
+    this.substring = substring;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  getSubstring() {
+    return this.substring;
+  }
+
+  evaluate(context) {
+    let value;
+
+    const startsWithString = this.getString();  ///
+
+    context.trace(`Evaluating the '${startsWithString}' function...`);
+
+    value = this.variable.evaluate(context);
+
+    const valueType = value.getType(),
+          valueTypeStringType = valueType.isStringType();
+
+    if (!valueTypeStringType) {
+      const valueString = value.getString(),
+            message = `The '${valueString}' value's '${valueType}' type should be '${STRING_TYPE_NAME}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    const string = value.getString(),
+          boolean = string.startsWith(this.substring);
+
+    value = valueFromBoolean(boolean);
+
+    const valueString = value.getString();
+
+    context.debug(`...evaluated the '${startsWithString}' function as '${valueString}'.`);
+
+    return value;
+  }
+
+  static name = "StartsWith";
+});

package/src/node/contains.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { VARIABLE_RULE_NAME } from "../ruleNames";
+import { stringFromStringLiteral } from "../utilities/stringLiteral";
+import { STRING_LITERAL_TOKEN_TYPE } from "../tokenTypes";
+
+export default class ContainsNode extends NonTerminalNode {
+  getString() {
+    const stringLiteral = this.getStringLiteral(),
+          string = stringFromStringLiteral(stringLiteral);
+
+    return string;
+  }
+
+  getStringLiteral() {
+    let stringLiteral;
+
+    const tokenType = STRING_LITERAL_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode) => {
+      const content = terminalNode.getContent();
+
+      stringLiteral = content;  ///
+
+      return true;
+    }, tokenType);
+
+    return stringLiteral;
+  }
+
+  getVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
+
+    return variableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/endsWith.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { VARIABLE_RULE_NAME } from "../ruleNames";
+import { stringFromStringLiteral } from "../utilities/stringLiteral";
+import { STRING_LITERAL_TOKEN_TYPE } from "../tokenTypes";
+
+export default class EndsWithNode extends NonTerminalNode {
+  getString() {
+    const stringLiteral = this.getStringLiteral(),
+          string = stringFromStringLiteral(stringLiteral);
+
+    return string;
+  }
+
+  getStringLiteral() {
+    let stringLiteral;
+
+    const tokenType = STRING_LITERAL_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode) => {
+      const content = terminalNode.getContent();
+
+      stringLiteral = content;  ///
+
+      return true;
+    }, tokenType);
+
+    return stringLiteral;
+  }
+
+  getVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
+
+    return variableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(EndsWithNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/expression.js

@@ -7,11 +7,14 @@ import { TERM_RULE_NAME,
          EVERY_RULE_NAME,
          REDUCE_RULE_NAME,
          TERNARY_RULE_NAME,
+         CONTAINS_RULE_NAME,
          LENGTH_OF_RULE_NAME,
+         ENDS_WITH_RULE_NAME,
          TO_INTEGER_RULE_NAME,
          NODE_QUERY_RULE_NAME,
          TRY_INTEGER_RULE_NAME,
          NODES_QUERY_RULE_NAME,
+         STARTS_WITH_RULE_NAME,
          RETURN_BLOCK_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
@@ -46,11 +49,25 @@ export default class ExpressionNode extends NonTerminalNode {
 
   getTernaryNode() {
     const ruleName = TERNARY_RULE_NAME,
-          ternaryNode = this.getNodeByRuleName(ruleName);
+      ternaryNode = this.getNodeByRuleName(ruleName);
 
     return ternaryNode;
   }
 
+  getContainsNode() {
+    const ruleName = CONTAINS_RULE_NAME,
+          containsNode = this.getNodeByRuleName(ruleName);
+
+    return containsNode;
+  }
+
+  getEndsWithNode() {
+    const ruleName = ENDS_WITH_RULE_NAME,
+          endsWithNode = this.getNodeByRuleName(ruleName);
+
+    return endsWithNode;
+  }
+
   getLengthOfNode() {
     const ruleName = LENGTH_OF_RULE_NAME,
           lengthOfNode = this.getNodeByRuleName(ruleName);
@@ -72,6 +89,13 @@ export default class ExpressionNode extends NonTerminalNode {
     return toIntegerNode;
   }
 
+  getStartsWithNode() {
+    const ruleName = STARTS_WITH_RULE_NAME,
+          startsWithNode = this.getNodeByRuleName(ruleName);
+
+    return startsWithNode;
+  }
+
   getNodesQueryNode() {
     const ruleName = NODES_QUERY_RULE_NAME,
           nodeSQueryNode = this.getNodeByRuleName(ruleName);

package/src/node/startsWith.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { VARIABLE_RULE_NAME } from "../ruleNames";
+import { stringFromStringLiteral } from "../utilities/stringLiteral";
+import { STRING_LITERAL_TOKEN_TYPE } from "../tokenTypes";
+
+export default class StartsWithNode extends NonTerminalNode {
+  getString() {
+    const stringLiteral = this.getStringLiteral(),
+          string = stringFromStringLiteral(stringLiteral);
+
+    return string;
+  }
+
+  getStringLiteral() {
+    let stringLiteral;
+
+    const tokenType = STRING_LITERAL_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode) => {
+      const content = terminalNode.getContent();
+
+      stringLiteral = content;  ///
+
+      return true;
+    }, tokenType);
+
+    return stringLiteral;
+  }
+
+  getVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
+
+    return variableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StartsWithNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nonTerminalNodeMap.js

@@ -17,6 +17,8 @@ import DocumentNode from "./node/document";
 import VariableNode from "./node/variable";
 import NonsenseNode from "./node/nonsense";
 import LengthOfNode from "./node/lengthOf";
+import ContainsNode from "./node/contains";
+import EndsWithNode from "./node/endsWith";
 import PrimitiveNode from "./node/primitive";
 import ReferenceNode from "./node/reference";
 import ParameterNode from "./node/parameter";
@@ -24,6 +26,7 @@ import StatementNode from "./node/statement";
 import NodeQueryNode from "./node/nodeQuery";
 import ToIntegerNode from "./node/toInteger";
 import ProcedureNode from "./node/procedure";
+import StartsWithNode from "./node/startsWith";
 import TryIntegerNode from "./node/tryInteger";
 import NodesQueryNode from "./node/nodesQuery";
 import ExpressionNode from "./node/expression";
@@ -59,6 +62,8 @@ import { SOME_RULE_NAME,
          DOCUMENT_RULE_NAME,
          VARIABLE_RULE_NAME,
          NONSENSE_RULE_NAME,
+         CONTAINS_RULE_NAME,
+         ENDS_WITH_RULE_NAME,
          LENGTH_OF_RULE_NAME,
          PRIMITIVE_RULE_NAME,
          REFERENCE_RULE_NAME,
@@ -71,6 +76,7 @@ import { SOME_RULE_NAME,
          TO_INTEGER_RULE_NAME,
          TRY_INTEGER_RULE_NAME,
          NODES_QUERY_RULE_NAME,
+         STARTS_WITH_RULE_NAME,
          RETURN_BLOCK_RULE_NAME,
          LOGICAL_TERM_RULE_NAME,
          NEGATED_TERM_RULE_NAME,
@@ -102,7 +108,9 @@ const NonTerminalNodeMap = {
   [BINDINGS_RULE_NAME]: BindingsNode,
   [VARIABLE_RULE_NAME]: VariableNode,
   [NONSENSE_RULE_NAME]: NonsenseNode,
+  [CONTAINS_RULE_NAME]: ContainsNode,
   [DOCUMENT_RULE_NAME]: DocumentNode,
+  [ENDS_WITH_RULE_NAME]: EndsWithNode,
   [LENGTH_OF_RULE_NAME]: LengthOfNode,
   [PRIMITIVE_RULE_NAME]: PrimitiveNode,
   [REFERENCE_RULE_NAME]: ReferenceNode,
@@ -113,6 +121,7 @@ const NonTerminalNodeMap = {
   [NODE_QUERY_RULE_NAME]: NodeQueryNode,
   [EXPRESSION_RULE_NAME]: ExpressionNode,
   [PARAMETERS_RULE_NAME]: ParametersNode,
+  [STARTS_WITH_RULE_NAME]: StartsWithNode,
   [TRY_INTEGER_RULE_NAME]: TryIntegerNode,
   [NODES_QUERY_RULE_NAME]: NodesQueryNode,
   [RETURN_BLOCK_RULE_NAME]: ReturnBlockNode,

package/src/preamble.js

@@ -15,6 +15,8 @@ import Binding from "./element/binding";
 import Bindings from "./element/bindings";
 import Variable from "./element/variable";
 import LengthOf from "./element/lengthOf";
+import Contains from "./element/contains";
+import EndsWith from "./element/endsWith";
 import Primitive from "./element/primitive";
 import Reference from "./element/reference";
 import Procedure from "./element/procedure";
@@ -22,6 +24,7 @@ import NodeQuery from "./element/nodeQuery";
 import Parameter from "./element/parameter";
 import ToInteger from "./element/toInteger";
 import Statement from "./element/statement";
+import StartsWith from "./element/startsWith";
 import TryInteger from "./element/tryInteger";
 import Parameters from "./element/parameters";
 import NodesQuery from "./element/nodesQuery";

package/src/ruleNames.js

@@ -16,16 +16,19 @@ export const VARIABLE_RULE_NAME = "variable";
 export const NONSENSE_RULE_NAME = "nonsense";
 export const DOCUMENT_RULE_NAME = "document";
 export const BINDINGS_RULE_NAME = "bindings";
+export const CONTAINS_RULE_NAME = "contains";
 export const STATEMENT_RULE_NAME = "statement";
 export const PROCEDURE_RULE_NAME = "procedure";
 export const LENGTH_OF_RULE_NAME = "lengthOf";
 export const PRIMITIVE_RULE_NAME = "primitive";
 export const REFERENCE_RULE_NAME = "reference";
 export const PARAMETER_RULE_NAME = "parameter";
+export const ENDS_WITH_RULE_NAME = "endsWith";
 export const NODE_QUERY_RULE_NAME = "nodeQuery";
 export const EXPRESSION_RULE_NAME = "expression";
 export const PARAMETERS_RULE_NAME = "parameters";
 export const TO_INTEGER_RULE_NAME = "toInteger";
+export const STARTS_WITH_RULE_NAME = "startsWith";
 export const TRY_INTEGER_RULE_NAME = "tryInteger";
 export const NODES_QUERY_RULE_NAME = "nodesQuery";
 export const RETURN_BLOCK_RULE_NAME = "returnBlock";
@@ -42,4 +45,3 @@ export const OBJECT_ASSIGNMENT_RULE_NAME = "objectAssignment";
 export const VARIABLE_ASSIGNMENT_RULE_NAME = "variableAssignment";
 export const ANONYMOUS_PROCEDURE_RULE_NAME = "anonymousProcedure";
 export const VARIABLE_ASSIGNMENTS_RULE_NAME = "variableAssignments";
-