vega 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c647654effe7e3ffa6c7b3a362327194dc4b8d7191eff79aa16cdab069145c99
-  data.tar.gz: 6a5270fd82810cfa524532e65ff7affe90ef976c6b0fd0921a5f0cc8cebe0255
+  metadata.gz: c3b596c09118b82dc1166f6413ff31aae7801b79db73f4dc2e09acab9ccfa21a
+  data.tar.gz: 9ce59baf66bfd278f457a7686d8d8b2e4aa9c6f046d99b1d1184d206b6a680a0
 SHA512:
-  metadata.gz: 0b5d92c2fcec4da87095c75f22fdaa5ab6d2f829c855a23c504e5e7c7e6f851ca40ae6335046fc8d410a62dfe9f180c644216df1c0a4128d6474f970993e54fe
-  data.tar.gz: 212a02dce568a2058fc637909422ec1d31fa3309816c5dca450fbbb5535389e8e5d85de7dfa9fc3681363425bda322512e74bb6da41533b2eac879b9d84a067e
+  metadata.gz: 79c6c4705a054f0f9b9a4001f10496c1af17440ebf672c77ca856a35c9778c98ed40ce5f31ac90f31b05ec23df9640ff41d070b31b8466e8dec7930b1cf1a56d
+  data.tar.gz: ff0808b2c0cbaac73e266798cb048c6d0884e36b135f76bc5ebe74af5125a42a7e9a7018c22a7077a4c8530be431171cdc3b6d4a9e28a48643a24772b65537f7

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.1.3 (2021-03-14)
+
+- Added Vega-Interpreter
+
 ## 0.1.2 (2021-02-09)
 
 - Updated Vega to 5.19.1, Vega-Lite to 4.17.0, and Vega-Embed to 6.15.1

data/README.md

@@ -56,9 +56,9 @@ No additional set up is needed.
 For Sinatra and other web frameworks, include the Vega JavaScript files on pages with charts:
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/vega@5.16.1"></script>
-<script src="https://cdn.jsdelivr.net/npm/vega-lite@4.16.2"></script>
-<script src="https://cdn.jsdelivr.net/npm/vega-embed@6.12.2"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega@5.19.1"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-lite@4.17.0"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-embed@6.15.1"></script>
 ```
 
 ## Getting Started
@@ -318,6 +318,28 @@ Get the spec for a chart
 chart.spec
 ```
 
