opal-d3 0.0.20170205

data/lib/opal/d3/native.rb

@@ -0,0 +1,84 @@
+require "native"
+
+module D3
+  module Native
+    include ::Native
+    def initialize(native)
+      raise unless native
+      @native = native
+    end
+
+    def self.included(klass)
+      klass.extend Helpers
+    end
+
+    module Helpers
+      # This provides ruby style and jquery style interfaces:
+      # obj.foo
+      # obj.foo = 1; obj.bar = 2
+      # obj.foo(1).bar(2)
+      def attribute_d3(ruby_name, js_name=ruby_name)
+        eval <<-EOF
+          def #{ruby_name}(new_value=`undefined`)
+            if `new_value !== undefined`
+              new_value = `null` if new_value == nil
+              @native.JS.#{js_name}(new_value)
+              self
+            else
+              value = @native.JS.#{js_name}
+              `value === null ? nil : value`
+            end
+          end
+          def #{ruby_name}=(new_value)
+            new_value = `null` if new_value == nil
+            @native.JS.#{js_name}(new_value)
+          end
+        EOF
+      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)
+        eval <<-EOF
+          def #{ruby_name}(new_value=`undefined`, &block)
+            if block_given?
+              @native.JS.#{js_name}(block)
+              self
+            elsif `new_value !== undefined`
+              new_value = `null` if new_value == nil
+              @native.JS.#{js_name}(new_value)
+              self
+            else
+              value = @native.JS.#{js_name}
+              `value === null ? nil : value`
+            end
+          end
+          def #{ruby_name}=(new_value)
+            new_value = `null` if new_value == nil
+            @native.JS.#{js_name}(new_value)
+          end
+        EOF
+      end
+
+      def alias_native_chainable(ruby_name, js_name=ruby_name)
+        eval <<-EOF
+          def #{ruby_name}(*args)
+            @native.JS.#{js_name}(*args)
+            self
+          end
+        EOF
+      end
+
+      def alias_native_new(ruby_name, js_name=ruby_name)
+        eval <<-EOF
+          def #{ruby_name}(*args)
+            self.class.new @native.JS.#{js_name}(*args)
+          end
+        EOF
+      end
+    end
+  end
+end

data/lib/opal/d3/nest.rb

@@ -0,0 +1,100 @@
+module D3
+  class Nest
+    def initialize
+      @native = `window.d3`.JS.nest
+      @depth = 0
+      @rollup = false
+    end
+
+    def key(&block)
+      @native.JS.key(block)
+      @depth += 1
+      self
+    end
+
+    def sort_keys(key=nil,&block)
+      if block
+        raise ArgumentError, "Pass block or :ascending/:descending"
+      else
+        if key == :ascending
+          block = `window.d3.ascending`
+        elsif key == :descending
+          block = `window.d3.descending`
+        else
+          raise ArgumentError, "Pass block or :ascending/:descending"
+        end
+      end
+      @native.JS.sortKeys(block)
+      self
+    end
+
+    def sort_values(key=nil,&block)
+      if block
+        raise ArgumentError, "Pass block or :ascending/:descending"
+      else
+        if key == :ascending
+          block = `window.d3.ascending`
+        elsif key == :descending
+          block = `window.d3.descending`
+        else
+          raise ArgumentError, "Pass block or :ascending/:descending"
+        end
+      end
+      @native.JS.sortValues(block)
+      self
+    end
+
+    # This is really attrocious, why don't we just return nested hash?
+    def map(array)
+      result = @native.JS.map(array)
+      map_map(result, @depth)
+    end
+
+    def entries(array)
+      result = @native.JS.entries(array)
+      map_entries(result, @depth)
+    end
+
+    def object(array)
+      @native.JS.object(array)
+    end
+
+    def rollup(&block)
+      @native.JS.rollup(block)
+      @rollup = true
+      self
+    end
+
+    private
+
+    def map_entries(result, depth)
+      if depth == 0
+        result
+      else
+        if @rollup and depth == 1
+          result.map{|o| [`o.key`, `o.value`]}
+        else
+          result.map{|o| [`o.key`, map_entries(`o.values`, depth-1)]}
+        end
+      end
+    end
+
+    def map_map(result, depth)
+      if depth == 0
+        result
+      else
+        output = D3::Map.new(`window.d3.map()`)
+        D3::Map.new(result).each do |vs, k|
+          output.set(k, map_map(vs, depth-1))
+        end
+        output
+      end
+    end
+  end
+
+  class << self
+    def nest
+      D3::Nest.new
+    end
+  end
+end

data/lib/opal/d3/ordinal_scale.rb

