opal-d3 0.0.20170205

data/lib/opal/d3/selection.rb

@@ -0,0 +1,149 @@
+module D3
+  class Selection
+    include D3::Native
+    alias_native :size
+    alias_native :empty?, :empty
+    alias_native :node
+    alias_native :nodes
+
+    def inspect
+      `#@native.toString()`
+    end
+
+    attribute_d3_block :text
+    attribute_d3_block :html
+
+    def data(data=nil,key=nil,&block)
+      if block
+        self.class.new @native.JS.data(block)
+      elsif key != nil
+        self.class.new @native.JS.data(data,key)
+      elsif data != nil
+        self.class.new @native.JS.data(data)
+      else
+        @native.JS.data
+      end
+    end
+
+    def append(name=`undefined`, &block)
+      raise if `name !== undefined` and block_given?
+      name = block if block_given?
+      D3::Selection.new @native.JS.append(name.to_n)
+    end
+
+    def insert(name=`undefined`, before=`undefined`, &block)
+      if `name === undefined`
+        raise unless block_given?
+        D3::Selection.new @native.JS.insert(block.to_n)
+      elsif `before === undefined`
+        if block_given?
+          D3::Selection.new @native.JS.insert(name.to_n, block.to_n)
+        else
+          D3::Selection.new @native.JS.insert(name.to_n)
+        end
+      else
+        raise if block_given?
+        D3::Selection.new @native.JS.insert(name.to_n, before.to_n)
+      end
+    end
+
+    alias_native_new :remove
+    alias_native_new :select
+    alias_native_new :select_all, :selectAll
+    alias_native_new :enter
+    alias_native_new :exit
+    alias_native :call
+    alias_native_chainable :raise
+    alias_native_chainable :lower
+
+    def merge(other)
+      D3::Selection.new @native.JS.merge(other.to_n)
+    end
+
+    def classed(classes, yesno=`undefined`, &block)
+      if block_given?
+        @native.JS.classed(classes, block)
+        self
+      elsif `yesno !== undefined`
+        @native.JS.classed(classes, yesno)
+        self
+      else
+        @native.JS.classed(classes)
+      end
+    end
+
+    def filter(other=`undefined`,&block)
+      if block_given?
+        D3::Selection.new @native.JS.filter(block)
+      else
+        D3::Selection.new @native.JS.filter(other)
+      end
+    end
+
+    def each(other=`undefined`,&block)
+      if block_given?
+        @native.JS.each(block)
+      else
+        @native.JS.each(other)
+      end
+      self
+    end
+
+    def property(key, value=`undefined`)
+      if `value === undefined`
+        @native.JS.property(key)
+      else
+        @native.JS.property(key, value)
+        self
+      end
+    end
+
+    # Usage:
+    # style("foo")
+    # style("foo"){ value }
+    # style("foo", value)
+    # style("foo", value, priority)
+    def style(name, value=`undefined`, priority=`undefined`, &block)
+      if block
+        raise if `name === undefined` or `priority !== undefined` or `value !== undefined`
+        Selection.new @native.JS.style(name, block)
+      elsif `value === undefined`
+        @native.JS.style(name)
+      else
+        value = `value === nil ? null : value`
+        Selection.new @native.JS.style(name, value, priority)
+      end
+    end
+
+    # nil means something specific (reset value),
+    # so we need another special value
+    def attr(name, value=`undefined`, &block)
+      if block
+        @native.JS.attr(name, block)
+        self
+      elsif `value == undefined`
+        @native.JS.attr(name)
+      elsif value == nil
+        @native.JS.attr(name, `null`)
+        self
+      else
+        @native.JS.attr(name, value)
+        self
+      end
+    end
+  end
+
+  class << self
+    def selection
+      D3::Selection.new(@d3.JS.selection)
+    end
+
+    def select(selector)
+      D3::Selection.new(@d3.JS.select(selector))
+    end
+
+    def select_all(selector)
+      D3::Selection.new(@d3.JS.selectAll(selector))
+    end
+  end
+end

data/lib/opal/d3/sequential_scale.rb

