hyper-d3 1.0.0.lap23

data/spec/area_spec.rb

@@ -0,0 +1,98 @@
+describe "d3 - area" do
+  it "d3.area" do
+    expect(D3.area).to be_instance_of(D3::AreaGenerator)
+  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(:area) {
+      D3.area
+          .x{|d| (d[:year]-2000)*10 }
+          .y1{|d| d[:value] }
+          .y0(50)
+    }
+    it "basics" do
+      expect(area.(simple_data)).to eq(
+        "M70,93.24L80,95.35L90,98.84L100,99.92L110,99.8L140,99.47L140,50L110,50L100,50L90,50L80,50L70,50Z"
+      )
+    end
+
+    it "curve" do
+      expect(area.curve).to be_instance_of(D3::Curve)
+      expect(area.curve(D3.curve_natural).(simple_data)).to eq(%W[
+        M70,93.24
+        C73.3652312599681,93.76974481658695,76.7304625199362,94.29948963317388,80,95.35
+        C83.2695374800638,96.40051036682611,86.4433811802233,97.97178628389153,90,98.84
+        C93.5566188197767,99.70821371610847,97.49601275917065,99.87336523125998,100,99.92
+        C102.50398724082935,99.96663476874002,103.5725677830941,99.89475279106857,110,99.8
+        C116.4274322169059,99.70524720893143,128.21371610845296,99.5876236044657,140,99.47L140,50
+        C128.21371610845296,50,116.4274322169059,50,110,50
+        C103.5725677830941,50,102.50398724082936,50,100,50
+        C97.49601275917064,50,93.55661881977672,50,90,50
+        C86.44338118022328,50,83.2695374800638,50,80,50
+        C76.7304625199362,50,73.3652312599681,50,70,50Z
+      ].join)
+    end
+
+    it ".defined" do
+      expect(area.defined{|d| d[:year] != 2010}.(simple_data)).to eq(
+        "M70,93.24L80,95.35L90,98.84L90,50L80,50L70,50ZM110,99.8L140,99.47L140,50L110,50Z"
+      )
+    end
+  end
+
+  describe "line generators" do
+    let(:area) {
+      D3.area
+        .x0{|d| (d[:year]-2000)*10 }
+        .x1{|d| (d[:year]-2000)*20 }
+        .y1{|d| d[:value] }
+        .y0(50)
+    }
+    let(:point) { {year: 2042, value: 117 } }
+
+    it ".x/.x0/.x1" do
+      expect(area.x0.(point)).to eq(420)
+      expect(area.x1.(point)).to eq(840)
+      expect(area.x.(point)).to eq(420)
+    end
+
+    it ".y/.y0/.y1" do
+      expect(area.y0.(point)).to eq(50)
+      expect(area.y1.(point)).to eq(117)
+      expect(area.y.(point)).to eq(50)
+    end
+
+    it ".line_x0" do # x0 y0
+      expect(area.line_x0).to be_instance_of(D3::LineGenerator)
+      expect(area.line_x0.x.(point)).to eq(420)
+      expect(area.line_x0.y.(point)).to eq(50)
+    end
+
+    it ".line_x1" do # x1 y0
+      expect(area.line_x1).to be_instance_of(D3::LineGenerator)
+      expect(area.line_x1.x.(point)).to eq(840)
+      expect(area.line_x1.y.(point)).to eq(50)
+    end
+
+    it ".line_y0" do # x0 y0
+      expect(area.line_y0).to be_instance_of(D3::LineGenerator)
+      expect(area.line_y0.x.(point)).to eq(420)
+      expect(area.line_y0.y.(point)).to eq(50)
+    end
+
+    it ".line_y1" do # x0 y1
+      expect(area.line_y1).to be_instance_of(D3::LineGenerator)
+      expect(area.line_y1.x.(point)).to eq(420)
+      expect(area.line_y1.y.(point)).to eq(117)
+    end
+  end
+end

data/spec/axis_spec.rb

