opal-d3 0.0.20170205

data/lib/opal/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

data/lib/opal/d3/format.rb

@@ -0,0 +1,97 @@
+module D3
+  class FormatSpecifier
+    include D3::Native
+
+    FIELDS = %W[fill align sign symbol zero width comma precision type]
+    FIELDS.each do |key|
+      define_method(key) {
+        `v = #@native[key]`
+        `v === undefined ? nil : v`
+      }
+      define_method("#{key}=") {|v|
+        `#@native[key] = (v === nil ? undefined : v)`
+      }
+    end
+
+    def to_h
+      result = {}
+      FIELDS.each do |key|
+        result[key] = send(key)
+      end
+      result
+    end
+
+    def to_n
+      @native
+    end
+  end
+
+  class FormatLocale
+    include D3::Native
+
+    def format(specifier)
+      if specifier.is_a?(FormatSpecifier)
+        @native.JS.format(specifier.to_n)
+      else
+        @native.JS.format(specifier)
+      end
+    end
+
+    def format_prefix(specifier, value)
+      if specifier.is_a?(FormatSpecifier)
+        @native.JS.formatPrefix(specifier.to_n, value)
+      else
+        @native.JS.formatPrefix(specifier, value)
+      end
+    end
+  end
+
+
+  class << self
+    alias_d3 :precision_fixed, :precisionFixed
+    alias_d3 :precision_prefix, :precisionPrefix
+    alias_d3 :precision_round, :precisionRound
+
+    def format(specifier)
+      if specifier.is_a?(FormatSpecifier)
+        @d3.JS.format(specifier.to_n)
+      else
+        @d3.JS.format(specifier)
+      end
+    end
+
+    def format_prefix(specifier, value)
+      if specifier.is_a?(FormatSpecifier)
+        @d3.JS.formatPrefix(specifier.to_n, value)
+      else
+        @d3.JS.formatPrefix(specifier, value)
+      end
+    end
+
+    def format_specifier(specifier)
+      D3::FormatSpecifier.new @d3.JS.formatSpecifier(specifier)
+    end
+
+    def format_locale(spec={})
+      D3::FormatLocale.new @d3.JS.formatLocale(
+        {
+          decimal: spec.fetch("decimal", "."),
+          thousands: spec.fetch("thousands", ","),
+          grouping: spec.fetch("grouping", [3]),
+          currency: spec.fetch("currency", ["$", ""]),
+        }.to_n
+      )
+    end
+
+    def format_default_locale(spec={})
+      D3::FormatLocale.new @d3.JS.formatDefaultLocale(
+        {
+          decimal: spec.fetch("decimal", "."),
+          thousands: spec.fetch("thousands", ","),
+          grouping: spec.fetch("grouping", [3]),
+          currency: spec.fetch("currency", ["$", ""]),
+        }.to_n
+      )
+    end
+  end
+end

data/lib/opal/d3/histograms.rb

@@ -0,0 +1,44 @@
+module D3
+  class Histogram
+    include D3::Native
+
+    def call(data)
+      @native.call(data)
+    end
+
+    def thresholds(count=nil, &block)
+      if block_given?
+        @native.JS.thresholds(block)
+      elsif count.is_a?(Numeric)
+        @native.JS.thresholds(count)
+      elsif count == :scott
+        @native.JS.thresholds{|*args| D3.threshold_scott(*args)}
+      elsif count == :sturges
+        @native.JS.thresholds{|*args| D3.threshold_sturges(*args)}
+      elsif count == :freedman_diaconis
+        @native.JS.thresholds{|*args| D3.threshold_freedman_diaconis(*args)}
+      else
+        raise ArgumentError, "Wrong use of D3::Histogram.thresholds API - pass block, number, or symbol"
+      end
+      self
+    end
+  end
+
+  class << self
+    def histogram
+      D3::Histogram.new @d3.JS.histogram
+    end
+
+    def threshold_freedman_diaconis(*args)
+      @d3.JS.thresholdFreedmanDiaconis(*args)
+    end
+
+    def threshold_scott(*args)
+      @d3.JS.thresholdScott(*args)
+    end
+
+    def threshold_sturges(*args)
+      @d3.JS.thresholdSturges(*args)
+    end
+  end
+end

data/lib/opal/d3/interpolate.rb

