rubyvis 0.1.0

data/lib/rubyvis/mark/anchor.rb

@@ -0,0 +1,22 @@
+module Rubyvis
+  def self.Anchor(target)
+    Rubyvis::Anchor.new(target)
+  end
+  
+  class Anchor < Mark
+    @properties=Mark.properties
+    attr_accessor_dsl :name, :text_baseline, :text_align
+    def type
+      'area'
+    end
+    def initialize(target)
+      super()
+      self.target=target
+      self.parent=target.parent
+    end
+    def _extend(proto)
+      self.proto=proto
+      return self
+    end
+  end
+end

data/lib/rubyvis/mark/area.rb

@@ -0,0 +1,34 @@
+module Rubyvis
+  def self.Area
+    Rubyvis::Area
+  end
+  
+  class Area < Mark
+    @properties=Mark.properties
+    attr_accessor_dsl :width, :height, :line_width, :stroke_style, :fill_style, :segmented, :interpolate, :tension
+    def type
+      'area'
+    end
+    def defaults
+      sd=super
+      return sd.merge({:line_width=>1.5, :fill_style=>pv.Colors.category20.by(pv.parent), :interpolate=>'linear', :tension=>0.7})
+    end
+    def build_implied(s)
+      s.heigth=0 if s.height.nil?
+      s.width=0 if s.width.nil?
+      super(s)
+    end
+    def self.anchor(name)
+      Mark.anchor(name).interpolate(lambda {
+          self.scene.target[self.index].interpolate
+      }).eccentricity(lambda {
+      self.scene.target[self.index].eccentricity
+      }).tension(lambda {
+      self.scene.target[self.index].tension
+      })
+    end
+    def anchor
+      (self.class).anchor(name)
+    end
+  end
+end

data/lib/rubyvis/mark/bar.rb

@@ -0,0 +1,23 @@
+module Rubyvis
+  def self.Bar
+    Rubyvis::Bar
+  end
+  class Bar < Mark
+    def type
+      "bar"
+    end
+
+    @properties=Mark.properties
+    attr_accessor_dsl :width, :height, :line_width, :stroke_style, :fill_style
+    def defaults
+      sd=super
+      return sd.merge({:line_width=>1.5, :fill_style=>Rubyvis.Colors.category20().by(Rubyvis.parent)})
+    end
+    def svg_render_pre
+      "<rect fill='#{pr_svg(:fill_style)}' height='#{pr_svg(:height)}' width='#{pr_svg(:width)}' x='#{pr_svg(:left)}' y='#{pr_svg(:top)}'>"
+    end
+    def svg_render_post
+      "</rect>"
+    end
+  end
+end

data/lib/rubyvis/mark/label.rb

@@ -0,0 +1,17 @@
+module Rubyvis
+  def self.Label
+    Rubyvis::Label
+  end
+  
+  class Label < Mark
+    @properties=Mark.properties
+    attr_accessor_dsl :text, :font, :text_angle, :text_style, :text_align, :text_baseline, :text_margin, :text_decoration, :text_shadow
+    def type
+      'label'
+    end
+    def defaults
+      sd=super
+      return sd.merge({:events=>'none', :text=>lambda{|x| puts "->#{x}"; x}, :font=>"10px sans-serif", :text_angle=>0, :text_style=>pv.color('black'), :text_align=>'left', :text_baseline=>'bottom', :text_margin=>3})
+    end
+  end
+end

data/lib/rubyvis/mark/line.rb

@@ -0,0 +1,14 @@
+module Rubyvis
+  def self.Line
+    Rubyvis::Line
+  end
+  
+  class Line < Mark
+    @properties=Mark.properties
+    attr_accessor_dsl :line_width, :line_join, :stroke_style, :fill_style, :segmented, :interporale, :eccentricity, :tension
+    def defaults
+      sd=super
+      return sd.merge({:line_join=>'miter', :line_width=>1.5, :stroke_style=>RubyVis::Color.category10().by(pv.parent), :interpolate=>'linear', :eccentricity=>0, :tension=>7})
+    end
+  end
+end