@@ -0,0 +1,174 @@
+describe "d3 - axis" do
+  after(:each) do
+    D3.select("#test-area").html("")
+  end
+
+  let(:scale) { D3.scale_linear.domain([0,80_000_000]).range([0,800]) }
+  let(:scale2) { D3.scale_linear.domain([0,30]).range([0,600]) }
+  let(:axis) { D3.axis_top(scale) }
+
+  it "d3.axis_top" do
+    expect(D3.axis_top(scale)).to be_instance_of(D3::Axis)
+  end
+
+  it "d3.axis_bottom" do
+    expect(D3.axis_bottom(scale)).to be_instance_of(D3::Axis)
+  end
+
+  it "d3.axis_right" do
+    expect(D3.axis_right(scale)).to be_instance_of(D3::Axis)
+  end
+
+  it "d3.axis_left" do
+    expect(D3.axis_left(scale)).to be_instance_of(D3::Axis)
+  end
+
+  it "axis.scale" do
+    expect(axis.scale).to eq(scale)
+    axis.scale(scale2)
+    expect(axis.scale).to eq(scale2)
+    axis.scale = scale
+    expect(axis.scale).to eq(scale)
+  end
+
+  it "axis.tick_size_inner" do
+    expect(axis.tick_size_inner).to eq(6)
+    axis.tick_size_inner(20)
+    expect(axis.tick_size_inner).to eq(20)
+  end
+
+  it "axis.tick_size_outer" do
+    expect(axis.tick_size_outer).to eq(6)
+    axis.tick_size_outer(20)
+    expect(axis.tick_size_outer).to eq(20)
+  end
+
+  it "axis.tick_size" do
+    expect(axis.tick_size).to eq(6)
+    axis.tick_size(20)
+    expect(axis.tick_size).to eq(20)
+  end
+
+  it "axis.tick_padding" do
+    expect(axis.tick_padding).to eq(3)
+    axis.tick_padding(10)
+    expect(axis.tick_padding).to eq(10)
+  end
+
+  describe "axis.tick_values" do
+    it "defaults" do
+      context = D3.select("#test-area").append("svg")
+      expect(axis.tick_values).to eq(nil)
+      axis.(context)
+      expect(D3.select("#test-area").html).to eq([
+        '<svg fill="none" font-size="10" font-family="sans-serif" text-anchor="middle">',
+        '<path class="domain" stroke="#000" d="M0.5,-6V0.5H800.5V-6"></path>',
+        '<g class="tick" opacity="1" transform="translate(0.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">0</text></g>',
+        '<g class="tick" opacity="1" transform="translate(100.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">10,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(200.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">20,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(300.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">30,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(400.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">40,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(500.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">50,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(600.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">60,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(700.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">70,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(800.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">80,000,000</text></g>',
+        '</svg>',
+      ].join)
+    end
+
+    it "set/get" do
+      context = D3.select("#test-area").append("svg")
+      axis.tick_values = [0, 20_000_000, 40_000_000]
+      expect(axis.tick_values).to eq([0, 20_000_000, 40_000_000])
+      axis.(context)
+      expect(D3.select("#test-area").html).to eq([
+        '<svg fill="none" font-size="10" font-family="sans-serif" text-anchor="middle">',
+        '<path class="domain" stroke="#000" d="M0.5,-6V0.5H800.5V-6"></path>',
+        '<g class="tick" opacity="1" transform="translate(0.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">0</text></g>',
+        '<g class="tick" opacity="1" transform="translate(200.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">20,000,000</text></g>',
+        '<g class="tick" opacity="1" transform="translate(400.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">40,000,000</text></g>',
+        '</svg>',
+      ].join)
+      axis.tick_values(nil)
+      expect(axis.tick_values).to eq(nil)
+    end
+  end
+
+  describe "axis.tick_format" do
+    let(:scale) { D3.scale_linear.domain([0,80_000]).range([0,800]) }
+    it "basics" do
+      context = D3.select("#test-area").append("svg")
+      expect(axis.tick_format).to eq(nil)
+      axis.tick_values = [0, 20_000, 40_000]
+      axis.tick_format = D3.format(",.2f")
+      axis.(context)
+      expect(D3.select("#test-area").html).to eq([
+        '<svg fill="none" font-size="10" font-family="sans-serif" text-anchor="middle">',
+        '<path class="domain" stroke="#000" d="M0.5,-6V0.5H800.5V-6"></path>',
+        '<g class="tick" opacity="1" transform="translate(0.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">0.00</text></g>',
+        '<g class="tick" opacity="1" transform="translate(200.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">20,000.00</text></g>',
+        '<g class="tick" opacity="1" transform="translate(400.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">40,000.00</text></g>',
+        '</svg>',
+      ].join)
+    end
+
+    it "block" do
+      context = D3.select("#test-area").append("svg")
+      expect(axis.tick_format).to eq(nil)
+      axis.tick_values = [0, 20_000, 40_000]
+      axis.tick_format{|d| "#{d}x"}
+      expect(axis.tick_format.(5)).to eq("5x")
+      axis.(context)
+      expect(D3.select("#test-area").html).to eq([
+        '<svg fill="none" font-size="10" font-family="sans-serif" text-anchor="middle">',
+        '<path class="domain" stroke="#000" d="M0.5,-6V0.5H800.5V-6"></path>',
+        '<g class="tick" opacity="1" transform="translate(0.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">0x</text></g>',
+        '<g class="tick" opacity="1" transform="translate(200.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">20000x</text></g>',
+        '<g class="tick" opacity="1" transform="translate(400.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">40000x</text></g>',
+        '</svg>',
+      ].join)
+    end
+  end
+
+  it "axis.ticks" do
+    context = D3.select("#test-area").append("svg")
+    axis.ticks(10, ".2f")
+    axis.(context)
+    expect(D3.select("#test-area").html).to eq([
+      '<svg fill="none" font-size="10" font-family="sans-serif" text-anchor="middle">',
+      '<path class="domain" stroke="#000" d="M0.5,-6V0.5H800.5V-6"></path>',
+      '<g class="tick" opacity="1" transform="translate(0.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">0.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(100.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">10000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(200.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">20000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(300.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">30000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(400.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">40000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(500.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">50000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(600.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">60000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(700.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">70000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(800.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">80000000.00</text></g>',
+      '</svg>',
+    ].join)
+  end
+
+  it "axis.tick_arguments" do
+    context = D3.select("#test-area").append("svg")
+    expect(axis.tick_arguments).to eq([])
+    axis.tick_arguments([10, ".2f"])
+    expect(axis.tick_arguments).to eq([10, ".2f"])
+    axis.(context)
+    expect(D3.select("#test-area").html).to eq([
+      '<svg fill="none" font-size="10" font-family="sans-serif" text-anchor="middle">',
+      '<path class="domain" stroke="#000" d="M0.5,-6V0.5H800.5V-6"></path>',
+      '<g class="tick" opacity="1" transform="translate(0.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">0.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(100.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">10000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(200.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">20000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(300.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">30000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(400.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">40000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(500.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">50000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(600.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">60000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(700.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">70000000.00</text></g>',
+      '<g class="tick" opacity="1" transform="translate(800.5,0)"><line stroke="#000" y2="-6"></line><text fill="#000" y="-9" dy="0em">80000000.00</text></g>',
+      '</svg>',
+    ].join)
+  end
+end

