opal-d3 0.0.20170205

data/spec/point_scale_spec.rb

@@ -0,0 +1,58 @@
+describe "d3 - point scale" do
+  it "d3.scale_point" do
+    expect(D3.scale_point).to be_instance_of(D3::PointScale)
+  end
+
+  let(:d) { ("a".."f").to_a }
+  it "basics" do
+    scale = D3.scale_point.domain(d)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([0, 0.2, 0.4, 0.6, 0.8, 1])
+    expect(scale.bandwidth).to eq(0)
+    expect(scale.step).to eq(0.2)
+    expect(scale.("z")).to eq(nil)
+  end
+
+  it "copy" do
+    scale = D3.scale_point.domain(d)
+    sc = scale.copy.range([10,20])
+    expect(scale.domain).to eq(d)
+    expect(sc.domain).to eq(d)
+    expect(scale.range).to eq([0,1])
+    expect(sc.range).to eq([10,20])
+  end
+
+  it "padding" do
+    scale = D3.scale_point.domain(d).range([0,100])
+    expect(scale.padding).to eq(0)
+
+    scale.padding(0.5)
+    expect(scale.padding).to eq(0.5)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([8.33, 25, 41.67, 58.33, 75, 91.67])
+  end
+
+  it "align" do
+    scale = D3.scale_point.domain(d).range([0,100])
+    scale.padding(0.5)
+
+    expect(scale.align).to eq(0.5)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([8.33, 25, 41.67, 58.33, 75, 91.67])
+
+    scale.align(0)
+    expect(scale.align).to eq(0)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([0, 16.67, 33.33, 50, 66.67, 83.33])
+
+    scale.align(1)
+    expect(scale.align).to eq(1)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([16.67, 33.33, 50, 66.67, 83.33, 100])
+  end
+
+  it "round" do
+    scale = D3.scale_point.domain(d).range([0,100])
+    expect(scale.round).to eq(false)
+    scale.range_round([0,1000]).padding(1)
+    expect(scale.range).to eq([0,1000])
+    expect(scale.round).to eq(true)
+    # This rounding is somewhat weird
+    expect(d.map{|v| scale.(v)}).to eq([145, 287, 429, 571, 713, 855])
+  end
+end

data/spec/polygon_spec.rb

@@ -0,0 +1,51 @@
+describe "d3 - polygon" do
+  let(:square) {
+    [[10,10], [40,10], [40,40], [10,40]]
+  }
+  let(:triangle) {
+    [[100,0], [160,0], [130, 40]]
+  }
+  let(:random_points) {[
+    [6, 39], [59, 86], [96, 20], [56, 5], [96, 98],
+    [70, 4], [47, 48], [77, 15], [2, 60], [41, 28],
+    [56, 59], [10, 15], [79, 12], [82, 97], [71, 14],
+    [18, 30], [64, 86], [35, 83], [49, 73], [78, 12],
+  ]}
+
+  # signed area
+  it "d3.polygon_area" do
+    expect(D3.polygon_area(square)).to eq(-900)
+    expect(D3.polygon_area(triangle)).to eq(-1200)
+  end
+
+  it "d3.polygon_centroid" do
+    expect(D3.polygon_centroid(square)).to eq([25, 25])
+    expect(D3.polygon_centroid(triangle)).to eq([130, 13.333333333333334])
+  end
+
+  it "d3.polygon_length" do
+    expect(D3.polygon_length(square)).to eq(120)
+    expect(D3.polygon_length(triangle)).to eq(160)
+  end
+
+  it "d3.polygon_contains?" do
+    expect(D3.polygon_contains?(square, [20, 20])).to eq(true)
+    expect(D3.polygon_contains?(square, [50, 20])).to eq(false)
+    # Sometimes corners considered "inside"
+    expect(D3.polygon_contains?(square, [10, 10])).to eq(true)
+  end
+
+  it "d3.polygon_hull" do
+    hull = D3.polygon_hull(random_points)
+    hull.each do |pt|
+      expect(random_points).to include(pt)
+    end
+
+    random_points.each do |pt|
+      # Sometimes corners not considered "inside"
+      expect(D3.polygon_contains?(hull, pt) || hull.include?(pt)).to eq(true)
+    end
+
+    expect(D3.polygon_hull([[10,10], [20,20]])).to eq(nil)
+  end
+end

data/spec/quadtree_spec.rb

