hyper-d3 1.0.0.lap23

data/lib/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/d3/ordinal_scale.rb

@@ -0,0 +1,39 @@
+module D3
+  class OrdinalScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+    attributes_d3 %i[domain 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
+  end
+end

data/lib/d3/path.rb

@@ -0,0 +1,24 @@
+module D3
+  class Path
+    include D3::Native
+
+    # D3 methods aren't chainable, but there's no reason why they shouldn't be
+    aliases_native_chainable %i[
+      moveTo
+      closePath
+      lineTo
+      quadraticCurveTo
+      bezierCurveTo
+      arcTo
+      arc
+      rect
+    ]
+    alias_native :to_s, :toString
+  end
+
+  class << self
+    def path
+      D3::Path.new @d3.JS.path
+    end
+  end
+end

data/lib/d3/pie.rb

@@ -0,0 +1,25 @@
+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
+
+    attributes_d3_block %i[
+      startAngle
+      endAngle
+      padAngle
+      value
+      sort
+      sortValues
+    ]
+  end
+
+  class << self
+    def pie
+      D3::PieGenerator.new @d3.JS.pie
+    end
+  end
+end

data/lib/d3/point_scale.rb

@@ -0,0 +1,27 @@
+module D3
+  class PointScale
+    include D3::Native
+
+    def call(t)
+      v = @native.call(t)
+      `v === undefined ? nil : v`
+    end
+    attributes_d3 %i[
+      domain
+      range
+      rangeRound
+      padding
+      align
+      round
+    ]
+    alias_native_new :copy
+    alias_native :bandwidth
+    alias_native :step
+  end
+
+  class << self
+    def scale_point
+      D3::PointScale.new @d3.JS.scalePoint
+    end
+  end
+end

data/lib/d3/polygon.rb

@@ -0,0 +1,18 @@
+module D3
+  class << self
+    # This could maybe use more OO interface in addition to this?
+    # Like D3::Polygon.new(points).area etc.
+
+    aliases_d3 %i[
+      polygonArea
+      polygonCentroid
+      polygonContains
+      polygonLength
+    ]
+
+    def polygon_hull(points)
+      hull = @d3.JS.polygonHull(points)
+      `hull === null ? nil : hull`
+    end
+  end
+end

data/lib/d3/quadtree.rb

@@ -0,0 +1,89 @@
+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
+    aliases_native %i[data find size]
+    aliases_native_chainable %i[add addAll cover remove 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/d3/quantile_scale.rb

@@ -0,0 +1,19 @@
+module D3
+  class QuantileScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+
+    attributes_d3 %i[domain range]
+    aliases_native %i[invertExtent quantiles]
+    alias_native_new :copy
+  end
+
+  class << self
+    def scale_quantile
+      D3::QuantileScale.new @d3.JS.scaleQuantile
+    end
+  end
+end

data/lib/d3/quantize_scale.rb

@@ -0,0 +1,20 @@
+module D3
+  class QuantizeScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+
+    attributes_d3 %i[domain range]
+    aliases_native %i[invertExtent ticks 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/d3/radial_area.rb

@@ -0,0 +1,55 @@
+module D3
+  class RadialAreaGenerator
+    include D3::Native
+
+    def call(*args)
+      result = @native.call(*args)
+      `result === null ? nil : result`
+    end
+
+    attributes_d3_block %i[
+      angle
+      startAngle
+      endAngle
+      radius
+      innerRadius
+      outerRadius
+      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(data = nil)
+      if data
+        D3::RadialAreaGenerator.new @d3.JS.radialArea(data.to_n)
+      else
+        D3::RadialAreaGenerator.new @d3.JS.radialArea
+      end
+    end
+  end
+end

data/lib/d3/radial_line.rb

@@ -0,0 +1,27 @@
+module D3
+  class RadialLineGenerator
+    include D3::Native
+
+    def call(*args)
+      result = @native.call(*args)
+      `result === null ? nil : result`
+    end
+
+    attributes_d3_block %i[angle radius 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