@@ -0,0 +1,96 @@
+module D3
+  class SequentialScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+
+    attribute_d3 :domain
+    attribute_d3 :clamp
+
+    def copy
+      self.class.new @native.JS.copy
+    end
+
+    def interpolator(&block)
+      if block_given?
+        @native.JS.interpolator(block)
+        self
+      else
+        @native.JS.interpolator
+      end
+    end
+  end
+
+  class << self
+    def scale_sequential(&block)
+      raise unless block_given?
+      SequentialScale.new @d3.JS.scaleSequential(block)
+    end
+
+    def interpolate_viridis(t=nil)
+      if t
+        @d3.JS.interpolateViridis(t)
+      else
+        `#@d3.interpolateViridis`
+      end
+    end
+
+    def interpolate_inferno(t=nil)
+      if t
+        @d3.JS.interpolateInferno(t)
+      else
+        `#@d3.interpolateInferno`
+      end
+    end
+
+    def interpolate_magma(t=nil)
+      if t
+        @d3.JS.interpolateMagma(t)
+      else
+        `#@d3.interpolateMagma`
+      end
+    end
+
+    def interpolate_plasma(t=nil)
+      if t
+        @d3.JS.interpolatePlasma(t)
+      else
+        `#@d3.interpolatePlasma`
+      end
+    end
+
+    def interpolate_warm(t=nil)
+      if t
+        @d3.JS.interpolateWarm(t)
+      else
+        `#@d3.interpolateWarm`
+      end
+    end
+
+    def interpolate_cool(t=nil)
+      if t
+        @d3.JS.interpolateCool(t)
+      else
+        `#@d3.interpolateCool`
+      end
+    end
+
+    def interpolate_rainbow(t=nil)
+      if t
+        @d3.JS.interpolateRainbow(t)
+      else
+        `#@d3.interpolateRainbow`
+      end
+    end
+
+    def interpolate_cubehelix_default(t=nil)
+      if t
+        @d3.JS.interpolateCubehelixDefault(t)
+      else
+        `#@d3.interpolateCubehelixDefault`
+      end
+    end
+  end
+end

data/lib/opal/d3/set.rb

@@ -0,0 +1,33 @@
+module D3
+  class Set
+    include D3::Native
+    alias_native :empty?, :empty
+    alias_native :has?, :has
+    alias_native :size
+    alias_native :values
+    alias_native_chainable :add
+    alias_native_chainable :clear
+    alias_native_chainable :remove
+
+    def each(&block)
+      @native.JS.each(block)
+      self
+    end
+
+    def inspect
+      "#<D3::Set: {#{ values.join(", ") }}>"
+    end
+  end
+
+  class << self
+    def set(array=nil, &block)
+      if block_given?
+        D3::Set.new @d3.JS.set(array, proc{|x| yield(x)})
+      elsif array
+        D3::Set.new @d3.JS.set(array)
+      else
+        D3::Set.new @d3.JS.set()
+      end
+    end
+  end
+end

data/lib/opal/d3/stack.rb

@@ -0,0 +1,11 @@
+module D3
+  class StackGenerator
+    include D3::Native
+  end
+
+  class << self
+    def stack
+      D3::StackGenerator.new @d3.JS.stack
+    end
+  end
+end

data/lib/opal/d3/statistics.rb

