d3js-plugins-rails 0.0.12 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0faed227b2539d6a29a28f6c3efe3408f3e5fa1
-  data.tar.gz: ca01ea7ef6130f37e3a6eac75f2b8c7322d90b69
+  metadata.gz: 7a17d75d2c86f99892135e42508aa38e0190560c
+  data.tar.gz: 0cdec6d6caaddd7db2329a5d929a1afe37cc248d
 SHA512:
-  metadata.gz: 874df8304003858f14b48fc6a60acd4345e609fd7985527c08493fd875d27e3ea4982eae34386187d6f466a290b0a4433a594c21002287e539885771a0eaa7b0
-  data.tar.gz: e2f852ad0364475a3e80aaf0b0c5752c933c62b9f9391b094297fffc7867c8453e8bc7c2d17ac8adcaa695276864cb31477bfd45602f85fc75c6234a86d602f4
+  metadata.gz: c979c51c71ee2f2eafe5cd7687877728a53a6df942257cd9f681d2392656edb59867117b3d3032cb0642f45721ebedc4f4b258f5e6460973098ea71e0e46a50c
+  data.tar.gz: 4da25bb701ae74cc54623585cf90cc627cc89f88e8f5800106353e55c9dc33b9bab4b0bee4b8912ee2b223b580643ab5279138425808a852ffbff834f49709c2

data/README.md

@@ -19,17 +19,6 @@ Add the *needed* directives to your JavaScript manifest file (application.js):
 
 It's unlikely you will need to include all plugins globally.
 