@@ -0,0 +1,128 @@
+describe "d3 - quadtree" do
+  let(:a) { [1,2,"a"] }
+  let(:a2) { [1,2,"a"] }
+  let(:b) { [3,4,"b"] }
+  let(:c) { [5,6,"c"] }
+  let(:d) { [7,8,"c"] }
+  let(:e) { [3,4,"e"] }
+
+  it "d3.quadtree" do
+    expect(D3.quadtree).to be_instance_of(D3::QuadTree)
+  end
+
+  it "quadtree.size" do
+    q = D3.quadtree
+    expect(q.size).to eq(0)
+    expect(q.add(a).size).to eq(1)
+    expect(q.add(b).size).to eq(2)
+  end
+
+  it "quadtree.remove" do
+    q = D3.quadtree
+    expect(q.size).to eq(0)
+    expect(q.add(a).add(b).size).to eq(2)
+    expect(q.remove(a2).size).to eq(2)
+    expect(q.remove(a).size).to eq(1)
+    expect(q.remove(c).size).to eq(1)
+  end
+
+  it "quadtree.remove_all" do
+    q = D3.quadtree([a,b,c])
+    expect(q.remove_all([b,d]).data).to eq([a,c])
+  end
+
+  it "quadtree.data" do
+    q = D3.quadtree
+    expect(q.data).to eq([])
+    expect(q.add(a).data).to eq([a])
+    expect(q.add_all([b,c]).data).to eq([a,b,c])
+  end
+
+  it "quadtree.find" do
+    q = D3.quadtree
+    expect(q.find(1,1)).to eq(nil)
+    q.add([1,2,"foo"])
+    expect(q.find(3,3)).to eq([1,2,"foo"])
+    expect(q.find(3,3,1)).to eq(nil)
+  end
+
+  it "quadtree.copy" do
+    q1 = D3.quadtree.add(a)
+    q2 = q1.copy.add(b)
+    q1.add(c)
+    expect(q1.data).to eq([a,c])
+    expect(q2.data).to eq([a,b])
+  end
+
+  it "quadtree.visit" do
+    q = D3.quadtree([a,b,c,e])
+    called = []
+    q.visit do |node, x0, y0, x1, y1|
+      called << [x0, y0, x1, y1, node.internal?, node.leaf?, node.data, !!node.next, node.children && node.children.map{|x| !!x}]
+      false
+    end
+    expect(called).to eq([
+      [1, 2, 5, 6, true, false, nil, false, [true, false, false, true]],
+      [1, 2, 3, 4, false, true, [1, 2, "a"], false, nil],
+      [3, 4, 5, 6, true, false, nil, false, [true, false, false, true]],
+      [3, 4, 4, 5, false, true, [3, 4, "e"], true, nil],
+      [4, 5, 5, 6, false, true, [5, 6, "c"], false, nil],
+    ])
+  end
+
+  it "quadtree.visit_after" do
+    q = D3.quadtree([a,b,c,e])
+    called = []
+    q.visit_after do |node, x0, y0, x1, y1|
+      called << [x0, y0, x1, y1, node.internal?, node.leaf?, node.data, !!node.next, node.children && node.children.map{|x| !!x}]
+      false
+    end
+    expect(called).to eq([
+      [1, 2, 3, 4, false, true, [1, 2, "a"], false, nil],
+      [3, 4, 4, 5, false, true, [3, 4, "e"], true, nil],
+      [4, 5, 5, 6, false, true, [5, 6, "c"], false, nil],
+      [3, 4, 5, 6, true, false, nil, false, [true, false, false, true]],
+      [1, 2, 5, 6, true, false, nil, false, [true, false, false, true]],
+    ])
+  end
+
+  it "quadtree.root" do
+    q = D3.quadtree([a,b,c])
+    root = q.root
+    expect(root).to be_instance_of(D3::Quad)
+    expect(root).to be_internal
+  end
+
+  it "quadtree.extent" do
+    q = D3.quadtree([a,b,c])
+    expect(q.extent).to eq([[1, 2], [5, 6]])
+    expect(q.extent([[0,0],[10,1]]).extent([[-1,-1],[1,1]]).extent).to eq([[-3, -10], [13, 6]])
+  end
+
+  it "quadtree.cover" do
+    q = D3.quadtree([a,b,c])
+    expect(q.extent).to eq([[1, 2], [5, 6]])
+    expect(q.cover(0,0).cover(-2,10).extent).to eq([[-11, -2], [5, 14]])
+  end
+
+  it "quadtree.x/y defaults" do
+    q = D3.quadtree([a,b,c])
+    expect(q.x.(c)).to eq(5)
+    expect(q.y.(c)).to eq(6)
+  end
+
+  it "quadtree.x/y constructor" do
+    q = D3.quadtree([a,b,c], proc{|(x,y,n)| x*10}, proc{|(x,y,n)| y*10})
+    expect(q.x.(c)).to eq(50)
+    expect(q.y.(c)).to eq(60)
+    expect(q.extent).to eq([[10, 20], [74, 84]])
+  end
+
+  it "quadtree.x/y" do
+    q = D3.quadtree
+    q.x{|(x,y,n)| y*100}.y{|(x,y,n)| x*100}.add_all([a,b,c])
+    expect(q.x.(c)).to eq(600)
+    expect(q.y.(c)).to eq(500)
+    expect(q.extent).to eq([[200, 100], [712, 612]])
+  end
+end

