Add slice and index-of expressions

src/style-spec/expression/definitions/index.js

@@ -24,8 +24,10 @@ import Assertion from './assertion';
 import Coercion from './coercion';
 import At from './at';
 import In from './in';
+import IndexOf from './index_of';
 import Match from './match';
 import Case from './case';
+import Slice from './slice';
 import Step from './step';
 import Interpolate from './interpolate';
 import Coalesce from './coalesce';
@@ -64,6 +66,7 @@ const expressions: ExpressionRegistry = {
     'format': FormatExpression,
     'image': ImageExpression,
     'in': In,
+    'index-of': IndexOf,
     'interpolate': Interpolate,
     'interpolate-hcl': Interpolate,
     'interpolate-lab': Interpolate,
@@ -74,6 +77,7 @@ const expressions: ExpressionRegistry = {
     'number': Assertion,
     'number-format': NumberFormat,
     'object': Assertion,
+    'slice': Slice,
     'step': Step,
     'string': Assertion,
     'to-boolean': Coercion,

src/style-spec/expression/definitions/index_of.js

@@ -0,0 +1,110 @@
+// @flow
+
+import {ValueType, toString, NumberType} from '../types';
+import RuntimeError from '../runtime_error';
+import {typeOf} from '../values';
+
+import type {Expression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
+import type {Value} from '../values';
+
+function isComparableType(type: Type) {
+    return type.kind === 'boolean' ||
+           type.kind === 'string' ||
+           type.kind === 'number' ||
+           type.kind === 'null' ||
+           type.kind === 'value';
+}
+
+function isComparableRuntimeValue(needle: boolean | string | number | null) {
+    return typeof needle === 'boolean' ||
+           typeof needle === 'string' ||
+           typeof needle === 'number' ||
+           needle ===  null;
+}
+
+function isSearchableRuntimeValue(haystack: Array<Value> | string) {
+    return Array.isArray(haystack) ||
+           typeof haystack === 'string';
+}
+
+class IndexOf implements Expression {
+    type: Type;
+    needle: Expression;
+    haystack: Expression;
+    fromIndex: ?Expression;
+
+    constructor(needle: Expression, haystack: Expression, fromIndex?: Expression) {
+        this.type = NumberType;
+        this.needle = needle;
+        this.haystack = haystack;
+        this.fromIndex = fromIndex;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+        if (args.length <= 2 ||  args.length >= 5) {
+            return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
+        }
+
+        const needle = context.parse(args[1], 1, ValueType);
+
+        const haystack = context.parse(args[2], 2, ValueType);
+
+        if (!needle || !haystack) return null;
+        if (!isComparableType(needle.type)) {
+            return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
+        }
+
+        if (args.length === 4) {
+            const fromIndex = context.parse(args[3], 3, NumberType);
+            if (!fromIndex) return null;
+            return new IndexOf(needle, haystack, fromIndex);
+        } else {
+            return new IndexOf(needle, haystack);
+        }
+    }
+
+    evaluate(ctx: EvaluationContext) {
+        const needle = (this.needle.evaluate(ctx): any);
+        const haystack = (this.haystack.evaluate(ctx): any);
+
+        if (!isComparableRuntimeValue(needle)) {
+            throw new RuntimeError(`Expected first argument to be of type boolean, string or number, but found ${toString(typeOf(needle))} instead.`);
+        }
+
+        if (!isSearchableRuntimeValue(haystack)) {
+            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
+        }
+
+        if (this.fromIndex) {
+            const fromIndex = (this.fromIndex.evaluate(ctx): number);
+            return haystack.indexOf(needle, fromIndex);
+        }
+
+        return haystack.indexOf(needle);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.needle);
+        fn(this.haystack);
+        if (this.fromIndex) {
+            fn(this.fromIndex);
+        }
+    }
+
+    outputDefined() {
+        return false;
+    }
+
+    serialize() {
+        if (this.fromIndex != null && this.fromIndex !== undefined) {
+            const fromIndex = this.fromIndex.serialize();
+            return ["index-of", this.needle.serialize(), this.haystack.serialize(), fromIndex];
+        }
+        return ["index-of", this.needle.serialize(), this.haystack.serialize()];
+    }
+}
+
+export default IndexOf;

src/style-spec/expression/definitions/slice.js

@@ -0,0 +1,96 @@
+// @flow
+
+import {ValueType, NumberType, toString} from '../types';
+import RuntimeError from '../runtime_error';
+import {typeOf} from '../values';
+
+import type {Expression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
+import type {Value} from '../values';
+
+function isSliceableType(type: Type) {
+    return type.kind === 'array' ||
+           type.kind === 'string' ||
+           type.kind === 'value';
+}
+function isAcceptableInputRuntimeValue(input: Array<Value> | string) {
+    return Array.isArray(input) ||
+           typeof input === 'string';
+}
+
+class Slice implements Expression {
+    type: Type;
+    input: Expression;
+    beginIndex: Expression;
+    endIndex: ?Expression;
+
+    constructor(type: Type, input: Expression, beginIndex: Expression, endIndex?: Expression) {
+        this.type = type;
+        this.input = input;
+        this.beginIndex = beginIndex;
+        this.endIndex = endIndex;
+
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+        if (args.length <= 2 ||  args.length >= 5) {
+            return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
+        }
+
+        const input = context.parse(args[1], 1, ValueType);
+        const beginIndex = context.parse(args[2], 2, NumberType);
+
+        if (!input || !beginIndex) return null;
+        if (!isSliceableType(input.type)) {
+            return context.error(`Expected first argument to be of type array or string, but found ${toString(input.type)} instead`);
+        }
+
+        if (args.length === 4) {
+            const endIndex = context.parse(args[3], 3, NumberType);
+            if (!endIndex) return null;
+            return new Slice(input.type, input, beginIndex, endIndex);
+        } else {
+            return new Slice(input.type, input, beginIndex);
+        }
+    }
+
+    evaluate(ctx: EvaluationContext) {
+        const input = (this.input.evaluate(ctx): any);
+        const beginIndex = (this.beginIndex.evaluate(ctx): number);
+
+        if (!isAcceptableInputRuntimeValue(input)) {
+            throw new RuntimeError(`Expected first argument to be of type array or string, but found ${toString(typeOf(input))} instead.`);
+        }
+
+        if (this.endIndex) {
+            const endIndex = (this.endIndex.evaluate(ctx): number);
+            return input.slice(beginIndex, endIndex);
+        }
+
+        return input.slice(beginIndex);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+        fn(this.beginIndex);
+        if (this.endIndex) {
+            fn(this.endIndex);
+        }
+    }
+
+    outputDefined() {
+        return false;
+    }
+
+    serialize() {
+        if (this.endIndex != null && this.endIndex !== undefined) {
+            const endIndex = this.endIndex.serialize();
+            return ["slice", this.input.serialize(), this.beginIndex.serialize(), endIndex];
+        }
+        return ["slice", this.input.serialize(), this.beginIndex.serialize()];
+    }
+}
+
+export default Slice;

src/style-spec/reference/v8.json

@@ -2597,6 +2597,15 @@
           }
         }
       },
