rubyvis 0.1.0

data/lib/rubyvis/scene/svg_bar.rb

@@ -0,0 +1,31 @@
+module Rubyvis
+  module SvgScene
+    def self.bar(scenes)
+      e=scenes._g.elements[1]
+      scenes.each_with_index do |s,i|
+      next unless s.visible
+      fill=s.fill_style
+      stroke=s.stroke_style
+      next if(!fill.opacity and !stroke.opacity)
+      e=SvgScene.expect(e,'rect', {
+      "shape-rendering"=> s.antialias ? nil : "crispEdges",
+      "pointer-events"=> s.events,
+      "cursor"=> s.cursor,
+      "x"=> s.left,
+      "y"=> s.top,
+      "width"=> [1E-10, s.width].max,
+      "height"=> [1E-10, s.height].max,
+      "fill"=> fill.color,
+      "fill-opacity"=> (fill.opacity==0) ? nil : fill.opacity,
+      "stroke"=> stroke.color,
+      "stroke-opacity"=> (stroke.opacity==0) ? nil : stroke.opacity,
+      "stroke-width"=> stroke.opacity ? s.line_width / SvgScene.scale.to_f : nil
+      })
+      
+      e=SvgScene.append(e,scenes,i)
+      
+      end
+      e
+    end
+  end
+end

data/lib/rubyvis/scene/svg_label.rb

@@ -0,0 +1,51 @@
+module Rubyvis
+  module SvgScene
+    def self.label(scenes)
+      e=scenes._g.elements[1]
+      scenes.each_with_index do |s,i|
+      next unless s.visible
+      fill=s.text_style
+      next if(fill.opacity==0 or s.text.nil?)
+      x=0
+      y=0
+      dy=0
+      anchor='start'
+      case s.text_baseline
+        when 'middle'
+          dy=".35em"
+        when "top"
+          dy = ".71em"; y = s.text_margin
+        when "bottom"
+          y = "-" + s.text_margin.to_s
+      end
+      case s.text_align
+      when 'rigth'
+        anchor = "end"; x = "-" + s.text_margin.to_s
+      when "center"
+        anchor = "middle"
+        
+      when "left"
+        x = s.text_margin
+      end
+      e=SvgScene.expect(e,'text', {
+        "pointer-events"=> s.events,
+        "cursor"=> s.cursor,
+        "x"=> x,
+        "y"=> y,
+        "dy"=> dy,
+        "transform"=> "translate(" + s.left.to_s + "," + s.top.to_s + ")" + (s.text_angle ? " rotate(" + (180 * s.text_angle / Math::PI).to_s + ")" : "") + (self.scale != 1 ? " scale(" + 1 / self.scale + ")" : ""),
+        "fill"=> fill.color,
+        "fill-opacity"=> fill.opacity || nil,
+        "text-anchor"=> anchor
+      }, {
+        "font"=> s.font, "text-shadow"=> s.text_shadow, "text-decoration"=> s.text_decoration      })
+      e.text=s.text
+      
+      
+      e=SvgScene.append(e,scenes,i)
+      
+      end
+      e
+    end
+  end
+end

data/lib/rubyvis/scene/svg_panel.rb