data/spec/quantile_scale_spec.rb

@@ -0,0 +1,24 @@
+describe "d3 - quantile scale" do
+  it "d3.scale_quantile" do
+    expect(D3.scale_quantile).to be_instance_of(D3::QuantileScale)
+  end
+
+  it "basics" do
+    q = D3.scale_quantile.domain([0,10]).range(("a".."f").to_a)
+    expect(q.(4)).to eq("c")
+
+    expect(q.domain).to eq([0,10])
+    expect(q.range).to eq(("a".."f").to_a)
+    expect(q.quantiles).to eq([1.6666666666666665, 3.333333333333333, 5, 6.666666666666666, 8.333333333333334])
+    expect(q.invert_extent("e")).to eq([6.666666666666666, 8.333333333333334])
+  end
+
+  it "copy" do
+    q = D3.scale_quantile.domain([1,5]).range(["x", "y"])
+    qc = q.copy.domain([0,20])
+    expect(qc.domain).to eq([0,20])
+    expect(qc.range).to eq(["x", "y"])
+    expect(q.domain).to eq([1,5])
+    expect(q.range).to eq(["x", "y"])
+  end
+end

data/spec/quantize_scale_spec.rb

@@ -0,0 +1,40 @@
+describe "d3 - quantize scale" do
+  let(:color) { D3.scale_quantize.domain([0, 1]).range(["brown", "steelblue"]) }
+  let(:width) { D3.scale_quantize.domain([10, 100]).range([1, 2, 4]) }
+
+  it "d3.quantize_scale" do
+    expect(D3.scale_quantize).to be_instance_of(D3::QuantizeScale)
+  end
+
+  it "basics - color" do
+    expect(color.(0.49)).to eq("brown")
+    expect(color.(0.51)).to eq("steelblue")
+    expect(color.domain).to eq([0,1])
+    expect(color.range).to eq(["brown", "steelblue"])
+  end
+
+  it "basics - width" do
+    expect(width.(20)).to eq(1)
+    expect(width.(50)).to eq(2)
+    expect(width.(80)).to eq(4)
+    expect(width.invert_extent(2)).to eq([40, 70])
+  end
+
+  it ".nice / .copy" do
+    s = D3.scale_quantize.domain([7, 109]).range([1, 2, 4])
+    sc = s.copy
+    expect(s.nice().domain).to eq([0, 110])
+    expect(sc.domain).to eq([7, 109])
+  end
+
+  it ".ticks" do
+    expect(width.ticks).to eq([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
+    expect(width.ticks(5)).to eq([20, 40, 60, 80, 100])
+  end
+
+  it ".tick_format" do
+    expect(width.tick_format.(30)).to eq("30")
+    expect(width.tick_format(5).(30)).to eq("30")
+    expect(width.tick_format(5, "+%").(30)).to eq("+3000%")
+  end
+end

data/spec/radial_area_spec.rb

@@ -0,0 +1,127 @@
+describe "d3 - radial area" do
+  it "d3.radial_area" do
+    expect(D3.radial_area).to be_instance_of(D3::RadialAreaGenerator)
+  end
+
+  let(:simple_data) {[
+    {year: 2007, value: 93.24},
+    {year: 2008, value: 95.35},
+    {year: 2009, value: 98.84},
+    {year: 2010, value: 99.92},
+    {year: 2011, value: 99.80},
+    {year: 2014, value: 99.47},
+  ]}
+
+  describe "basics" do
+    let(:radial_area) {
+      D3.radial_area
+          .angle{|d| (d[:year]-2000)/10 }
+          .outer_radius{|d| d[:value] }
+          .inner_radius(50)
+    }
+    it "basics" do
+      expect(radial_area.(simple_data).gsub(/\d+\.\d+/){$&.to_f.round(2)}).to eq(%W[
+        M60.07,-71.31
+        L68.4,-66.43
+        L77.42,-61.44
+        L84.08,-53.99
+        L88.94,-45.27
+        L98.02,-16.91
+        L49.27,-8.5
+        L44.56,-22.68
+        L42.07,-27.02
+        L39.17,-31.08
+        L35.87,-34.84
+        L32.21,-38.24
+        Z
+      ].join)
+    end
+
+    it "curve" do
+      expect(radial_area.curve).to be_instance_of(D3::Curve)
+      expect(radial_area.curve(D3.curve_natural).(simple_data).gsub(/\d+\.\d+/){$&.to_f.round(2)}).to eq(%W[
+        M60.07,-71.31C62.74,-69.61,65.42,-67.91,68.4,-66.43
+        C71.38,-64.95,74.66,-63.68,77.42,-61.44
+        C80.19,-59.2,82.45,-55.98,84.08,-53.99
+        C85.71,-52,86.72,-51.24,88.94,-45.27
+        C91.16,-39.29,94.59,-28.1,98.02,-16.91
+        L49.27,-8.5
+        C47.49,-14.1,45.72,-19.7,44.56,-22.68
+        C43.4,-25.66,42.87,-26.01,42.07,-27.02
+        C41.28,-28.02,40.23,-29.66,39.17,-31.08
+        C38.1,-32.5,37.03,-33.68,35.87,-34.84
+        C34.71,-35.99,33.46,-37.12,32.21,-38.24
+        Z
+      ].join)
+    end
+
+
+    it ".defined" do
+      expect(radial_area.defined{|d| d[:year] != 2010}.(simple_data).gsub(/\d+\.\d+/){$&.to_f.round(2)}).to eq(%W[
+        M60.07,-71.31
+        L68.4,-66.43
+        L77.42,-61.44
+        L39.17,-31.08
+        L35.87,-34.84
+        L32.21,-38.24
+        Z
+        M88.94,-45.27
+        L98.02,-16.91
+        L49.27,-8.5
+        L44.56,-22.68
+        Z
+      ].join)
+    end
+  end
+
+  describe "line generators" do
+    let(:radial_area) {
+      D3.radial_area
+        .start_angle{|d| (d[:year]-2000)/20 }
+        .end_angle{|d| (d[:year]-2000)/10 }
+        .outer_radius{|d| d[:value] }
+        .inner_radius(50)
+    }
+    let(:point) { {year: 2042, value: 117 } }
+
+    it ".angle/.start_angle/.end_angle" do
+      expect(radial_area.start_angle.(point)).to eq(2.1)
+      expect(radial_area.end_angle.(point)).to eq(4.2)
+      expect(radial_area.angle.(point)).to eq(2.1)
+    end
+
+    it ".radius/.inner_radius/.outer_radius" do
+      expect(radial_area.inner_radius.(point)).to eq(50)
+      expect(radial_area.outer_radius.(point)).to eq(117)
+      expect(radial_area.radius.(point)).to eq(50)
+    end
+
+    it ".line_start_angle" do # start_angle inner_radius
+      expect(radial_area.line_start_angle).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_start_angle.angle.(point)).to eq(2.1)
+      expect(radial_area.line_start_angle.radius.(point)).to eq(50)
+    end
+
+    it ".line_end_angle" do # end_angle inner_radius
+      expect(radial_area.line_end_angle).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_end_angle.angle.(point)).to eq(4.2)
+      expect(radial_area.line_end_angle.radius.(point)).to eq(50)
+    end
+
+    it ".line_inner_radius" do # start_angle inner_radius
+      expect(radial_area.line_inner_radius).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_inner_radius.angle.(point)).to eq(2.1)
+      expect(radial_area.line_inner_radius.radius.(point)).to eq(50)
+    end
+
+    it ".line_outer_radius" do # start_angle outer_radius
+      expect(radial_area.line_outer_radius).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_outer_radius.angle.(point)).to eq(2.1)
+      expect(radial_area.line_outer_radius.radius.(point)).to eq(117)
+    end
+  end
+end
+
+__END__
+
+radialArea.context - set the rendering context.

