hyper-d3 1.0.0.lap23

data/spec/coverage_spec.rb

@@ -0,0 +1,16 @@
+describe "D3 coverage" do
+  # Test code is here because opal-repl doesn't support aggregate_failures mode
+  native_methods = `Opal.hash(window.d3)`.keys.sort
+  nice_methods = native_methods.map{|m| m.gsub(/([a-z])(?=[A-Z0-9])/, "\\1_").downcase }
+
+  # format conflict with base ruby
+  nice_methods.each do |method|
+    it method do
+      if D3.respond_to?(method)
+        # OK
+      else
+        skip "not implemented yet"
+      end
+    end
+  end
+end

data/spec/creator_spec.rb

@@ -0,0 +1,15 @@
+describe "d3 - creator" do
+  after(:each) do
+    D3.select("#test-area").html("")
+  end
+  let(:root) { D3.select("#test-area") }
+  let(:html) { root.html }
+
+  it "d3.creator" do
+    expect(D3.creator("div")).to be_instance_of(D3::Creator)
+    D3.select("div").append(D3.creator("span"))
+    expect(html).to eq(
+      "<span></span>"
+    )
+  end
+end

data/spec/curve_spec.rb

@@ -0,0 +1,206 @@
+describe "d3 - curve" do
+  let(:curve) { D3.send(name) }
+  # 5   x-x
+  #    /   \
+  # 4 x    |  x
+  #        \ /
+  # 3       x
+  #   0 1 2 3 4
+  let(:data) { [[0, 4], [1, 5], [2, 5], [3, 3], [4, 4]] }
+  let(:line) { D3.line.curve(curve).(data) }
+  let(:rounded) { line.gsub(/\d+\.\d+/){$&.to_f.round(2)} }
+  describe "curve_basis" do
+    let(:name){ :curve_basis }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4L0.17,4.17C0.33,4.33,0.67,4.67,1,4.83C1.33,5,1.67,5,2,4.67C2.33,4.33,2.67,3.67,3,3.5C3.33,3.33,3.67,3.67,3.83,3.83L4,4")
+    end
+  end
+
+  describe "curve_basis_closed" do
+    let(:name){ :curve_basis_closed }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M1,4.83C1.33,5,1.67,5,2,4.67C2.33,4.33,2.67,3.67,3,3.5C3.33,3.33,3.67,3.67,3.17,3.83C2.67,4,1.33,4,0.83,4.17C0.33,4.33,0.67,4.67,1,4.83")
+    end
+  end
+
+  describe "curve_basis_open" do
+    let(:name){ :curve_basis_open }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M1,4.83C1.33,5,1.67,5,2,4.67C2.33,4.33,2.67,3.67,3,3.5")
+    end
+  end
+
+  describe "curve_bundle" do
+    let(:name){ :curve_bundle }
+    it do
+      expect(curve).to be_instance_of(D3::CurveBundle)
+      expect(rounded).to eq("M0,4L0.17,4.14C0.33,4.28,0.67,4.57,1,4.71C1.33,4.85,1.67,4.85,2,4.57C2.33,4.28,2.67,3.72,3,3.58C3.33,3.43,3.67,3.72,3.83,3.86L4,4")
+    end
+
+    describe ".beta" do
+      let(:curve) { D3.curve_bundle.beta(0.5) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveBundle)
+        expect(rounded).to eq("M0,4L0.17,4.08C0.33,4.17,0.67,4.33,1,4.42C1.33,4.5,1.67,4.5,2,4.33C2.33,4.17,2.67,3.83,3,3.75C3.33,3.67,3.67,3.83,3.83,3.92L4,4")
+      end
+    end
+  end
+
+  describe "curve_cardinal" do
+    let(:name){ :curve_cardinal }
+    it do
+      expect(curve).to be_instance_of(D3::CurveCardinal)
+      expect(rounded).to eq("M0,4C0,4,0.67,4.83,1,5C1.33,5.17,1.67,5.33,2,5C2.33,4.67,2.67,3.17,3,3C3.33,2.83,4,4,4,4")
+    end
+    describe ".tension" do
+      let(:curve) { D3.curve_cardinal.tension(0.5) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveCardinal)
+        expect(rounded).to eq("M0,4C0,4,0.83,4.92,1,5C1.17,5.08,1.83,5.17,2,5C2.17,4.83,2.83,3.08,3,3C3.17,2.92,4,4,4,4")
+      end
+    end
+  end
+
+  describe "curve_cardinal_closed" do
+    let(:name){ :curve_cardinal_closed }
+    it do
+      expect(curve).to be_instance_of(D3::CurveCardinal)
+      expect(rounded).to eq("M1,5C1.33,5.17,1.67,5.33,2,5C2.33,4.67,2.67,3.17,3,3C3.33,2.83,4.5,3.83,4,4C3.5,4.17,0.5,3.83,0,4C-0.5,4.17,0.67,4.83,1,5")
+    end
+    describe ".tension" do
+      let(:curve) { D3.curve_cardinal_closed.tension(0.5) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveCardinal)
+        expect(rounded).to eq("M1,5C1.17,5.08,1.83,5.17,2,5C2.17,4.83,2.83,3.08,3,3C3.17,2.92,4.25,3.92,4,4C3.75,4.08,0.25,3.92,0,4C-0.25,4.08,0.83,4.92,1,5")
+      end
+    end
+  end
+
+  describe "curve_cardinal_open" do
+    let(:name){ :curve_cardinal_open }
+    it do
+      expect(curve).to be_instance_of(D3::CurveCardinal)
+      expect(rounded).to eq("M1,5C1.33,5.17,1.67,5.33,2,5C2.33,4.67,2.67,3.17,3,3")
+    end
+    describe ".tension" do
+      let(:curve) { D3.curve_cardinal_open.tension(0.5) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveCardinal)
+        expect(rounded).to eq("M1,5C1.17,5.08,1.83,5.17,2,5C2.17,4.83,2.83,3.08,3,3")
+      end
+    end
+  end
+
+  describe "curve_catmull_rom" do
+    let(:name){ :curve_catmull_rom }
+    it do
+      expect(curve).to be_instance_of(D3::CurveCatmullRom)
+      expect(rounded).to eq("M0,4C0,4,0.63,4.85,1,5C1.31,5.13,1.71,5.18,2,5C2.43,4.73,2.62,3.06,3,3C3.3,2.95,4,4,4,4")
+    end
+    describe ".alpha" do
+      let(:curve) { D3.curve_catmull_rom.alpha(0.75) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveCatmullRom)
+        expect(rounded).to eq("M0,4C0,4,0.61,4.85,1,5C1.3,5.11,1.72,5.13,2,5C2.51,4.76,2.59,3,3,3C3.29,3,4,4,4,4")
+      end
+    end
+  end
+
+  describe "curve_catmull_rom_closed" do
+    let(:name){ :curve_catmull_rom_closed }
+    it do
+      expect(curve).to be_instance_of(D3::CurveCatmullRom)
+      expect(rounded).to eq("M1,5C1.31,5.13,1.71,5.18,2,5C2.43,4.73,2.62,3.06,3,3C3.3,2.95,4.09,3.79,4,4C3.85,4.35,0.15,3.65,0,4C-0.09,4.21,0.63,4.85,1,5")
+    end
+    describe ".alpha" do
+      let(:curve) { D3.curve_catmull_rom_closed.alpha(0.75) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveCatmullRom)
+        expect(rounded).to eq("M1,5C1.3,5.11,1.72,5.13,2,5C2.51,4.76,2.59,3,3,3C3.29,3,3.96,3.77,4,4C4.08,4.5,-0.08,3.5,0,4C0.04,4.23,0.61,4.85,1,5")
+      end
+    end
+  end
+
+  describe "curve_catmull_rom_open" do
+    let(:name){ :curve_catmull_rom_open }
+    it do
+      expect(curve).to be_instance_of(D3::CurveCatmullRom)
+      expect(rounded).to eq("M1,5C1.31,5.13,1.71,5.18,2,5C2.43,4.73,2.62,3.06,3,3")
+    end
+    describe ".alpha" do
+      let(:curve) { D3.curve_catmull_rom_open.alpha(0.75) }
+      it do
+        expect(curve).to be_instance_of(D3::CurveCatmullRom)
+        expect(rounded).to eq("M1,5C1.3,5.11,1.72,5.13,2,5C2.51,4.76,2.59,3,3,3")
+      end
+    end
+  end
+
+  describe "curve_linear" do
+    let(:name){ :curve_linear }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4L1,5L2,5L3,3L4,4")
+    end
+  end
+
+  describe "curve_linear_closed" do
+    let(:name){ :curve_linear_closed }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4L1,5L2,5L3,3L4,4Z")
+    end
+  end
+
+  describe "curve_monotone_x" do
+    let(:name){ :curve_monotone_x }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4C0.33,4.5,0.67,5,1,5C1.33,5,1.67,5,2,5C2.33,5,2.67,3,3,3C3.33,3,3.67,3.5,4,4")
+    end
+  end
+
+  describe "curve_monotone_y" do
+    let(:name){ :curve_monotone_y }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4C0.17,4.33,0.33,4.67,1,5C1,5,2,5,2,5C2.67,4.33,3,3.67,3,3C3,3.33,3.5,3.67,4,4")
+    end
+  end
+
+  describe "curve_natural" do
+    let(:name){ :curve_natural }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4C0.33,4.36,0.67,4.71,1,5C1.33,5.29,1.67,5.5,2,5C2.33,4.5,2.67,3.29,3,3C3.33,2.71,3.67,3.36,4,4")
+    end
+  end
+
+  describe "curve_step" do
+    let(:name){ :curve_step }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4L0.5,4L0.5,5L1.5,5L1.5,5L2.5,5L2.5,3L3.5,3L3.5,4L4,4")
+    end
+  end
+
+  describe "curve_step_after" do
+    let(:name){ :curve_step_after }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4L1,4L1,5L2,5L2,5L3,5L3,3L4,3L4,4")
+    end
+  end
+
+  describe "curve_step_before" do
+    let(:name){ :curve_step_before }
+    it do
+      expect(curve).to be_instance_of(D3::Curve)
+      expect(rounded).to eq("M0,4L0,5L1,5L1,5L2,5L2,3L3,3L3,4L4,4")
+    end
+  end
+
+end