@@ -0,0 +1,117 @@
+module Rubyvis
+  module SvgScene
+    def self.panel(scenes)
+      g=scenes._g
+      e=(@g.nil?) ? nil : @g.elements[1]
+      if g
+        e=g.elements[0]
+      end
+      scenes.each_with_index do |s,i|
+        next unless s.visible
+        
+        if(!scenes.parent)
+          if g and g.parent!=s.canvas
+            g=s.canvas.elements[1]
+            e=(@g.nil?) ? nil : @g.elements[1]
+          end
+          if(!g)
+            g=s.canvas.add_element(self.create('svg'))
+            g.attributes["font-size"]="10px"
+            g.attributes["font-family"]="sans-serif"
+            g.attributes["fill"]="none"
+            g.attributes["stroke"]="none"
+            g.attributes["stroke-width"]=1.5
+            e=g.elements[1]
+          end
+          scenes._g=g
+          #p s
+          g.attributes['width']=s.width+s.left+s.right
+          g.attributes['height']=s.height+s.top+s.bottom
+        end
+        if s.overflow=='hidden'
+          id=Rubyvis.id.to_s(36)
+          c=self.expect(e,'g',{'clip-path'=>'url(#'+id+')'});
+          g.add_element(c) if(!c.parent) 
+          scenes._g=g=c
+          e=c.elements[1]
+          e=self.expect(e,'clipPath',{'id'=>id})
+          r=(e.elements[1]) ? e.elements[1] : e.add_element(self.create('rect'))
+          r.attributes['x']=s.left
+          r.attributes['y']=s.top
+          r.attributes['width']=s.width
+          r.attributes['height']=s.height
+          g.add_element(e) if !e.parent
+          e=e.next_sibling_node
+          
+        end
+        e=self.fill(e,scenes, i)
+        k=self.scale
+        t=s.transform
+        
+        x=s.left+t.x
+        y=s.top+t.y
+        
+        
+        SvgScene.scale=SvgScene.scale*t.k
+        s.children.each_with_index {|child, i|
+          child._g=e=SvgScene.expect(e, "g", {
+              "transform"=> "translate(" + x.to_s + "," + y.to_s + ")" + (t.k != 1 ? " scale(" + t.k.to_s + ")" : "")
+          })
+          SvgScene.update_all(child)
+          g.add_element(e) if(!e.parent)
+          e=e.next_sibling_node
+        }
+        SvgScene.scale=k
+        e=SvgScene.stroke(e,scenes,i)
+        
+        return e
+      end
+    end 
+
+ 
+    
+    def self.fill(e,scenes,i)
+      s=scenes[i]
+      fill=s.fill_style
+      if(fill.opacity>0 or s.events=='all')
+        e=SvgScene.expect(e,'rect', {
+        "shape-rendering"=> s.antialias ? nil : "crispEdges",
+        "pointer-events"=> s.events,
+        "cursor"=> s.cursor,
+        "x"=> s.left,
+        "y"=> s.top,
+        "width"=> s.width,
+        "height"=> s.height,
+        "fill"=> fill.color,
+        "fill-opacity"=> fill.opacity,
+        "stroke"=> nil
+        })        
+        e=SvgScene.append(e,scenes, i)
+      end
+      e
+    end
+    
+    
+    def self.stroke(e, scenes, i)
+      s = scenes[i]
+      stroke = s.stroke_style
+      if (stroke.opacity>0 or s.events == "all") 
+        e = self.expect(e, "rect", {
+          "shape-rendering"=> s.antialias ? nil : "crispEdges",
+          "pointer-events"=> s.events == "all" ? "stroke" : s.events,
+          "cursor"=> s.cursor,
+          "x"=> s.left,
+          "y"=> s.top,
+          "width"=> [1E-10, s.width].max, 
+          "height"=>[1E-10, s.height].max,
+          "fill"=>nil,
+          "stroke"=> stroke.color,
+          "stroke-opacity"=> stroke.opacity,
+          "stroke-width"=> s.line_width / self.scale.to_f
+        });
+        e = self.append(e, scenes, i);
+      end
+      return e
+    end
+  end
+end

data/lib/rubyvis/scene/svg_rule.rb

@@ -0,0 +1,29 @@
+module Rubyvis
+  module SvgScene
+    def self.rule(scenes)
+      e=scenes._g.elements[1]
+      scenes.each_with_index do |s,i|
+      next unless s.visible
+      stroke=s.stroke_style
+      
+      next if(!stroke.opacity)
+      e=SvgScene.expect(e,'line', {
+      "shape-rendering"=> s.antialias ? nil : "crispEdges",
+      "pointer-events"=> s.events,
+      "cursor"=> s.cursor,
+      "x1"=> s.left,
+      "y1"=> s.top,
+      'x2'=> s.left+s.width,
+      'y2'=>s.top+s.height,
+      "stroke"=> stroke.color,
+      "stroke-opacity"=> stroke.opacity,
+      "stroke-width"=> s.line_width/self.scale.to_f
+      })
+      
+      e=SvgScene.append(e,scenes,i)
+      
+      end
+      e
+    end
+  end
+end