data/spec/radial_line_spec.rb

@@ -0,0 +1,54 @@
+describe "d3 - radial line" do
+  it "d3.radial_line" do
+    expect(D3.radial_line).to be_instance_of(D3::RadialLineGenerator)
+  end
+
+  let(:simple_data) { [[0,2],[Math::PI*0.10,5],[Math::PI*0.20,3]] }
+
+  it "basics" do
+    expect(D3.radial_line.(simple_data)).to eq("M0,-2L1.545084971874737,-4.755282581475767L1.7633557568774194,-2.4270509831248424")
+  end
+
+  it "curve" do
+    expect(D3.radial_line.curve).to be_instance_of(D3::Curve)
+    expect(D3.radial_line.curve(D3.curve_natural).(simple_data)).to eq(%W[
+      M0,-2
+      C0.6255961728642502,-3.3420537088108135,1.2511923457285004,-4.684107417621627,1.545084971874737,-4.755282581475767
+      C1.8389775980209737,-4.826457745329908,1.8011666774491966,-3.626754364227375,1.7633557568774194,-2.4270509831248424
+    ].join)
+  end
+
+  it "angle/radius accessors" do
+    radial_line = D3.radial_line
+    radial_line.angle{|(a,r)| a*2}.radius{|(a,r)| r*100}
+    expect(radial_line.angle.([2,42])).to eq(4)
+    expect(radial_line.radius.([2,42])).to eq(4200)
+    expect(radial_line.(simple_data)).to eq("M0,-200L293.8926261462366,-404.5084971874737L285.31695488854604,-92.70509831248424")
+  end
+
+  it ".angle constant" do
+    radial_line = D3.radial_line.angle(Math::PI)
+    expect(radial_line.(simple_data)).to eq("M2.4492935982947064e-16,2L6.123233995736766e-16,5L3.6739403974420594e-16,3")
+    expect(radial_line.angle.(42)).to eq(Math::PI)
+    radial_line.angle = 20
+    expect(radial_line.angle.(42)).to eq(20)
+  end
+
+  it ".radius constant" do
+    radial_line = D3.radial_line.radius(10)
+    expect(radial_line.(simple_data)).to eq("M0,-10L3.090169943749474,-9.510565162951535L5.877852522924732,-8.090169943749475")
+    expect(radial_line.radius.(42)).to eq(10)
+    radial_line.radius = 20
+    expect(radial_line.radius.(42)).to eq(20)
+  end
+
+  it ".defined" do
+    radial_line = D3.radial_line.defined{|(a,r)| r.even?}
+    data = [[0,6], [0,10], [0,11], [0,14], [0,16], [0,19]]
+    expect(radial_line.(data)).to eq("M0,-6L0,-10M0,-14L0,-16")
+  end
+end
+
+__END__
+
+radialLine.context - set the rendering context.