+      "index-of": { 
+        "doc": "Returns the first index at which a given element can be found in an array, or for a string, the first occurrence of the specified value. If a second argument is provided, then the search is started from that position. Returns -1 if the value is not found.",
+        "group": "Lookup",
+        "sdk-support": {
+          "basic functionality": {
+            "js": "1.10.0"
+          }
+        }
+      },
       "case": {
         "doc": "Selects the first output whose corresponding test condition evaluates to true, or the fallback value otherwise.",
         "group": "Decision",
@@ -3520,6 +3529,15 @@
             "macos": "0.9.0"
           }
         }
+      },
+      "slice": { 
+        "doc": "Returns a portion of a string or an array starting from the provided beginning index. If a second argument is provided, then the return portion will run to, but not include, the end index.",
+        "group": "String",
+        "sdk-support": {
+          "basic functionality": {
+            "js": "1.10.0"
+          }
+        }
       }
     }
   },

test/integration/expression-tests/index-of/assert-array/test.json

@@ -0,0 +1,26 @@
+{
+  "expression": ["index-of", ["get", "i"], ["array", ["get", "arr"]]],
+  "inputs": [
+    [{}, { "properties": { "i": null, "arr": [9, 8, 7] } }],
+    [{}, { "properties": { "i": null, "arr": [9, 8, 7, null] } }],
+    [{}, { "properties": { "i": 1, "arr": [9, 8, 7] } }],
+    [{}, { "properties": { "i": 9, "arr": [9, 8, 7, 9] } }],
+    [{}, { "properties": { "i": 1, "arr": null } }]
+  ],
+  "expected": {
+    "compiled": {
+      "result": "success",
+      "isFeatureConstant": false,
+      "isZoomConstant": true,
+      "type": "number"
+    },
+    "outputs": [
+      -1,
+      3,
+      -1,
+      0,
+      { "error": "Expected value to be of type array, but found null instead." }
+    ],
+    "serialized": ["index-of", ["get", "i"], ["array", ["get", "arr"]]]
+  }
+}

test/integration/expression-tests/index-of/assert-string/test.json

@@ -0,0 +1,26 @@
+{
+  "expression": ["index-of", ["get", "substr"], ["string", ["get", "str"]]],
+  "inputs": [
+    [{}, { "properties": { "substr": null, "str": "helloworld" } }],
+    [{}, { "properties": { "substr": "foo", "str": "helloworld" } }],
+    [{}, { "properties": { "substr": "low", "str": "helloworld" } }],
+    [{}, { "properties": { "substr": "low", "str": null } }]
+  ],
+  "expected": {
+    "compiled": {
+      "result": "success",
+      "isFeatureConstant": false,
+      "isZoomConstant": true,
+      "type": "number"
+    },
+    "outputs": [
+      -1,
+      -1,
+      3,
+      {
+        "error": "Expected value to be of type string, but found null instead."
+      }
+    ],
+    "serialized": ["index-of", ["get", "substr"], ["string", ["get", "str"]]]
+  }
+}

test/integration/expression-tests/index-of/basic-array/test.json

@@ -0,0 +1,46 @@
+{
+  "expression": ["index-of", ["get", "i"], ["get", "arr"]],
+  "inputs": [
+    [{}, { "properties": { "i": null, "arr": [9, 8, 7] } }],
+    [{}, { "properties": { "i": 1, "arr": [9, 8, 7] } }],
+    [{}, { "properties": { "i": 9, "arr": [9, 8, 7] } }],
+    [
+      {},
+      {
+        "properties": {
+          "i": "foo",
+          "arr": ["baz", "bar", "hello", "foo", "world"]
+        }
+      }
+    ],
+    [
+      {},
+      {
+        "properties": {
+          "i": true,
+          "arr": ["foo", 123, null, 456, false, {}, true]
+        }
+      }
+    ],
+    [{}, { "properties": { "i": 1, "arr": null } }]
+  ],
+  "expected": {
+    "compiled": {
+      "result": "success",
+      "isFeatureConstant": false,
+      "isZoomConstant": true,
+      "type": "number"
+    },
+    "outputs": [
+      -1,
+      -1,
+      0,
+      3,
+      6,
+      {
+        "error": "Expected second argument to be of type array or string, but found null instead."
+      }
+    ],
+    "serialized": ["index-of", ["get", "i"], ["get", "arr"]]
+  }
+}