data/lib/rubyvis/scene/svg_scene.rb

@@ -0,0 +1,118 @@
+require 'rubyvis/scene/svg_panel'
+require 'rubyvis/scene/svg_bar'
+require 'rubyvis/scene/svg_rule'
+require 'rubyvis/scene/svg_label'
+
+class REXML::Element
+  attr_accessor :_scene
+end
+
+module Rubyvis
+  def self.Scene
+    Rubyvis::SvgScene
+  end
+  module SvgScene
+    include REXML
+    def self.svg
+      "http://www.w3.org/2000/svg"
+    end;
+    def self.xmlns
+      "http://www.w3.org/2000/xmlns"
+    end
+    def self.xlink
+      "http://www.w3.org/1999/xlink"
+    end
+    def self.xhtml 
+      "http://www.w3.org/1999/xhtml"
+    end
+    @scale=1
+    def self.scale
+      @scale
+    end
+    def self.scale=(v)
+      @scale=v
+    end
+    def self.implicit
+      svg={
+      "shape-rendering"=> "auto",
+      "pointer-events"=> "painted",
+      "x"=> 0,
+      "y"=> 0,
+      "dy"=> 0,
+      "text-anchor"=> "start",
+      "transform"=> "translate(0,0)",
+      "fill"=> "none",
+      "fill-opacity"=> 1,
+      "stroke"=> "none",
+      "stroke-opacity"=> 1,
+      "stroke-width"=> 1.5,
+      "stroke-linejoin"=> "miter"
+    }
+    css={"font"=>"10px sans-serif"}
+    
+    {:svg=>svg,:css=>css}
+    end
+    def self.update_all(scenes)
+      if (scenes.size>0 and scenes[0].reverse and scenes.type!='line' and scenes.type!='area')
+        scenes=scenes.reverse
+      end
+      
+      self.remove_siblings(self.send(scenes.type, scenes))
+    end
+    def self.remove_siblings(e)
+      while(e)
+        n=e.next_sibling_node
+        e.remove
+        e=n
+      end
+    end
+    def self.create(type)
+      el=Element.new "#{type}"
+      #el.add_namespace('svg',self.svg)
+    end
+    
+    def self.append(e,scenes,index)
+      e._scene=OpenStruct.new({:scenes=>scenes, :index=>index})
+      #e=self.title
+      
+      if(!e.parent)
+        scenes._g.add_element(e)
+      end
+      return e.next_sibling_node
+    end
+    
+    def self.expect(e, type, attributes, style=nil) 
+      
+      if (e)
+        e = e.elements[1] if (e.name == "a") 
+        if (e.name != type) 
+          n = self.create(type);
+          e.parent.replace_child(e, n);
+          e = n
+        end
+      else
+        e = self.create(type)
+      end
+      attributes.each {|name,value|
+        value = nil if (value == self.implicit[:svg][name])
+        if (value.nil?) 
+          e.delete_attribute(name) 
+        else 
+          e.attributes[name]=value
+        end
+      }
+      if(style)
+        style.each {|name,value|
+          value=nil if value==self.implicit[:css][name]
+          if (value.nil?)
+            e.delete_attribute(name)
+          else
+            e.style[name] = value;
+          end
+        }
+      end
+      e
+    end
+    
+  end
+end

data/lib/rubyvis/sceneelement.rb

@@ -0,0 +1,44 @@
+module Rubyvis
+  class SceneElement
+    def initialize
+      @scenes=Array.new
+    end
+    include Enumerable
+    attr_accessor :visible
+    attr_accessor :mark, :type, :child_index, :parent, :parent_index, :target, :defs, :data,  :antialias, :line_width, :fill_style, :overflow, :width, :height, :top, :bottom, :left, :right, :title, :reverse, :stroke_style, :transform, :canvas, :_g, :events, :cursor, :children, :id, :segmented, :interpolate, :tension, :name, :text_baseline, :text_align, :text, :font, :text_angle, :text_style, :text_margin, :text_decoration, :text_shadow
+    def []=(v,i)
+      if v.is_a? Numeric
+        @scenes[v]=i
+      elsif self.respond_to?(v.to_s+"=")
+        self.send(v.to_s+"=",i)
+      end
+    end
+    def [](v)
+      if v.is_a? Numeric
+        @scenes[v]
+      elsif self.respond_to? v
+        self.send(v)
+      end
+    end
+    def each
+      @scenes.each do |v|
+        yield v
+      end
+    end
+    def push(v)
+      @scenes.push(v)
+    end
+    def size
+      @scenes.size
+    end
+    def size=(v)
+      if self.size==v
+        return true
+      elsif self.size<v
+        (v-self.size).times {push(nil)}
+      else
+        self.slice!(0,v)
+      end
+    end
+  end
+end

