hyper-d3 1.0.0.lap23

data/spec/misc_spec.rb

@@ -0,0 +1,21 @@
+describe "d3 misc methods" do
+  it "d3.version" do
+    # opal-d3 is highly compatible with various d3 minor updates,
+    # but we're only testing against one bundled here
+    expect(D3.version).to eq("4.12.2")
+  end
+
+  it "d3.namespace" do
+    expect(D3.namespace("svg:text")).to eq({"space"=>"http://www.w3.org/2000/svg", "local"=>"text"})
+  end
+
+  it "d3.namespaces" do
+    expect(D3.namespaces).to eq({
+      "svg"=>"http://www.w3.org/2000/svg",
+      "xhtml"=>"http://www.w3.org/1999/xhtml",
+      "xlink"=>"http://www.w3.org/1999/xlink",
+      "xml"=>"http://www.w3.org/XML/1998/namespace",
+      "xmlns"=>"http://www.w3.org/2000/xmlns/"
+    })
+  end
+end

data/spec/nest_spec.rb

@@ -0,0 +1,89 @@
+describe "d3-collections - nests" do
+  it "d3.nest" do
+    expect(D3.nest).to be_instance_of(D3::Nest)
+  end
+
+  it "zero levels" do
+    data = [61, 35, 24, 37, 9, 20, 42, 55, 58, 57]
+    nest = D3.nest.sort_values(:ascending)
+    expect(nest.entries(data)).to eq(data)
+    expect(nest.map(data)).to eq(data)
+  end
+
+  it "one level" do
+    data = [61, 35, 24, 37, 9, 20, 42, 55, 58, 57]
+    nest = D3.nest.key{|x| (x / 10).floor}.sort_keys(:ascending).sort_values(:descending)
+    expect(nest.map(data).to_h).to eq(
+      {"6"=>[61], "3"=>[37, 35], "2"=>[24, 20], "0"=>[9], "4"=>[42], "5"=>[58, 57, 55]}
+    )
+    expect(nest.entries(data)).to eq([
+      ["0", [9]],
+      ["2", [24, 20]],
+      ["3", [37, 35]],
+      ["4", [42]],
+      ["5", [58, 57, 55]],
+      ["6", [61]],
+    ])
+    o = nest.object(data)
+    expect(`JSON.stringify(#{o})`).to eq(
+      '{"0":[9],"2":[24,20],"3":[37,35],"4":[42],"5":[58,57,55],"6":[61]}'
+    )
+  end
+
+  it "one level and rollup" do
+    data = [61, 35, 24, 37, 9, 20, 42, 55, 58, 57]
+    # rollup and sorting got fixed in 4.10
+    nest = D3.nest.key{|x| (x / 10).floor}.sort_keys(:ascending)
+                  .sort_values(:descending)
+                  .rollup{|*x| x.join(":")}
+    expect(nest.map(data).to_h).to eq(
+      {"6"=>"61", "3"=>"37:35", "2"=>"24:20", "0"=>"9", "4"=>"42", "5"=>"58:57:55"}
+    )
+    expect(nest.entries(data)).to eq([
+      ["0", "9"],
+      ["2", "24:20"],
+      ["3", "37:35"],
+      ["4", "42"],
+      ["5", "58:57:55"],
+      ["6", "61"]
+    ])
+  end
+
+  it "three levels" do
+    data = (1..25).to_a + (80..85).to_a
+    nest = D3.nest.key{|x| "d#{ x % 2}" }.sort_keys(:ascending)
+                  .key{|x| "t#{ x % 3}" }.sort_keys(:descending)
+                  .key{|x| "v#{ x % 5}" }.sort_keys(:ascending)
+                  .sort_values(:descending)
+    expect(nest.entries(data)).to eq([
+      ["d0", [["t2", [["v0", [80, 20]], ["v2", [2]], ["v3", [8]], ["v4", [14]]]],
+              ["t1", [["v0", [10]], ["v1", [16]], ["v2", [82, 22]], ["v4", [4]]]],
+              ["t0", [["v1", [6]], ["v2", [12]], ["v3", [18]], ["v4", [84, 24]]]]]],
+      ["d1", [["t2", [["v0", [5]], ["v1", [11]], ["v2", [17]], ["v3", [83, 23]]]],
+              ["t1", [["v0", [85, 25]], ["v1", [1]], ["v2", [7]], ["v3", [13]], ["v4", [19]]]],
+              ["t0", [["v0", [15]], ["v1", [81, 21]], ["v3", [3]], ["v4", [9]]]]]]
+    ])
+    expect(nest.map(data).inspect).to eq(
+      %Q[#<D3::Map: {"d1"=>#<D3::Map: {"t1"=>#<D3::Map: {"v1"=>[1], "v2"=>[7], "v3"=>[13], "v4"=>[19], "v0"=>[85, 25]}>, "t0"=>#<D3::Map: {"v3"=>[3], "v4"=>[9], "v0"=>[15], "v1"=>[81, 21]}>, "t2"=>#<D3::Map: {"v0"=>[5], "v1"=>[11], "v2"=>[17], "v3"=>[83, 23]}>}>, "d0"=>#<D3::Map: {"t2"=>#<D3::Map: {"v2"=>[2], "v3"=>[8], "v4"=>[14], "v0"=>[80, 20]}>, "t1"=>#<D3::Map: {"v4"=>[4], "v0"=>[10], "v1"=>[16], "v2"=>[82, 22]}>, "t0"=>#<D3::Map: {"v1"=>[6], "v2"=>[12], "v3"=>[18], "v4"=>[84, 24]}>}>}>]
+    )
+  end
+
+  it "three levels and rollup" do
+    data = (1..25).to_a + (80..85).to_a
+    nest = D3.nest.key{|x| "d#{ x % 2}" }.sort_keys(:ascending)
+                  .key{|x| "t#{ x % 3}" }.sort_keys(:descending)
+                  .key{|x| "v#{ x % 5}" }.sort_keys(:ascending)
+                  .rollup{|*x| x.join(":")}
+    expect(nest.entries(data)).to eq([
+      ["d0", [["t2", [["v0", "20:80"], ["v2", "2"], ["v3", "8"], ["v4", "14"]]],
+              ["t1", [["v0", "10"], ["v1", "16"], ["v2", "22:82"], ["v4", "4"]]],
+              ["t0", [["v1", "6"], ["v2", "12"], ["v3", "18"], ["v4", "24:84"]]]]],
+      ["d1", [["t2", [["v0", "5"], ["v1", "11"], ["v2", "17"], ["v3", "23:83"]]],
+              ["t1", [["v0", "25:85"], ["v1", "1"], ["v2", "7"], ["v3", "13"], ["v4", "19"]]],
+              ["t0", [["v0", "15"], ["v1", "21:81"], ["v3", "3"], ["v4", "9"]]]]]
+    ])
+    expect(nest.map(data).inspect).to eq(
+      %Q[#<D3::Map: {"d1"=>#<D3::Map: {"t1"=>#<D3::Map: {"v1"=>"1", "v2"=>"7", "v3"=>"13", "v4"=>"19", "v0"=>"25:85"}>, "t0"=>#<D3::Map: {"v3"=>"3", "v4"=>"9", "v0"=>"15", "v1"=>"21:81"}>, "t2"=>#<D3::Map: {"v0"=>"5", "v1"=>"11", "v2"=>"17", "v3"=>"23:83"}>}>, "d0"=>#<D3::Map: {"t2"=>#<D3::Map: {"v2"=>"2", "v3"=>"8", "v4"=>"14", "v0"=>"20:80"}>, "t1"=>#<D3::Map: {"v4"=>"4", "v0"=>"10", "v1"=>"16", "v2"=>"22:82"}>, "t0"=>#<D3::Map: {"v1"=>"6", "v2"=>"12", "v3"=>"18", "v4"=>"24:84"}>}>}>]
+    )
+  end
+end

data/spec/objects_spec.rb

@@ -0,0 +1,22 @@
+# These operate on JS native objects, and might not be that useful from Opal
+# Not converting these to work on ruby objects, as ruby standard library
+# already has all relevant methods
+describe "d3-collections - objects" do
+  let(:object) { `{a: 1, b: 2, c: 3}` }
+
+  it "d3.keys" do
+    expect(D3.keys(object)).to eq(["a", "b", "c"])
+  end
+
+  it "d3.values" do
+    expect(D3.values(object)).to eq([1, 2, 3])
+  end
+
+  it "d3.entries" do
+    expect(D3.entries(object)).to eq([
+       ["a",1],
+       ["b",2],
+       ["c",3],
+    ])
+  end
+end

data/spec/ordinal_scale_spec.rb

@@ -0,0 +1,59 @@
+describe "d3 ordinal scale" do
+  it "d3.scale_ordinal" do
+    expect(D3.scale_ordinal).to be_instance_of(D3::OrdinalScale)
+  end
+
+  let(:d) { ("a".."z").to_a }
+  let(:r) { D3.scheme_category_10 }
+  let(:colors) { D3.scale_ordinal.domain(d).range(r) }
+
+  it "basics" do
+    expect(colors.domain).to eq(d)
+    expect(colors.range).to eq(r)
+    expect(colors.("c")).to eq("#2ca02c")
+    expect(colors.("z")).to eq("#8c564b")
+    # default implicit
+    expect(colors.("X")).to eq("#e377c2")
+    expect(colors.("Y")).to eq("#7f7f7f")
+    expect(colors.("X")).to eq("#e377c2")
+  end
+
+  it "unknown" do
+    expect(D3.scale_implicit).to eq(:implicit)
+    expect(colors.unknown).to eq(:implicit)
+
+    colors.unknown("#ffffff")
+    expect(colors.unknown).to eq("#ffffff")
+    expect(colors.("c")).to eq("#2ca02c")
+    expect(colors.("C")).to eq("#ffffff")
+
+    colors.unknown(:implicit)
+    expect(colors.unknown).to eq(:implicit)
+    expect(colors.("c")).to eq("#2ca02c")
+    expect(colors.("C")).to eq("#e377c2")
+  end
+
+  it "copy" do
+    cc = colors.copy.domain([1,2,3])
+    expect(colors.domain).to eq(d)
+    expect(cc.domain).to eq([1,2,3])
+    expect(colors.range).to eq(r)
+    expect(cc.range).to eq(r)
+  end
+
+  it "d3.scheme_category_10" do
+    expect(D3.scheme_category_10).to eq(["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"])
+  end
+
+  it "d3.scheme_category_20" do
+    expect(D3.scheme_category_20).to eq(["#1f77b4", "#aec7e8", "#ff7f0e", "#ffbb78", "#2ca02c", "#98df8a", "#d62728", "#ff9896", "#9467bd", "#c5b0d5", "#8c564b", "#c49c94", "#e377c2", "#f7b6d2", "#7f7f7f", "#c7c7c7", "#bcbd22", "#dbdb8d", "#17becf", "#9edae5"])
+  end
+
+  it "d3.scheme_category_20b" do
+    expect(D3.scheme_category_20b).to eq(["#393b79", "#5254a3", "#6b6ecf", "#9c9ede", "#637939", "#8ca252", "#b5cf6b", "#cedb9c", "#8c6d31", "#bd9e39", "#e7ba52", "#e7cb94", "#843c39", "#ad494a", "#d6616b", "#e7969c", "#7b4173", "#a55194", "#ce6dbd", "#de9ed6"])
+  end
+
+  it "d3.scheme_category_20c" do
+    expect(D3.scheme_category_20c).to eq(["#3182bd", "#6baed6", "#9ecae1", "#c6dbef", "#e6550d", "#fd8d3c", "#fdae6b", "#fdd0a2", "#31a354", "#74c476", "#a1d99b", "#c7e9c0", "#756bb1", "#9e9ac8", "#bcbddc", "#dadaeb", "#636363", "#969696", "#bdbdbd", "#d9d9d9"])
+  end
+end

data/spec/path_spec.rb

@@ -0,0 +1,65 @@
+describe "d3 - path" do
+  it "d3.path" do
+    expect(D3.path).to be_instance_of(D3::Path)
+  end
+
+  it "path.move_to" do
+    expect(D3.path.move_to(10,20).to_s).to eq("M10,20")
+    expect(D3.path.move_to(10,20).move_to(30,40).to_s).to eq("M10,20M30,40")
+  end
+
+  it "path.line_to" do
+    expect(D3.path.line_to(30,40).to_s).to eq("L30,40")
+    expect(D3.path.line_to(10,20).line_to(30,40).to_s).to eq("L10,20L30,40")
+  end
+
+  it "path.close_path" do
+    expect(D3.path.line_to(10,20).close_path.to_s).to eq("L10,20Z")
+    expect(D3.path.line_to(10,20).close_path.line_to(30,40).close_path.to_s).to eq("L10,20ZL30,40Z")
+  end
+
+  it "path.rect" do # (x,y,w,h) not (x1,y1,x2,y2)
+    expect(D3.path.rect(10,20,30,40).to_s).to eq("M10,20h30v40h-30Z")
+    expect(D3.path.rect(10,20,30,40).rect(50,60,70,80).to_s).to eq("M10,20h30v40h-30ZM50,60h70v80h-70Z")
+  end
+
+  it "path.quadratic_curve_to" do
+    expect(D3.path.quadratic_curve_to(10,20,30,40).to_s).to eq("Q10,20,30,40")
+    expect(D3.path.quadratic_curve_to(10,20,30,40)
+                  .quadratic_curve_to(50,60,70,80).to_s).to eq("Q10,20,30,40Q50,60,70,80")
+  end
+
+  it "path.bezier_curve_to" do
+    expect(D3.path.bezier_curve_to(10,20,30,40,50,60).to_s).to eq("C10,20,30,40,50,60")
+    expect(D3.path.bezier_curve_to(10,20,30,40,50,60)
+                  .bezier_curve_to(70,80,90,100,110,120).to_s).to eq(
+                  "C10,20,30,40,50,60C70,80,90,100,110,120")
+  end
+
+  it "path.arc" do
+    expect(D3.path.arc(100,100,50,90,225).to_s).to eq(
+      "M77.59631919354149,144.6998331800279"+
+      "A50,50,0,1,1,122.40368080645851,55.300166819972105"+
+      "A50,50,0,1,1,77.59631919354149,144.6998331800279"
+    )
+    expect(D3.path.arc(100,100,50,90,225,false)
+                  .arc(100,100,50,90,225,true).to_s).to eq(
+      "M77.59631919354149,144.6998331800279"+
+      "A50,50,0,1,1,122.40368080645851,55.300166819972105" +
+      "A50,50,0,1,1,77.59631919354149,144.6998331800279" +
+      "A50,50,0,1,0,118.36596838651226,53.495256099773734"
+    )
+  end
+
+  it "path.arc_to" do
+    # To be honest it's not clear to me how that's supposed to work exactly
+    # but we're just doing bindings here
+    expect(D3.path
+             .move_to(10,10)
+             .arc_to(20,20,30,10,10)
+             .to_s).to eq(
+               "M10,10"+
+               "L12.928932188134526,12.928932188134526"+
+               "A10,10,0,0,0,27.071067811865476,12.928932188134526")
+  end
+end

data/spec/pie_spec.rb

@@ -0,0 +1,114 @@
+describe "d3 - pie" do
+  let(:generated) { pie.(data) }
+  let(:rounded) {
+    generated.map{|arc| arc.map{|k,v| [k, v.is_a?(Float) ? v.round(2) : v] }.to_h}
+  }
+  let(:data) { [1, 3, 4] }
+  let(:pie) { D3.pie }
+
+  it "d3.pie" do
+    expect(D3.pie).to be_instance_of(D3::PieGenerator)
+  end
+
+  describe "basics" do
+    it do
+      expect(rounded).to eq([
+        {data: 1, index: 2, value: 1, start_angle: 5.50, end_angle: 6.28, pad_angle: 0},
+        {data: 3, index: 1, value: 3, start_angle: 3.14, end_angle: 5.50, pad_angle: 0},
+        {data: 4, index: 0, value: 4, start_angle: 0.00, end_angle: 3.14, pad_angle: 0},
+      ])
+    end
+  end
+
+  describe "pie.start_angle" do
+    it do
+      expect(pie.start_angle.()).to eq(0)
+      pie.start_angle(2)
+      expect(pie.start_angle.()).to eq(2)
+      expect(rounded).to eq([
+        {data: 1, index: 2, value: 1, start_angle: 5.75, end_angle: 6.28, pad_angle: 0},
+        {data: 3, index: 1, value: 3, start_angle: 4.14, end_angle: 5.75, pad_angle: 0},
+        {data: 4, index: 0, value: 4, start_angle: 2.00, end_angle: 4.14, pad_angle: 0},
+      ])
+    end
+  end
+
+  describe "pie.end_angle" do
+    it do
+      expect(pie.end_angle.()).to eq(2*Math::PI)
+      pie.end_angle(4)
+      expect(pie.end_angle.()).to eq(4)
+      expect(rounded).to eq([
+        {data: 1, index: 2, value: 1, start_angle: 3.50, end_angle: 4.00, pad_angle: 0},
+        {data: 3, index: 1, value: 3, start_angle: 2.00, end_angle: 3.50, pad_angle: 0},
+        {data: 4, index: 0, value: 4, start_angle: 0.00, end_angle: 2.00, pad_angle: 0},
+      ])
+    end
+  end
+
+  describe "pie.pad_angle" do
+    it do
+      expect(pie.pad_angle.()).to eq(0)
+      pie.pad_angle(0.1)
+      expect(pie.pad_angle.()).to eq(0.1)
+      expect(rounded).to eq([
+        {data: 1, index: 2, value: 1, start_angle: 5.44, end_angle: 6.28, pad_angle: 0.1},
+        {data: 3, index: 1, value: 3, start_angle: 3.09, end_angle: 5.44, pad_angle: 0.1},
+        {data: 4, index: 0, value: 4, start_angle: 0.00, end_angle: 3.09, pad_angle: 0.1},
+      ])
+    end
+  end
+
+  describe "accessors" do
+    let(:data) {[
+      ["a", 10],
+      ["b", 5],
+      ["d", 15],
+      ["c", 20],
+    ]}
+    let(:pie) { D3.pie.value{|d| d[1]} }
+    let(:order) {
+      generated
+        .sort_by{|arc| arc[:index] }
+        .map{|arc| arc.select{|k,v| k =~ /data|value/ }}
+    }
+    it "pie.value" do
+      expect(order).to eq([
+        {"data"=>["c", 20], "value"=>20},
+        {"data"=>["d", 15], "value"=>15},
+        {"data"=>["a", 10], "value"=>10},
+        {"data"=>["b",  5], "value"=> 5},
+      ])
+    end
+
+    it "pie.sort" do
+      pie.sort{|a,b| a <=> b}
+      expect(order).to eq([
+        {"data"=>["a", 10], "value"=>10},
+        {"data"=>["b",  5], "value"=> 5},
+        {"data"=>["c", 20], "value"=>20},
+        {"data"=>["d", 15], "value"=>15},
+      ])
+    end
+
+    it "pie.sort - nil" do
+      pie.sort(nil)
+      expect(order).to eq([
+        {"data"=>["a", 10], "value"=>10},
+        {"data"=>["b",  5], "value"=> 5},
+        {"data"=>["d", 15], "value"=>15},
+        {"data"=>["c", 20], "value"=>20},
+      ])
+    end
+
+    it "pie.sort_values" do
+      pie.sort_values{|a,b| a <=> b}
+      expect(order).to eq([
+        {"data"=>["b",  5], "value"=> 5},
+        {"data"=>["a", 10], "value"=>10},
+        {"data"=>["d", 15], "value"=>15},
+        {"data"=>["c", 20], "value"=>20},
+      ])
+    end
+  end
+end

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