data/spec/band_scale_spec.rb

@@ -0,0 +1,73 @@
+describe "d3 - band scale" do
+  it "d3.scale_band" do
+    expect(D3.scale_band).to be_instance_of(D3::BandScale)
+  end
+
+  let(:d) { ("a".."f").to_a }
+  it "basics" do
+    scale = D3.scale_band.domain(d)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([0, 0.17, 0.33, 0.5, 0.67, 0.83])
+    expect(scale.bandwidth).to eq(0.16666666666666666)
+    expect(scale.step).to eq(0.16666666666666666)
+    expect(scale.("z")).to eq(nil)
+  end
+
+  it "padding" do
+    scale = D3.scale_band.domain(d).range([0,100])
+    expect(scale.padding).to eq(0)
+    expect(scale.padding_inner).to eq(0)
+    expect(scale.padding_outer).to eq(0)
+
+    scale.padding(0.5)
+    expect(scale.padding).to eq(0.5)
+    expect(scale.padding_inner).to eq(0.5)
+    expect(scale.padding_outer).to eq(0.5)
+
+    scale.padding_inner(0.2)
+    scale.padding_outer(0.4)
+    expect(scale.padding).to eq(0.2)
+    expect(scale.padding_inner).to eq(0.2)
+    expect(scale.padding_outer).to eq(0.4)
+
+    expect(d.map{|v| scale.(v).round(2)}).to eq([6.06, 21.21, 36.36, 51.52, 66.67, 81.82])
+    expect(scale.bandwidth).to eq(12.121212121212123)
+    expect(scale.step).to eq(15.151515151515152)
+  end
+
+  it "copy" do
+    scale = D3.scale_band.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 "align" do
+    scale = D3.scale_band.domain(d).range([0,100])
+    expect(scale.align).to eq(0.5)
+    scale.padding_inner(0.2)
+    scale.padding_outer(0.4)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([6.06, 21.21, 36.36, 51.52, 66.67, 81.82])
+
+    scale.align(0)
+    expect(scale.align).to eq(0)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([0, 15.15, 30.3, 45.45, 60.61, 75.76])
+
+    scale.align(1)
+    expect(scale.align).to eq(1)
+    expect(d.map{|v| scale.(v).round(2)}).to eq([12.12, 27.27, 42.42, 57.58, 72.73, 87.88])
+    expect(scale.bandwidth).to eq(12.121212121212123)
+    expect(scale.step).to eq(15.151515151515152)
+  end
+
+  it "round" do
+    scale = D3.scale_band.domain(d).range([0,100])
+    expect(scale.round).to eq(false)
+    scale.range_round([0,1000])
+    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([2, 168, 334, 500, 666, 832])
+  end
+end