data/lib/rubyvis/transform.rb

@@ -0,0 +1,25 @@
+module Rubyvis
+  def self.Transform
+    Rubyvis::Transform
+  end
+  class Transform
+    attr_accessor :k,:x,:y
+    def initialize
+      @k=1
+      @x=0
+      @y=0
+    end
+    def translate(x,y)
+      v=Transform.new
+      v.k=self.k
+      v.x=self.k*x+self.x
+      v.y=self.k*y+self.y
+      v
+      
+    end
+    def self.identity
+      Transform.new
+    end
+  end
+  
+end

data/spec/internal_spec.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+describe "Rubyvis module methods" do
+  describe "from pv.js" do
+    it "method identify should always return the same value" do
+      f=Rubyvis.identity
+      a="a"
+      f.js_call(a, 5).should==5
+    end
+    it "method index should return index method from a object" do
+      o1=Rubyvis.o_index(1)
+      o2=Rubyvis.o_index(10)
+      Rubyvis.index.js_call(o1,1,2).should==1
+      Rubyvis.index.js_call(o2,1,2).should==10
+    end
+  end
+  describe "from pv-internal.js" do 
+    it "should create a infinite succesion with id" do
+      f=Rubyvis.id
+      Rubyvis.id.should==f+1
+    end
+    it "should return a lambda with functor" do
+      Rubyvis.functor(5).call.should==5
+    end
+  end
+  describe "from data/Arrays.js" do 
+    it "map method should map an array using a index based object" do
+      f=lambda {|d| "#{self.index}-#{d}"}
+      i=%w{a b c}
+      o=%w{0-a 1-b 2-c}
+      Rubyvis.map(i).should==i
+      Rubyvis.map(i,f).should==o
+    end
+    it "repeat method should repeat the specified array n times" do
+      Rubyvis.repeat([1,2]).should==[1,2,1,2]
+      Rubyvis.repeat([1,2],3).should==[1,2,1,2,1,2]
+    end
+    it "cross method should return an array of all posible pairs of element" do
+      Rubyvis.cross([1,2],[3,4]).should==[[1,3],[1,4],[2,3],[2,4]]
+    end
+    it "blend method should concatenates the arrays into a single array" do
+      Rubyvis.blend([[1,2,3],[4,5,6],[7,8,9]]).should==(1..9).to_a
+    end
+    it "transpose method should returns a transposed array of arrays" do
+      Rubyvis.transpose([[1,2,3],[4,5,6]]).should==[[1,4],[2,5],[3,6]]
+    end
+    it "normalize method should returns a normalized copy of array" do
+      Rubyvis.normalize([1,1,3]).should==[0.2,0.2,0.6]
+      a=%w{aa ccc ddddd}
+      f=lambda {|e| e.size}
+      Rubyvis.normalize(a,f).should==[0.2,0.3,0.5]
+    end
+    it "permute method allows to permute the order of elements" do
+      Rubyvis.permute(%w{a b c},[1,2,0]).should==%w{b c a}
+      f=lambda {|e| [self.index,e]}
+      Rubyvis.permute(%w{a b c},[1,2,0],f).should==[[1,"b"],[2,"c"],[0,"a"]]
+    end
+    it "numerate should  map from key to index for the specified keys array" do
+      Rubyvis.numerate(["a", "b", "c"]).should=={"a"=>0,"b"=>1,"c"=>2}
+    end
+    it "method uniq returns the unique elements in the specified array" do
+      Rubyvis.uniq(["a", "b", "c","c"]).should==["a","b","c"]
+      Rubyvis.uniq(["a", "b", "c","c"], lambda{|e| e*2}).should==["aa","bb","cc"]
+    end
+    it "method search should return correct values" do
+      a=(0..9).to_a
+      Rubyvis.search(a,1).should==1
+      Rubyvis.search(a,20).should==-11
+      Rubyvis.search(a,5.5).should==-7
+    end
+    it "method search_index should return correct values" do
+      a=(0..9).to_a
+      Rubyvis.search_index(a,1).should==1
+      Rubyvis.search_index(a,20).should==10
+      Rubyvis.search_index(a,5.5).should==6
+    end
+  end
+  describe "from data/Numbers.js" do
+    it "method range should create range of numbers" do
+      Rubyvis.range(1,10).should==[1,2,3,4,5,6,7,8,9]
+      Rubyvis.range(1,10,0.5).should==[1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5]
+      Rubyvis.range(1,10,3).should==[1,4,7]  
+      lambda {Rubyvis.range(1,10,0)}.should raise_exception
+    end
+    it "method random returns a random number between values" do
+      srand(10)
+      100.times.map{ Rubyvis.random(5)}.uniq.sort.should==(0..4).to_a
+      100.times.map{ Rubyvis.random(1,5)}.uniq.sort.should==(1..4).to_a
+      100.times.map{ Rubyvis.random(1,3,0.5)}.uniq.sort.should== [1.0,1.5,2.0,2.5]
+    end
+    it "methods sum returns a sum" do
+      Rubyvis.sum([1,2,3,4]).should==(1+2+3+4)
+      Rubyvis.sum(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==(4*1 + 3*2 + 2*3 + 5*4)
+    end
+    it "method max returns maximum value" do
+      Rubyvis.max([1,2,3,4]).should==4
+      Rubyvis.max([1,2,3,4], Rubyvis.index).should==3
+      Rubyvis.max(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==20
+    end
+    it "method max_index returns maximum value index" do
+      Rubyvis.max_index([1,2,4,3]).should==2
+      Rubyvis.max_index(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==4
+    end
+    it "method min returns minimum value" do
+      Rubyvis.min([1,2,3,4]).should==1
+      Rubyvis.min([1,2,3,4], Rubyvis.index).should==0
+      Rubyvis.min(%w{2 0 3 2 5}, lambda {|v| v.to_i + self.index}).should==1
+    end
+    it "method min_index returns minimum value index" do
+      Rubyvis.min_index([1,2,4,-1]).should==3
+      Rubyvis.min_index(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==0
+    end
+    it "method mean returns mean of values" do
+      a,b,c,d=rand,rand,rand,rand
+      #Rubyvis.mean([a,b,c,d]).should==(a+b+c+d).quo(4)
+      Rubyvis.mean([a,b,c,d].map {|x| x.to_s}, lambda {|v| v.to_f+1}).should==(a+b+c+d).quo(4)+1
+    end
+    it "method median returns median of values" do
+      Rubyvis.median([1,2,4,3]).should==2.5
+      Rubyvis.median([1,3,2,5,3]).should==3
+      Rubyvis.median([1,3,2,5,3].map(&:to_s), lambda(&:to_f)).should==3
+    end
+    it "method variance returns sum of squares" do
+      Rubyvis.variance([5,7,9,11]).should==20
+      Rubyvis.variance([5,7,9,11], lambda {|x| x+self.index}).should==45
+    end
+    it "method deviation returns standard deviation" do
+      Rubyvis.deviation([5,7,9,11]).should be_close(2.581, 0.001)
+    end
+    it "method log" do
+      Rubyvis.log(5,4).should be_close(1.16, 0.001)
+    end
+    it "method log_symmetric" do
+      Rubyvis.log_symmetric(-5,4).should be_close(-1.16, 0.001)
+    end
+    it "method log_adjusted" do
+      Rubyvis.log_adjusted(6,10).should be_close(0.806, 0.001)
+    end
+    it "method log_floor" do
+      Rubyvis.log_floor(-5,4).should be_close(16, 0.001)
+    end
+    it "method log_ceil" do
+      Rubyvis.log_ceil(-5,4).should be_close(-4, 0.001)
+    end
+  end
+  
+end