hyper-d3 1.0.0.lap23

data/lib/d3/continuous_scale.rb

@@ -0,0 +1,60 @@
+module D3
+  class ContinuousScale
+    include D3::Native
+    def call(t)
+      @native.call(t)
+    end
+
+    aliases_native %i[invert ticks tickFormat]
+    attributes_d3 %i[domain range rangeRound clamp]
+    alias_native_chainable :nice
+    alias_native_new :copy
+
+    def interpolate(&block)
+      if block
+        @native.JS.interpolate(block)
+        self
+      else
+        @native.JS.interpolate
+      end
+    end
+  end
+
+  class PowScale < ContinuousScale
+    attribute_d3 :exponent
+  end
+
+  class LogScale < ContinuousScale
+    attribute_d3 :base
+  end
+
+  class << self
+    def scale_pow
+      D3::PowScale.new @d3.JS.scalePow
+    end
+
+    def scale_sqrt
+      D3::PowScale.new @d3.JS.scaleSqrt
+    end
+
+    def scale_linear
+      D3::ContinuousScale.new @d3.JS.scaleLinear
+    end
+
+    def scale_log
+      D3::LogScale.new @d3.JS.scaleLog
+    end
+
+    def scale_identity
+      D3::ContinuousScale.new @d3.JS.scaleIdentity
+    end
+
+    def scale_time
+      D3::ContinuousScale.new @d3.JS.scaleTime
+    end
+
+    def scale_utc
+      D3::ContinuousScale.new @d3.JS.scaleUtc
+    end
+  end
+end

data/lib/d3/creator.rb

@@ -0,0 +1,11 @@
+module D3
+  class Creator
+    include D3::Native
+  end
+
+  class << self
+    def creator(name)
+      D3::Creator.new @d3.JS.creator(name)
+    end
+  end
+end

data/lib/d3/curve.rb

@@ -0,0 +1,74 @@
+module D3
+  class Curve
+    include D3::Native
+  end
+
+  class CurveBundle < Curve
+    alias_native_new :beta
+  end
+
+  class CurveCardinal < Curve
+    alias_native_new :tension
+  end
+
+  class CurveCatmullRom < Curve
+    alias_native_new :alpha
+  end
+
+  class << self
+    def curve_basis
+      D3::Curve.new `window.d3.curveBasis`
+    end
+    def curve_basis_closed
+      D3::Curve.new `window.d3.curveBasisClosed`
+    end
+    def curve_basis_open
+      D3::Curve.new `window.d3.curveBasisOpen`
+    end
+    def curve_bundle
+      D3::CurveBundle.new `window.d3.curveBundle`
+    end
+    def curve_cardinal
+      D3::CurveCardinal.new `window.d3.curveCardinal`
+    end
+    def curve_cardinal_closed
+      D3::CurveCardinal.new `window.d3.curveCardinalClosed`
+    end
+    def curve_cardinal_open
+      D3::CurveCardinal.new `window.d3.curveCardinalOpen`
+    end
+    def curve_catmull_rom
+      D3::CurveCatmullRom.new `window.d3.curveCatmullRom`
+    end
+    def curve_catmull_rom_closed
+      D3::CurveCatmullRom.new `window.d3.curveCatmullRomClosed`
+    end
+    def curve_catmull_rom_open
+      D3::CurveCatmullRom.new `window.d3.curveCatmullRomOpen`
+    end
+    def curve_linear
+      D3::Curve.new `window.d3.curveLinear`
+    end
+    def curve_linear_closed
+      D3::Curve.new `window.d3.curveLinearClosed`
+    end
+    def curve_monotone_x
+      D3::Curve.new `window.d3.curveMonotoneX`
+    end
+    def curve_monotone_y
+      D3::Curve.new `window.d3.curveMonotoneY`
+    end
+    def curve_natural
+      D3::Curve.new `window.d3.curveNatural`
+    end
+    def curve_step
+      D3::Curve.new `window.d3.curveStep`
+    end
+    def curve_step_after
+      D3::Curve.new `window.d3.curveStepAfter`
+    end
+    def curve_step_before
+      D3::Curve.new `window.d3.curveStepBefore`
+    end
+  end
+end

data/lib/d3/dsv.rb