+## Content Security Policy (CSP)
+
+By default, the Vega parser uses the Function constructor, which [can cause issues with CSP](https://vega.github.io/vega/usage/interpreter/).
+
+For Rails 6 / Webpacker, run:
+
+```sh
+yarn add vega-interpreter
+```
+
+For Rails 5 / Sprockets, add to `app/assets/javascripts/application.js`:
+
+```js
+//= require vega-interpreter
+```
+
+And set embed options for your charts
+
+```ruby
+embed_options(ast: true)
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/vega/blob/master/CHANGELOG.md)

data/lib/vega/version.rb

@@ -1,3 +1,3 @@
 module Vega
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/licenses/LICENSE-vega-interpreter.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2015-2018, University of Washington Interactive Data Lab
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/assets/javascripts/vega-interpreter.js

@@ -0,0 +1,311 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vega = global.vega || {}));
+}(this, (function (exports) { 'use strict';
+
+  function adjustSpatial (item, encode, swap) {
+    let t;
+
+    if (encode.x2) {
+      if (encode.x) {
+        if (swap && item.x > item.x2) {
+          t = item.x;
+          item.x = item.x2;
+          item.x2 = t;
+        }
+
+        item.width = item.x2 - item.x;
+      } else {
+        item.x = item.x2 - (item.width || 0);
+      }
+    }
+
+    if (encode.xc) {
+      item.x = item.xc - (item.width || 0) / 2;
+    }
+
+    if (encode.y2) {
+      if (encode.y) {
+        if (swap && item.y > item.y2) {
+          t = item.y;
+          item.y = item.y2;
+          item.y2 = t;
+        }
+
+        item.height = item.y2 - item.y;
+      } else {
+        item.y = item.y2 - (item.height || 0);
+      }
+    }
+
+    if (encode.yc) {
+      item.y = item.yc - (item.height || 0) / 2;
+    }
+  }
+
+  var Constants = {
+    NaN: NaN,
+    E: Math.E,
+    LN2: Math.LN2,
+    LN10: Math.LN10,
+    LOG2E: Math.LOG2E,
+    LOG10E: Math.LOG10E,
+    PI: Math.PI,
+    SQRT1_2: Math.SQRT1_2,
+    SQRT2: Math.SQRT2,
+    MIN_VALUE: Number.MIN_VALUE,
+    MAX_VALUE: Number.MAX_VALUE
+  };
+
+  var Ops = {
+    '*': (a, b) => a * b,
+    '+': (a, b) => a + b,
+    '-': (a, b) => a - b,
+    '/': (a, b) => a / b,
+    '%': (a, b) => a % b,
+    '>': (a, b) => a > b,
+    '<': (a, b) => a < b,
+    '<=': (a, b) => a <= b,
+    '>=': (a, b) => a >= b,
+    '==': (a, b) => a == b,
+    '!=': (a, b) => a != b,
+    '===': (a, b) => a === b,
+    '!==': (a, b) => a !== b,
+    '&': (a, b) => a & b,
+    '|': (a, b) => a | b,
+    '^': (a, b) => a ^ b,
+    '<<': (a, b) => a << b,
+    '>>': (a, b) => a >> b,
+    '>>>': (a, b) => a >>> b
+  };
+
+  var Unary = {
+    '+': a => +a,
+    '-': a => -a,
+    '~': a => ~a,
+    '!': a => !a
+  };
+
+  const slice = Array.prototype.slice;
+
+  const apply = (m, args, cast) => {
+    const obj = cast ? cast(args[0]) : args[0];
+    return obj[m].apply(obj, slice.call(args, 1));
+  };
+
+  const datetime = (y, m, d, H, M, S, ms) => new Date(y, m || 0, d != null ? d : 1, H || 0, M || 0, S || 0, ms || 0);
+
+  var Functions = {
+    // math functions
+    isNaN: Number.isNaN,
+    isFinite: Number.isFinite,
+    abs: Math.abs,
+    acos: Math.acos,
+    asin: Math.asin,
+    atan: Math.atan,
+    atan2: Math.atan2,
+    ceil: Math.ceil,
+    cos: Math.cos,
+    exp: Math.exp,
+    floor: Math.floor,
+    log: Math.log,
+    max: Math.max,
+    min: Math.min,
+    pow: Math.pow,
+    random: Math.random,
+    round: Math.round,
+    sin: Math.sin,
+    sqrt: Math.sqrt,
+    tan: Math.tan,
+    clamp: (a, b, c) => Math.max(b, Math.min(c, a)),
+    // date functions
+    now: Date.now,
+    utc: Date.UTC,
+    datetime: datetime,
+    date: d => new Date(d).getDate(),
+    day: d => new Date(d).getDay(),
+    year: d => new Date(d).getFullYear(),
+    month: d => new Date(d).getMonth(),
+    hours: d => new Date(d).getHours(),
+    minutes: d => new Date(d).getMinutes(),
+    seconds: d => new Date(d).getSeconds(),
+    milliseconds: d => new Date(d).getMilliseconds(),
+    time: d => new Date(d).getTime(),
+    timezoneoffset: d => new Date(d).getTimezoneOffset(),
+    utcdate: d => new Date(d).getUTCDate(),
+    utcday: d => new Date(d).getUTCDay(),
+    utcyear: d => new Date(d).getUTCFullYear(),
+    utcmonth: d => new Date(d).getUTCMonth(),
+    utchours: d => new Date(d).getUTCHours(),
+    utcminutes: d => new Date(d).getUTCMinutes(),
+    utcseconds: d => new Date(d).getUTCSeconds(),
+    utcmilliseconds: d => new Date(d).getUTCMilliseconds(),
+    // sequence functions
+    length: x => x.length,
+    join: function () {
+      return apply('join', arguments);
+    },
+    indexof: function () {
+      return apply('indexOf', arguments);
+    },
+    lastindexof: function () {
+      return apply('lastIndexOf', arguments);
+    },
+    slice: function () {
+      return apply('slice', arguments);
+    },
+    reverse: x => x.slice().reverse(),
+    // string functions
+    parseFloat: parseFloat,
+    parseInt: parseInt,
+    upper: x => String(x).toUpperCase(),
+    lower: x => String(x).toLowerCase(),
+    substring: function () {
+      return apply('substring', arguments, String);
+    },
+    split: function () {
+      return apply('split', arguments, String);
+    },
+    replace: function () {
+      return apply('replace', arguments, String);
+    },
+    trim: x => String(x).trim(),
+    // regexp functions
+    regexp: RegExp,
+    test: (r, t) => RegExp(r).test(t)
+  };
+
+  const EventFunctions = ['view', 'item', 'group', 'xy', 'x', 'y'];
+  const Visitors = {
+    Literal: ($, n) => n.value,
+    Identifier: ($, n) => {
+      const id = n.name;
+      return $.memberDepth > 0 ? id : id === 'datum' ? $.datum : id === 'event' ? $.event : id === 'item' ? $.item : Constants[id] || $.params['$' + id];
+    },
+    MemberExpression: ($, n) => {
+      const d = !n.computed,
+            o = $(n.object);
+      if (d) $.memberDepth += 1;
+      const p = $(n.property);
+      if (d) $.memberDepth -= 1;
+      return o[p];
+    },
+    CallExpression: ($, n) => {
+      const args = n.arguments;
+      let name = n.callee.name; // handle special internal functions used by encoders
+      // re-route to corresponding standard function
+
+      if (name.startsWith('_')) {
+        name = name.slice(1);
+      } // special case "if" due to conditional evaluation of branches
+
+
+      return name === 'if' ? $(args[0]) ? $(args[1]) : $(args[2]) : ($.fn[name] || Functions[name]).apply($.fn, args.map($));
+    },
+    ArrayExpression: ($, n) => n.elements.map($),
+    BinaryExpression: ($, n) => Ops[n.operator]($(n.left), $(n.right)),
+    UnaryExpression: ($, n) => Unary[n.operator]($(n.argument)),
+    ConditionalExpression: ($, n) => $(n.test) ? $(n.consequent) : $(n.alternate),
+    LogicalExpression: ($, n) => n.operator === '&&' ? $(n.left) && $(n.right) : $(n.left) || $(n.right),
+    ObjectExpression: ($, n) => n.properties.reduce((o, p) => {
+      $.memberDepth += 1;
+      const k = $(p.key);
+      $.memberDepth -= 1;
+      o[k] = $(p.value);
+      return o;
+    }, {})
+  };
+  function interpret (ast, fn, params, datum, event, item) {
+    const $ = n => Visitors[n.type]($, n);
+
+    $.memberDepth = 0;
+    $.fn = Object.create(fn);
+    $.params = params;
+    $.datum = datum;
+    $.event = event;
+    $.item = item; // route event functions to annotated vega event context
+
+    EventFunctions.forEach(f => $.fn[f] = (...args) => event.vega[f](...args));
+    return $(ast);
+  }
+
+  var expression = {
+    /**
+     * Parse an expression used to update an operator value.
+     */
+    operator(ctx, expr) {
+      const ast = expr.ast,
+            fn = ctx.functions;
+      return _ => interpret(ast, fn, _);
+    },
+
+    /**
+     * Parse an expression provided as an operator parameter value.
+     */
+    parameter(ctx, expr) {
+      const ast = expr.ast,
+            fn = ctx.functions;
+      return (datum, _) => interpret(ast, fn, _, datum);
+    },
+
+    /**
+     * Parse an expression applied to an event stream.
+     */
+    event(ctx, expr) {
+      const ast = expr.ast,
+            fn = ctx.functions;
+      return event => interpret(ast, fn, undefined, undefined, event);
+    },
+
+    /**
+     * Parse an expression used to handle an event-driven operator update.
+     */
+    handler(ctx, expr) {
+      const ast = expr.ast,
+            fn = ctx.functions;
+      return (_, event) => {
+        const datum = event.item && event.item.datum;
+        return interpret(ast, fn, _, datum, event);
+      };
+    },
+
+    /**
+     * Parse an expression that performs visual encoding.
+     */
+    encode(ctx, encode) {
+      const {
+        marktype,
+        channels
+      } = encode,
+            fn = ctx.functions,
+            swap = marktype === 'group' || marktype === 'image' || marktype === 'rect';
+      return (item, _) => {
+        const datum = item.datum;
+        let m = 0,
+            v;
+
+        for (const name in channels) {
+          v = interpret(channels[name].ast, fn, _, datum, undefined, item);
+
+          if (item[name] !== v) {
+            item[name] = v;
+            m = 1;
+          }
+        }
+
+        if (marktype !== 'rule') {
+          adjustSpatial(item, channels, swap);
+        }
+
+        return m;
+      };
+    }
+
+  };
+
+  exports.expressionInterpreter = expression;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vega
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-10 00:00:00.000000000 Z
+date: 2021-03-15 00:00:00.000000000 Z
 dependencies: []
 description:
 email: andrew@ankane.org
@@ -28,9 +28,11 @@ files:
 - lib/vega/spec.rb
 - lib/vega/version.rb
 - licenses/LICENSE-vega-embed.txt
+- licenses/LICENSE-vega-interpreter.txt
 - licenses/LICENSE-vega-lite.txt
 - licenses/LICENSE-vega.txt
 - vendor/assets/javascripts/vega-embed.js
+- vendor/assets/javascripts/vega-interpreter.js
 - vendor/assets/javascripts/vega-lite.js
 - vendor/assets/javascripts/vega.js
 homepage: https://github.com/ankane/vega