hyper-d3 1.0.0.lap23

data/lib/d3/format.rb

@@ -0,0 +1,95 @@
+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
+    aliases_d3 %i[precisionFixed precisionPrefix 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/d3/histograms.rb

@@ -0,0 +1,46 @@
+module D3
+  class Histogram
+    include D3::Native
+
+    def call(data)
+      @native.call(data)
+    end
+
+    attributes_d3 %i[value domain]
+
+    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/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/d3/line.rb

@@ -0,0 +1,27 @@
+module D3
+  class LineGenerator
+    include D3::Native
+
+    def call(*args)
+      result = @native.call(*args)
+      `result === null ? nil : result`
+    end
+
+    attributes_d3_block %i[x y 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/d3/map.rb

@@ -0,0 +1,48 @@
+module D3
+  class Map
+    include D3::Native
+
+    def get(key)
+      result = @native.JS.get(key)
+      `result === undefined ? nil : result`
+    end
+    include Native
+    aliases_native_chainable %i[set remove clear]
+    aliases_native %i[get keys values 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/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

data/lib/d3/native.rb

@@ -0,0 +1,112 @@
+require "native"
+
+module Native
+  module Helpers
+    def aliases_native(native_names)
+      native_names.each do |native_name|
+        alias_native(native_name.underscore, native_name)
+      end
+    end
+  end
+end
+
+module D3
+  module Native
+    include ::Native
+    def initialize(native)
+      raise unless native
+      @native = native
+    end
+
+    def self.included(klass)
+      klass.extend ::Native::Helpers
+      klass.extend Helpers
+    end
+
+    module Helpers
+      # This provides ruby style interfaces:
+      # obj.foo
+      # obj.foo = 1; obj.bar = 2
+      # obj.foo(1).bar(2)
+
+      def attributes_d3(native_names)
+        native_names.each do |native_name|
+          attribute_d3(native_name.underscore, native_name)
+        end
+      end
+
+      def attribute_d3(ruby_name, js_name=ruby_name)
+        define_method(ruby_name) do |new_value=`undefined`|
+          if `new_value !== undefined`
+            new_value = `null` if new_value == nil
+            `self["native"][#{js_name}](#{new_value})`
+            self
+          else
+            value = `self["native"][#{js_name}]()`
+            `value === null ? nil : value`
+          end
+        end
+        define_method(ruby_name + '=') do |new_value|
+          new_value = `null` if new_value == nil
+          @native.JS.call(js_name, new_value)
+        end
+      end
+
+      def attributes_d3_block(native_names)
+        native_names.each do |native_name|
+          attribute_d3_block(native_name.underscore, native_name)
+        end
+      end
+      
+      # This provides ruby style and jquery style interfaces,
+      # and also block interface:
+      # obj.foo
+      # obj.foo = 1; obj.bar = 2
+      # obj.foo(1).bar(2).buzz{...}
+      def attribute_d3_block(ruby_name, js_name=ruby_name)
+        define_method(ruby_name) do |new_value=`undefined`, &block|
+          if block_given?
+            @native.JS[js_name].JS.apply(@native, `Opal.to_a(block)`)
+            self
+          elsif `new_value !== undefined`
+            new_value = `null` if new_value == nil
+            `self["native"][#{js_name}](#{new_value})`
+            self
+          else
+            value = `self["native"][#{js_name}]()`
+            `value === null ? nil : value`
+          end
+        end
+        define_method(ruby_name + '=') do |new_value|
+          new_value = `null` if new_value == nil
+          @native.JS.call(js_name, new_value)
+        end
+      end
+
+      def aliases_native_chainable(native_names)
+        native_names.each do |native_name|
+          alias_native_chainable(native_name.underscore, native_name)
+        end
+      end
+      
+      def alias_native_chainable(ruby_name, js_name=ruby_name)
+        define_method(ruby_name) do |*args|
+          @native.JS[js_name].JS.apply(@native, `Opal.to_a(args)`)
+          self
+        end
+      end
+
+      def aliases_native_new(native_names)
+        native_names.each do |native_name|
+          alias_native_new(native_name.downcase, native_name)
+        end
+      end
+
+      def alias_native_new(ruby_name, js_name=ruby_name)
+        define_method(ruby_name) do |*args|
+          self.class.new( @native.JS[js_name].JS.apply(@native, `Opal.to_a(args)`) )
+        end
+      end
+    end
+  end
+end