@@ -0,0 +1,56 @@
+module D3
+  class OrdinalScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+    attribute_d3 :domain
+    attribute_d3 :range
+    alias_native_new :copy
+
+    # D3 is trying to reinvent Ruby symbols here
+    def unknown(new_value=nil)
+      if new_value == nil
+        v = @native.JS.unknown
+        if `JSON.stringify(v) === '{"name":"implicit"}'`
+          :implicit
+        else
+          v
+        end
+      else
+        if new_value == :implicit
+          new_value = `window.d3.scaleImplicit`
+        end
+        @native.JS.unknown(new_value)
+        self
+      end
+    end
+  end
+
+  class << self
+    def scale_ordinal(*args)
+      D3::OrdinalScale.new @d3.JS.scaleOrdinal(*args)
+    end
+
+    def scale_implicit
+      :implicit
+    end
+
+    def scheme_category_10
+      `window.d3.schemeCategory10`
+    end
+
+    def scheme_category_20
+      `window.d3.schemeCategory20`
+    end
+
+    def scheme_category_20b
+      `window.d3.schemeCategory20b`
+    end
+
+    def scheme_category_20c
+      `window.d3.schemeCategory20c`
+    end
+  end
+end

data/lib/opal/d3/path.rb

@@ -0,0 +1,22 @@
+module D3
+  class Path
+    include D3::Native
+
+    # D3 methods aren't chainable, but there's no reason why they shouldn't be
+    alias_native_chainable :move_to, :moveTo
+    alias_native_chainable :close_path, :closePath
+    alias_native_chainable :line_to, :lineTo
+    alias_native_chainable :quadratic_curve_to, :quadraticCurveTo
+    alias_native_chainable :bezier_curve_to, :bezierCurveTo
+    alias_native_chainable :arc_to, :arcTo
+    alias_native_chainable :arc, :arc
+    alias_native_chainable :rect, :rect
+    alias_native :to_s, :toString
+  end
+
+  class << self
+    def path
+      D3::Path.new @d3.JS.path
+    end
+  end
+end

data/lib/opal/d3/pie.rb

@@ -0,0 +1,23 @@
+module D3
+  class PieGenerator
+    include D3::Native
+    def call(*args)
+      @native.call(*args).map{|o|
+        `Opal.hash({ data: o.data, index: o.index, value: o.value, start_angle: o.startAngle, end_angle: o.endAngle, pad_angle: o.padAngle })`
+      }
+    end
+
+    attribute_d3_block :start_angle, :startAngle
+    attribute_d3_block :end_angle, :endAngle
+    attribute_d3_block :pad_angle, :padAngle
+    attribute_d3_block :value
+    attribute_d3_block :sort
+    attribute_d3_block :sort_values, :sortValues
+  end
+
+  class << self
+    def pie
+      D3::PieGenerator.new @d3.JS.pie
+    end
+  end
+end

data/lib/opal/d3/point_scale.rb

@@ -0,0 +1,26 @@
+module D3
+  class PointScale
+    include D3::Native
+
+    def call(t)
+      v = @native.call(t)
+      `v === undefined ? nil : v`
+    end
+    attribute_d3 :domain
+    attribute_d3 :range
+    alias_native_new :copy
+    alias_native :bandwidth
+    alias_native :step
+    attribute_d3 :padding
+    attribute_d3 :align
+    attribute_d3 :round
+    # This requires argument, we might redo this not to
+    alias_native_chainable :range_round, :rangeRound
+  end
+
+  class << self
+    def scale_point
+      D3::PointScale.new @d3.JS.scalePoint
+    end
+  end
+end

data/lib/opal/d3/polygon.rb

@@ -0,0 +1,16 @@
+module D3
+  class << self
+    # This could maybe use more OO interface in addition to this?
+    # Like D3::Polygon.new(points).area etc.
+
+    alias_d3 :polygon_area, :polygonArea # signed area
+    alias_d3 :polygon_centroid, :polygonCentroid
+    alias_d3 :polygon_contains?, :polygonContains
+    alias_d3 :polygon_length, :polygonLength
+
+    def polygon_hull(points)
+      hull = @d3.JS.polygonHull(points)
+      `hull === null ? nil : hull`
+    end
+  end
+end

data/lib/opal/d3/quadtree.rb

@@ -0,0 +1,95 @@
+module D3
+  class Quad
+    include D3::Native
+
+    def internal?
+      `#@native.constructor === Array`
+    end
+
+    def leaf?
+      `#@native.constructor !== Array`
+    end
+
+    def next
+      return nil if internal?
+      return nil if `#@native.next == undefined`
+      D3::Quad.new(`#@native.next`)
+    end
+
+    def data
+      return nil if internal?
+      `#@native.data`
+    end
+
+    def children
+      return nil if leaf?
+      result = (0..3).map do |i|
+        q = `#@native[i]`
+        if `q == null`
+          nil
+        else
+          D3::Quad.new(q)
+        end
+      end
+    end
+  end
+
+  class QuadTree
+    include D3::Native
+    alias_native :data
+    alias_native :find
+    alias_native :size
+    alias_native_chainable :add
+    alias_native_chainable :add_all, :addAll
+    alias_native_chainable :cover
+    alias_native_chainable :remove
+    alias_native_chainable :remove_all, :removeAll
+    alias_native_new :copy
+    attribute_d3 :extent
+
+    # visit/visitAfter functions have stupid JS habit of using non-nil return as control
+    # and that messes up with languages which have automatic return
+    # Maybe worth rewriting to require explicit StopIteration ?
+    def visit
+      @native.JS.visit(proc do |node, x0, y0, x1, y1|
+        yield(D3::Quad.new(node), x0, y0, x1, y1)
+      end)
+      self
+    end
+
+    def visit_after
+      @native.JS.visitAfter(proc do |node, x0, y0, x1, y1|
+        yield(D3::Quad.new(node), x0, y0, x1, y1)
+      end)
+      self
+    end
+
+    def root
+      D3::Quad.new @native.JS.root
+    end
+
+    def x(&block)
+      if block_given?
+        @native.JS.x(block)
+        self
+      else
+        @native.JS.x
+      end
+    end
+
+    def y(&block)
+      if block_given?
+        @native.JS.y(block)
+        self
+      else
+        @native.JS.y
+      end
+    end
+  end
+
+  class << self
+    def quadtree(*args)
+      D3::QuadTree.new @d3.JS.quadtree(*args)
+    end
+  end
+end

