hyper-d3 1.0.0.lap23

data/spec/format_spec.rb

@@ -0,0 +1,87 @@
+describe "d3 - format" do
+  it "d3.format" do
+    expect(D3.format(".2").(42)).to eq("42")
+    expect(D3.format(".2").(4.2)).to eq("4.2")
+    expect(D3.format(".1").(42)).to eq("4e+1")
+    expect(D3.format(".1").(4.2)).to eq("4")
+    expect(D3.format(".0%").(0.123)).to eq("12%")
+    expect(D3.format("($.2f").(-3.5)).to eq("($3.50)")
+    expect(D3.format("+20").(42)).to eq("                 +42")
+    expect(D3.format(".^20").(42)).to eq(".........42.........")
+    expect(D3.format(".2s").(42e6)).to eq("42M")
+    expect(D3.format("#x").(48879)).to eq("0xbeef")
+    expect(D3.format(",.2r").(4223)).to eq("4,200")
+  end
+
+  it "d3.format_prefix" do
+    f = D3.format_prefix(",.0", 1e-6)
+    expect(f.(0.0042)).to eq("4,200µ")
+    expect(f.(0.00042)).to eq("420µ")
+  end
+
+  it "d3.format_specifier" do
+    expect(D3.format_specifier("s")).to be_instance_of(D3::FormatSpecifier)
+    expect(D3.format_specifier("s").to_h).to eq({
+      fill: " ",
+      align: ">",
+      sign: "-",
+      symbol: "",
+      zero: false,
+      width: nil,
+      comma: false,
+      precision: nil,
+      type: "s",
+    })
+    s = D3.format_specifier("f")
+    s.precision = D3.precision_fixed(0.01)
+    f = D3.format(s)
+    expect(f.(42)).to eq("42.00")
+  end
+
+  it "d3.precision_fixed" do
+    expect(D3.precision_fixed(0.5)).to eq(1)
+  end
+
+  it "d3.precision_prefix" do
+    expect(D3.precision_prefix(1e5, 1.3e6)).to eq(1)
+  end
+
+  it "d3.precision_round" do
+    expect(D3.precision_round(0.01, 1.01)).to eq(3)
+  end
+
+  let(:pl) {{
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "zł"],
+  }}
+  let(:us) {{
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["$", ""],
+  }}
+  it "d3.format_locale" do
+    locale = D3.format_locale(pl)
+    expect(locale).to be_instance_of(D3::FormatLocale)
+    expect(locale.format("$.2f").(-3.5)).to eq("-3,50zł")
+    expect(locale.format("$.2f").(123456.789)).to eq("123456,79zł")
+    expect(locale.format(",.2r").(4223)).to eq("4.200")
+    expect(locale.format_prefix(",.0", 1e-3).(123456.789012)).to eq("123.456.789m")
+  end
+
+  # This test affects global state, so we must be sure to restore it
+  it "d3.format_default_locale" do
+    expect(D3.format(",.2r").(4223)).to eq("4,200")
+
+    locale_pl = D3.format_default_locale(pl)
+    expect(D3.format(",.2r").(4223)).to eq("4.200")
+    expect(locale_pl.format(",.2r").(4223)).to eq("4.200")
+
+    locale_us = D3.format_default_locale(us)
+    expect(D3.format(",.2r").(4223)).to eq("4,200")
+    expect(locale_pl.format(",.2r").(4223)).to eq("4.200")
+    expect(locale_us.format(",.2r").(4223)).to eq("4,200")
+  end
+end

data/spec/histograms_spec.rb

@@ -0,0 +1,61 @@
+describe "d3-array - histograms" do
+  it "d3.histogram" do
+    expect(D3.histogram).to be_a(D3::Histogram)
+  end
+
+  describe "histogram.thresholds" do
+    let(:data) { (1..10).to_a }
+    let(:h) { D3.histogram }
+    it "block" do
+      h.thresholds{|*args| D3.threshold_sturges(*args) }
+      expect(h.(data)).to eq([
+        [1],
+        [2,3],
+        [4,5],
+        [6,7],
+        [8,9,10]
+      ])
+    end
+
+    it "symbol" do
+      h.thresholds(:scott)
+      expect(h.(data)).to eq([
+        [1,2,3,4],
+        [5,6,7,8,9,10],
+      ])
+    end
+
+    it "number" do
+      h.thresholds(2)
+      expect(h.(data)).to eq([
+        [1, 2, 3, 4],
+        [5, 6, 7, 8, 9, 10]
+      ])
+    end
+  end
+
+  it "histogram.call" do
+    h = D3.histogram
+    expect(h.([1,2,1,2,1,3])).to eq([
+      [1,1,1],
+      [],
+      [2,2],
+      [3],
+    ])
+  end
+
+  it "d3.threshold_freedman_diaconis" do
+    data = (0..10).to_a
+    expect(D3.threshold_freedman_diaconis(data,0,10)).to eq(3)
+  end
+
+  it "d3.threshold_scott" do
+    data = (0..10).to_a
+    expect(D3.threshold_scott(data,0,10)).to eq(2)
+  end
+
+  it "d3.threshold_sturges" do
+    data = (0..10).to_a
+    expect(D3.threshold_sturges(data,0,10)).to eq(5)
+  end
+end