data/spec/dsv_spec.rb

@@ -0,0 +1,194 @@
+describe "d3 - dsv" do
+  let(:csv_example) do
+    "Year,Make,Model,Length\n"+
+    "1997,Ford,E350,2.34\n"+
+    "2000,Mercury,Cougar,2.38\n"
+  end
+  let(:tsv_example) do
+    "Year\tMake\tModel\tLength\n"+
+    "1997\tFord\tE350\t2.34\n"+
+    "2000\tMercury\tCougar\t2.38\n"
+  end
+  let(:dsv_example) do
+    "Year;Make;Model;Length\n"+
+    "1997;Ford;E350;2.34\n"+
+    "2000;Mercury;Cougar;2.38\n"
+  end
+  let(:rows_example) {
+    [
+      ["Year", "Make", "Model", "Length"],
+      ["1997", "Ford", "E350", "2.34"],
+      ["2000", "Mercury", "Cougar", "2.38"],
+    ]
+  }
+  let(:objs_example) {
+    [
+      {"Year"=>"1997", "Make"=>"Ford", "Model"=>"E350", "Length"=>"2.34"},
+      {"Year"=>"2000", "Make"=>"Mercury", "Model"=>"Cougar", "Length"=>"2.38"},
+    ]
+  }
+  let(:csv_format) { D3.dsv_format(",") }
+  let(:tsv_format) { D3.dsv_format("\t") }
+  let(:dsv_format) { D3.dsv_format(";") }
+  let(:format_row) { proc{|(y,f,m,l)|
+    ["converted", (Integer(y) rescue y), f, m, (Float(l) rescue l)]
+  }}
+  let(:filter_row) { proc{|d|
+    format_row.(d) if d[0] == "2000" or d[0] == "1997"
+  }}
+  let(:format_obj) { proc{|o|
+    {y: o["Year"].to_i, f:o["Make"], m:o["Model"], l:o["Length"].to_f}
+  }}
+  let(:filter_obj) { proc{|o|
+    format_obj.(o) if o["Year"] == "2000"
+  }}
+
+  it "d3.dsv_format" do
+    expect(D3.dsv_format(";")).to be_instance_of(D3::DsvFormat)
+  end
+
+  it "dsv_format.parse_rows" do
+    expect(dsv_format.parse_rows(dsv_example)).to eq(rows_example)
+    expect(dsv_format.parse_rows(dsv_example, format_row)).to eq(
+           dsv_format.parse_rows(dsv_example, &format_row)
+    )
+    expect(dsv_format.parse_rows(dsv_example, format_row)).to eq([
+      ["converted", "Year", "Make", "Model", "Length"],
+      ["converted", 1997, "Ford", "E350", 2.34],
+      ["converted", 2000, "Mercury", "Cougar", 2.38],
+    ])
+    expect(dsv_format.parse_rows(dsv_example, filter_row)).to eq([
+      ["converted", 1997, "Ford", "E350", 2.34],
+      ["converted", 2000, "Mercury", "Cougar", 2.38],
+    ])
+  end
+
+  it "d3.csv_parse_rows" do
+    expect(D3.csv_parse_rows(csv_example)).to eq(
+           csv_format.parse_rows(csv_example))
+    expect(dsv_format.parse_rows(dsv_example)).to eq(
+           csv_format.parse_rows(csv_example))
+    expect(D3.csv_parse_rows(csv_example, format_row)).to eq(
+           csv_format.parse_rows(csv_example, format_row))
+    expect(D3.csv_parse_rows(csv_example, &format_row)).to eq(
+           csv_format.parse_rows(csv_example, &format_row))
+    expect(D3.csv_parse_rows(csv_example, filter_row)).to eq(
+           csv_format.parse_rows(csv_example, filter_row))
+    expect(D3.csv_parse_rows(csv_example, &filter_row)).to eq(
+           csv_format.parse_rows(csv_example, &filter_row))
+  end
+
+  it "d3.tsv_parse_rows" do
+    expect(D3.tsv_parse_rows(tsv_example)).to eq(
+           tsv_format.parse_rows(tsv_example))
+    expect(dsv_format.parse_rows(dsv_example)).to eq(
+           tsv_format.parse_rows(tsv_example))
+    expect(D3.tsv_parse_rows(tsv_example, format_row)).to eq(
+           tsv_format.parse_rows(tsv_example, format_row))
+    expect(D3.tsv_parse_rows(tsv_example, &format_row)).to eq(
+           tsv_format.parse_rows(tsv_example, &format_row))
+    expect(D3.tsv_parse_rows(tsv_example, filter_row)).to eq(
+           tsv_format.parse_rows(tsv_example, filter_row))
+    expect(D3.tsv_parse_rows(tsv_example, &filter_row)).to eq(
+          tsv_format.parse_rows(tsv_example, &filter_row))
+  end
+
+  # It's awful practice not to include final \n,
+  # but it's not our place to workaround D3's bugs here
+  it "dsv_format.format_rows" do
+    expect(dsv_format.format_rows(rows_example)).to eq(dsv_example.chomp)
+  end
+
+  it "d3.csv_format_rows" do
+    expect(csv_format.format_rows(rows_example)).to eq(csv_example.chomp)
+    expect(D3.csv_format_rows(rows_example)).to eq(csv_example.chomp)
+  end
+
+  it "d3.tsv_format_rows" do
+    expect(tsv_format.format_rows(rows_example)).to eq(tsv_example.chomp)
+    expect(D3.tsv_format_rows(rows_example)).to eq(tsv_example.chomp)
+  end
+
+  # We have ways to enforce proper Hash order, maybe it's a good idea
+  it "dsv_format.parse" do
+    expect(dsv_format.parse(dsv_example)).to eq(objs_example)
+    expect(dsv_format.parse(dsv_example, format_obj)).to eq(
+           dsv_format.parse(dsv_example, &format_obj))
+    expect(dsv_format.parse(dsv_example, &format_obj)).to eq([
+      {"y"=>1997, "f"=>"Ford", "m"=>"E350", "l"=>2.34},
+      {"y"=>2000, "f"=>"Mercury", "m"=>"Cougar", "l"=>2.38},
+    ])
+  end
+
+  it "dsv_format.parse - filtering" do
+    expect(dsv_format.parse(dsv_example, &filter_obj)).to eq(
+           dsv_format.parse(dsv_example, filter_obj))
+    expect(dsv_format.parse(dsv_example, &filter_obj)).to eq([
+      {"y"=>2000, "f"=>"Mercury", "m"=>"Cougar", "l"=>2.38},
+    ])
+  end
+
+  it "d3.csv_parse" do
+    expect(D3.csv_parse(csv_example)).to eq(
+           csv_format.parse(csv_example))
+    expect(dsv_format.parse(dsv_example)).to eq(
+           csv_format.parse(csv_example))
+    expect(D3.csv_parse(csv_example, format_obj)).to eq(
+           csv_format.parse(csv_example, format_obj))
+    expect(D3.csv_parse(csv_example, &format_obj)).to eq(
+           csv_format.parse(csv_example, &format_obj))
+    expect(D3.csv_parse(csv_example, filter_obj)).to eq(
+           csv_format.parse(csv_example, filter_obj))
+    expect(D3.csv_parse(csv_example, &filter_obj)).to eq(
+          csv_format.parse(csv_example, &filter_obj))
+  end
+
+  it "d3.tsv_parse" do
+    expect(D3.tsv_parse(tsv_example)).to eq(
+           tsv_format.parse(tsv_example))
+    expect(dsv_format.parse(dsv_example)).to eq(
+           tsv_format.parse(tsv_example))
+    expect(D3.tsv_parse(tsv_example, format_obj)).to eq(
+           tsv_format.parse(tsv_example, format_obj))
+    expect(D3.tsv_parse(tsv_example, &format_obj)).to eq(
+           tsv_format.parse(tsv_example, &format_obj))
+    expect(D3.tsv_parse(tsv_example, filter_obj)).to eq(
+           tsv_format.parse(tsv_example, filter_obj))
+    expect(D3.tsv_parse(tsv_example, &filter_obj)).to eq(
+          tsv_format.parse(tsv_example, &filter_obj))
+  end
+
+  # Same awful idea of not including final \n
+  it "dsv_format.format" do
+    expect(dsv_format.format(objs_example)).to eq(dsv_example.chomp)
+    expect(dsv_format.format(objs_example, ["Year", "Make", "Speed"])).to eq(
+      "Year;Make;Speed\n"+
+      "1997;Ford;\n"+
+      "2000;Mercury;"
+    )
+  end
+
+  it "d3.tsv_format" do
+    expect(tsv_format.format(objs_example, ["Year", "Make", "Speed"])).to eq(
+      "Year\tMake\tSpeed\n"+
+      "1997\tFord\t\n"+
+      "2000\tMercury\t"
+    )
+    expect(tsv_format.format(objs_example)).to eq(
+           D3.tsv_format(objs_example))
+    expect(tsv_format.format(objs_example, ["Year", "Make", "Speed"])).to eq(
+           D3.tsv_format(objs_example, ["Year", "Make", "Speed"]))
+  end
+
+  it "d3.csv_format" do
+    expect(csv_format.format(objs_example, ["Year", "Make", "Speed"])).to eq(
+      "Year,Make,Speed\n"+
+      "1997,Ford,\n"+
+      "2000,Mercury,"
+    )
+    expect(csv_format.format(objs_example)).to eq(
+           D3.csv_format(objs_example))
+    expect(csv_format.format(objs_example, ["Year", "Make", "Speed"])).to eq(
+           D3.csv_format(objs_example, ["Year", "Make", "Speed"]))
+  end
+end

