opal-d3 0.0.20170205

data/spec/symbol_spec.rb

@@ -0,0 +1,121 @@
+describe "d3 - symbol" do
+  let(:path) { symbol.() }
+  let(:rounded) { path.gsub(/\d+\.\d+/){$&.to_f.round(2)} }
+
+  it "d3.symbol" do
+    expect(D3.symbol).to be_instance_of(D3::SymbolGenerator)
+  end
+
+  describe "basics" do
+    let(:symbol) { D3.symbol }
+    it do
+      expect(rounded).to eq("M4.51,0A4.51,4.51,0,1,1,-4.51,0A4.51,4.51,0,1,1,4.51,0")
+    end
+  end
+
+  describe "static size/type" do
+    let(:symbol) { D3.symbol.type(D3.symbol_triangle).size(1000) }
+    it do
+      expect(rounded).to eq("M0,-27.75L24.03,13.87L-24.03,13.87Z")
+    end
+  end
+
+  describe "fuctional size/type" do
+    let(:symbol) {
+      D3.symbol
+        .size{|d| d[:size]}
+        .type{|d| D3.symbols[d[:type]]}
+    }
+    let(:path) { symbol.(data) }
+    describe do
+      let(:data) {{ size: 100, type: 0 }}
+      it do
+        expect(rounded).to eq("M5.64,0A5.64,5.64,0,1,1,-5.64,0A5.64,5.64,0,1,1,5.64,0")
+      end
+    end
+    describe do
+      let(:data) {{ size: 200, type: 0 }}
+      it do
+        expect(rounded).to eq("M7.98,0A7.98,7.98,0,1,1,-7.98,0A7.98,7.98,0,1,1,7.98,0")
+      end
+    end
+    describe do
+      let(:data) {{ size: 100, type: 1 }}
+      it do
+        expect(rounded).to eq( "M-6.71,-2.24L-2.24,-2.24L-2.24,-6.71L2.24,-6.71L2.24,-2.24L6.71,-2.24L6.71,2.24L2.24,2.24L2.24,6.71L-2.24,6.71L-2.24,2.24L-6.71,2.24Z")
+      end
+    end
+  end
+
+  it "d3.symbols" do
+    expect(D3.symbols.size).to eq(7)
+    D3.symbols.each do |sym|
+      expect(sym).to be_instance_of(D3::SymbolType)
+    end
+  end
+
+  describe "symbol types" do
+    let(:symbol) { D3.symbol.type(symbol_type) }
+
+    describe "d3.symbol_circle" do
+      let(:symbol_type) { D3.symbol_circle }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M4.51,0A4.51,4.51,0,1,1,-4.51,0A4.51,4.51,0,1,1,4.51,0")
+      end
+    end
+
+    describe "d3.symbol_cross" do
+      let(:symbol_type) { D3.symbol_cross }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M-5.37,-1.79L-1.79,-1.79L-1.79,-5.37L1.79,-5.37L1.79,-1.79L5.37,-1.79L5.37,1.79L1.79,1.79L1.79,5.37L-1.79,5.37L-1.79,1.79L-5.37,1.79Z")
+      end
+    end
+
+    describe "d3.symbol_diamond" do
+      let(:symbol_type) { D3.symbol_diamond }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M0,-7.44L4.3,0L0,7.44L-4.3,0Z")
+      end
+    end
+
+    describe "d3.symbol_square" do
+      let(:symbol_type) { D3.symbol_square }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M-4,-4h8v8h-8Z")
+      end
+    end
+
+    describe "d3.symbol_star" do
+      let(:symbol_type) { D3.symbol_star }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M0,-7.55L1.7,-2.33L7.18,-2.33L2.74,0.89L4.44,6.11L4.44e-16,2.88L-4.44,6.11L-2.74,0.89L-7.18,-2.33L-1.7,-2.33Z")
+      end
+    end
+
+    describe "d3.symbol_triangle" do
+      let(:symbol_type) { D3.symbol_triangle }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M0,-7.02L6.08,3.51L-6.08,3.51Z")
+      end
+    end
+
+    describe "d3.symbol_wye" do
+      let(:symbol_type) { D3.symbol_wye }
+      it do
+        expect(symbol_type).to be_instance_of(D3::SymbolType)
+        expect(rounded).to eq("M2.16,1.25L2.16,5.56L-2.16,5.56L-2.16,1.25L-5.9,-0.91L-3.74,-4.65L0,-2.49L3.74,-4.65L5.9,-0.91Z")
+      end
+    end
+  end
+end
+
+__END__
+
+symbol.context - set the rendering context.
+symbolType.draw - draw this symbol to the given context.