@@ -0,0 +1,81 @@
+module D3
+  class << self
+    def min(data, &block)
+      if block
+        @d3.JS.min(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.min(data.compact)
+      end
+    end
+
+    def max(data, &block)
+      if block
+        @d3.JS.max(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.max(data.compact)
+      end
+    end
+
+    def sum(data, &block)
+      if block
+        @d3.JS.sum(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.sum(data.compact)
+      end
+    end
+
+    def mean(data, &block)
+      result = if block
+        @d3.JS.mean(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.mean(data.compact)
+      end
+      `result === undefined ? nil : result`
+    end
+
+    def median(data, &block)
+      result = if block
+        @d3.JS.median(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.median(data.compact)
+      end
+      `result === undefined ? nil : result`
+    end
+
+    def deviation(data, &block)
+      result = if block
+        @d3.JS.deviation(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.deviation(data.compact)
+      end
+      `result === undefined ? nil : result`
+    end
+
+    def variance(data, &block)
+      result = if block
+        @d3.JS.variance(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.variance(data.compact)
+      end
+      `result === undefined ? nil : result`
+    end
+
+    def quantile(data, p, &block)
+      result = if block
+        @d3.JS.quantile(data, p, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.quantile(data.compact, p)
+      end
+      `result === undefined ? nil : result`
+    end
+
+    def extent(data, &block)
+      (a,b) = if block
+        @d3.JS.extent(data, proc{|x| y=yield(x); y.nil? ? `undefined` : y})
+      else
+        @d3.JS.extent(data.compact)
+      end
+      [`a === undefined ? nil : a`, `b === undefined ? nil : b`]
+    end
+  end
+end

data/lib/opal/d3/symbol.rb

@@ -0,0 +1,70 @@
+module D3
+  class SymbolGenerator
+    include D3::Native
+
+    def call(*args)
+      @native.call(*args)
+    end
+
+    attribute_d3_block :size
+
+    def type(new_value=`undefined`, &block)
+      if block_given?
+        @native.JS.type{|*args| yield(*args).to_n}
+        self
+      elsif `new_value === undefined`
+        D3::SymbolType.new @native.JS.type
+      else
+        @native.JS.type(new_value.to_n)
+        self
+      end
+    end
+
+    def type=(new_value)
+      @native.type(new_value.to_n)
+      self
+    end
+  end
+
+  class SymbolType
+    include D3::Native
+  end
+
+  class << self
+    def symbol
+      D3::SymbolGenerator.new @d3.JS.symbol
+    end
+
+    def symbols
+      `window.d3.symbols`.map{|st| D3::SymbolType.new(st)}
+    end
+
+    def symbol_circle
+      D3::SymbolType.new `window.d3.symbolCircle`
+    end
+
+    def symbol_cross
+      D3::SymbolType.new `window.d3.symbolCross`
+    end
+
+    def symbol_diamond
+      D3::SymbolType.new `window.d3.symbolDiamond`
+    end
+
+    def symbol_square
+      D3::SymbolType.new `window.d3.symbolSquare`
+    end
+
+    def symbol_star
+      D3::SymbolType.new `window.d3.symbolStar`
+    end
+
+    def symbol_triangle
+      D3::SymbolType.new `window.d3.symbolTriangle`
+    end
+
+    def symbol_wye
+      D3::SymbolType.new `window.d3.symbolWye`
+    end
+  end
+end

data/lib/opal/d3/threshold_scale.rb

@@ -0,0 +1,23 @@
+module D3
+  class ThresholdScale
+    include D3::Native
+    attribute_d3 :domain
+    attribute_d3 :range
+    alias_native_new :copy
+
+    def call(t)
+      @native.call(t)
+    end
+
+    def invert_extent(t)
+      a,b = @native.JS.invertExtent(t)
+      [`a === undefined ? nil : a`, `b === undefined ? nil : b`]
+    end
+  end
+
+  class << self
+    def scale_threshold
+      D3::ThresholdScale.new @d3.JS.scaleThreshold
+    end
+  end
+end

data/lib/opal/d3/time_format.rb

@@ -0,0 +1,48 @@
+module D3
+  class TimeFormatLocale
+    include D3::Native
+    alias_native :format, :format
+    alias_native :parse, :parse
+    alias_native :utc_format, :utcFormat
+    alias_native :utc_parse, :utcParse
+  end
+
+  class << self
+    alias_d3 :time_format, :timeFormat
+    alias_d3 :time_parse, :timeParse
+    alias_d3 :utc_format, :utcFormat
+    alias_d3 :utc_parse, :utcParse
+    alias_d3 :iso_format, :isoFormat
+    alias_d3 :iso_parse, :isoParse
+
+    def time_format_locale(spec={})
+      D3::TimeFormatLocale.new @d3.JS.timeFormatLocale(
+        {
+          dateTime: spec.fetch(:date_time, "%x, %X"),
+          date: spec.fetch(:date, "%-m/%-d/%Y"),
+          time: spec.fetch(:time, "%-I:%M:%S %p"),
+          periods: spec.fetch(:periods, ["AM", "PM"]),
+          days: spec.fetch(:days, ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]),
+          shortDays: spec.fetch(:short_days, ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]),
+          months: spec.fetch(:months, ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]),
+          shortMonths: spec.fetch(:short_months, ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]),
+        }.to_n
+      )
+    end
+
+    def time_format_default_locale(spec={})
+      D3::TimeFormatLocale.new @d3.JS.timeFormatDefaultLocale(
+        {
+          dateTime: spec.fetch(:date_time, "%x, %X"),
+          date: spec.fetch(:date, "%-m/%-d/%Y"),
+          time: spec.fetch(:time, "%-I:%M:%S %p"),
+          periods: spec.fetch(:periods, ["AM", "PM"]),
+          days: spec.fetch(:days, ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]),
+          shortDays: spec.fetch(:short_days, ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]),
+          months: spec.fetch(:months, ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]),
+          shortMonths: spec.fetch(:short_months, ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]),
+        }.to_n
+      )
+    end
+  end
+end

