opal-d3 0.0.20170205

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

data/spec/coverage_spec.rb

@@ -0,0 +1,23 @@
+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 }
+
+  it "everything is covered" do
+    working_methods = nice_methods.select{|m| D3.respond_to?(m) }
+    expect(working_methods.size).to eq(nice_methods.size)
+  end
+
+  # DETAILED
+  # 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,214 @@
+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
+
+__END__
+
+curve.areaStart - start a new area segment.
+curve.areaEnd - end the current area segment.
+curve.lineStart - start a new line segment.
+curve.lineEnd - end the current line segment.
+curve.point - add a point to the current line segment.

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