data/spec/threshold_scale_spec.rb

@@ -0,0 +1,28 @@
+describe "d3 - threshold scale" do
+  let(:color) { D3.scale_threshold.domain([0, 1]).range(["red", "white", "green"]) }
+  it "d3.scale_threshold" do
+    expect(D3.scale_threshold).to be_instance_of(D3::ThresholdScale)
+  end
+
+  it "basics" do
+    expect(color.(-1)).to eq("red")
+    expect(color.(0)).to eq("white")
+    expect(color.(0.5)).to eq("white")
+    expect(color.(1)).to eq("green")
+    expect(color.(1000)).to eq("green")
+  end
+
+  it "invert_extent" do
+    expect(color.invert_extent("red")).to eq([nil, 0])
+    expect(color.invert_extent("white")).to eq([0, 1])
+    expect(color.invert_extent("green")).to eq([1, nil])
+  end
+
+  it "copy" do
+    cc = color.copy.domain([0,10])
+    expect(cc.domain).to eq([0,10])
+    expect(cc.range).to eq(["red", "white", "green"])
+    expect(color.domain).to eq([0,1])
+    expect(color.range).to eq(["red", "white", "green"])
+  end
+end

data/spec/time_format_spec.rb

@@ -0,0 +1,99 @@
+require "time"
+
+# Running these specs in weird timezone will fail because javascript timezones are pile of fail
+describe "d3 - time format" do
+  let(:us) {{
+    date_time: "%x, %X",
+    date: "%-m/%-d/%Y",
+    time: "%-I:%M:%S %p",
+    periods: ["AM", "PM"],
+    days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    short_days: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+    short_months: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+  }}
+  let(:pl) {{
+    date_time: "%A, %e %B %Y, %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["Niedziela", "Poniedziałek", "Wtorek", "Środa", "Czwartek", "Piątek", "Sobota"],
+    short_days: ["Niedz.", "Pon.", "Wt.", "Śr.", "Czw.", "Pt.", "Sob."],
+    months: ["Styczeń", "Luty", "Marzec", "Kwiecień", "Maj", "Czerwiec", "Lipiec", "Sierpień", "Wrzesień", "Październik", "Listopad", "Grudzień"],
+    short_months: ["Stycz.", "Luty", "Marz.", "Kwie.", "Maj", "Czerw.", "Lipc.", "Sierp.", "Wrz.", "Paźdz.", "Listop.", "Grudz."],
+  }}
+
+  it "d3.time_format" do
+    f = D3.time_format("%B %d, %Y")
+    expect(f).to be_instance_of(Proc)
+    expect(f.(Time.parse("June 30, 2015"))).to eq("June 30, 2015")
+  end
+
+  it "d3.time_parse" do
+    f = D3.time_parse("%B %d, %Y")
+    expect(f).to be_instance_of(Proc)
+    expect(f.("June 30, 2015")).to eq(Time.parse("June 30, 2015 00:00:00"))
+  end
+
+  it "d3.utc_format" do
+    f = D3.utc_format("%B %d, %Y")
+    expect(f).to be_instance_of(Proc)
+    expect(f.(Time.parse("June 30, 2015 12:00:00"))).to eq("June 30, 2015")
+  end
+
+  it "d3.utc_parse" do
+    f = D3.utc_parse("%B %d, %Y")
+    expect(f).to be_instance_of(Proc)
+    expect(f.("June 30, 2015")).to eq(Time.parse("June 30, 2015 00:00:00 UTC"))
+  end
+
+  it "d3.iso_format / d3.iso_parse" do
+    t = Time.parse("June 30, 2015 12:30:45 UTC")
+    s = "2015-06-30T12:30:45.000Z"
+    expect(D3.iso_format(t)).to eq(s)
+    expect(D3.iso_parse(s)).to eq(t)
+  end
+
+  describe "locale" do
+    let(:locale) { D3.time_format_locale(pl) }
+
+    it "d3.format" do
+      f = locale.format("%B %d, %Y")
+      expect(f).to be_instance_of(Proc)
+      expect(f.(Time.parse("June 30, 2015"))).to eq("Czerwiec 30, 2015")
+    end
+
+    it "d3.parse" do
+      f = locale.parse("%B %d, %Y")
+      expect(f).to be_instance_of(Proc)
+      expect(f.("Czerwiec 30, 2015")).to eq(Time.parse("June 30, 2015 00:00:00"))
+    end
+
+    it "d3.utc_format" do
+      f = locale.utc_format("%B %d, %Y")
+      expect(f).to be_instance_of(Proc)
+      expect(f.(Time.parse("June 30, 2015 12:00:00"))).to eq("Czerwiec 30, 2015")
+    end
+
+    it "d3.utc_parse" do
+      f = locale.utc_parse("%B %d, %Y")
+      expect(f).to be_instance_of(Proc)
+      expect(f.("Czerwiec 30, 2015")).to eq(Time.parse("June 30, 2015 00:00:00 UTC"))
+    end
+  end
+
+  # This test affects global state, so we must be sure to restore it
+  it "d3.time_format_default_locale" do
+    t = Time.parse("June 30, 2015 12:30:00")
+    expect(D3.time_format("%c").(t)).to eq("6/30/2015, 12:30:00 PM")
+
+    locale_pl = D3.time_format_default_locale(pl)
+    expect(D3.time_format("%c").(t)).to eq("Wtorek, 30 Czerwiec 2015, 12:30:00")
+
+    locale_us = D3.time_format_default_locale(us)
+    expect(D3.time_format("%c").(t)).to eq("6/30/2015, 12:30:00 PM")
+
+    expect(locale_pl.format("%c").(t)).to eq("Wtorek, 30 Czerwiec 2015, 12:30:00")
+    expect(locale_us.format("%c").(t)).to eq("6/30/2015, 12:30:00 PM")
+  end
+end