data/lib/opal/d3/time_interval.rb

@@ -0,0 +1,81 @@
+module D3
+  class TimeInterval
+    include D3::Native
+
+    alias_native :round
+    alias_native :floor
+    alias_native :ceil
+    alias_native :offset
+    alias_native :range
+    alias_native :count
+    alias_native_new :every
+
+    def filter(&block)
+      D3::TimeInterval.new(@native.JS.filter(block))
+    end
+  end
+
+  class << self
+    def time_year; D3::TimeInterval.new(`window.d3.timeYear`); end
+    def utc_year; D3::TimeInterval.new(`window.d3.utcYear`); end
+    def time_month; D3::TimeInterval.new(`window.d3.timeMonth`); end
+    def utc_month; D3::TimeInterval.new(`window.d3.utcMonth`); end
+    def time_week; D3::TimeInterval.new(`window.d3.timeWeek`); end
+    def utc_week; D3::TimeInterval.new(`window.d3.utcWeek`); end
+    def time_monday; D3::TimeInterval.new(`window.d3.timeMonday`); end
+    def utc_monday; D3::TimeInterval.new(`window.d3.utcMonday`); end
+    def time_tuesday; D3::TimeInterval.new(`window.d3.timeTuesday`); end
+    def utc_tuesday; D3::TimeInterval.new(`window.d3.utcTuesday`); end
+    def time_wednesday; D3::TimeInterval.new(`window.d3.timeWednesday`); end
+    def utc_wednesday; D3::TimeInterval.new(`window.d3.utcWednesday`); end
+    def time_thursday; D3::TimeInterval.new(`window.d3.timeThursday`); end
+    def utc_thursday; D3::TimeInterval.new(`window.d3.utcThursday`); end
+    def time_friday; D3::TimeInterval.new(`window.d3.timeFriday`); end
+    def utc_friday; D3::TimeInterval.new(`window.d3.utcFriday`); end
+    def time_saturday; D3::TimeInterval.new(`window.d3.timeSaturday`); end
+    def utc_saturday; D3::TimeInterval.new(`window.d3.utcSaturday`); end
+    def time_sunday; D3::TimeInterval.new(`window.d3.timeSunday`); end
+    def utc_sunday; D3::TimeInterval.new(`window.d3.utcSunday`); end
+    def time_day; D3::TimeInterval.new(`window.d3.timeDay`); end
+    def utc_day; D3::TimeInterval.new(`window.d3.utcDay`); end
+    def time_hour; D3::TimeInterval.new(`window.d3.timeHour`); end
+    def utc_hour; D3::TimeInterval.new(`window.d3.utcHour`); end
+    def time_minute; D3::TimeInterval.new(`window.d3.timeMinute`); end
+    def utc_minute; D3::TimeInterval.new(`window.d3.utcMinute`); end
+    def time_second; D3::TimeInterval.new(`window.d3.timeSecond`); end
+    def utc_second; D3::TimeInterval.new(`window.d3.utcSecond`); end
+    def time_millisecond; D3::TimeInterval.new(`window.d3.timeMillisecond`); end
+    def utc_millisecond; D3::TimeInterval.new(`window.d3.utcMillisecond`); end
+
+    alias_d3 :time_years, :timeYears
+    alias_d3 :utc_years, :utcYears
+    alias_d3 :time_milliseconds, :timeMilliseconds
+    alias_d3 :utc_milliseconds, :utcMilliseconds
+    alias_d3 :time_seconds, :timeSeconds
+    alias_d3 :utc_seconds, :utcSeconds
+    alias_d3 :time_minutes, :timeMinutes
+    alias_d3 :utc_minutes, :utcMinutes
+    alias_d3 :time_hours, :timeHours
+    alias_d3 :utc_hours, :utcHours
+    alias_d3 :time_days, :timeDays
+    alias_d3 :utc_days, :utcDays
+    alias_d3 :time_weeks, :timeWeeks
+    alias_d3 :utc_weeks, :utcWeeks
+    alias_d3 :time_sundays, :timeSundays
+    alias_d3 :utc_sundays, :utcSundays
+    alias_d3 :time_mondays, :timeMondays
+    alias_d3 :utc_mondays, :utcMondays
+    alias_d3 :time_tuesdays, :timeTuesdays
+    alias_d3 :utc_tuesdays, :utcTuesdays
+    alias_d3 :time_wednesdays, :timeWednesdays
+    alias_d3 :utc_wednesdays, :utcWednesdays
+    alias_d3 :time_thursdays, :timeThursdays
+    alias_d3 :utc_thursdays, :utcThursdays
+    alias_d3 :time_fridays, :timeFridays
+    alias_d3 :utc_fridays, :utcFridays
+    alias_d3 :time_saturdays, :timeSaturdays
+    alias_d3 :utc_saturdays, :utcSaturdays
+    alias_d3 :time_months, :timeMonths
+    alias_d3 :utc_months, :utcMonths
+  end
+end