data/spec/ease_spec.rb

@@ -0,0 +1,370 @@
+describe "d3-ease" do
+  let(:range) { (0..20).map{|x| x / 20 }}
+  let(:curve) { range.map{|t| D3.send(ease, t).round(4) }}
+  let(:f) { D3.send(ease) }
+  let(:curve_f) { range.map{|t| f.call(t).round(4) } }
+  describe "d3.ease_linear" do
+    let(:ease) { :ease_linear }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1])
+    end
+  end
+
+  describe "d3.ease_quad" do
+    let(:ease) { :ease_quad }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.005, 0.02, 0.045, 0.08, 0.125, 0.18, 0.245, 0.32, 0.405, 0.5, 0.595, 0.68, 0.755, 0.82, 0.875, 0.92, 0.955, 0.98, 0.995, 1])
+    end
+  end
+
+  describe "d3.ease_quad_in" do
+    let(:ease) { :ease_quad_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0025, 0.01, 0.0225, 0.04, 0.0625, 0.09, 0.1225, 0.16, 0.2025, 0.25, 0.3025, 0.36, 0.4225, 0.49, 0.5625, 0.64, 0.7225, 0.81, 0.9025, 1])
+    end
+  end
+
+  describe "d3.ease_quad_out" do
+    let(:ease) { :ease_quad_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0975, 0.19, 0.2775, 0.36, 0.4375, 0.51, 0.5775, 0.64, 0.6975, 0.75, 0.7975, 0.84, 0.8775, 0.91, 0.9375, 0.96, 0.9775, 0.99, 0.9975, 1])
+    end
+  end
+
+  describe "d3.ease_quad_in_out" do
+    let(:ease) { :ease_quad_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.005, 0.02, 0.045, 0.08, 0.125, 0.18, 0.245, 0.32, 0.405, 0.5, 0.595, 0.68, 0.755, 0.82, 0.875, 0.92, 0.955, 0.98, 0.995, 1])
+    end
+  end
+
+  describe "d3.ease_cubic" do
+    let(:ease) { :ease_cubic }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0005, 0.004, 0.0135, 0.032, 0.0625, 0.108, 0.1715, 0.256, 0.3645, 0.5, 0.6355, 0.744, 0.8285, 0.892, 0.9375, 0.968, 0.9865, 0.996, 0.9995, 1])
+    end
+  end
+
+  describe "d3.ease_cubic_in" do
+    let(:ease) { :ease_cubic_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0001, 0.001, 0.0034, 0.008, 0.0156, 0.027, 0.0429, 0.064, 0.0911, 0.125, 0.1664, 0.216, 0.2746, 0.343, 0.4219, 0.512, 0.6141, 0.729, 0.8574, 1])
+    end
+  end
+
+  describe "d3.ease_cubic_out" do
+    let(:ease) { :ease_cubic_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.1426, 0.271, 0.3859, 0.488, 0.5781, 0.657, 0.7254, 0.784, 0.8336, 0.875, 0.9089, 0.936, 0.9571, 0.973, 0.9844, 0.992, 0.9966, 0.999, 0.9999, 1])
+    end
+  end
+
+  describe "d3.ease_cubic_in_out" do
+    let(:ease) { :ease_cubic_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0005, 0.004, 0.0135, 0.032, 0.0625, 0.108, 0.1715, 0.256, 0.3645, 0.5, 0.6355, 0.744, 0.8285, 0.892, 0.9375, 0.968, 0.9865, 0.996, 0.9995, 1])
+    end
+  end
+
+  describe "d3.ease_sin" do
+    let(:ease) { :ease_sin }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0062, 0.0245, 0.0545, 0.0955, 0.1464, 0.2061, 0.273, 0.3455, 0.4218, 0.5, 0.5782, 0.6545, 0.727, 0.7939, 0.8536, 0.9045, 0.9455, 0.9755, 0.9938, 1])
+    end
+  end
+
+  describe "d3.ease_sin_in" do
+    let(:ease) { :ease_sin_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0031, 0.0123, 0.0276, 0.0489, 0.0761, 0.109, 0.1474, 0.191, 0.2396, 0.2929, 0.3506, 0.4122, 0.4775, 0.546, 0.6173, 0.691, 0.7666, 0.8436, 0.9215, 1])
+    end
+  end
+
+  describe "d3.ease_sin_out" do
+    let(:ease) { :ease_sin_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0785, 0.1564, 0.2334, 0.309, 0.3827, 0.454, 0.5225, 0.5878, 0.6494, 0.7071, 0.7604, 0.809, 0.8526, 0.891, 0.9239, 0.9511, 0.9724, 0.9877, 0.9969, 1])
+    end
+  end
+
+  describe "d3.ease_sin_in_out" do
+    let(:ease) { :ease_sin_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0062, 0.0245, 0.0545, 0.0955, 0.1464, 0.2061, 0.273, 0.3455, 0.4218, 0.5, 0.5782, 0.6545, 0.727, 0.7939, 0.8536, 0.9045, 0.9455, 0.9755, 0.9938, 1])
+    end
+  end
+
+  describe "d3.ease_exp" do
+    let(:ease) { :ease_exp }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0.0005, 0.001, 0.002, 0.0039, 0.0078, 0.0156, 0.0313, 0.0625, 0.125, 0.25, 0.5, 0.75, 0.875, 0.9375, 0.9688, 0.9844, 0.9922, 0.9961, 0.998, 0.999, 0.9995])
+    end
+  end
+
+  describe "d3.ease_exp_in" do
+    let(:ease) { :ease_exp_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0.001, 0.0014, 0.002, 0.0028, 0.0039, 0.0055, 0.0078, 0.011, 0.0156, 0.0221, 0.0313, 0.0442, 0.0625, 0.0884, 0.125, 0.1768, 0.25, 0.3536, 0.5, 0.7071, 1])
+    end
+  end
+
+  describe "d3.ease_exp_out" do
+    let(:ease) { :ease_exp_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.2929, 0.5, 0.6464, 0.75, 0.8232, 0.875, 0.9116, 0.9375, 0.9558, 0.9688, 0.9779, 0.9844, 0.989, 0.9922, 0.9945, 0.9961, 0.9972, 0.998, 0.9986, 0.999])
+    end
+  end
+
+  describe "d3.ease_exp_in_out" do
+    let(:ease) { :ease_exp_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0.0005, 0.001, 0.002, 0.0039, 0.0078, 0.0156, 0.0313, 0.0625, 0.125, 0.25, 0.5, 0.75, 0.875, 0.9375, 0.9688, 0.9844, 0.9922, 0.9961, 0.998, 0.999, 0.9995])
+    end
+  end
+
+  describe "d3.ease_circle" do
+    let(:ease) { :ease_circle }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0025, 0.0101, 0.023, 0.0417, 0.067, 0.1, 0.1429, 0.2, 0.2821, 0.5, 0.7179, 0.8, 0.8571, 0.9, 0.933, 0.9583, 0.977, 0.9899, 0.9975, 1])
+    end
+  end
+
+  describe "d3.ease_circle_in" do
+    let(:ease) { :ease_circle_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0013, 0.005, 0.0113, 0.0202, 0.0318, 0.0461, 0.0633, 0.0835, 0.107, 0.134, 0.1648, 0.2, 0.2401, 0.2859, 0.3386, 0.4, 0.4732, 0.5641, 0.6878, 1])
+    end
+  end
+
+  describe "d3.ease_circle_out" do
+    let(:ease) { :ease_circle_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.3122, 0.4359, 0.5268, 0.6, 0.6614, 0.7141, 0.7599, 0.8, 0.8352, 0.866, 0.893, 0.9165, 0.9367, 0.9539, 0.9682, 0.9798, 0.9887, 0.995, 0.9987, 1])
+    end
+  end
+
+  describe "d3.ease_circle_in_out" do
+    let(:ease) { :ease_circle_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0025, 0.0101, 0.023, 0.0417, 0.067, 0.1, 0.1429, 0.2, 0.2821, 0.5, 0.7179, 0.8, 0.8571, 0.9, 0.933, 0.9583, 0.977, 0.9899, 0.9975, 1])
+    end
+  end
+
+  describe "d3.ease_bounce" do
+    let(:ease) { :ease_bounce }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0189, 0.0756, 0.1702, 0.3025, 0.4727, 0.6806, 0.9264, 0.91, 0.8189, 0.7656, 0.7502, 0.7725, 0.8327, 0.9306, 0.9727, 0.94, 0.9452, 0.9881, 0.9845, 1])
+    end
+  end
+
+  describe "d3.ease_bounce_in" do
+    let(:ease) { :ease_bounce_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0155, 0.0119, 0.0548, 0.06, 0.0273, 0.0694, 0.1673, 0.2275, 0.2498, 0.2344, 0.1811, 0.09, 0.0736, 0.3194, 0.5273, 0.6975, 0.8298, 0.9244, 0.9811, 1])
+    end
+  end
+
+  describe "d3.ease_bounce_out" do
+    let(:ease) { :ease_bounce_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0189, 0.0756, 0.1702, 0.3025, 0.4727, 0.6806, 0.9264, 0.91, 0.8189, 0.7656, 0.7502, 0.7725, 0.8327, 0.9306, 0.9727, 0.94, 0.9452, 0.9881, 0.9845, 1])
+    end
+  end
+
+  describe "d3.ease_bounce_in_out" do
+    let(:ease) { :ease_bounce_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0059, 0.03, 0.0347, 0.1138, 0.1172, 0.045, 0.1597, 0.3488, 0.4622, 0.5, 0.5378, 0.6512, 0.8403, 0.955, 0.8828, 0.8863, 0.9653, 0.97, 0.9941, 1])
+    end
+  end
+
+  describe "d3.ease_poly_in" do
+    let(:ease) { :ease_poly_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0001, 0.001, 0.0034, 0.008, 0.0156, 0.027, 0.0429, 0.064, 0.0911, 0.125, 0.1664, 0.216, 0.2746, 0.343, 0.4219, 0.512, 0.6141, 0.729, 0.8574, 1])
+    end
+
+    describe "custom exponent" do
+      let(:f) { D3.send(ease).exponent(2) }
+      it do
+        expect(curve_f).to eq([0, 0.0025, 0.01, 0.0225, 0.04, 0.0625, 0.09, 0.1225, 0.16, 0.2025, 0.25, 0.3025, 0.36, 0.4225, 0.49, 0.5625, 0.64, 0.7225, 0.81, 0.9025, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_poly_out" do
+    let(:ease) { :ease_poly_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.1426, 0.271, 0.3859, 0.488, 0.5781, 0.657, 0.7254, 0.784, 0.8336, 0.875, 0.9089, 0.936, 0.9571, 0.973, 0.9844, 0.992, 0.9966, 0.999, 0.9999, 1])
+    end
+
+    describe "custom exponent" do
+      let(:f) { D3.send(ease).exponent(2) }
+      it do
+        expect(curve_f).to eq([0, 0.0975, 0.19, 0.2775, 0.36, 0.4375, 0.51, 0.5775, 0.64, 0.6975, 0.75, 0.7975, 0.84, 0.8775, 0.91, 0.9375, 0.96, 0.9775, 0.99, 0.9975, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_poly_in_out" do
+    let(:ease) { :ease_poly_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.0005, 0.004, 0.0135, 0.032, 0.0625, 0.108, 0.1715, 0.256, 0.3645, 0.5, 0.6355, 0.744, 0.8285, 0.892, 0.9375, 0.968, 0.9865, 0.996, 0.9995, 1])
+    end
+
+    describe "custom exponent" do
+      let(:f) { D3.send(ease).exponent(2) }
+      it do
+        expect(curve_f).to eq([0, 0.005, 0.02, 0.045, 0.08, 0.125, 0.18, 0.245, 0.32, 0.405, 0.5, 0.595, 0.68, 0.755, 0.82, 0.875, 0.92, 0.955, 0.98, 0.995, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_back_in" do
+    let(:ease) { :ease_back_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, -0.0039, -0.0143, -0.0292, -0.0465, -0.0641, -0.0802, -0.0926, -0.0994, -0.0984, -0.0877, -0.0653, -0.029, 0.023, 0.0929, 0.1826, 0.2942, 0.4297, 0.5912, 0.7806, 1])
+    end
+
+    describe "custom overshoot" do
+      let(:f) { D3.send(ease).overshoot(4) }
+      it do
+        expect(curve_f).to eq([0, -0.0094, -0.035, -0.0731, -0.12, -0.1719, -0.225, -0.2756, -0.32, -0.3544, -0.375, -0.3781, -0.36, -0.3169, -0.245, -0.1406, 0, 0.1806, 0.405, 0.6769, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_back_out" do
+    let(:ease) { :ease_back_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.2194, 0.4088, 0.5703, 0.7058, 0.8174, 0.9071, 0.977, 1.029, 1.0653, 1.0877, 1.0984, 1.0994, 1.0926, 1.0802, 1.0641, 1.0465, 1.0292, 1.0143, 1.0039, 1])
+    end
+
+    describe "custom overshoot" do
+      let(:f) { D3.send(ease).overshoot(4) }
+      it do
+        expect(curve_f).to eq([0, 0.3231, 0.595, 0.8194, 1, 1.1406, 1.245, 1.3169, 1.36, 1.3781, 1.375, 1.3544, 1.32, 1.2756, 1.225, 1.1719, 1.12, 1.0731, 1.035, 1.0094, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_back" do
+    let(:ease) { :ease_back }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, -0.0072, -0.0232, -0.0401, -0.0497, -0.0438, -0.0145, 0.0464, 0.1471, 0.2956, 0.5, 0.7044, 0.8529, 0.9536, 1.0145, 1.0438, 1.0497, 1.0401, 1.0232, 1.0072, 1])
+    end
+
+    describe "custom overshoot" do
+      let(:f) { D3.send(ease).overshoot(4) }
+      it do
+        expect(curve_f).to eq([0, -0.0175, -0.06, -0.1125, -0.16, -0.1875, -0.18, -0.1225, 0, 0.2025, 0.5, 0.7975, 1, 1.1225, 1.18, 1.1875, 1.16, 1.1125, 1.06, 1.0175, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_back_in_out" do
+    let(:ease) { :ease_back_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, -0.0072, -0.0232, -0.0401, -0.0497, -0.0438, -0.0145, 0.0464, 0.1471, 0.2956, 0.5, 0.7044, 0.8529, 0.9536, 1.0145, 1.0438, 1.0497, 1.0401, 1.0232, 1.0072, 1])
+    end
+
+    describe "custom overshoot" do
+      let(:f) { D3.send(ease).overshoot(4) }
+      it do
+        expect(curve_f).to eq([0, -0.0175, -0.06, -0.1125, -0.16, -0.1875, -0.18, -0.1225, 0, 0.2025, 0.5, 0.7975, 1, 1.1225, 1.18, 1.1875, 1.16, 1.1125, 1.06, 1.0175, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_elastic_in" do
+    let(:ease) { :ease_elastic_in }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([-0.0005, 0.0007, 0.002, 0.0014, -0.002, -0.0055, -0.0039, 0.0055, 0.0156, 0.011, -0.0156, -0.0442, -0.0313, 0.0442, 0.125, 0.0884, -0.125, -0.3536, -0.25, 0.3536, 1])
+    end
+
+    describe "custom amplitude/period" do
+      let(:f) { D3.send(ease).amplitude(2).period(0.2) }
+      it do
+        expect(curve_f).to eq([0.001, -0.0024, -0.002, 0.0048, 0.0039, -0.0096, -0.0078, 0.0191, 0.0156, -0.0383, -0.0313, 0.0765, 0.0625, -0.1531, -0.125, 0.3062, 0.25, -0.6124, -0.5, 1.2247, 1])
+      end
+    end
+  end
+
+  describe "d3.ease_elastic_out" do
+    let(:ease) { :ease_elastic_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.6464, 1.25, 1.3536, 1.125, 0.9116, 0.875, 0.9558, 1.0313, 1.0442, 1.0156, 0.989, 0.9844, 0.9945, 1.0039, 1.0055, 1.002, 0.9986, 0.998, 0.9993, 1.0005])
+    end
+
+    describe "custom amplitude/period" do
+      let(:f) { D3.send(ease).amplitude(2).period(0.2) }
+      it do
+        expect(curve_f).to eq([0, -0.2247, 1.5, 1.6124, 0.75, 0.6938, 1.125, 1.1531, 0.9375, 0.9235, 1.0313, 1.0383, 0.9844, 0.9809, 1.0078, 1.0096, 0.9961, 0.9952, 1.002, 1.0024, 0.999])
+      end
+    end
+  end
+
+  describe "d3.ease_elastic" do
+    let(:ease) { :ease_elastic }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([0, 0.6464, 1.25, 1.3536, 1.125, 0.9116, 0.875, 0.9558, 1.0313, 1.0442, 1.0156, 0.989, 0.9844, 0.9945, 1.0039, 1.0055, 1.002, 0.9986, 0.998, 0.9993, 1.0005])
+    end
+
+    describe "custom amplitude/period" do
+      let(:f) { D3.send(ease).amplitude(2).period(0.2) }
+      it do
+        expect(curve_f).to eq([0, -0.2247, 1.5, 1.6124, 0.75, 0.6938, 1.125, 1.1531, 0.9375, 0.9235, 1.0313, 1.0383, 0.9844, 0.9809, 1.0078, 1.0096, 0.9961, 0.9952, 1.002, 1.0024, 0.999])
+      end
+    end
+  end
+
+  describe "d3.ease_elastic_in_out" do
+    let(:ease) { :ease_elastic_in_out }
+    it do
+      expect(curve).to eq(curve_f)
+      expect(curve).to eq([-0.0002, 0.001, -0.001, -0.002, 0.0078, -0.0078, -0.0156, 0.0625, -0.0625, -0.125, 0.5, 1.125, 1.0625, 0.9375, 1.0156, 1.0078, 0.9922, 1.002, 1.001, 0.999, 1.0002])
+    end
+
+    describe "custom amplitude/period" do
+      let(:f) { D3.send(ease).amplitude(2).period(0.2) }
+      it do
+        expect(curve_f).to eq([0.0005, -0.001, 0.002, -0.0039, 0.0078, -0.0156, 0.0313, -0.0625, 0.125, -0.25, 0.5, 1.25, 0.875, 1.0625, 0.9688, 1.0156, 0.9922, 1.0039, 0.998, 1.001, 0.9995])
+      end
+    end
+  end
+end