data/spec/color_spec.rb

@@ -0,0 +1,74 @@
+describe "d3-colors" do
+  it "d3.color" do
+    expect(D3.color("blue")).to be_instance_of(D3::Color)
+  end
+
+  it "supported syntax" do
+    expect(D3.color("rgb(255, 255, 255)").to_s).to eq("rgb(255, 255, 255)")
+    expect(D3.color("rgb(10%, 20%, 30%)").to_s).to eq("rgb(26, 51, 77)")
+    expect(D3.color("rgba(255, 255, 255, 0.4)").to_s).to eq("rgba(255, 255, 255, 0.4)")
+    expect(D3.color("rgba(10%, 20%, 30%, 0.4)").to_s).to eq("rgba(26, 51, 77, 0.4)")
+    expect(D3.color("hsl(120, 50%, 20%)").to_s).to eq("rgb(25, 77, 25)")
+    expect(D3.color("hsla(120, 50%, 20%, 0.4)").to_s).to eq("rgba(25, 77, 25, 0.4)")
+    expect(D3.color("#ffeeaa").to_s).to eq("rgb(255, 238, 170)")
+    expect(D3.color("#fea").to_s).to eq("rgb(255, 238, 170)")
+    expect(D3.color("steelblue").to_s).to eq("rgb(70, 130, 180)")
+  end
+
+  it "invalid colors" do
+    expect{ D3.color("poop_emoji") }.to raise_error(/Invalid color/)
+  end
+
+  it "color.brighter" do
+    steelblue = D3.color("steelblue")
+    expect(steelblue.brighter.to_s).to eq("rgb(100, 186, 255)")
+    expect(steelblue.brighter(0.25).to_s).to eq("rgb(77, 142, 197)")
+  end
+
+  it "color.darker" do
+    steelblue = D3.color("steelblue")
+    expect(steelblue.darker.to_s).to eq("rgb(49, 91, 126)")
+    expect(steelblue.darker(0.25).to_s).to eq("rgb(64, 119, 165)")
+  end
+
+  it "color.displayable?" do
+    expect(D3.color("rgb(255,255,255)")).to be_displayable
+    expect(D3.color("rgb(260,260,260)")).to_not be_displayable
+  end
+
+  it "d3.rgb" do
+    steelblue = D3.rgb("steelblue")
+    expect([steelblue.r, steelblue.g, steelblue.b]).to eq([70, 130, 180])
+    expect(D3.rgb(10,20,30).to_s).to eq("rgb(10, 20, 30)")
+    expect(D3.rgb(10,20,30,0.5).to_s).to eq("rgba(10, 20, 30, 0.5)")
+    expect(D3.rgb(D3.hsl("steelblue")).to_s).to eq("rgb(70, 130, 180)")
+  end
+
+  it "d3.hsl" do
+    steelblue = D3.hsl("steelblue")
+    expect([steelblue.h, steelblue.s, steelblue.l]).to eq([207.27272727272728, 0.44, 0.4901960784313726])
+    expect(D3.hsl(207.27272727272728, 0.44, 0.4901960784313726).to_s).to eq("rgb(70, 130, 180)")
+    expect(D3.hsl(207.27272727272728, 0.44, 0.4901960784313726, 0.5).to_s).to eq("rgba(70, 130, 180, 0.5)")
+  end
+
+  it "d3.lab" do
+    steelblue = D3.lab("steelblue")
+    expect([steelblue.l, steelblue.a, steelblue.b]).to eq([52.46551718768575, -4.0774710123572255, -32.19186122981343])
+    expect(D3.lab(52.46551718768575, -4.0774710123572255, -32.19186122981343).to_s).to eq("rgb(70, 130, 180)")
+    expect(D3.lab(52.46551718768575, -4.0774710123572255, -32.19186122981343, 0.5).to_s).to eq("rgba(70, 130, 180, 0.5)")
+  end
+
+  it "d3.hcl" do
+    steelblue = D3.hcl("steelblue")
+    expect([steelblue.h, steelblue.c, steelblue.l]).to eq([262.78126775909277, 32.44906314974561, 52.46551718768575])
+    expect(D3.hcl(262.78126775909277, 32.44906314974561, 52.46551718768575).to_s).to eq("rgb(70, 130, 180)")
+    expect(D3.hcl(262.78126775909277, 32.44906314974561, 52.46551718768575, 0.5).to_s).to eq("rgba(70, 130, 180, 0.5)")
+  end
+
+  it "d3.cubehelix" do
+    steelblue = D3.cubehelix("steelblue")
+    expect([steelblue.h, steelblue.s, steelblue.l]).to eq([202.84837896488932, 0.6273147230777709, 0.460784355920337])
+    expect(D3.cubehelix(202.84837896488932, 0.6273147230777709, 0.460784355920337).to_s).to eq("rgb(70, 130, 180)")
+    expect(D3.cubehelix(202.84837896488932, 0.6273147230777709, 0.460784355920337, 0.5).to_s).to eq("rgba(70, 130, 180, 0.5)")
+  end
+end