data/lib/rubyvis/mark/panel.rb

@@ -0,0 +1,87 @@
+module Rubyvis
+  def self.Panel
+    Rubyvis::Panel
+  end    
+  class Panel < Bar
+    def type
+      "panel"
+    end
+
+    @properties=Bar.properties
+    attr_accessor_dsl :transform, :overflow, :canvas
+    attr_accessor :children, :root
+    def initialize
+      super
+      @children=[]
+      @root=self
+    end
+    def defaults
+      sd=super
+      return sd.merge({:fill_style=>nil, :overflow=>'visible', :canvas=>Rubyvis.document.add_element("canvas")})
+    end
+    def add(type)
+      child=type.new
+      child.parent=self
+      child.root=root
+      child.child_index=children.size
+      children.push(child)
+      child
+    end
+    
+    attr_reader :_canvas
+    def bind
+      super
+      children.each {|c|
+        c.bind()
+      }
+    end
+    def build_instance(s)
+      super(s)
+      return if !s.visible
+      s.children=[] if !s.children
+      scale=self.scale*s.transform.k
+      n=self.children.size
+      Mark.index=-1
+      n.times {|i|
+        child=children[i]
+        child.scene=s.children[i]
+        child.scale=scale
+        child.build()
+      }
+      n.times {|i|
+        child=children[i]
+        s.children[i]=child.scene
+        child.scene=nil
+        child.scale=nil
+      }
+      s.children=s.children[0,n]
+    end
+    def build_implied(s)
+      if(!self.parent)
+        c=s.canvas
+        if(c)
+          if s.width.nil?
+            w=Rubyvis.css(c,'width')
+            s.width=w-s.left-s.right
+          end
+          if s.height.nil?
+            w=Rubyvis.css(c,'height')
+            s.height=h-s.top-s.bottom
+          end
+        else
+          @_canvas||={}
+          cache=@_canvas
+          if(!(c=cache[self.index]))
+            c=cache[this.index]=Rubyvis.add_element('span')
+          end
+        end
+        s.canvas=c
+      end
+      
+      s.transform=Rubyvis.Transform.identity if (s.transform.nil?)
+      super(s)
+      
+    end
+    
+  end
+end

data/lib/rubyvis/mark/rule.rb

@@ -0,0 +1,28 @@
+module Rubyvis
+  def self.Rule
+    Rubyvis::Rule
+  end
+  class Rule < Mark
+    @properties=Mark.properties
+    attr_accessor_dsl :width, :height, :line_width, :stroke_style
+    def defaults
+      sd=super
+      return sd.merge({:line_width=>1,:stroke_style=>pv.color('black'),:antialias=>false})
+    end
+    def type
+      'rule'
+    end
+    def build_implied(s)
+      l=s.left
+      r=s.right
+      t=s.top
+      b=s.bottom
+      if((!s.width.nil?) or ((l.nil?) and (r.nil?)) or ((!r.nil?) or (!l.nil?)))
+        s.height=0
+      else
+        s.width=0
+      end
+      super(s)
+    end
+  end
+end

data/lib/rubyvis/scale.rb