@@ -0,0 +1,125 @@
+module D3
+  class << self
+    def interpolate_number(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateNumber`
+      else
+        @d3.JS.interpolateNumber(a,b)
+      end
+    end
+
+    def interpolate_round(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateRound`
+      else
+        @d3.JS.interpolateRound(a,b)
+      end
+    end
+
+    def interpolate_string(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateString`
+      else
+        @d3.JS.interpolateString(a,b)
+      end
+    end
+
+    def interpolate_array(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateArray`
+      else
+        @d3.JS.interpolateArray(a,b)
+      end
+    end
+
+    def interpolate_date(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateDate`
+      else
+        @d3.JS.interpolateDate(a,b)
+      end
+    end
+
+    # These should support gamma
+    def interpolate_rgb(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateRgb`
+      else
+        @d3.JS.interpolateRgb(a,b)
+      end
+    end
+
+    def interpolate_rgb_basis(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateRgbBasis`
+      else
+        @d3.JS.interpolateRgbBasis(a,b)
+      end
+    end
+
+    def interpolate_rgb_basis_closed(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateRgbBasisClosed`
+      else
+        @d3.JS.interpolateRgbBasisClosed(a,b)
+      end
+    end
+
+    def interpolate_hsl(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateHsl`
+      else
+        @d3.JS.interpolateHsl(a,b)
+      end
+    end
+
+    def interpolate_hsl_long(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateHslLong`
+      else
+        @d3.JS.interpolateHslLong(a,b)
+      end
+    end
+
+    def interpolate_lab(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateLab`
+      else
+        @d3.JS.interpolateLab(a,b)
+      end
+    end
+
+    def interpolate_hcl(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateHcl`
+      else
+        @d3.JS.interpolateHcl(a,b)
+      end
+    end
+
+    def interpolate_hcl_long(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateHclLong`
+      else
+        @d3.JS.interpolateHclLong(a,b)
+      end
+    end
+
+    def interpolate_cubehelix(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateCubehelix`
+      else
+        @d3.JS.interpolateCubehelix(a,b)
+      end
+    end
+
+    def interpolate_cubehelix_long(a=nil,b=nil)
+      if a == nil and b == nil
+        `#@d3.interpolateCubehelixLong`
+      else
+        @d3.JS.interpolateCubehelixLong(a,b)
+      end
+    end
+
+  end
+end

data/lib/opal/d3/line.rb

@@ -0,0 +1,29 @@
+module D3
+  class LineGenerator
+    include D3::Native
+
+    def call(*args)
+      result = @native.call(*args)
+      `result === null ? nil : result`
+    end
+
+    attribute_d3_block :x
+    attribute_d3_block :y
+    attribute_d3_block :defined
+
+    def curve(new_value=`undefined`)
+      if `new_value === undefined`
+        D3::Curve.new @native.JS.curve
+      else
+        @native.JS.curve(new_value.to_n)
+        self
+      end
+    end
+  end
+
+  class << self
+    def line
+      D3::LineGenerator.new @d3.JS.line
+    end
+  end
+end

data/lib/opal/d3/map.rb

@@ -0,0 +1,52 @@
+module D3
+  class Map
+    include D3::Native
+
+    def get(key)
+      result = @native.JS.get(key)
+      `result === undefined ? nil : result`
+    end
+    include Native
+    alias_native_chainable :set
+    alias_native_chainable :remove
+    alias_native_chainable :clear
+    alias_native :keys
+    alias_native :values
+    alias_native :size
+    alias_native :empty?, :empty
+    alias_native :has?, :has
+    alias_method :[], :get
+    alias_method :[]=, :set
+
+    def entries
+      @native.JS.entries().map{|o| [`o.key`, `o.value`]}
+    end
+
+    def to_h
+      `Opal.hash(#{entries})`
+    end
+
+    # Should that be reversed to better match ruby and to work with Enumerable?
+    # Or just use #to_h if you want ruby interface?
+    def each(&block)
+      @native.JS.each(block)
+      self
+    end
+
+    def inspect
+      "#<D3::Map: #{ to_h.inspect }>"
+    end
+  end
+
+  class << self
+    def map(object=nil, &block)
+      if block_given?
+        D3::Map.new(@d3.JS.map(object, proc{|x| yield(x)}))
+      elsif object
+        D3::Map.new(@d3.JS.map(object))
+      else
+        D3::Map.new(@d3.JS.map())
+      end
+    end
+  end
+end

data/lib/opal/d3/misc.rb

@@ -0,0 +1,15 @@
+module D3
+  class << self
+    def version
+      `window.d3.version`
+    end
+
+    def namespaces
+      `Opal.hash(window.d3.namespaces)`
+    end
+
+    def namespace(name)
+      `Opal.hash(window.d3.namespace(name))`
+    end
+  end
+end