@@ -0,0 +1,103 @@
+module D3
+  class DsvFormat
+    include D3::Native
+
+    def parse_rows(string, row=`undefined`, &block)
+      row = block if block_given?
+      if `row !== undefined`
+        @native.JS.parseRows(string, proc{|d|
+          result = row.call(d)
+          result == nil ? `null` : result
+        })
+      else
+        @native.JS.parseRows(string)
+      end
+    end
+
+    def parse(string, row=`undefined`, &block)
+      row = block if block_given?
+      if `row !== undefined`
+        @native.JS.parse(string, proc{|e|
+          result = row.call(`Opal.hash(e)`)
+          result == nil ? `null` : result
+        })
+      else
+        @native.JS.parse(string).map{|e| `Opal.hash(e)` }
+      end
+    end
+
+    alias_native_new :format_rows, :formatRows
+
+    alias_native_new :format
+  end
+
+  class << self
+    def dsv_format(separator)
+      D3::DsvFormat.new @d3.JS.dsvFormat(separator)
+    end
+
+    def csv_parse_rows(string, row=`undefined`, &block)
+      row = block if block_given?
+      if `row !== undefined`
+        @d3.JS.csvParseRows(string, proc{|d|
+          result = row.call(d)
+          result == nil ? `null` : result
+        })
+      else
+        @d3.JS.csvParseRows(string)
+      end
+    end
+
+    def tsv_parse_rows(string, row=`undefined`, &block)
+      row = block if block_given?
+      if `row !== undefined`
+        @d3.JS.tsvParseRows(string, proc{|d|
+          result = row.call(d)
+          result == nil ? `null` : result
+        })
+      else
+        @d3.JS.tsvParseRows(string)
+      end
+    end
+
+    def csv_format_rows(rows)
+      @d3.JS.csvFormatRows(rows)
+    end
+
+    def tsv_format_rows(rows)
+      @d3.JS.tsvFormatRows(rows)
+    end
+
+    def csv_parse(string, row=`undefined`, &block)
+      row = block if block_given?
+      if `row !== undefined`
+        @d3.JS.csvParse(string, proc{|e|
+          result = row.call(`Opal.hash(e)`)
+          result == nil ? `null` : result
+        })
+      else
+        @d3.JS.csvParse(string).map{|e| `Opal.hash(e)` }
+      end
+    end
+
+    def tsv_parse(string, row=`undefined`, &block)
+      row = block if block_given?
+      if `row !== undefined`
+        @d3.JS.tsvParse(string, proc{|e|
+          result = row.call(`Opal.hash(e)`)
+          result == nil ? `null` : result
+        })
+      else
+        @d3.JS.tsvParse(string).map{|e| `Opal.hash(e)` }
+      end
+    end
+
+    def csv_format(rows, columns=`undefined`)
+      @d3.JS.csvFormat(rows.to_n, columns)
+    end
+
+    def tsv_format(rows, columns=`undefined`)
+      @d3.JS.tsvFormat(rows.to_n, columns)
+    end
+  end
+end

data/lib/d3/ease.rb