@@ -0,0 +1,34 @@
+module Rubyvis
+  def self.Scale
+    Rubyvis::Scale
+  end
+  module Scale
+    def self.quantitative(*args)
+      Quantitative.new(*args)
+    end
+    def self.linear(*args)
+      Linear.new(*args)
+    end
+    def self.ordinal(*args)
+      Ordinal.new(*args)
+    end    
+    def self.interpolator(start,_end)
+      if start.is_a? Numeric
+        return lambda {|t| t*(_end-start)+start}
+      end
+      start=Rubyvis.color(start).rgb()
+      _end = Rubyvis.color(_end).rgb()
+      return lambda {|t|
+        a=start.a*(1-t)+_end.a*t
+        a=0 if a<1e-5
+        return (start.a == 0) ? Rubyvis.rgb(_end.r, _end.g, _end.b, a) : ((_end.a == 0) ? pv.rgb(start.r, start.g, start.b, a) : Rubyvis.rgb(
+          (start.r * (1 - t) + _end.r * t).round,
+          (start.g * (1 - t) + _end.g * t).round,
+          (start.b * (1 - t) + _end.b * t).round, a))
+      }
+    end
+  end
+end
+require 'rubyvis/scale/quantitative.rb'
+require 'rubyvis/scale/linear.rb'
+require 'rubyvis/scale/ordinal.rb'

data/lib/rubyvis/scale/linear.rb

@@ -0,0 +1,5 @@
+module Rubyvis
+  
+  class Scale::Linear < Rubyvis::Scale::Quantitative
+    end
+end

data/lib/rubyvis/scale/ordinal.rb

@@ -0,0 +1,52 @@
+module Rubyvis
+  class Scale::Ordinal
+    include Rubyvis::Scale
+    
+      def initialize(*args)
+        @d=[] # domain
+        @i={}
+        @r=[]
+        @band=0
+        domain(*args)
+      end
+      def scale(x)
+        if @i[x].nil?
+          @d.push(x)
+          @i[x]=@d.size-1
+        end
+        @r[@i[x] % @r.size]
+      end
+      def domain(*arguments)
+        array,f=arguments[0],arguments[1]
+        if(arguments.size>0)
+          array= (array.is_a? Array) ? ((arguments.size>1) ? array.map(&f) : array) : arguments.dup
+          @d=array.uniq
+          i=pv.numerate(d)
+          return self
+        end
+        @d
+      end
+      def range(*arguments)
+        array, f = arguments[0],arguments[1]
+        if(arguments.size>0)
+        @r=(array.is_a? Array) ? ((arguments.size>1) ? array.map(&f) : array) : arguments.dup
+          if @r[0].is_a? String
+            @r=@r.map {|i| pv.color(i)}
+          end
+          self
+        end
+        @r
+      end
+      def split(min,max)
+        step=(max-min).quo(domain().size)
+        @r=pv.range(min+step.quo(2),max,step)
+        self
+      end
+      def by(*arguments)
+        f,dummy=arguments
+        t=self
+        by=lambda { t.scale(f.js_apply(self,arguments))}
+        by
+      end
+    end
+end

data/lib/rubyvis/scale/quantitative.rb