data/spec/continuous_scale_spec.rb

@@ -0,0 +1,217 @@
+require "time"
+
+describe "d3 - continuous scale" do
+  describe "linear" do
+    it "d3.scale_linear" do
+      expect(D3.scale_linear).to be_instance_of(D3::ContinuousScale)
+    end
+
+    it "basics" do
+      x = D3.scale_linear.domain([10, 130]).range([0, 960])
+      expect(x.domain).to eq([10, 130])
+      expect(x.range).to eq([0, 960])
+      expect(x.(20)).to eq(80)
+      expect(x.(50)).to eq(320)
+      expect(x.(-10)).to eq(-160)
+      expect(x.invert(-160)).to eq(-10)
+    end
+
+    it "range_round" do
+      x = D3.scale_linear.domain([0,6]).range([0, 100])
+      y = D3.scale_linear.domain([0,6]).range_round([0, 100])
+      expect(x.(4)).to eq(66.66666666666666)
+      expect(y.(4)).to eq(67)
+    end
+
+    describe "interpolate" do
+      let(:x) { D3.scale_linear.domain([0,6]).range([0, 100]) }
+      let(:xf) { x.copy.interpolate{|a,b| proc{|t| (a + (b-a)*t).floor }}}
+      let(:xc) { x.copy.interpolate{|a,b| proc{|t| (a + (b-a)*t).ceil }}}
+      let(:xr) { x.copy.interpolate(&D3.interpolate_round) }
+      it "floor" do
+        expect(xf.(4)).to eq(66)
+      end
+      it "ceil" do
+        expect(xc.(4)).to eq(67)
+      end
+      it "round" do
+        expect(xr.(4)).to eq(67)
+      end
+      it "get interpolator" do
+        expect(x.interpolate.(0,10).(0.34)).to eq(3.4000000000000004)
+        expect(xr.interpolate.(0,10).(0.34)).to eq(3)
+      end
+    end
+
+    it ".clamp" do
+      x = D3.scale_linear.domain([10, 130]).range([0, 960])
+      expect(x.clamp).to eq(false)
+      x.clamp(true)
+      expect(x.clamp).to eq(true)
+      expect(x.(-10)).to eq(0)
+      expect(x.invert(-160)).to eq(10)
+    end
+
+    it ".nice / .copy" do
+      x = D3.scale_linear.domain([7, 127]).range([3, 955])
+      xn = x.copy.nice
+      expect(xn.domain).to eq([0, 130])
+      expect(xn.range).to eq([3, 955])
+
+      xc = x.copy
+      x5 = x.nice(5)
+      expect(x5.domain).to eq([0, 140])
+      expect(x5.range).to eq([3, 955])
+      expect(xc.domain).to eq([7, 127])
+      expect(xc.range).to eq([3, 955])
+      expect(x.domain).to eq(x5.domain)
+      expect(x.range).to eq(x5.range)
+    end
+
+    it "color" do
+      color = D3.scale_linear.domain([10, 100]).range(["brown", "steelblue"])
+      expect(color.(20)).to eq("rgb(154, 52, 57)")
+      expect(color.(50)).to eq("rgb(123, 81, 103)")
+    end
+
+    it "color piecewise" do
+      color = D3.scale_linear.domain([-1, 0, 1]).range(["red", "white", "green"])
+      expect(color.(-1)).to eq("rgb(255, 0, 0)")
+      expect(color.(-0.5)).to eq("rgb(255, 128, 128)")
+      expect(color.(0)).to eq("rgb(255, 255, 255)")
+      expect(color.(+0.5)).to eq("rgb(128, 192, 128)")
+      expect(color.(1)).to eq("rgb(0, 128, 0)")
+    end
+
+    it ".ticks / .tick_format" do
+      x = D3.scale_linear.domain([-1, 1]).range([0, 960])
+      expect(x.ticks(5)).to eq([-1, -0.5, 0, 0.5, 1])
+      expect(x.ticks.map{|v| v.round(2)}).to eq([-1, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1])
+      tick_format = x.tick_format(5, "+%")
+      expect(x.ticks(5).map(&tick_format)).to eq(["-100%", "-50%", "+0%", "+50%", "+100%"])
+    end
+  end
+
+  describe "pow" do
+    it "d3.scale_pow" do
+      expect(D3.scale_pow).to be_instance_of(D3::PowScale)
+      expect(D3.scale_pow.exponent).to eq(1)
+    end
+
+    it "basics" do
+      x = D3.scale_pow.exponent(2).domain([0, 10]).range([0, 10000])
+      expect(x.(5)).to eq(2500)
+      expect(x.invert(4900)).to eq(7)
+    end
+  end
+
+  describe "sqrt" do
+    it "d3.scale_sqrt" do
+      expect(D3.scale_sqrt).to be_instance_of(D3::PowScale)
+      expect(D3.scale_sqrt.exponent).to eq(0.5)
+    end
+  end
+
+  describe "log" do
+    it 'd3.scale_log' do
+      expect(D3.scale_log).to be_instance_of(D3::LogScale)
+      expect(D3.scale_log.base).to eq(10)
+    end
+
+    it "basics" do
+      x = D3.scale_log.base(2).domain([1, 1024]).range([0, 100])
+      expect(x.(256)).to eq(80)
+      expect(x.invert(50)).to eq(32)
+    end
+  end
+
+  describe "identity" do
+    it 'd3.scale_log' do
+      expect(D3.scale_identity).to be_instance_of(D3::ContinuousScale)
+    end
+
+    it "basics" do
+      x = D3.scale_identity.domain([10,20])
+      expect(x.(16)).to eq(16)
+      expect(x.invert(12)).to eq(12)
+      expect(x.domain).to eq([10,20])
+      expect(x.range).to eq([10,20])
+    end
+  end
+
+  # Sadly this can't be tested totally properly due to ridiculous mess
+  # javascript timezone management is
+  describe "time" do
+    let(:x) { D3.scale_time.domain([Time.parse("Jan 01 1990 00:00:00"), Time.parse(Time.parse("Jan 01 1998 00:00:00"))]).range([0,100]) }
+    let(:y) { D3.scale_utc.domain([Time.parse("Jan 01 1990 00:00:00"), Time.parse(Time.parse("Jan 01 1998 00:00:00"))]).range([0,100]) }
+    it "d3.scale_time" do
+      expect(D3.scale_time).to be_instance_of(D3::ContinuousScale)
+    end
+
+    it "d3.scale_utc" do
+      expect(D3.scale_utc).to be_instance_of(D3::ContinuousScale)
+    end
+
+    it "basics" do
+      expect(x.(Time.parse("Jul 01 1995 00:00:00")).round(1)).to eq(68.7)
+    end
+
+    it "invert" do
+      expect(x.invert(75).to_s).to eq("1996-01-01 12:00:00 -0000")
+    end
+
+    it "ticks" do
+      expect(x.ticks(4).map(&:to_s)).to eq([
+        "1990-01-01 00:00:00 -0000",
+        "1992-01-01 00:00:00 -0000",
+        "1994-01-01 00:00:00 -0000",
+        "1996-01-01 00:00:00 -0000",
+        "1998-01-01 00:00:00 -0000",
+      ])
+    end
+
+    it "ticks interval" do
+      expect(x.ticks(D3.time_month.every(8)).map{|d| d.to_s.split[0]}).to eq([
+        "1990-01-01",
+        "1990-09-01",
+        "1991-01-01",
+        "1991-09-01",
+        "1992-01-01",
+        "1992-09-01",
+        "1993-01-01",
+        "1993-09-01",
+        "1994-01-01",
+        "1994-09-01",
+        "1995-01-01",
+        "1995-09-01",
+        "1996-01-01",
+        "1996-09-01",
+        "1997-01-01",
+        "1997-09-01",
+        "1998-01-01",
+      ])
+    end
+
+    it "utc ticks interval" do
+      expect(y.ticks(D3.utc_month.every(8)).map{|d| d.to_s.split[0]}).to eq([
+        "1990-01-01",
+        "1990-09-01",
+        "1991-01-01",
+        "1991-09-01",
+        "1992-01-01",
+        "1992-09-01",
+        "1993-01-01",
+        "1993-09-01",
+        "1994-01-01",
+        "1994-09-01",
+        "1995-01-01",
+        "1995-09-01",
+        "1996-01-01",
+        "1996-09-01",
+        "1997-01-01",
+        "1997-09-01",
+        "1998-01-01",
+      ])
+    end
+  end
+end