data/lib/opal/d3/quantile_scale.rb

@@ -0,0 +1,21 @@
+module D3
+  class QuantileScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+
+    attribute_d3 :domain
+    attribute_d3 :range
+    alias_native :invert_extent, :invertExtent
+    alias_native :quantiles
+    alias_native_new :copy
+  end
+
+  class << self
+    def scale_quantile
+      D3::QuantileScale.new @d3.JS.scaleQuantile
+    end
+  end
+end

data/lib/opal/d3/quantize_scale.rb

@@ -0,0 +1,23 @@
+module D3
+  class QuantizeScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+
+    attribute_d3 :domain
+    attribute_d3 :range
+    alias_native :invert_extent, :invertExtent
+    alias_native :ticks
+    alias_native :tick_format, :tickFormat
+    alias_native_chainable :nice
+    alias_native_new :copy
+  end
+
+  class << self
+    def scale_quantize
+      D3::QuantizeScale.new @d3.JS.scaleQuantize
+    end
+  end
+end

data/lib/opal/d3/radial_area.rb

@@ -0,0 +1,49 @@
+module D3
+  class RadialAreaGenerator
+    include D3::Native
+
+    def call(*args)
+      result = @native.call(*args)
+      `result === null ? nil : result`
+    end
+
+    attribute_d3_block :angle
+    attribute_d3_block :start_angle, :startAngle
+    attribute_d3_block :end_angle, :endAngle
+    attribute_d3_block :radius
+    attribute_d3_block :inner_radius, :innerRadius
+    attribute_d3_block :outer_radius, :outerRadius
+    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
+
+    def line_start_angle
+      D3::RadialLineGenerator.new @native.JS.lineStartAngle
+    end
+
+    def line_end_angle
+      D3::RadialLineGenerator.new @native.JS.lineEndAngle
+    end
+
+    def line_inner_radius
+      D3::RadialLineGenerator.new @native.JS.lineInnerRadius
+    end
+
+    def line_outer_radius
+      D3::RadialLineGenerator.new @native.JS.lineOuterRadius
+    end
+  end
+
+  class << self
+    def radial_area
+      D3::RadialAreaGenerator.new @d3.JS.radialArea
+    end
+  end
+end

data/lib/opal/d3/radial_line.rb

@@ -0,0 +1,29 @@
+module D3
+  class RadialLineGenerator
+    include D3::Native
+
+    def call(*args)
+      result = @native.call(*args)
+      `result === null ? nil : result`
+    end
+
+    attribute_d3_block :angle
+    attribute_d3_block :radius
+    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 radial_line
+      D3::RadialLineGenerator.new @d3.JS.radialLine
+    end
+  end
+end

data/lib/opal/d3/random.rb

@@ -0,0 +1,12 @@
+module D3
+  class << self
+    # These return functions,
+    # which doesn't feel very Ruby
+    alias_d3 :random_uniform, :randomUniform
+    alias_d3 :random_normal, :randomNormal
+    alias_d3 :random_log_normal, :randomLogNormal
+    alias_d3 :random_bates, :randomBates
+    alias_d3 :random_irwin_hall, :randomIrwinHall
+    alias_d3 :random_exponential, :randomExponential
+  end
+end

data/lib/opal/d3/search.rb

@@ -0,0 +1,28 @@
+# all these methods return indexes not values
+module D3
+  class Bisector
+    include D3::Native
+    alias_native :left
+    alias_native :right
+  end
+
+  class << self
+    alias_d3 :ascending
+    alias_d3 :descending
+    alias_d3 :bisect
+    alias_d3 :bisect_left, :bisectLeft
+    alias_d3 :bisect_right, :bisectRight
+
+    def scan(array, &block)
+      if block_given?
+        @d3.JS.scan(array, block)
+      else
+        @d3.JS.scan(array)
+      end
+    end
+
+    def bisector(&block)
+      D3::Bisector.new @d3.JS.bisector(block)
+    end
+  end
+end