data/spec/html/index.html.erb

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Tests</title>
+</head>
+<body>
+  <div id="test-area"></div>
+  <%= javascript_include_tag @server.main %>
+</body>
+</html>

data/spec/interpolate_spec.rb

@@ -0,0 +1,152 @@
+describe "d3 - interpolate" do
+  let(:f) { D3.send(name, a, b) }
+  let(:v) { f.(0.5) }
+  let(:f2) { D3.send(name).(a, b) }
+  let(:v2) { f2.(0.5) }
+
+  describe "numbers" do
+    let(:a) { 10 }
+    let(:b) { 20 }
+
+    describe "d3.interpolate_number" do
+      let(:name) { :interpolate_number }
+      it do
+        expect(f.(0.3)).to eq(13)
+        expect(f.(0.31)).to eq(13.1)
+        expect(f.(0.31)).to eq(f2.(0.31))
+      end
+    end
+
+    describe "d3.interpolate_round" do
+      let(:name) { :interpolate_round }
+      it do
+        expect(f.(0.3)).to eq(13)
+        expect(f.(0.31)).to eq(13)
+        expect(f.(0.31)).to eq(f2.(0.31))
+      end
+    end
+  end
+
+  describe "d3.interpolate_string" do
+    let(:a) { "300 12px sans-serif" }
+    let(:b) { "500 36px Comic-Sans" }
+    let(:name) { :interpolate_string }
+
+    it do
+      expect(f.(0.5)).to eq("400 24px Comic-Sans")
+      expect(f.(0.5)).to eq(f2.(0.5))
+    end
+  end
+
+  describe "d3.interpolate_array" do
+    let(:a) { [0, 200] }
+    let(:b) { [10, 500] }
+    let(:name) { :interpolate_array }
+
+    it do
+      expect(f.(0.5)).to eq([5, 350])
+      expect(f.(0.5)).to eq(f2.(0.5))
+    end
+  end
+
+  describe "d3.interpolate_date" do
+    let(:a) { Time.parse("June 30, 2015 00:00:00 UTC") }
+    let(:b) { Time.parse("December 31, 2016 12:00:00 UTC") }
+    let(:name) { :interpolate_date }
+
+    it do
+      expect(f.(0.5)).to eq(Time.parse("March 31, 2016 06:00:00 UTC"))
+      expect(f.(0.5)).to eq(f2.(0.5))
+    end
+  end
+
+  describe "colors" do
+    let(:a) { "purple" }
+    let(:b) { "orange" }
+
+    describe "d3.interpolate_rgb" do
+      let(:name) { :interpolate_rgb }
+      it do
+        expect(v).to eq("rgb(192, 83, 64)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "basis" do
+      let(:f) { D3.send(name, [a, b]) }
+      let(:f2) { D3.send(name).([a, b]) }
+
+      describe "d3.interpolate_rgb_basis" do
+        let(:name) { :interpolate_rgb_basis }
+        it do
+          expect(v).to eq("rgb(192, 83, 64)")
+          expect(v).to eq(v2)
+        end
+      end
+
+      describe "d3.interpolate_rgb_basis_closed" do
+        let(:name) { :interpolate_rgb_basis_closed }
+        it do
+          expect(v).to eq("rgb(213, 110, 43)")
+          expect(v).to eq(v2)
+        end
+      end
+    end
+
+    describe "d3.interpolate_hsl" do
+      let(:name) { :interpolate_hsl }
+      it do
+        expect(v).to eq("rgb(192, 0, 34)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "d3.interpolate_hsl_long" do
+      let(:name) { :interpolate_hsl_long }
+      it do
+        expect(v).to eq("rgb(0, 192, 158)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "d3.interpolate_lab" do
+      let(:name) { :interpolate_lab }
+      it do
+        expect(v).to eq("rgb(197, 93, 91)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "d3.interpolate_hcl" do
+      let(:name) { :interpolate_hcl }
+      it do
+        expect(v).to eq("rgb(236, 46, 83)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "d3.interpolate_hcl_long" do
+      let(:name) { :interpolate_hcl_long }
+      it do
+        expect(v).to eq("rgb(0, 153, 169)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "d3.interpolate_cubehelix" do
+      let(:name) { :interpolate_cubehelix }
+      it do
+        expect(v).to eq("rgb(255, 32, 68)")
+        expect(v).to eq(v2)
+      end
+    end
+
+    describe "d3.interpolate_cubehelix_long" do
+      let(:name) { :interpolate_cubehelix_long }
+      it do
+        expect(v).to eq("rgb(0, 194, 158)")
+        expect(v).to eq(v2)
+      end
+    end
+  end
+end

data/spec/line_spec.rb

@@ -0,0 +1,54 @@
+describe "d3 - line" do
+  it "d3.line" do
+    expect(D3.line).to be_instance_of(D3::LineGenerator)
+  end
+
+  let(:simple_data) { [[1,2],[3,5],[4,9]] }
+  let(:extended_data) { [[1,2],[3,5],[4,9],[6,10],[7,8]] }
+
+  it "basics" do
+    expect(D3.line.(simple_data)).to eq("M1,2L3,5L4,9")
+  end
+
+  it "curve" do
+    expect(D3.line.curve).to be_instance_of(D3::Curve)
+    expect(D3.line.curve(D3.curve_natural).(simple_data)).to eq(%W[
+      M1,2
+      C1.75,2.9166666666666665,2.5,3.833333333333333,3,5
+      C3.5,6.166666666666667,3.75,7.583333333333334,4,9
+    ].join)
+  end
+
+  it "x/y accessors" do
+    line = D3.line
+    line.x{|(x,y)| x*10}.y{|(x,y)| y*100}
+    expect(line.x.([23,42])).to eq(230)
+    expect(line.y.([23,42])).to eq(4200)
+    expect(line.(simple_data)).to eq("M10,200L30,500L40,900")
+  end
+
+  it ".x constant" do
+    line = D3.line.x(10)
+    expect(line.(simple_data)).to eq("M10,2L10,5L10,9")
+    expect(line.x.(42)).to eq(10)
+    line.x = 20
+    expect(line.x.(42)).to eq(20)
+  end
+
+  it ".y constant" do
+    line = D3.line.y(10)
+    expect(line.(simple_data)).to eq("M1,10L3,10L4,10")
+    expect(line.y.(42)).to eq(10)
+    line.y = 20
+    expect(line.y.(42)).to eq(20)
+  end
+
+  it ".defined" do
+    expect(D3.line.defined(false).(simple_data)).to eq(nil)
+    expect(D3.line.defined{false}.(simple_data)).to eq(nil)
+    expect(D3.line.defined(true).(simple_data)).to eq("M1,2L3,5L4,9")
+    expect(D3.line.defined{true}.(simple_data)).to eq("M1,2L3,5L4,9")
+    expect(D3.line.(extended_data)).to eq("M1,2L3,5L4,9L6,10L7,8")
+    expect(D3.line.defined{|(x,y)| x.odd?}.(extended_data)).to eq("M1,2L3,5M7,8Z")
+  end
+end

data/spec/map_spec.rb

@@ -0,0 +1,80 @@
+describe "d3-collections - maps" do
+  it "d3.map" do
+    expect(D3.map).to be_instance_of(D3::Map)
+  end
+
+  it "d3.has?" do
+    expect(D3.map().has?("1")).to eq(false)
+    expect(D3.map(["a","b"]).has?("0")).to eq(true)
+    expect(D3.map(["a","b"]).has?(0)).to eq(true)
+    expect(D3.map(["a","b"]).has?(2)).to eq(false)
+    expect(D3.map(["a","b"]).has?("a")).to eq(false)
+  end
+
+  it "d3.get" do
+    a = D3.map(["a", "b"])
+    expect(nil).to eq(nil)
+    expect(a[0]).to eq("a")
+    expect(a[2]).to eq(nil)
+    expect(a.get(0)).to eq("a")
+    expect(a.get(2)).to eq(nil)
+  end
+
+  it "d3.set" do
+    a = D3.map.set("foo", 1).set("bar", 2)
+    a["baz"] = 3
+    expect(a["foo"]).to eq(1)
+    expect(a["bar"]).to eq(2)
+    expect(a["baz"]).to eq(3)
+  end
+
+  it "map.remove" do
+    a = D3.map.set("a", 1).set("b", 2).remove("a").set("c", 3)
+    expect(a.keys).to eq(["b", "c"])
+  end
+
+  it "map.clear" do
+    a = D3.map.set("a", 1).set("b", 2).clear.set("c", 3)
+    expect(a.keys).to eq(["c"])
+  end
+
+  it "map.keys" do
+    a = D3.map.set("foo", 1).set("bar", 2)
+    expect(a.keys).to eq(["foo", "bar"])
+  end
+
+  it "map.values" do
+    a = D3.map.set("foo", 1).set("bar", 2)
+    expect(a.values).to eq([1, 2])
+  end
+
+  it "map.entries" do
+    a = D3.map.set("foo", 1).set("bar", 2)
+    expect(a.entries).to eq([["foo", 1], ["bar", 2]])
+  end
+
+  it "map.to_h" do
+    a = D3.map.set("foo", 1).set("bar", 2)
+    expect(a.to_h).to eq({"foo" => 1, "bar" => 2})
+  end
+
+  it "map.each" do
+    called = []
+    a = D3.map.set("foo", 1).set("bar", 2)
+    a.each do |v,k|
+      called << [k,v]
+    end
+    expect(called).to eq([["foo",1], ["bar",2]])
+
+  end
+
+  it "map.empty" do
+    expect(D3.map).to be_empty
+    expect(D3.map(["a"])).to_not be_empty
+  end
+
+  it "map.size" do
+    expect(D3.map.size).to eq(0)
+    expect(D3.map(["a"]).size).to eq(1)
+  end
+end