@@ -0,0 +1,319 @@
+module D3
+  class EasePoly
+    include D3::Native
+    alias_native_new :exponent
+
+    def call(t)
+      @native.call(t)
+    end
+  end
+
+  class EaseBack
+    include D3::Native
+    alias_native_new :overshoot
+
+    def call(t)
+      @native.call(t)
+    end
+  end
+
+  class EaseElastic
+    include D3::Native
+    alias_native_new :amplitude
+    alias_native_new :period
+
+    def call(t)
+      @native.call(t)
+    end
+  end
+
+  class <<self
+    def ease_linear(t=nil)
+      if t
+        @d3.JS.easeLinear(t)
+      else
+        `#@d3.easeLinear`
+      end
+    end
+
+    def ease_quad(t=nil)
+      if t
+        @d3.JS.easeQuad(t)
+      else
+        `#@d3.easeQuad`
+      end
+    end
+
+    def ease_quad_in(t=nil)
+      if t
+        @d3.JS.easeQuadIn(t)
+      else
+        `#@d3.easeQuadIn`
+      end
+    end
+
+    def ease_quad_out(t=nil)
+      if t
+        @d3.JS.easeQuadOut(t)
+      else
+        `#@d3.easeQuadOut`
+      end
+    end
+
+    def ease_quad_in_out(t=nil)
+      if t
+        @d3.JS.easeQuadInOut(t)
+      else
+        `#@d3.easeQuadInOut`
+      end
+    end
+
+    def ease_cubic(t=nil)
+      if t
+        @d3.JS.easeCubic(t)
+      else
+        `#@d3.easeCubic`
+      end
+    end
+
+    def ease_cubic_in(t=nil)
+      if t
+        @d3.JS.easeCubicIn(t)
+      else
+        `#@d3.easeCubicIn`
+      end
+    end
+
+    def ease_cubic_out(t=nil)
+      if t
+        @d3.JS.easeCubicOut(t)
+      else
+        `#@d3.easeCubicOut`
+      end
+    end
+
+    def ease_cubic_in_out(t=nil)
+      if t
+        @d3.JS.easeCubicInOut(t)
+      else
+        `#@d3.easeCubicInOut`
+      end
+    end
+
+    def ease_sin(t=nil)
+      if t
+        @d3.JS.easeSin(t)
+      else
+        `#@d3.easeSin`
+      end
+    end
+
+    def ease_sin_in(t=nil)
+      if t
+        @d3.JS.easeSinIn(t)
+      else
+        `#@d3.easeSinIn`
+      end
+    end
+
+    def ease_sin_out(t=nil)
+      if t
+        @d3.JS.easeSinOut(t)
+      else
+        `#@d3.easeSinOut`
+      end
+    end
+
+    def ease_sin_in_out(t=nil)
+      if t
+        @d3.JS.easeSinInOut(t)
+      else
+        `#@d3.easeSinInOut`
+      end
+    end
+
+    def ease_exp(t=nil)
+      if t
+        @d3.JS.easeExp(t)
+      else
+        `#@d3.easeExp`
+      end
+    end
+
+    def ease_exp_in(t=nil)
+      if t
+        @d3.JS.easeExpIn(t)
+      else
+        `#@d3.easeExpIn`
+      end
+    end
+
+    def ease_exp_out(t=nil)
+      if t
+        @d3.JS.easeExpOut(t)
+      else
+        `#@d3.easeExpOut`
+      end
+    end
+
+    def ease_exp_in_out(t=nil)
+      if t
+        @d3.JS.easeExpInOut(t)
+      else
+        `#@d3.easeExpInOut`
+      end
+    end
+
+    def ease_circle(t=nil)
+      if t
+        @d3.JS.easeCircle(t)
+      else
+        `#@d3.easeCircle`
+      end
+    end
+
+    def ease_circle_in(t=nil)
+      if t
+        @d3.JS.easeCircleIn(t)
+      else
+        `#@d3.easeCircleIn`
+      end
+    end
+
+    def ease_circle_out(t=nil)
+      if t
+        @d3.JS.easeCircleOut(t)
+      else
+        `#@d3.easeCircleOut`
+      end
+    end
+
+    def ease_circle_in_out(t=nil)
+      if t
+        @d3.JS.easeCircleInOut(t)
+      else
+        `#@d3.easeCircleInOut`
+      end
+    end
+
+    def ease_bounce(t=nil)
+      if t
+        @d3.JS.easeBounce(t)
+      else
+        `#@d3.easeBounce`
+      end
+    end
+
+    def ease_bounce_in(t=nil)
+      if t
+        @d3.JS.easeBounceIn(t)
+      else
+        `#@d3.easeBounceIn`
+      end
+    end
+
+    def ease_bounce_out(t=nil)
+      if t
+        @d3.JS.easeBounceOut(t)
+      else
+        `#@d3.easeBounceOut`
+      end
+    end
+
+    def ease_bounce_in_out(t=nil)
+      if t
+        @d3.JS.easeBounceInOut(t)
+      else
+        `#@d3.easeBounceInOut`
+      end
+    end
+
+    def ease_poly_in(t=nil)
+      if t
+        @d3.JS.easePolyIn(t)
+      else
+        D3::EasePoly.new `#@d3.easePolyIn`
+      end
+    end
+
+    def ease_poly_out(t=nil)
+      if t
+        @d3.JS.easePolyOut(t)
+      else
+        D3::EasePoly.new `#@d3.easePolyOut`
+      end
+    end
+
+    def ease_poly_in_out(t=nil)
+      if t
+        @d3.JS.easePolyInOut(t)
+      else
+        D3::EasePoly.new `#@d3.easePolyInOut`
+      end
+    end
+
+    def ease_back(t=nil)
+      if t
+        @d3.JS.easeBack(t)
+      else
+        D3::EaseBack.new `#@d3.easeBack`
+      end
+    end
+
+    def ease_back_in(t=nil)
+      if t
+        @d3.JS.easeBackIn(t)
+      else
+        D3::EaseBack.new `#@d3.easeBackIn`
+      end
+    end
+
+    def ease_back_out(t=nil)
+      if t
+        @d3.JS.easeBackOut(t)
+      else
+        D3::EaseBack.new `#@d3.easeBackOut`
+      end
+    end
+
+    def ease_back_in_out(t=nil)
+      if t
+        @d3.JS.easeBackInOut(t)
+      else
+        D3::EaseBack.new `#@d3.easeBackInOut`
+      end
+    end
+
+    def ease_elastic(t=nil)
+      if t
+        @d3.JS.easeElastic(t)
+      else
+        D3::EaseElastic.new `#@d3.easeElastic`
+      end
+    end
+
+    def ease_elastic_in(t=nil)
+      if t
+        @d3.JS.easeElasticIn(t)
+      else
+        D3::EaseElastic.new `#@d3.easeElasticIn`
+      end
+    end
+
+    def ease_elastic_out(t=nil)
+      if t
+        @d3.JS.easeElasticOut(t)
+      else
+        D3::EaseElastic.new `#@d3.easeElasticOut`
+      end
+    end
+
+    def ease_elastic_in_out(t=nil)
+      if t
+        @d3.JS.easeElasticInOut(t)
+      else
+        D3::EaseElastic.new `#@d3.easeElasticInOut`
+      end
+    end
+  end
+end