-## HighSecurity
-
-To ensure that you're including a gem with original code, you can install this gem using a HighSecurity policy.
-
-    gem cert --add <(curl -Ls https://gist.github.com/bai/5150087/raw/public_cert.pem)
-    bundle install --trust-policy HighSecurity
-
-Or, if you don't use bundler:
-
-    gem install d3js-plugins-rails -P HighSecurity
-
 ## Contributing
 
 1. Fork it

data/d3js-plugins-rails.gemspec

@@ -18,8 +18,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.signing_key   = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
-  gem.cert_chain    = ["certs/bai.pem"]
-
   gem.add_dependency "railties", ">= 3.0", "< 5.0"
 end

data/lib/d3js-plugins-rails/version.rb

@@ -1,8 +1,8 @@
 module D3js
   module Plugins
     module Rails
-      VERSION = "0.0.12"
-      D3_PLUGINS_VERSION = "88ae0e7d8f285d2f8f3a8e71e52ad2e5b75d403c"
+      VERSION = "0.0.15"
+      D3_PLUGINS_VERSION = "bfc4a8a42b3b0c8613c7ac582180547f2c21ac35"
     end
   end
 end

data/vendor/assets/javascripts/d3/plugins/README.md

@@ -1,5 +1,3 @@
 # D3 Plugins
 
-This is a repository for sharing D3 plugins.
-
-Each plugin should live in a directory that matches its name.
+Please note: the plugins in this repository will soon be broken up into separate repositories for easier distributed ownership. If you have a new plugin you’d like to share, please add a link to it from the [D3 plugins wiki](https://github.com/mbostock/d3/wiki/Plugins).

data/vendor/assets/javascripts/d3/plugins/cubehelix/README.md

@@ -0,0 +1,48 @@
+An interpolator that implements Dave Green’s [cubehelix color scheme](http://www.mrao.cam.ac.uk/~dag/CUBEHELIX/).
+
+See [bl.ocks.org/11413789](http://bl.ocks.org/mbostock/11413789) and [bl.ocks.org/11415064](http://bl.ocks.org/mbostock/11415064) for examples.
+
+<a href="#interpolateCubehelix" name="interpolateCubehelix">#</a> d3.<b>interpolateCubehelix</b>(<i>a</i>, <i>b</i>)
+
+Returns a cubehelix <a href="https://github.com/mbostock/d3/wiki/Transitions#_interpolate">interpolator</a> between the two colors <i>a</i> and <i>b</i>, using a gamma correction value of 1. The two colors are typically specified in HSL color space. For example, the default cubehelix color scheme is:
+
+```js
+var cubehelix = d3.interpolateCubehelix("hsl(300,50%,0%)", "hsl(-240,50%,100%)");
+```
+
+The hue of color <i>a</i> determines the starting hue angle in degrees, while the hue of color <i>b</i> determines the ending hue angle in degrees; the hue angle is interpolated linearly for intermediate values. Likewise for saturation and lightness, which are specified in percentages. (The [d3.hsl](https://github.com/mbostock/d3/wiki/Colors#d3_hsl) constructor can also be used.)
+
+If either color <i>a</i> or <i>b</i> is not an HSL color, the colors are converted to HSL color space first. However, it is recommended that you specify each color’s hue, saturation and lightness explicitly: cubehelix interpolation does not actually use the HSL color space, and thus the terms <i>hue</i>, <i>saturation</i> and <i>lightness</i> here are similar but slightly different to their meaning in HSL color space.
+
+The return value of the interpolator is a hexadecimal RGB string.
+
+To convert from the original color scheme’s <i>START</i>, <i>ROTS</i> and <i>HUE</i> parameters, use the following equalities:
+
+   * starting hue angle = (<i>START</i> - 1) * 120
+   * ending hue angle = (<i>START</i> - 1) * 120 + <i>ROTS</i> * 360
+   * saturation = <i>HUE</i> / 2
+
+For example, the default color scheme’s settings are:
+
+   * <i>START</i> = 0.5
+   * <i>ROTS</i> = -1.5
+   * <i>HUE</i> = 1.0
+
+These correspond to the following start and end colors:
+
+   * hsl(300, 50%, 0%)
+   * hsl(-240, 50%, 100%)
+
+While the original cubehelix color scheme always uses the full range of lightness from 0% to 100%, note that it is possible in this interpolator to use a subset of this range by specifying start and end colors with different lightnesses.
+
+<a href="#interpolateCubehelix_gamma" name="interpolateCubehelix_gamma">#</a> d3.interpolateCubehelix.<b>gamma</b>(<i>gamma</i>)
+
+Returns a cubehelix interpolator factory with the specified <i>gamma</i> correction value. For example, to create the default cubehelix color scheme with a gamma correction value of 1.2:
+
+```js
+var cubehelix = d3.interpolateCubehelix.gamma(1.2)("hsl(300,50%,0%)", "hsl(-240,50%,100%)");
+```
+
+<a href="#cubehelix" name="cubehelix">#</a> d3.scale.<b>cubehelix</b>
+
+Constructs a new [linear scale](https://github.com/mbostock/d3/wiki/Quantitative-Scales) with the interpolator [d3.interpolateCubehelix](#interpolateCubehelix), the domain [0, 1] and the range [hsl(300°, 50%, 0%), hsl(-240°, 50%, 100%)]. This is merely a convenience function.

data/vendor/assets/javascripts/d3/plugins/cubehelix/cubehelix.js

@@ -0,0 +1,46 @@
+(function() {
+  var radians = Math.PI / 180;
+
+  d3.scale.cubehelix = function() {
+    return d3.scale.linear()
+        .range([d3.hsl(300, .5, 0), d3.hsl(-240, .5, 1)])
+        .interpolate(d3.interpolateCubehelix);
+  };
+
+  d3.interpolateCubehelix = d3_interpolateCubehelix(1);
+  d3.interpolateCubehelix.gamma = d3_interpolateCubehelix;
+
+  function d3_interpolateCubehelix(γ) {
+    return function(a, b) {
+      a = d3.hsl(a);
+      b = d3.hsl(b);
+
+      var ah = (a.h + 120) * radians,
+          bh = (b.h + 120) * radians - ah,
+          as = a.s,
+          bs = b.s - as,
+          al = a.l,
+          bl = b.l - al;
+
+      if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as;
+      if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah;
+
+      return function(t) {
+        var h = ah + bh * t,
+            l = Math.pow(al + bl * t, γ),
+            a = (as + bs * t) * l * (1 - l),
+            cosh = Math.cos(h),
+            sinh = Math.sin(h);
+        return "#"
+            + hex(l + a * (-0.14861 * cosh + 1.78277 * sinh))
+            + hex(l + a * (-0.29227 * cosh - 0.90649 * sinh))
+            + hex(l + a * (+1.97294 * cosh));
+      };
+    };
+  }
+
+  function hex(v) {
+    var s = (v = v <= 0 ? 0 : v >= 1 ? 255 : v * 255 | 0).toString(16);
+    return v < 0x10 ? "0" + s : s;
+  }
+})();

data/vendor/assets/javascripts/d3/plugins/fisheye/fisheye.js

@@ -14,7 +14,7 @@
         var dx = d.x - focus[0],
             dy = d.y - focus[1],
             dd = Math.sqrt(dx * dx + dy * dy);
-        if (!dd || dd >= radius) return {x: d.x, y: d.y, z: 1};
+        if (!dd || dd >= radius) return {x: d.x, y: d.y, z: dd >= radius ? 1 : 10};
         var k = k0 * (1 - Math.exp(-dd * k1)) / dd * .75 + .25;
         return {x: focus[0] + dx * k, y: focus[1] + dy * k, z: Math.min(k, 10)};
       }

data/vendor/assets/javascripts/d3/plugins/geo/tile/README.md

@@ -3,5 +3,6 @@
 * Panning & Zooming: <http://bl.ocks.org/mbostock/4132797>
 * Clipping: <http://bl.ocks.org/mbostock/4150951>
 * Vector Tiles: <http://bl.ocks.org/mbostock/5593150>
+* Raster Tiles & Vector Overlay: <http://bl.ocks.org/mbostock/5342063>
 
 A layout for determining which 256x256 quadtree tiles to display in a rectangular viewport, based on a scale and translate. This layout can be used to create a simple slippy map, or render standard map tiles (e.g., MapBox, CloudMade) as a base layer behind a geographic projection.

data/vendor/assets/javascripts/d3/plugins/geodesic/geodesic.js

@@ -27,7 +27,6 @@
           face = face.map(project);
           face.push(face[0]);
           face = [face];
-          if (d3.geo.area({type: "Polygon", coordinates: face}) > Math.PI) face[0].reverse();
           return face;
         })
       };
@@ -72,8 +71,8 @@
         for (var j = 0; j < i; ++j) {
           faces.push([
             i1(j / i),
-            i1((j + 1) / i),
-            i2((j + 1) / (i + 1))
+            i2((j + 1) / (i + 1)),
+            i1((j + 1) / i)
           ]);
         }
       }

data/vendor/assets/javascripts/d3/plugins/hexbin/README.md

@@ -48,11 +48,15 @@ Alternatively, use a transform attribute:
 
 ```js
 path.attr("transform", function(d) { return "translate(" + d.x + "," + d.y + ")"; })
-    .attr("d", hexbin.hexagon);
+    .attr("d", hexbin.hexagon());
 ```
 
 If *radius* is not specified, the hexbin’s current radius is used. If *radius* is specified, a hexagon with the specified radius is returned, which is useful for area-encoded bivariate hexbins.
 
+<a href="centers" href="#centers">#</a> hexbin.<b>centers</b>()
+
+Returns an array of [*x*, *y*] points representing the centers of each hexagon. Each point also has properties *i* and *j* representing the grid column and row, respectively, of the hexagon.
+
 <a href="mesh" href="#mesh">#</a> hexbin.<b>mesh</b>()
 
 Returns the SVG path string for a hexagonal mesh that covers the area of the layout (as determined by the layout size). The returned mesh is designed to be stroked. The mesh may extend slightly beyond the layout’s defined area, and thus may need to be clipped.

data/vendor/assets/javascripts/d3/plugins/horizon/horizon.js

@@ -2,12 +2,12 @@
   d3.horizon = function() {
     var bands = 1, // between 1 and 5, typically
         mode = "offset", // or mirror
-        interpolate = "linear", // or basis, monotone, step-before, etc.
+        area = d3.svg.area(),
+        defined,
         x = d3_horizonX,
         y = d3_horizonY,
-        w = 960,
-        h = 40,
-        duration = 0;
+        width = 960,
+        height = 40;
 
     var color = d3.scale.linear()
         .domain([-1, 0, 1])
@@ -37,9 +37,9 @@
         });
 
         // Compute the new x- and y-scales, and transform.
-        var x1 = d3.scale.linear().domain([xMin, xMax]).range([0, w]),
-            y1 = d3.scale.linear().domain([0, yMax]).range([0, h * bands]),
-            t1 = d3_horizonTransform(bands, h, mode);
+        var x1 = d3.scale.linear().domain([xMin, xMax]).range([0, width]),
+            y1 = d3.scale.linear().domain([0, yMax]).range([0, height * bands]),
+            t1 = d3_horizonTransform(bands, height, mode);
 
         // Retrieve the old scales, if this is an update.
         if (this.__chart__) {
@@ -62,13 +62,12 @@
         defs.enter().append("defs").append("clipPath")
             .attr("id", "d3_horizon_clip" + id)
           .append("rect")
-            .attr("width", w)
-            .attr("height", h);
+            .attr("width", width)
+            .attr("height", height);
 
-        defs.select("rect").transition()
-            .duration(duration)
-            .attr("width", w)
-            .attr("height", h);
+        d3.transition(defs.select("rect"))
+            .attr("width", width)
+            .attr("height", height);
 
         // We'll use a container to clip all horizon layers at once.
         g.selectAll("g")
@@ -80,16 +79,17 @@
         var path = g.select("g").selectAll("path")
             .data(d3.range(-1, -bands - 1, -1).concat(d3.range(1, bands + 1)), Number);
 
-        var d0 = d3_horizonArea
-            .interpolate(interpolate)
+        if (defined) area.defined(function(_, i) { return defined.call(this, d[i], i); });
+
+        var d0 = area
             .x(function(d) { return x0(d[0]); })
-            .y0(h * bands)
-            .y1(function(d) { return h * bands - y0(d[1]); })
+            .y0(height * bands)
+            .y1(function(d) { return height * bands - y0(d[1]); })
             (data);
 
-        var d1 = d3_horizonArea
+        var d1 = area
             .x(function(d) { return x1(d[0]); })
-            .y1(function(d) { return h * bands - y1(d[1]); })
+            .y1(function(d) { return height * bands - y1(d[1]); })
             (data);
 
         path.enter().append("path")
@@ -97,14 +97,12 @@
             .attr("transform", t0)
             .attr("d", d0);
 
-        path.transition()
-            .duration(duration)
+        d3.transition(path)
             .style("fill", color)
             .attr("transform", t1)
             .attr("d", d1);
 
-        path.exit().transition()
-            .duration(duration)
+        d3.transition(path.exit())
             .attr("transform", t1)
             .attr("d", d1)
             .remove();
@@ -112,77 +110,64 @@
         // Stash the new scales.
         this.__chart__ = {x: x1, y: y1, t: t1, id: id};
       });