data/spec/time_interval_spec.rb

@@ -0,0 +1,304 @@
+describe "d3 - time interval" do
+  let(:a) { Time.at(1481073422.123678) } # 2016-12-07 01:17:02.123678
+  let(:b) { Time.at(1482781833.345345) } # 2016-12-26 19:50:33.345345
+  let(:c) { Time.at(1000000000 )} # 2001-09-09 02:46:40 +0100
+
+  it "time_interval.offset" do
+    expect(D3.time_year.offset(a).to_s).to eq("2017-12-07 01:17:02 -0000")
+    expect(D3.time_year.offset(a, 10).to_s).to eq("2026-12-07 01:17:02 -0000")
+  end
+
+  it "time_interval.range" do
+    expect(D3.time_day.range(a, a+3*24*3600).map(&:to_s)).to eq([
+      "2016-12-08 00:00:00 -0000", "2016-12-09 00:00:00 -0000", "2016-12-10 00:00:00 -0000"
+    ])
+    expect(D3.time_day.range(a, b, 5).map(&:to_s)).to eq([
+      "2016-12-08 00:00:00 -0000", "2016-12-13 00:00:00 -0000", "2016-12-18 00:00:00 -0000", "2016-12-23 00:00:00 -0000"
+    ])
+  end
+
+  # It's not same as passing step to range
+  it "time_interval.every" do
+    expect(D3.time_day.every(5).range(a, b).map(&:to_s)).to eq([
+      "2016-12-11 00:00:00 -0000", "2016-12-16 00:00:00 -0000", "2016-12-21 00:00:00 -0000", "2016-12-26 00:00:00 -0000"
+    ])
+  end
+
+  it "time_interval.filter" do
+    expect(D3.time_day.filter{|d| d.day % 5 == 1}.range(a, b).map(&:to_s)).to eq([
+      "2016-12-11 00:00:00 -0000", "2016-12-16 00:00:00 -0000", "2016-12-21 00:00:00 -0000", "2016-12-26 00:00:00 -0000"
+    ])
+  end
+
+  it "time_interval.count" do
+    expect(D3.time_day.count(a, b)).to eq(19)
+  end
+
+  it "d3.time_year" do
+    expect(D3.time_year.floor(a).to_s).to eq("2016-01-01 00:00:00 -0000")
+    expect(D3.time_year.round(a).to_s).to eq("2017-01-01 00:00:00 -0000")
+    expect(D3.time_year.ceil(a).to_s).to eq("2017-01-01 00:00:00 -0000")
+  end
+  it "d3.utc_year" do
+    expect(D3.utc_year.floor(a).to_s).to eq("2016-01-01 00:00:00 -0000")
+    expect(D3.utc_year.round(a).to_s).to eq("2017-01-01 00:00:00 -0000")
+    expect(D3.utc_year.ceil(a).to_s).to eq("2017-01-01 00:00:00 -0000")
+  end
+
+  it "d3.time_month" do
+    expect(D3.time_month.floor(a).to_s).to eq("2016-12-01 00:00:00 -0000")
+  end
+  it "d3.utc_month" do
+    expect(D3.utc_month.floor(a).to_s).to eq("2016-12-01 00:00:00 -0000")
+  end
+
+  it "d3.time_week" do
+    expect(D3.time_week.floor(a).to_s).to eq("2016-12-04 00:00:00 -0000")
+  end
+  it "d3.utc_week" do
+    expect(D3.utc_week.floor(a).to_s).to eq("2016-12-04 00:00:00 -0000")
+  end
+
+  it "d3.time_monday" do
+    expect(D3.time_monday.floor(a).to_s).to eq("2016-12-05 00:00:00 -0000")
+  end
+  it "d3.utc_monday" do
+    expect(D3.utc_monday.floor(a).to_s).to eq("2016-12-05 00:00:00 -0000")
+  end
+
+  it "d3.time_tuesday" do
+    expect(D3.time_tuesday.floor(a).to_s).to eq("2016-12-06 00:00:00 -0000")
+  end
+  it "d3.utc_tuesday" do
+    expect(D3.utc_tuesday.floor(a).to_s).to eq("2016-12-06 00:00:00 -0000")
+  end
+
+  it "d3.time_wednesday" do
+    expect(D3.time_wednesday.floor(a).to_s).to eq("2016-12-07 00:00:00 -0000")
+  end
+  it "d3.utc_wednesday" do
+    expect(D3.utc_wednesday.floor(a).to_s).to eq("2016-12-07 00:00:00 -0000")
+  end
+
+  it "d3.time_thursday" do
+    expect(D3.time_thursday.floor(a).to_s).to eq("2016-12-01 00:00:00 -0000")
+  end
+  it "d3.utc_thursday" do
+    expect(D3.utc_thursday.floor(a).to_s).to eq("2016-12-01 00:00:00 -0000")
+  end
+
+  it "d3.time_friday" do
+    expect(D3.time_friday.floor(a).to_s).to eq("2016-12-02 00:00:00 -0000")
+  end
+  it "d3.utc_friday" do
+    expect(D3.utc_friday.floor(a).to_s).to eq("2016-12-02 00:00:00 -0000")
+  end
+
+  it "d3.time_saturday" do
+    expect(D3.time_saturday.floor(a).to_s).to eq("2016-12-03 00:00:00 -0000")
+  end
+  it "d3.utc_saturday" do
+    expect(D3.utc_saturday.floor(a).to_s).to eq("2016-12-03 00:00:00 -0000")
+  end
+
+  it "d3.time_sunday" do
+    expect(D3.time_sunday.floor(a).to_s).to eq("2016-12-04 00:00:00 -0000")
+  end
+  it "d3.utc_sunday" do
+    expect(D3.utc_sunday.floor(a).to_s).to eq("2016-12-04 00:00:00 -0000")
+  end
+
+  it "d3.time_day" do
+    expect(D3.time_day.floor(a).to_s).to eq("2016-12-07 00:00:00 -0000")
+  end
+  it "d3.utc_day" do
+    expect(D3.utc_day.floor(a).to_s).to eq("2016-12-07 00:00:00 -0000")
+  end
+
+  it "d3.time_hour" do
+    expect(D3.time_hour.floor(a).to_s).to eq("2016-12-07 01:00:00 -0000")
+  end
+  it "d3.utc_hour" do
+    expect(D3.utc_hour.floor(a).to_s).to eq("2016-12-07 01:00:00 -0000")
+  end
+
+  it "d3.time_minute" do
+    expect(D3.time_minute.floor(a).to_s).to eq("2016-12-07 01:17:00 -0000")
+  end
+  it "d3.utc_minute" do
+    expect(D3.utc_minute.floor(a).to_s).to eq("2016-12-07 01:17:00 -0000")
+  end
+
+  it "d3.time_second" do
+    expect(D3.time_second.floor(a).to_s).to eq("2016-12-07 01:17:02 -0000")
+    expect(D3.utc_second.ceil(a).to_s).to eq("2016-12-07 01:17:03 -0000")
+  end
+  it "d3.utc_second" do
+    expect(D3.utc_second.floor(a).to_s).to eq("2016-12-07 01:17:02 -0000")
+    expect(D3.utc_second.ceil(a).to_s).to eq("2016-12-07 01:17:03 -0000")
+  end
+
+  # This looks like bug in D3, ceil should be 124000
+  it "d3.time_millisecond" do
+    expect(D3.time_millisecond.floor(a).to_s).to eq("2016-12-07 01:17:02 -0000")
+    expect(D3.time_millisecond.ceil(a).to_s).to eq("2016-12-07 01:17:02 -0000")
+    expect(D3.utc_millisecond.floor(a).usec).to eq(123000)
+    expect(D3.utc_millisecond.ceil(a).usec).to eq(123000)
+  end
+  it "d3.utc_millisecond" do
+    expect(D3.utc_millisecond.floor(a).to_s).to eq("2016-12-07 01:17:02 -0000")
+    expect(D3.utc_millisecond.ceil(a).to_s).to eq("2016-12-07 01:17:02 -0000")
+    expect(D3.utc_millisecond.floor(a).usec).to eq(123000)
+    expect(D3.utc_millisecond.ceil(a).usec).to eq(123000)
+  end
+
+  it "d3.time_years" do
+    expect(D3.time_years(c,a).size).to eq(15)
+    expect(D3.time_years(c,a,2).size).to eq(8)
+  end
+  it "d3.utc_years" do
+    expect(D3.time_years(c,a).size).to eq(15)
+    expect(D3.time_years(c,a,2).size).to eq(8)
+  end
+
+  it "d3.time_months" do
+    expect(D3.time_months(c,a).size).to eq(183)
+    expect(D3.time_months(c,a,12).size).to eq(16)
+  end
+  it "d3.utc_months" do
+    expect(D3.time_months(c,a).size).to eq(183)
+    expect(D3.time_months(c,a,12).size).to eq(16)
+  end
+
+  it "d3.time_mondays" do
+    expect(D3.time_mondays(a,b).map(&:to_s)).to eq([
+      "2016-12-12 00:00:00 -0000", "2016-12-19 00:00:00 -0000", "2016-12-26 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_mondays" do
+    expect(D3.utc_mondays(a,b).map(&:to_s)).to eq([
+      "2016-12-12 00:00:00 -0000", "2016-12-19 00:00:00 -0000", "2016-12-26 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_tuesdays" do
+    expect(D3.time_tuesdays(a,b).map(&:to_s)).to eq([
+      "2016-12-13 00:00:00 -0000", "2016-12-20 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_tuesdays" do
+    expect(D3.utc_tuesdays(a,b).map(&:to_s)).to eq([
+      "2016-12-13 00:00:00 -0000", "2016-12-20 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_wednesdays" do
+    expect(D3.time_wednesdays(a,b).map(&:to_s)).to eq([
+      "2016-12-14 00:00:00 -0000", "2016-12-21 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_wednesdays" do
+    expect(D3.utc_wednesdays(a,b).map(&:to_s)).to eq([
+      "2016-12-14 00:00:00 -0000", "2016-12-21 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_thursdays" do
+    expect(D3.time_thursdays(a,b).map(&:to_s)).to eq([
+      "2016-12-08 00:00:00 -0000", "2016-12-15 00:00:00 -0000", "2016-12-22 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_thursdays" do
+    expect(D3.utc_thursdays(a,b).map(&:to_s)).to eq([
+      "2016-12-08 00:00:00 -0000", "2016-12-15 00:00:00 -0000", "2016-12-22 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_fridays" do
+    expect(D3.time_fridays(a,b).map(&:to_s)).to eq([
+      "2016-12-09 00:00:00 -0000", "2016-12-16 00:00:00 -0000", "2016-12-23 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_fridays" do
+    expect(D3.utc_fridays(a,b).map(&:to_s)).to eq([
+      "2016-12-09 00:00:00 -0000", "2016-12-16 00:00:00 -0000", "2016-12-23 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_saturdays" do
+    expect(D3.time_saturdays(a,b).map(&:to_s)).to eq([
+      "2016-12-10 00:00:00 -0000", "2016-12-17 00:00:00 -0000", "2016-12-24 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_saturdays" do
+    expect(D3.utc_saturdays(a,b).map(&:to_s)).to eq([
+      "2016-12-10 00:00:00 -0000", "2016-12-17 00:00:00 -0000", "2016-12-24 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_sundays" do
+    expect(D3.time_sundays(a,b).map(&:to_s)).to eq([
+      "2016-12-11 00:00:00 -0000", "2016-12-18 00:00:00 -0000", "2016-12-25 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_sundays" do
+    expect(D3.utc_sundays(a,b).map(&:to_s)).to eq([
+      "2016-12-11 00:00:00 -0000", "2016-12-18 00:00:00 -0000", "2016-12-25 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_weeks" do
+    expect(D3.time_weeks(a,b).map(&:to_s)).to eq([
+      "2016-12-11 00:00:00 -0000", "2016-12-18 00:00:00 -0000", "2016-12-25 00:00:00 -0000"
+    ])
+  end
+  it "d3.utc_weeks" do
+    expect(D3.utc_weeks(a,b).map(&:to_s)).to eq([
+      "2016-12-11 00:00:00 -0000", "2016-12-18 00:00:00 -0000", "2016-12-25 00:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_hours" do
+    expect(D3.time_hours(a,a+10000).map(&:to_s)).to eq([
+      "2016-12-07 02:00:00 -0000", "2016-12-07 03:00:00 -0000", "2016-12-07 04:00:00 -0000"
+    ])
+  end
+  it "d3.utc_hours" do
+    expect(D3.utc_hours(a,a+10000).map(&:to_s)).to eq([
+      "2016-12-07 02:00:00 -0000", "2016-12-07 03:00:00 -0000", "2016-12-07 04:00:00 -0000"
+    ])
+  end
+
+  it "d3.time_minutes" do
+    expect(D3.time_minutes(a,a+200).map(&:to_s)).to eq([
+      "2016-12-07 01:18:00 -0000", "2016-12-07 01:19:00 -0000", "2016-12-07 01:20:00 -0000"
+    ])
+  end
+  it "d3.utc_minutes" do
+    expect(D3.utc_minutes(a,a+200).map(&:to_s)).to eq([
+      "2016-12-07 01:18:00 -0000", "2016-12-07 01:19:00 -0000", "2016-12-07 01:20:00 -0000"
+    ])
+  end
+
+  it "d3.time_seconds" do
+    expect(D3.time_seconds(a,a+3).map(&:to_s)).to eq([
+      "2016-12-07 01:17:03 -0000", "2016-12-07 01:17:04 -0000", "2016-12-07 01:17:05 -0000"
+    ])
+  end
+  it "d3.utc_seconds" do
+    expect(D3.utc_seconds(a,a+3).map(&:to_s)).to eq([
+      "2016-12-07 01:17:03 -0000", "2016-12-07 01:17:04 -0000", "2016-12-07 01:17:05 -0000"
+    ])
+  end
+
+  it "d3.time_milliseconds" do
+    expect(D3.time_milliseconds(a,a+0.004).map(&:tv_usec)).to eq([
+      123000, 124000, 125000, 126000
+    ])
+  end
+  it "d3.utc_milliseconds" do
+    expect(D3.utc_milliseconds(a,a+0.004).map(&:tv_usec)).to eq([
+      123000, 124000, 125000, 126000
+    ])
+  end
+end

data/spec/transformations_spec.rb

@@ -0,0 +1,51 @@
+describe "d3-array - transformations" do
+  it "d3.merge" do
+    expect(D3.merge([[1], [2, 3]])).to eq([1, 2, 3])
+  end
+
+  it "d3.pairs" do
+    expect(D3.pairs([1, 2, 3, 4])).to eq([[1, 2], [2, 3], [3, 4]])
+  end
+
+  it "d3.permute" do
+    expect(D3.permute(["a", "b", "c"], [1, 2, 0])).to eq(["b", "c", "a"])
+  end
+
+  it "d3.shuffle" do
+    a = (1..20).to_a
+    b = (1..20).to_a
+    D3.shuffle(b)  # modifies in place
+    expect(a).not_to eq(b) # 61 bit chance of random test fail
+    expect(a.sort).to eq(b.sort)
+  end
+
+  it "d3.ticks" do
+    expect(D3.ticks(1, 47, 5)).to eq([10, 20, 30, 40])
+  end
+
+  it "d3.tick_step" do
+    expect(D3.tick_step(1, 47, 5)).to eq(10)
+  end
+
+  it "d3.range" do
+    expect(D3.range(5)).to eq([0,1,2,3,4])
+    expect(D3.range(2, 7)).to eq([2,3,4,5,6])
+    expect(D3.range(10,50,5)).to eq([10,15,20,25,30,35,40,45])
+    expect(D3.range(0, 1, 0.2)).to eq([0, 0.2, 0.4, 0.6000000000000001, 0.8])
+  end
+
+  it "d3.transpose" do
+    expect(D3.transpose([[1,2],[3,4]])).to eq([[1,3],[2,4]])
+  end
+
+  it "d3.zip" do
+    expect(D3.zip([1, 2], [3, 4])).to eq([[1, 3], [2, 4]])
+    expect(D3.zip([1, 2, 5], [3, 4])).to eq([[1, 3], [2, 4]])
+    expect(D3.zip([1, 2], [3, 4, 5])).to eq([[1, 3], [2, 4]])
+    expect(D3.zip([1, 2], [3, 4], [5, 6])).to eq([[1, 3, 5], [2, 4, 6]])
+    expect(D3.zip([1, 2])).to eq([[1], [2]])
+    expect(D3.zip([1, 2], [])).to eq([])
+    expect(D3.zip([])).to eq([])
+    expect(D3.zip()).to eq([])
+  end
+end