data/spec/random_spec.rb

@@ -0,0 +1,34 @@
+describe "d3-random" do
+  # Not really testing anything more meaningful,
+  # just that they return some numbers
+  # http://xkcd.com/221/
+  it "d3.random_uniform" do
+    expect(D3.random_uniform.call).to be_a(Numeric)
+    expect(D3.random_uniform(10).call).to be_a(Numeric)
+    expect(D3.random_uniform(10,20).call).to be_a(Numeric)
+  end
+
+  it "d3.random_normal" do
+    expect(D3.random_normal.call).to be_a(Numeric)
+    expect(D3.random_normal(10).call).to be_a(Numeric)
+    expect(D3.random_normal(10, 2).call).to be_a(Numeric)
+  end
+
+  it "d3.random_log_normal" do
+    expect(D3.random_log_normal.call).to be_a(Numeric)
+    expect(D3.random_log_normal(10).call).to be_a(Numeric)
+    expect(D3.random_log_normal(10, 2).call).to be_a(Numeric)
+  end
+
+  it "d3.random_bates" do
+    expect(D3.random_bates(5).call).to be_a(Numeric)
+  end
+
+  it "d3.random_irwin_hall" do
+    expect(D3.random_irwin_hall(5).call).to be_a(Numeric)
+  end
+
+  it "d3.random_exponential" do
+    expect(D3.random_exponential(3).call).to be_a(Numeric)
+  end
+end

data/spec/search_spec.rb