data/lib/opal/d3/transformations.rb

@@ -0,0 +1,13 @@
+module D3
+  class << self
+    alias_d3 :merge
+    alias_d3 :pairs
+    alias_d3 :permute
+    alias_d3 :shuffle
+    alias_d3 :ticks
+    alias_d3 :tick_step, :tickStep
+    alias_d3 :range
+    alias_d3 :transpose
+    alias_d3 :zip
+  end
+end

data/lib/opal/d3/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module D3
+    VERSION = "0.0.20170205"
+  end
+end

data/lib/opal/d3.rb

@@ -0,0 +1,62 @@
+require "opal"
+require "opal-parser"
+
+class Module
+  def alias_d3(ruby_name, js_name=ruby_name)
+    eval <<-EOF
+      def #{ruby_name}(*args)
+        @d3.JS.#{js_name}(*args)
+      end
+    EOF
+  end
+end
+
+module D3
+  @d3 = `window.d3`
+  class << self
+  end
+end
+# Metaclass:
+require_relative "d3/native"
+
+# Everything else:
+require_relative "d3/arc"
+require_relative "d3/area"
+require_relative "d3/axis"
+require_relative "d3/band_scale"
+require_relative "d3/collections"
+require_relative "d3/color"
+require_relative "d3/continuous_scale"
+require_relative "d3/creator"
+require_relative "d3/curve"
+require_relative "d3/dsv"
+require_relative "d3/ease"
+require_relative "d3/format"
+require_relative "d3/histograms"
+require_relative "d3/interpolate"
+require_relative "d3/line"
+require_relative "d3/map"
+require_relative "d3/misc"
+require_relative "d3/nest"
+require_relative "d3/ordinal_scale"
+require_relative "d3/path"
+require_relative "d3/pie"
+require_relative "d3/point_scale"
+require_relative "d3/polygon"
+require_relative "d3/quadtree"
+require_relative "d3/quantile_scale"
+require_relative "d3/quantize_scale"
+require_relative "d3/radial_area"
+require_relative "d3/radial_line"
+require_relative "d3/random"
+require_relative "d3/search"
+require_relative "d3/selection"
+require_relative "d3/sequential_scale"
+require_relative "d3/set"
+require_relative "d3/stack"
+require_relative "d3/statistics"
+require_relative "d3/symbol"
+require_relative "d3/threshold_scale"
+require_relative "d3/time_format"
+require_relative "d3/time_interval"
+require_relative "d3/transformations"

data/lib/opal-d3.rb

@@ -0,0 +1,9 @@
+if RUBY_ENGINE == 'opal'
+  require_relative "opal/d3"
+else
+  require "opal"
+  require_relative "opal/d3/version"
+
+  # This seems to be needed by sprockets somehow
+  Opal.append_path __dir__.untaint
+end