-      d3.timer.flush();
     }
 
-    horizon.duration = function(x) {
-      if (!arguments.length) return duration;
-      duration = +x;
-      return horizon;
-    };
-
-    horizon.bands = function(x) {
+    horizon.bands = function(_) {
       if (!arguments.length) return bands;
-      bands = +x;
+      bands = +_;
       color.domain([-bands, 0, bands]);
       return horizon;
     };
 
-    horizon.mode = function(x) {
+    horizon.mode = function(_) {
       if (!arguments.length) return mode;
-      mode = x + "";
+      mode = _ + "";
       return horizon;
     };
 
-    horizon.colors = function(x) {
+    horizon.colors = function(_) {
       if (!arguments.length) return color.range();
-      color.range(x);
+      color.range(_);
       return horizon;
     };
 
-    horizon.interpolate = function(x) {
-      if (!arguments.length) return interpolate;
-      interpolate = x + "";
+    horizon.x = function(_) {
+      if (!arguments.length) return x;
+      x = _;
       return horizon;
     };
 
-    horizon.x = function(z) {
-      if (!arguments.length) return x;
-      x = z;
+    horizon.y = function(_) {
+      if (!arguments.length) return y;
+      y = _;
       return horizon;
     };
 
-    horizon.y = function(z) {
-      if (!arguments.length) return y;
-      y = z;
+    horizon.width = function(_) {
+      if (!arguments.length) return width;
+      width = +_;
       return horizon;
     };
 
-    horizon.width = function(x) {
-      if (!arguments.length) return w;
-      w = +x;
+    horizon.height = function(_) {
+      if (!arguments.length) return height;
+      height = +_;
       return horizon;
     };
 
-    horizon.height = function(x) {
-      if (!arguments.length) return h;
-      h = +x;
+    horizon.defined = function(_) {
+      if (!arguments.length) return defined;
+      defined = _;
       return horizon;
     };
 
-    return horizon;
+    return d3.rebind(horizon, area, "interpolate", "tension");
   };
 
-  var d3_horizonArea = d3.svg.area(),
-      d3_horizonId = 0;
+  var d3_horizonId = 0;
 
-  function d3_horizonX(d) {
-    return d[0];
-  }
-
-  function d3_horizonY(d) {
-    return d[1];
-  }
+  function d3_horizonX(d) { return d[0]; }
+  function d3_horizonY(d) { return d[1]; }
 
   function d3_horizonTransform(bands, h, mode) {
     return mode == "offset"

data/vendor/assets/javascripts/d3/plugins/lasso/README.md

@@ -0,0 +1,88 @@
+lasso
+=========
+
+lasso.js is a D3 plugin that allows you to tag elements on a page by drawing a line over or around objects. Functions can be run based on the lasso action. This functionality can be useful for brushing or filtering.
+
+An example of the lasso implemented in a scatterplot can be found here: [http://bl.ocks.org/skokenes/511c5b658c405ad68941](http://bl.ocks.org/skokenes/511c5b658c405ad68941)
+
+This example is based off of Mike Bostock's scatterplot example here: [http://bl.ocks.org/mbostock/3887118](http://bl.ocks.org/mbostock/3887118)
+
+Lassoing tags
+--
+When the lasso is used, it tags elements by adding properties to their data. The properties are:
+
+- possible: while drawing a lasso, if an element is part of the final selection that would be made if the lasso was completed at that instance, this value is true. Otherwise, it is false.
+- selected: when a lasso is completed, all elements that were tagged as possible are given a selected value of true. Otherwise, the value is false.
+
+The tags can be used in combination with functions to perform actions like styling the possible or selected values while the lasso is in use.
+
+Note that the lasso only works with elements whose data is defined as an object.
+
+
+Function Overview
+--
+**d3.lasso**()
+
+Creates a new lasso object. This object can then have parameters set before the lasso is drawn.
+```
+var lasso = d3.lasso(); // creates a new lasso
+```
+
+lasso.**items**(_[selection]_)
+
+The items() parameter takes in a d3 selection. Each element in the selection will be tagged with lasso-specific properties when the lasso is used. If no input is specified, the function returns the lasso's current items.
+```
+lasso.items(d3.selectAll("circle")); // sets all circles on the page to be lasso-able
+```
+
+lasso.**hoverSelect**(_[bool]_)
+
+The hoverSelect() parameter takes in a boolean that determines whether objects can be lassoed by hovering over an element during lassoing. The default value is set to true. If no input is specified, the function returns the lasso's current hover parameter.
+```
+lasso.hoverSelect(true); // allows hovering of elements for selection during lassoing
+```
+
+lasso.**closePathSelect**(_[bool]_)
+
+The closePathSelect() parameter takes in a boolean that determines whether objects can be lassoed by drawing a loop around them. The default value is set to true. If no input is specified, the function returns the lasso's current parameter.
+```
+lasso.closePathSelect(true); // allows looping of elements for selection during lassoing
+```
+
+lasso.**closePathDistance**(_[num]_)
+
+The closePathDistance() parameter takes in a number that specifies the maximum distance in pixels from the lasso origin that a lasso needs to be drawn in order to complete the loop and select elements. This parameter only works if closePathSelect is set to true; If no input is specified, the function returns the lasso's current parameter.
+```
+lasso.closePathDistance(75); // the lasso loop will complete itself whenever the lasso end is within 75 pixels of the origin
+```
+
+lasso.**area**(_[sel]_)
+
+The area() parameter takes in a selection representing the element to be used as a target area for the lasso event. If no input is specified, the function returns the current area selection.
+```
+lasso.area(d3.select("#myLassoRect")); // the lasso will be trigger whenever a user clicks and drags on #myLassoRect
+```
+
+lasso.**on**(_type,[func]_)
+
+The on() parameter takes in a type of event and a function for that event. There are 3 types of events that can be defined:
+- start: this function will be executed whenever a lasso is started
+- draw: this function will execute repeatedly as the lasso is drawn
+- end: this function will be executed whenever a lasso is completed
+
+If no function is specified, the function will return the current function defined for the type specified.
+```
+lasso.on("start",function() { alert("lasso started!"); }); // every time a lasso is started, an alert will trigger
+```
+
+Initiating a lasso
+--
+Once a lasso object is defined, it can be added to a page by calling it on an element like an svg.
+```
+var lasso = d3.lasso()
+                .items(d3.selectAll("circle")) // Create a lasso and provide it some target elements
+                .area(de.select("#myLassoRect")); // Sets the drag area for the lasso on the rectangle #myLassoRect
+d3.select("svg").call(lasso); // Initiate the lasso on an svg element
+```
+
+If a lasso is going to be used on graphical elements that have been translated via a g element acting as a container, which is a common practice for incorporating chart margins, then the lasso should be called on that g element so that it is in the same coordinate system as the graphical elements.

data/vendor/assets/javascripts/d3/plugins/lasso/lasso.js

@@ -0,0 +1,299 @@
+d3.lasso = function() {
+
+	var	items = null,
+		closePathDistance = 75,
+		closePathSelect = true,
+		isPathClosed = false,
+		hoverSelect = true,
+		area = null,
+		on = {start:function(){}, draw: function(){}, end: function(){}};
+
+	function lasso() {
+		var _this = d3.select(this[0][0]);
+		var g = _this.append("g")
+					.attr("class","lasso");
+		var dyn_path = g.append("path")
+			.attr("class","drawn");
+		var close_path = g.append("path")
+			.attr("class","loop_close");
+		var complete_path = g.append("path")
+			.attr("display","none");
+		var origin_node = g.append("circle")
+			.attr("class","origin");
+		var path;
+		var origin;
+		var last_known_point;
+		var path_length_start;
+		var drag = d3.behavior.drag()
+			.on("dragstart",dragstart)
+			.on("drag",dragmove)
+			.on("dragend",dragend);
+		area.call(drag);
+
+		function dragstart() {
+			// Reset blank lasso path
+			path="";
+			dyn_path.attr("d",null);
+			close_path.attr("d",null);
+			// Set path length start
+			path_length_start = 0;
+			// Set every item to have a false selection and reset their center point and counters
+			items[0].forEach(function(d) {
+				d.hoverSelected = false;
+				d.loopSelected = false;
+				var cur_box = d.getBBox();
+			  	d.lassoPoint = {
+			  		cx: Math.round(cur_box.x + cur_box.width/2),
+					cy: Math.round(cur_box.y + cur_box.height/2),
+					edges: {top:0,right:0,bottom:0,left:0},
+					close_edges: {left: 0, right: 0}
+			  	};
+			});
+
+			// if hover is on, add hover function
+			if(hoverSelect==true) {
+				items.on("mouseover.lasso",function() {
+					// if hovered, change lasso selection attribute to true
+					d3.select(this)[0][0].hoverSelected = true;
+				})
+			}
+
+			// Run user defined start function
+			on.start();
+		}
+
+		function dragmove() {
+			var x = d3.mouse(this)[0]; 
+			var y = d3.mouse(this)[1]; 
+			// Initialize the path or add the latest point to it
+			if (path=="") {
+				path = path + "M " + x + " " + y;
+				origin = [x,y];
+				// Draw origin node
+				origin_node
+					.attr("cx",x)
+					.attr("cy",y)
+					.attr("r",7)
+					.attr("display",null);
+			}
+			else {
+				path = path + " L " + x + " " + y;
+			}
+
+			// Reset closed edges counter
+			items[0].forEach(function(d) {
+				d.lassoPoint.close_edges = {left:0,right:0};
+			});
+
+			// Calculate the current distance from the lasso origin
+			var distance = Math.sqrt(Math.pow(x-origin[0],2)+Math.pow(y-origin[1],2));
+
+			// Set the closed path line
+			var close_draw_path = "M " + x + " " + y + " L " + origin[0] + " " + origin[1];
+
+			// Draw the lines
+			dyn_path.attr("d",path);
+
+
+			// If within the closed path distance parameter, show the closed path. otherwise, hide it
+			if(distance<=closePathDistance) {
+				close_path.attr("display",null);
+			}
+			else {
+			  	close_path.attr("display","none");
+			}
+
+			isPathClosed = distance<=closePathDistance;
+
+	  		// create complete path
+	  		var complete_path_d = d3.select("path")[0][0].attributes.d.value + "Z";
+	  		complete_path.attr("d",complete_path_d);
+
+			// get path length
+			var path_node = dyn_path.node();
+		  	var path_length_end = path_node.getTotalLength();
+		  	var last_pos = path_node.getPointAtLength(path_length_start-1);
+		  
+		  	for (var i = path_length_start; i<=path_length_end; i++) {
+		  		var cur_pos = path_node.getPointAtLength(i);
+		  		var cur_pos_obj = {
+			  		x:Math.round(cur_pos.x*100)/100,
+			  		y:Math.round(cur_pos.y*100)/100
+			  	};
+			  	var prior_pos = path_node.getPointAtLength(i-1);
+			  	var prior_pos_obj = {
+			  		x:Math.round(prior_pos.x*100)/100,
+			  		y:Math.round(prior_pos.y*100)/100
+			  	};
+
+		  		items[0].filter(function(d) {
+		  			var a; 
+		  			if(d.lassoPoint.cy === cur_pos_obj.y && d.lassoPoint.cy != prior_pos_obj.y) { 
+	  					last_known_point = {
+	  						x: prior_pos_obj.x,
+	  						y: prior_pos_obj.y
+	  					};
+	  					a=false; 
+	  				} 
+		  			else if (d.lassoPoint.cy === cur_pos_obj.y && d.lassoPoint.cy === prior_pos_obj.y) {
+	  					a = false;
+	  				} 
+		  			else if (d.lassoPoint.cy === prior_pos_obj.y && d.lassoPoint.cy != cur_pos_obj.y) {
+		  				a = sign(d.lassoPoint.cy-cur_pos_obj.y)!=sign(d.lassoPoint.cy-last_known_point.y);
+		  			}
+		  			else {
+		  				last_known_point = {
+	  						x: prior_pos_obj.x,
+	  						y: prior_pos_obj.y
+	  					};
+		  				a = sign(d.lassoPoint.cy-cur_pos_obj.y)!=sign(d.lassoPoint.cy-prior_pos_obj.y);
+		  			} 
+		  			return a;
+		  		}).forEach(function(d) {
+		  			if(cur_pos_obj.x>d.lassoPoint.cx) {
+			  			d.lassoPoint.edges.right = d.lassoPoint.edges.right+1;
+			  		}
+			  		if(cur_pos_obj.x<d.lassoPoint.cx) {
+			  			d.lassoPoint.edges.left = d.lassoPoint.edges.left+1;
+			  		}
+		  		});
+		  	}
+
+
+			 if(isPathClosed == true && closePathSelect == true) {
+			 	close_path.attr("d",close_draw_path);
+			  	close_path_node =close_path.node();
+			  	var close_path_length = close_path_node.getTotalLength();
+			  	var close_path_edges = {left:0,right:0};
+			  	for (var i = 0; i<=close_path_length; i++) {
+			  		var cur_pos = close_path_node.getPointAtLength(i);
+			  		var prior_pos = close_path_node.getPointAtLength(i-1);
+
+			  		items[0].filter(function(d) {return d.lassoPoint.cy==Math.round(cur_pos.y)}).forEach(function(d) {
+				  		if(Math.round(cur_pos.y)!=Math.round(prior_pos.y) && Math.round(cur_pos.x)>d.lassoPoint.cx) {
+				  			d.lassoPoint.close_edges.right = 1;
+				  		}
+				  		if(Math.round(cur_pos.y)!=Math.round(prior_pos.y) && Math.round(cur_pos.x)<d.lassoPoint.cx) {
+				  			d.lassoPoint.close_edges.left = 1;
+				  		}
+				  	});
+
+			  	}
+
+			  	items[0].forEach(function(a) {
+	  				if((a.lassoPoint.edges.left+a.lassoPoint.close_edges.left)>0 && (a.lassoPoint.edges.right + a.lassoPoint.close_edges.right)%2 ==1) {
+	  					a.loopSelected = true;
+	  				}
+	  				else {
+	  					a.loopSelected = false;
+	  				}
+	  			});
+			}
+			else {
+				items[0].forEach(function(d) {
+					d.loopSelected = false;
+				})
+			}
+			
+			// Tag possible items
+			d3.selectAll(items[0].filter(function(d) {return (d.loopSelected && isPathClosed) || d.hoverSelected}))
+				.attr("d",function(d) {return d.possible = true;});
+
+			d3.selectAll(items[0].filter(function(d) {return !((d.loopSelected && isPathClosed) || d.hoverSelected)}))
+				.attr("d",function(d) {return d.possible = false;});
+
+			on.draw();
+
+			// Continue drawing path from where it left off
+			path_length_start = path_length_end+1;
+		}
+
+		function dragend() {
+			// Remove mouseover tagging function
+			items.on("mouseover.lasso",null);
+
+			// Tag selected items
+			items.filter(function(d) {return d.possible === true})
+				.attr("d",function(d) {return d.selected = true;});
+
+			items.filter(function(d) {return d.possible === false})
+				.attr("d",function(d) {return d.selected = false;});
+
+			// Reset possible items
+			items.attr("d",function(d) {return d.possible = false});
+
+			// Clear lasso
+			dyn_path.attr("d",null);
+			close_path.attr("d",null);
+			origin_node.attr("display","none");
+
+			// Run user defined end function
+			on.end();
+	  		
+		}
+	}
+
+	lasso.items  = function(_) {
+
+		if (!arguments.length) return items;
+    	items = _;
+    	items[0].forEach(function(d) {
+    		var item = d3.select(d);
+    		if(typeof item.datum() === 'undefined') {
+    			item.datum({possible:false,selected:false});
+    		}
+    		else {
+    			item.attr("d",function(e) {e.possible = false; e.selected = false; return e;});
+    		}
+    	});
+    	return lasso;
+	};
+
+	lasso.closePathDistance  = function(_) {
+		if (!arguments.length) return closePathDistance;
+    	closePathDistance = _;
+    	return lasso;
+	};
+
+	lasso.closePathSelect = function(_) {
+		if (!arguments.length) return closePathSelect;
+    	closePathSelect = _==true;
+    	return lasso;
+	};
+
+	lasso.isPathClosed = function(_) {
+		if (!arguments.length) return isPathClosed;
+    	isPathClosed = _==true;
+    	return lasso;
+	};
+
+	lasso.hoverSelect = function(_) {
+		if (!arguments.length) return hoverSelect;
+    	hoverSelect = _==true;
+    	return lasso;
+	};
+
+	lasso.on = function(type,_) {
+		if(!arguments.length) return on;
+		if(arguments.length===1) return on[type];
+		var types = ["start","draw","end"];
+		if(types.indexOf(type)>-1) {
+			on[type] = _;
+		}
+		return lasso;
+	};
+
+	lasso.area = function(_) {
+		if(!arguments.length) return area;
+		area=_;
+		return lasso;
+	};
+
+	function sign(x) {
+		return x?x<0?-1:1:0;
+	}
+
+
+	return lasso;
+
+};

data/vendor/assets/javascripts/d3/plugins/longscroll/longscroll.js

@@ -47,27 +47,19 @@ d3.longscroll = function() {
   }
 
   longscroll.render = function(_) {
-    if (!arguments.length) return render;
-    render = _;
-    return longscroll;
+    return arguments.length ? (render = _, longscroll) : render;
   };
 
   longscroll.rowHeight = function(_) {
-    if (!arguments.length) return rowHeight;
-    rowHeight = +_;
-    return longscroll;
+    return arguments.length ? (rowHeight = +_, longscroll) : rowHeight;
   };
 
   longscroll.position = function(_) {
-    if (!arguments.length) return position;
-    position = +_;
-    return longscroll;
+    return arguments.length ? (position = +_, longscroll) : position;
   };
 
   longscroll.size = function(_) {
-    if (!arguments.length) return size;
-    size = +_;
-    return longscroll;
+    return arguments.length ? (size = +_, longscroll) : size;
   };
 
   return longscroll;

data/vendor/assets/javascripts/d3/plugins/sankey/sankey.js

@@ -118,7 +118,9 @@ d3.sankey = function() {
         node.x = x;
         node.dx = nodeWidth;
         node.sourceLinks.forEach(function(link) {
-          nextNodes.push(link.target);
+          if (nextNodes.indexOf(link.target) < 0) {
+            nextNodes.push(link.target);
+          }
         });
       });
       remainingNodes = nextNodes;

metadata

@@ -1,35 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: d3js-plugins-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.15
 platform: ruby
 authors:
 - Vlad Gorodetsky
 autorequire: 
 bindir: bin
-cert_chain:
-- |
-  -----BEGIN CERTIFICATE-----
-  MIIDSDCCAjCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA1MQowCAYDVQQDDAF2MRMw
-  EQYKCZImiZPyLGQBGRYDZ29yMRIwEAYKCZImiZPyLGQBGRYCaW8wHhcNMTMwNTIz
-  MjA0MTI3WhcNMTQwNTIzMjA0MTI3WjA1MQowCAYDVQQDDAF2MRMwEQYKCZImiZPy
-  LGQBGRYDZ29yMRIwEAYKCZImiZPyLGQBGRYCaW8wggEiMA0GCSqGSIb3DQEBAQUA
-  A4IBDwAwggEKAoIBAQCtb8+GfjqcYl6M4IhIGomKsGgWEC4mwTXIq/Yl+jJAdP7s
-  bdV3lWnZybUPKtdHSQIJcxbm8GZspTqSqDgsECI/laTyLj7Srqcbyivf/ov50Tg1
-  CxMtt8STA6wNmY0ljO4SK72Pr8uQwFZIgNHBB9LcvrpmRn/TWDXlcqaq0db6QJKk
-  jGOv74ukiQun+saqthpxwNN6wm0rj1GDulrDuMeeMj/XDgu0piNHhBtsgQ6KrN94
-  cs0XGgwKihL0LdqWiOG9L8tZKeksKk72EcTpvaw1EYUfJ/rAcC8l6SluN2+BDMA0
-  /4LU70O+wTwHcHv2HimtKdlcpS936qOez3lXUD+3AgMBAAGjYzBhMAkGA1UdEwQC
-  MAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSRvHatldjBIKT5agA2bnkfm4KUxTAT
-  BgNVHREEDDAKgQh2QGdvci5pbzATBgNVHRIEDDAKgQh2QGdvci5pbzANBgkqhkiG
-  9w0BAQUFAAOCAQEAmyGZCL6ISHS6UCkPAie1LZgyc+yS4ckMPtzBJtjODr5kfRTC
-  tLb9W4epJ9Aa2aGkKy/NL8MFS0BwTJmjSfufFDwFZlw0kI9aAvL4Nx9OHWNen9Dm
-  GtEWXXKpB0du12DBjfavJYl0QLcz18M0mtvug634t40H06GussO83uu7wHEvIPBP
-  Z5VMAbKvOmDgaP2I9XxZ2/lDmBKDZkVNqmqYiScw2CWsKxVPx3vhMGprTIz4O8y/
-  JCf887eMZl/8mEIeCLb+gH5sh5yJJpti2HTLnR4Q1QKWR/0T9tASoQPF3kL62n9+
-  m1B90+fEzJsBDQIAsnLPqxjivWbIIfZ7GeGZyA==
-  -----END CERTIFICATE-----
-date: 2014-03-10 00:00:00.000000000 Z
+cert_chain: []
+date: 2015-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -63,7 +42,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- certs/bai.pem
 - d3js-plugins-rails.gemspec
 - lib/d3js-plugins-rails.rb
 - lib/d3js-plugins-rails/version.rb
@@ -74,6 +52,8 @@ files:
 - vendor/assets/javascripts/d3/plugins/bullet/bullet.js
 - vendor/assets/javascripts/d3/plugins/chernoff/README.md
 - vendor/assets/javascripts/d3/plugins/chernoff/chernoff.js
+- vendor/assets/javascripts/d3/plugins/cubehelix/README.md
+- vendor/assets/javascripts/d3/plugins/cubehelix/cubehelix.js
 - vendor/assets/javascripts/d3/plugins/fisheye/README.md
 - vendor/assets/javascripts/d3/plugins/fisheye/fisheye.js
 - vendor/assets/javascripts/d3/plugins/force_labels/README.md
@@ -106,6 +86,8 @@ files:
 - vendor/assets/javascripts/d3/plugins/jsonp/jsonp.js
 - vendor/assets/javascripts/d3/plugins/keybinding/README.md
 - vendor/assets/javascripts/d3/plugins/keybinding/keybinding.js
+- vendor/assets/javascripts/d3/plugins/lasso/README.md
+- vendor/assets/javascripts/d3/plugins/lasso/lasso.js
 - vendor/assets/javascripts/d3/plugins/longscroll/README.md
 - vendor/assets/javascripts/d3/plugins/longscroll/longscroll.js
 - vendor/assets/javascripts/d3/plugins/qq/README.md
@@ -138,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Gemified d3js-plugins asset for Rails

data/certs/bai.pem

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDSDCCAjCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA1MQowCAYDVQQDDAF2MRMw
-EQYKCZImiZPyLGQBGRYDZ29yMRIwEAYKCZImiZPyLGQBGRYCaW8wHhcNMTMwNTIz
-MjA0MTI3WhcNMTQwNTIzMjA0MTI3WjA1MQowCAYDVQQDDAF2MRMwEQYKCZImiZPy
-LGQBGRYDZ29yMRIwEAYKCZImiZPyLGQBGRYCaW8wggEiMA0GCSqGSIb3DQEBAQUA
-A4IBDwAwggEKAoIBAQCtb8+GfjqcYl6M4IhIGomKsGgWEC4mwTXIq/Yl+jJAdP7s
-bdV3lWnZybUPKtdHSQIJcxbm8GZspTqSqDgsECI/laTyLj7Srqcbyivf/ov50Tg1
-CxMtt8STA6wNmY0ljO4SK72Pr8uQwFZIgNHBB9LcvrpmRn/TWDXlcqaq0db6QJKk
-jGOv74ukiQun+saqthpxwNN6wm0rj1GDulrDuMeeMj/XDgu0piNHhBtsgQ6KrN94
-cs0XGgwKihL0LdqWiOG9L8tZKeksKk72EcTpvaw1EYUfJ/rAcC8l6SluN2+BDMA0
-/4LU70O+wTwHcHv2HimtKdlcpS936qOez3lXUD+3AgMBAAGjYzBhMAkGA1UdEwQC
-MAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSRvHatldjBIKT5agA2bnkfm4KUxTAT
-BgNVHREEDDAKgQh2QGdvci5pbzATBgNVHRIEDDAKgQh2QGdvci5pbzANBgkqhkiG
-9w0BAQUFAAOCAQEAmyGZCL6ISHS6UCkPAie1LZgyc+yS4ckMPtzBJtjODr5kfRTC
-tLb9W4epJ9Aa2aGkKy/NL8MFS0BwTJmjSfufFDwFZlw0kI9aAvL4Nx9OHWNen9Dm
-GtEWXXKpB0du12DBjfavJYl0QLcz18M0mtvug634t40H06GussO83uu7wHEvIPBP
-Z5VMAbKvOmDgaP2I9XxZ2/lDmBKDZkVNqmqYiScw2CWsKxVPx3vhMGprTIz4O8y/
-JCf887eMZl/8mEIeCLb+gH5sh5yJJpti2HTLnR4Q1QKWR/0T9tASoQPF3kL62n9+
-m1B90+fEzJsBDQIAsnLPqxjivWbIIfZ7GeGZyA==
------END CERTIFICATE-----