@@ -0,0 +1,263 @@
+module Rubyvis
+  class Scale::Quantitative
+    include Rubyvis::Scale
+    attr_reader :l
+      def initialize(*args)
+        @d=[0,1] # domain
+        @l=[0,1] # transformed domain
+        @r=[0,1] # default range
+        @i=[Rubyvis.identity] # default interpolator
+        @type=:to_f # default type
+        @n=false
+        @f=Rubyvis.identity # default forward transformation
+        @g=Rubyvis.identity
+        @tick_format=lambda {|x| x.to_f}
+        domain(*args)
+      end
+      def new_date(x=nil)
+        x.nil? ? Date.today : DateTime.civil(x)
+      end
+
+      def scale(x)
+        j=Rubyvis.search(@d,x)
+        j=-j-2 if (j<0)
+        j=[0,[@i.size-1,j].min].max
+        # p @l
+        # puts "Primero #{j}: #{@f.call(x) - @l[j]}"
+        # puts "Segundo #{(@l[j + 1] - @l[j])}"
+        @i[j].call((@f.call(x) - @l[j]) .quo(@l[j + 1] - @l[j]));
+      end
+      def [](x)
+        scale(x)
+      end
+      def transform(forward, inverse)
+        @f=lambda {|x| @n ? -forward.call(-x) : forward.call(x); }
+        @g=lambda {|y| @n ? -inverse.call(-y) : inverse.call(y); }
+        @l=@d.map{|v| @f.call(v)}
+        self
+      end
+      
+      
+      def domain(*arguments)
+        array,min,max=arguments
+        if (arguments.size>0)
+          if array.is_a? Array 
+            min = pv.identity if (arguments.size < 2)
+            max = min if (arguments.size < 3)
+            o = array.size>0 && [array[0]].min
+            @d = array.size ? [Rubyvis.min(array, min), Rubyvis.max(array, max)] : [];
+          else 
+            o = array;
+            @d = arguments.map {|i| i.to_f}
+          end
+          if !@d.size 
+            @d = [-Infinity, Infinity];
+          elsif (@d.size == 1) 
+            @d = [@d.first, @d.first]
+          end
+          @n = (@d.first<0 or @d.last<0)
+          @l=@d.map{|v| @f.call(v)}
+          @type = (o.is_a? Date) ? new_date : :to_f;
+          return self
+        end
+        # TODO: Fix this.
+        @d.map{|v| 
+          case @type
+          when :to_f
+            v.to_f
+          when :to_date
+            Date.new(v)
+          else 
+            v
+          end
+        }
+      end
+      
+      
+      def range(*arguments)
+        if (arguments.size>0) 
+          @r = arguments.dup
+          if (@r.size==0)
+            @r = [-Infinity, Infinity];
+          elsif (@r.size == 1)
+            @r = [@r[0], @r[0]]
+          end
+          @i=(@r.size-1).times.map do |j|
+            Rubyvis::Scale.interpolator(@r[j], @r[j + 1]);
+          end
+          return self
+        end
+        @r
+      end
+      
+      def invert(y)
+        j=Rubyvis.search(@r, y)
+        j=-j-2 if j<0
+        j = [0, [@i.size - 1, j].min].max
+        
+        @g.call(@l[j] + (y - @r[j]).quo(@r[j + 1] - @r[j]) * (@l[j + 1] - @l[j]));
+      end
+      
+      def type(v=nil)
+        return @type if v.nil?
+        case @type
+          when Numeric
+            v.to_f
+          when Date
+            raise "Not implemented yet"
+          end
+      end
+      # TODO: FIX this func
+      def ticks(*arguments) 
+        m = arguments[0]
+        start = @d.first
+        _end = @d.last
+        reverse = _end < start
+        min = reverse ? _end : start
+        max = reverse ? start : _end
+        span = max - min
+        
+        # Special case: empty, invalid or infinite span.
+        if (!span or (span.is_a? Float and span.infinite?)) 
+          @tick_format= Rubyvis.Format.date("%x") if (@type == newDate) 
+          return [type(min)];
+        end
+        # From here, �chaos!
+        #/* Special case: dates. */
+        if (@type == new_date) 
+        #/* Floor the date d given the precision p. */
+        lambda  do |d,p|
+        case(p) 
+        when 31536e6
+          d.setMonth(0);
+        when 2592e6
+          d.setDate(1);
+        when 6048e5
+          if (p == 6048e5) 
+            d.setDate(d.getDate() - d.getDay());
+          end
+        when 864e5
+          d.setHours(0);
+        when 36e5
+          d.setMinutes(0);
+        when 6e4
+          d.setSeconds(0);
+        when 1e3
+          d.setMilliseconds(0);
+        end
+        end
+        
+        precision, format, increment, step = 1,1,1,1
+        if (span >= 3 * 31536e6) 
+        precision = 31536e6;
+        format = "%Y";
+        increment = lambda {|d| d.setFullYear(d.getFullYear() + step); };
+        elsif (span >= 3 * 2592e6) 
+        precision = 2592e6;
+        format = "%m/%Y";
+        increment = lambda {|d| d.setMonth(d.getMonth() + step); };
+        elsif (span >= 3 * 6048e5) 
+        precision = 6048e5;
+        format = "%m/%d";
+        increment = lambda {|d| d.setDate(d.getDate() + 7 * step); };
+        elsif (span >= 3 * 864e5) 
+        precision = 864e5;
+        format = "%m/%d";
+        increment = lambda {|d| d.setDate(d.getDate() + step); };
+        elsif (span >= 3 * 36e5) 
+        precision = 36e5;
+        format = "%I:%M %p";
+        increment = lambda {|d| d.setHours(d.getHours() + step); };
+        elsif (span >= 3 * 6e4) 
+        precision = 6e4;
+        format = "%I:%M %p";
+        increment = lambda {|d| d.setMinutes(d.getMinutes() + step); };
+        elsif (span >= 3 * 1e3) 
+        precision = 1e3;
+        format = "%I:%M:%S";
+        increment = lambda {|d|  d.setSeconds(d.getSeconds() + step); };
+        else 
+        precision = 1;
+        format = "%S.%Qs";
+        increment = lambda {|d|  d.setTime(d.getTime() + step); };
+        end
+        @tick_format = pv.Format.date(format);
+        
+        date = Date.new(min)
+        dates = []
+        #floor(date, precision);
+        
+        # If we'd generate too many ticks, skip some!.
+        n = span.quo(precision)
+        if (n > 10) 
+        case (precision) 
+        when 36e5
+          step = (n > 20) ? 6 : 3;
+          date.setHours(Math.floor(date.getHours() / step) * step);
+        when 2592e6
+          step = 3; # seasons
+          date.setMonth(Math.floor(date.getMonth() / step) * step);
+        when 6e4
+          step = (n > 30) ? 15 : ((n > 15) ? 10 : 5);
+          date.setMinutes(Math.floor(date.getMinutes() / step) * step);
+        when 1e3
+          step = (n > 90) ? 15 : ((n > 60) ? 10 : 5);
+          date.setSeconds(Math.floor(date.getSeconds() / step) * step);
+        when 1
+          step = (n > 1000) ? 250 : ((n > 200) ? 100 : ((n > 100) ? 50 : ((n > 50) ? 25 : 5)));
+          date.setMilliseconds(Math.floor(date.getMilliseconds() / step) * step);
+        else
+          step = pv.logCeil(n / 15, 10);
+          if (n / step < 2) 
+            step =step.quo(5)
+          elsif (n / step < 5)
+            step = step.quo(2)
+          end
+          date.setFullYear((date.getFullYear().quo(step)).floor * step);
+        end
+        end
+        
+        while (true)
+        increment(date);
+        break if (date > max)
+        dates.push(Date.new(date));
+        end
+        return reverse ? dates.reverse() : dates;
+        end
+        
+        # Normal case: numbers. 
+        m = 10 if (arguments.size==0)
+        
+        step = pv.log_floor(span.quo(m), 10)
+        err = m.quo(span.quo(step))
+        if (err <= 0.15)
+        step = step*10
+        elsif (err <= 0.35)
+        step = step*5
+        elsif (err <= 0.75)
+        step = step*2
+        end
+        start = (min.quo(step)).ceil * step
+        _end = (max.quo(step)).floor * step
+        @tick_format= pv.Format.number().fraction_digits([0, -(pv.log(step, 10) + 0.01).floor].max);
+        ticks = pv.range(start, _end + step, step);
+        return reverse ? ticks.reverse() : ticks;
+      end
+      def nice
+        if (@d.size!=2)
+          return self;
+        end
+        start=@d.first
+        _end=@d[@d.size-1]
+        reverse=_end<start
+        min=reverse ? _end : start
+        max = reverse ? start : _end
+        span=max-min
+        return self if(!span or span.infinite?)
+        step=10**((Math::log(span).quo(Math::log(10))).round-1)
+        @d=[(min.quo(step)).floor*step, (max.quo(step)).ceil*step]
+        @d.reverse if  reverse
+        @l=@d.map {|v| @f.call(v)}
+      end
+    end
+end