@@ -0,0 +1,69 @@
+describe "d3-array - search" do
+  it "d3.ascending" do
+    expect(D3.ascending(2,1)).to eq(1)
+    expect(D3.ascending(1,1)).to eq(0)
+    expect(D3.ascending(1,2)).to eq(-1)
+  end
+
+  it "d3.descending" do
+    expect(D3.descending(2,1)).to eq(-1)
+    expect(D3.descending(1,1)).to eq(0)
+    expect(D3.descending(1,2)).to eq(1)
+  end
+
+  it "d3.scan" do
+    array = [13,5,11,26,32]
+    expect(D3.scan(array)).to eq(1)
+    expect(D3.scan(array){|a,b| (a%10) - (b%10)}).to eq(2)
+    expect(D3.scan(array){|a,b| (b%10) - (a%10)}).to eq(3)
+  end
+
+  it "d3.bisect_left" do
+    array = (100..200).to_a
+    expect(D3.bisect_left(array, 117)).to eq(17)
+    expect(D3.bisect_left(array, 130.5)).to eq(31)
+  end
+
+  it "d3.bisect_right" do
+    array = (100..200).to_a
+    expect(D3.bisect_right(array, 117)).to eq(18)
+    expect(D3.bisect_right(array, 130.5)).to eq(31)
+  end
+
+  it "d3.bisect" do
+    array = (100..200).to_a
+    expect(D3.bisect(array, 117)).to eq(18)
+    expect(D3.bisect(array, 130.5)).to eq(31)
+  end
+
+  it "d3.bisector" do
+    expect(D3.bisector{|x| x.abs}).to be_instance_of(D3::Bisector)
+    expect(D3.bisector{|x,y| x.abs - y.abs}).to be_instance_of(D3::Bisector)
+  end
+
+  describe "D3::Bisector" do
+    let(:array) { (100..200).map{|i| i * (-1)**i} }
+    let(:a) { D3.bisector{|x| x.abs} }
+    let(:c) { D3.bisector{|x,y| x.abs - y.abs} }
+
+    it "A.left" do
+      expect(a.left(array, 117)).to eq(17)
+      expect(a.left(array, 130.5)).to eq(31)
+    end
+
+    it "C.left" do
+      expect(c.left(array, 117)).to eq(17)
+      expect(c.left(array, 130.5)).to eq(31)
+    end
+
+    it "A.right" do
+      expect(a.right(array, 117)).to eq(18)
+      expect(a.right(array, 130.5)).to eq(31)
+    end
+
+    it "C.right" do
+      expect(c.right(array, 117)).to eq(18)
+      expect(c.right(array, 130.5)).to eq(31)
+    end
+  end
+end

data/spec/selection_data_spec.rb

@@ -0,0 +1,71 @@
+describe "d3 - selection - data" do
+  after(:each) do
+    D3.select("#test-area").html("")
+  end
+  let(:root) { D3.select("#test-area") }
+  let(:html) { root.html }
+
+  describe "list" do
+    let(:data) {[
+      {name: "A", value: 10},
+      {name: "B", value: 20},
+      {name: "C", value: 30},
+    ]}
+    it "enter" do
+      root
+        .append("ul")
+        .select_all("li")
+        .data(data)
+        .enter
+        .append("li")
+        .html{|d| "<b>#{d[:name]}</b>"}
+        .style("font-size"){|d| "#{d[:value]}px"}
+      expect(html).to eq([
+        %Q[<ul>],
+        %Q[<li style="font-size: 10px;"><b>A</b></li>],
+        %Q[<li style="font-size: 20px;"><b>B</b></li>],
+        %Q[<li style="font-size: 30px;"><b>C</b></li>],
+        %Q[</ul>],
+      ].join)
+    end
+  end
+
+  describe "matrix" do
+    let(:data) {
+      [
+        [11975,  5871, 8916, 2868],
+        [ 1951, 10048, 2060, 6171],
+        [ 8010, 16145, 8090, 8045],
+        [ 1013,   990,  940, 6907],
+      ]
+    }
+    it do
+      tr = root
+        .append("table")
+        .select_all("tr")
+        .data(data)
+        .enter
+        .append("tr")
+      tr.select_all("td")
+        .data{|d| d}
+        .enter
+        .append("td")
+        .text{|d| d}
+      expect(html).to eq([
+        %Q[<table>],
+        %Q[<tr><td>11975</td><td>5871</td><td>8916</td><td>2868</td></tr>],
+        %Q[<tr><td>1951</td><td>10048</td><td>2060</td><td>6171</td></tr>],
+        %Q[<tr><td>8010</td><td>16145</td><td>8090</td><td>8045</td></tr>],
+        %Q[<tr><td>1013</td><td>990</td><td>940</td><td>6907</td></tr>],
+        %Q[</table>],
+      ].join)
+    end
+  end
+end
+
+__END__
+
+.data key
+
+selection.exit - get the exit selection (elements missing data).
+selection.datum - get or set element data (without joining).