rubyvis 0.1.0

data/lib/rubyvis/color/colors.rb

@@ -0,0 +1,40 @@
+module Rubyvis
+  def self.Colors
+    Rubyvis::Colors
+  end
+  def self.colors(*args)
+    scale=Rubyvis::Scale.ordinal
+    scale.range(*args)
+    scale
+  end
+  module Colors
+    def pv
+      Rubyvis
+    end
+     def self.category10(*arguments)
+      scale = pv.colors(
+     "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
+      "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf")
+      scale.domain(*arguments);
+      scale
+    end
+    def self.category19(*arguments)
+       scale = pv.colors(
+      "#9c9ede", "#7375b5", "#4a5584", "#cedb9c", "#b5cf6b",
+      "#8ca252", "#637939", "#e7cb94", "#e7ba52", "#bd9e39",
+      "#8c6d31", "#e7969c", "#d6616b", "#ad494a", "#843c39",
+      "#de9ed6", "#ce6dbd", "#a55194", "#7b4173")
+      scale.domain(*arguments);
+      scale
+    end
+    def self.category20(*arguments)
+      scale = pv.colors(
+      "#1f77b4", "#aec7e8", "#ff7f0e", "#ffbb78", "#2ca02c",
+      "#98df8a", "#d62728", "#ff9896", "#9467bd", "#c5b0d5",
+      "#8c564b", "#c49c94", "#e377c2", "#f7b6d2", "#7f7f7f",
+      "#c7c7c7", "#bcbd22", "#dbdb8d", "#17becf", "#9edae5")
+      scale.domain(*arguments);
+      scale
+    end
+  end
+end

data/lib/rubyvis/format.rb

@@ -0,0 +1,19 @@
+module Rubyvis
+  def self.Format
+    Rubyvis::Format
+  end
+  
+  module Format
+    def self.re(s)
+      s.gsub(/[\\\^\$\*\+\?\[\]\(\)\.\{\}]/, "\\$&")
+    end
+    def self.number
+      Format::Number.new
+    end
+    def self.date(pattern)
+      Format::Date.new(pattern)
+    end
+  end
+end
+require 'rubyvis/format/number'
+require 'rubyvis/format/date'

data/lib/rubyvis/format/date.rb

@@ -0,0 +1,18 @@
+require 'date'
+module Rubyvis
+  module Format
+    class Date
+      attr_reader :pattern
+      def initialize(pattern)
+        @pattern=pattern
+        #@pad=Rubyvis::Format.pad
+      end
+      def format(d)
+        d.strftime(pattern)
+      end
+      def parse(s)
+        ::Date.strptime(s, pattern)
+      end
+    end
+  end
+end

data/lib/rubyvis/format/number.rb

@@ -0,0 +1,31 @@
+module Rubyvis
+  module Format
+    class Number
+      def initialize
+        @maxi = Infinity # default maximum integer digits
+        @mins = 0 # mini, including group separators
+        @minf = 0 # default minimum fraction digits
+        @maxf = 0 # default maximum fraction digits
+        @maxk = 1 # 10^maxf
+        @padi = "0" # default integer pad
+        @padf = "0" # default fraction pad
+        @padg = true # whether group separator affects integer padding
+        @decimal = "." # default decimal separator
+        @group = "," # default group separator
+        @np = "\u2212" # default negative prefix
+        @ns = "" # default negative suffix
+      end
+      def fraction_digits(*arguments) 
+        if (arguments.size>0)
+          min=arguments[0]
+          max=arguments[1]
+          @minf = min.to_f
+          @maxf = (arguments.size > 1) ? max.to_f : @minf
+          @maxk = 10**@maxf
+          return self
+        end
+        [minf, maxf]      
+      end
+    end
+  end
+end

data/lib/rubyvis/internals.rb

@@ -0,0 +1,215 @@
+module Rubyvis
+  # :section: /pv-internals.js
+  @@id=0
+  def self.id
+    @@id+=1
+  end
+  def self.functor(f)
+    (f.is_a? Proc) ? f : lambda {f}
+  end
+  # :section: /data/Arrays.js
+  
+  def self.map(array, f=nil)
+    if f
+      array.size.times.map {|i|
+        o=o_index(i)
+        f.js_call(o, array[i])
+      }
+    else
+      array.dup
+    end
+  end
+  def self.repeat(array, n=2)
+    array*n
+  end
+  def self.cross(a,b)
+    array = [];
+    a.each {|x|
+      b.each {|y|
+        array.push([x,y])
+      }
+    }
+    array
+  end
+  def self.blend(arrays)
+    # I love Ruby expresivness
+    arrays.inject([]) {|ac,v| ac+v}
+  end
+  def self.transpose(matrix)
+    out=[]
+    matrix.size.times do |i|
+      matrix[i].size.times do |j|
+        out[j]||=Array.new
+        out[j][i]=matrix[i][j]
+      end
+    end
+    out
+  end
+  def self.normalize(array,f=nil)
+    norm=Rubyvis.map(array,f)
+    sum=pv.sum(norm)
+    norm.map {|x| x.quo(sum)}
+  end
+  def self.o_index(i)
+    o=OpenStruct.new :index=>i
+  end
+  def self.permute(array,indexes, f=nil)
+    f=Rubyvis.identity if f.nil?
+    indexes.map {|i| o=o_index(i); f.js_call(o, array[i])}
+  end
+  def self.numerate(keys, f=nil)
+    f=Rubyvis.identity if f.nil?
+    m = {}
+    keys.each_with_index {|x,i|
+      o=o_index(i)
+      m[f.js_call(o,x)]=i
+    }
+    m
+  end
+  def self.uniq(array, f=nil  )
+    self.map(array,f).uniq
+  end
+  def self.natural_order(a,b)
+    a<=>b
+  end
+  def self.reverse_order(a,b)
+    -(a<=>b)
+  end
+  
+  def self.search(array, value, f=nil)
+    f = Rubyvis.identity if (f.nil?) 
+    low = 0
+    high = array.size - 1;
+    while (low <= high)
+      mid = (low + high) >> 1
+      midValue = f.call(array[mid]);
+      if (midValue < value)
+        low = mid + 1;
+      elsif (midValue > value)
+        high = mid - 1;
+      else
+        return mid;
+      end
+    end
+    return -low - 1;
+  end
+  def self.search_index(array,value,f=nil)
+    i=Rubyvis.search(array,value,f)
+    (i < 0 ) ? (-i-1) : i;
+  end
+  
+  
+  # :section: /data/Numbers.js
+  
+    def self.range(*arguments)
+    start, stop, step=arguments
+    if (arguments.size == 1)
+      stop = start;
+      start = 0;
+    end
+    step||= 1
+    raise "range must be finite" if ((stop - start) / step.to_f).infinite?
+    array = []
+    i = 0
+    stop = stop- (stop - start) * 1e-10 #// floating point precision!
+    j = start + step * i
+    if (step < 0)
+      while (j > stop) 
+        array.push(j)
+        i+=1
+        j = start + step * i
+      end
+     else 
+      while (j < stop)
+        array.push(j)
+        i+=1
+        j = start + step * i
+      end
+    end
+    array
+  end
+  def self.random(*arguments)
+    start,stop,step=arguments
+    if (arguments.size == 1) 
+      stop = start;
+      start = 0;
+    end
+    step||= 1;
+    return step ? ((rand() * (stop - start).quo(step)).floor * step + start) : (rand() * (stop - start) + start);
+  end
+  
+  def self.sum(array,f=nil)
+    if f.nil?
+      array.inject(0) {|ac,v| ac+v}
+    else
+      i=0
+      array.inject(0) {|ac,v|
+        o=o_index(i);i+=1;
+        ac+f.js_call(o,v);
+      }
+    end
+  end
+  def self.max(array, f=nil)
+    return array.size-1 if f==Rubyvis.index
+    f ? Rubyvis.map(array, f).max : array.max
+  end
+  def self.max_index(array,f=nil)
+    a2=Rubyvis.map(array,f)
+    max=a2.max
+    a2.index(max)
+  end
+
+  def self.min(array, f=nil)
+    return array.size-1 if f==Rubyvis.index
+    f ? Rubyvis.map(array, f).min : array.min
+  end
+  def self.min_index(array,f=nil)
+    a2=Rubyvis.map(array,f)
+    min=a2.min
+    a2.index(min)
+  end
+  def self.mean(array, f=nil)
+    Rubyvis.sum(array,f).quo(array.size)
+  end
+  def self.median(array,f=nil)
+    return (array.length - 1).quo(2) if (f == pv.index) 
+    array = Rubyvis.map(array, f).sort{|a,b| Rubyvis.natural_order(a,b)}
+    return array[array.size.quo(2).floor] if (array.length % 2>0) 
+    i = array.size.quo(2);
+    return (array[i - 1] + array[i]).quo(2);
+  end
+  # Sum of square, really
+  def self.variance(array,f=nil)
+    return 0 if array.size==1 or array.uniq.size==1
+    ar=(f.nil?) ? array : Rubyvis.map(array,f)
+    mean=Rubyvis.mean(ar)
+    ar.inject(0) {|ac,v| ac+(v-mean)**2}
+  end
+  def self.deviation(array,f=nil)
+    Math::sqrt(self.variance(array,f) / (array.size.to_f-1))
+  end
+  def self.log(x,b)
+    Math::log(x).quo(Math::log(b))
+  end
+  def self.log_symmetric(x,b)
+    (x == 0) ? 0 : ((x < 0) ? -Rubyvis.log(-x, b) : Rubyvis.log(x, b));
+  end
+  def self.log_adjusted(x,b)
+    x if x.is_a? Float and !x.finite?
+    negative=x<0
+    x += (b - x) / b.to_f if (x < b)
+    negative ? -Rubyvis.log(x, b) : Rubyvis.log(x, b);
+  end
+  def self.log_floor(x,b)
+    (x>0)  ? b**(Rubyvis.log(x,b).floor) : b**(-(-Rubyvis.log(-x,b)).floor)
+  end
+  def self.log_ceil(x,b)
+    (x > 0) ? b ** (Rubyvis.log(x, b)).ceil : -(b ** -(-Rubyvis.log(-x, b)).ceil);
+  end
+  def self.radians(degrees)
+    (Math::PI/180.0)*degrees
+  end
+  def self.degrees(radians)
+    ((180.0) / Math::PI)*radians
+  end
+end

data/lib/rubyvis/javascript_behaviour.rb

@@ -0,0 +1,64 @@
+class TrueClass
+  def to_i
+    1
+  end
+end
+class FalseClass
+  def to_i
+    0
+  end
+end
+
+
+unless Object.public_method_defined? :instance_exec
+  class Object
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    def instance_exec(*args, &block) # :nodoc:
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+
+end
+# Add javascript-like +apply+ and +call+ methods to Proc,
+# called +js_apply+ and +js_call+, respectivly.
+
+class Proc
+  # Apply on javascript is very flexible. Can accept more or less
+  # variables than explicitly defined parameters on lambda, so the method
+  # adds or remove elements according to lambda arity
+  #
+  def js_apply(obj,args)
+    arguments=args.dup
+    # Modify numbers of args to works with arity
+    min_args=self.arity>0 ? self.arity : (-self.arity)-1
+    if args.size > min_args and self.arity>0
+      arguments=arguments[0,self.arity]
+    elsif args.size < min_args
+      arguments+=[nil]*(min_args-args.size)
+    end
+    #puts "#{args}->#{arguments} (#{self.arity})"
+    if self.arity==0
+      obj.instance_eval(&self)
+    else
+      obj.instance_exec(*arguments,&self)
+    end
+	end
+  # Same as js_apply, but using explicit arguments
+	def js_call(obj,*args)
+    js_apply(obj,args)
+	end
+end

data/lib/rubyvis/mark.rb

@@ -0,0 +1,528 @@
+module Rubyvis
+   # Represents a data-driven graphical mark. The <tt>Mark</tt> class is
+   # the base class for all graphical marks in Protovis; it does not provide any
+   # specific rendering functionality, but together with {@link Panel} establishes
+   # the core framework.
+  class Mark
+     @properties={}
+     
+     def self.property_method(name,_def)
+       define_method(name) do |*arguments|
+         v,dummy = arguments
+         if _def and self.scene
+           if arguments.size>0
+             defs[name]=OpenStruct.new({:id=>(v.nil?) ? 0 : Rubyvis.id, :value=> v})
+             return self
+           end
+           return defs[name]
+         end
+         if arguments.size>0
+           type=(!_def).to_i<<1 | (v.is_a? Proc).to_i
+           property_value(name,(type & 1 !=0) ? lambda {|*args|  v.js_apply(self, args)} : v)._type=type
+           @_properties_types[name]=type
+           return self
+         end
+         i=instance()
+         if i.nil?
+           raise "No instancia para #{name}"
+         else
+           #puts "Instancia para #{name}"
+           
+           i.send(name)
+         end
+       end
+     end
+     def property_value(name,v)
+       prop=OpenStruct.new({:name=>name, :id=>Rubyvis.id, :value=>v})
+       @_properties.delete_if{|v| v.name==name}
+       @_properties.push(prop)
+       @_properties_values[name]=v
+       return prop
+     end
+     def margin(n)
+       self.left(n).right(n).top(n).bottom(n)
+     end
+     def instance(default_index=nil)
+       scene=self.scene
+       scene||=self.parent.instance(-1).children[self.child_index]
+       if(default_index)
+         index=self.respond_to?(:index) ? self.index : default_index
+       else
+         index=scene.size-1
+       end
+       #puts "index:#{index} , scene.size:#{scene.size}, default_index:#{default_index}"
+       scene[index]
+     end
+     
+     
+     def self.attr_accessor_dsl(*attr)
+      attr.each  do |sym|
+        @properties[sym]=true
+        sym_w_sm=sym.to_s.gsub(":","")
+        self.property_method(sym,false)
+        define_method(sym.to_s+"=") {|v|
+          self.send(sym,v)
+        }
+      end
+    end
+    
+    attr_accessor :parent, :root, :index, :child_index, :scene, :proto, :target, :scale
+    attr_accessor_dsl :data,:visible, :left, :right, :top, :bottom, :title, :reverse, :antialias, :id
+   
+    @scene=nil
+    @stack=[]
+    @index=nil
+    def self.properties
+      @properties
+    end
+    def self.index
+      @index
+    end
+    def self.index=(v)
+      @index=v
+    end
+
+
+
+    def self.scene
+      @scene
+    end
+    def self.scene=(v)
+      @scene=v
+    end
+    def properties
+      (self.class).properties
+    end
+    def Mark.stack
+      @stack
+    end
+    def Mark.stack=(v)
+      @stack=v
+    end
+    
+    def initialize(opts=Hash.new)
+      @_properties_values={}
+      @_properties_types={}
+      @_properties=[]
+      @options=defaults.merge opts
+      # @stack=[]
+      @options.each {|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+      }
+      @defs={}
+      @child_index=-1
+      @index=-1
+      @scale=1
+      @scene=nil
+      
+    end
+    def type
+      "mark"
+    end
+    def _properties
+      out={}
+      @_properties_values.each {|k,v|
+        out[k]=OpenStruct.new({:name=>k.to_s,:value=>v, :_type=>@_properties_types[k]})
+      }
+      out
+    end
+   
+    
+   
+
+
+    
+    
+    def defaults
+      {:data=>lambda {|d| [d]}, :visible=>true, :antialias=>true}
+    end
+    def extend(proto)
+      @proto=proto
+      @target=target
+      self
+    end
+    
+    def add(type)
+      parent.add(type).extend(self)
+    end
+    def anchor(name=nil)
+      name = "center" if (!name) # default anchor name
+      return Rubyvis::Anchor.new(self).name(name).data(lambda {
+      self.scene.target.map {|s| s.data} }).visible(lambda {
+      self.scene.target[self.index].visible
+      }).id(lambda {self.scene.target[self.index].id}).left(lambda {
+        s = self.scene.target[self.index]
+        w = s.width
+        w||=0
+        if ['bottom','top','center'].include?(self.name)
+          s.left + w / 2.0
+        elsif self.name=='left'
+          nil
+        else
+          s.left + w
+        end
+      }).top(lambda {
+       s = self.scene.target[self.index]
+       h = s.height
+       h||= 0
+       if ['left','right','center'].include? self.name
+          s.top+h/2.0
+        elsif self.name=='top'
+          nil
+        else
+          s.top + h
+        end
+      }).right(lambda {
+        s = self.scene.target[self.index]
+        self.name() == "left" ? s.right + (s.width ? s.width : 0) : nil;
+      }).bottom(lambda {
+        s = self.scene.target[self.index];
+        self.name() == "top" ? s.bottom + (s.height ? s.height : 0) : nil;
+      }).text_align(lambda {
+      if ['bottom','top','center'].include? self.name
+        'center'
+      elsif self.name=='right'
+        'right'
+      else
+        'left'
+      end
+      }).text_baseline(lambda {
+      if ['right','left','center'].include? self.name
+        'middle'
+      elsif self.name=='top'
+        'top'
+      else
+        'bottom'
+      end
+      })
+
+      
+      
+    end
+    
+    
+    
+    
+    
+    def build_implied(s)
+      l=s.left
+      r=s.right
+      t=s.top
+      b=s.bottom
+      prop=self.properties
+      w = (prop[:width] and !prop[:width].nil?)  ? s.width : 0
+      h = (prop[:height] and !prop[:height].nil?)  ? s.height : 0
+      #puts "#{l},#{r},#{t},#{b}"
+      #puts "#{w},#{h}"
+      
+      width=self.parent ? self.parent.width(): (w+(l.nil? ? 0 : l)+(r.nil? ? 0 :r))
+      if w.nil?
+        r||=0
+        l||=0
+        w=width-r-l
+      elsif r.nil?
+        if l.nil?
+          
+          r=(width-w) / (2.0)
+          l=r
+        else
+          r=width-w-l
+        end
+      elsif l.nil?
+        l=width-w-r
+      end
+      
+      height=self.parent ? self.parent.height(): (h+(t.nil? ? 0 : t )+(b.nil? ? 0 : b))
+      
+      if h.nil?
+        t||=0
+        b||=0
+        h=height-t-b
+      elsif b.nil?
+        if t.nil?
+          t=(height-h) / 2.0
+          b=t
+        else
+          b=height-h-t
+        end
+      elsif t.nil?
+        t=height-h-b
+      end
+      
+      
+      
+      s.left=l
+      s.right=r
+      s.top=t
+      s.bottom=b
+      
+      # puts "#{l},#{r},#{t},#{b}"
+      
+      s.width=w if prop[:width]
+      s.height=h if prop[:height]
+      s.text_style=Rubyvis::Color.transparent if prop[:text_style] and !s.text_style
+      s.fill_style=Rubyvis::Color.transparent if prop[:fill_style] and !s.fill_style
+      s.stroke_style=Rubyvis::Color.transparent if prop[:stroke_style] and !s.stroke_style
+    end
+    
+    
+    
+    
+    def pr_svg(name)
+      res=self.send(name)
+      if res.nil?
+        "none"
+      else
+        res.to_s
+      end
+    end
+    def render_render(mark,depth,scale)
+      mark.scale=scale
+      if (depth < @indexes.size) 
+        @stack.unshift(nil)
+        if (mark.respond_to? :index) 
+            render_instance(mark, depth, scale);
+        else 
+          mark.scene.size.times {|i|
+            mark.index = i;
+            render_instance(mark, depth, scale);
+          }
+        mark.index=nil
+        end
+        stack.shift();
+      else 
+        mark.build();
+        pv.Scene.scale = scale;
+        pv.Scene.update_all(mark.scene);
+      end
+      mark.scale=nil
+    end
+    def render_instance(mark,depth,scale)
+      s=mark.scene[mark.index]
+      if s.visible
+        child_index=@indexes[depth]
+        child=mark.children[child_index]
+        child_index.times {|i|
+          mark.children[i].scene=s.children[i]
+        }
+        Mark.stack[0]=s.data
+        
+        if (child.scene)
+          render_render(child,depth+1,scale*s.transform.k)
+        else
+          child.scene=s.children[child_index]
+          render_render(child, depth+1,scale*s.transform.k)
+          child.scene=nil
+        end
+        child_index.times {|i|
+          mark.children[i].scene=nil
+        }
+        
+      end
+    end
+    private :render_render, :render_instance
+    def bind_bind(mark)
+      begin
+        @_properties.each {|v|
+          k=v.name.to_s
+          if !@seen.has_key?(k)
+            @seen[k]=v
+            case k
+              when "data"
+                @_data=v
+              when "visible"
+                @_required.push(v)
+              when "id"
+                @_required.push(v)
+              else
+                @types[v._type].push(v)
+            end
+          end
+        }
+      end while(mark = mark.proto)
+    end
+    attr_accessor :binds
+    def bind()
+      @seen={}
+      @types={1=>[],2=>[],3=>[]}
+      @_data=nil
+      @_required=[]
+      bind_bind(self)
+      @types[1].reverse!
+      @types[3].reverse!
+      mark=self
+      begin
+      properties.each {|name,v|
+        if !@seen[name.to_s]
+          @seen[name.to_s]=OpenStruct.new(:name=>name.to_s, :_type=>2, :value=>nil)
+          @types[2].push(@seen[name.to_s])
+        end
+      }
+      end while(mark=mark.proto)
+      @binds=OpenStruct.new({:properties=>@seen, :data=>@_data, :required=>@_required, :optional=>@types[1]+@types[2]+@types[3]
+      })
+    end
+    def render
+      parent=self.parent
+      @stack=Mark.stack
+      if parent and !self.root.scene
+        root.render()
+        return 
+      end
+      @indexes=[]
+      mark=self
+      until mark.parent.nil?
+        indexes.unshift(mark.child_index)
+      end
+      self.bind()
+      while(parent and !parent.respond_to? :index) do
+        parent=parent.parent
+      end
+      self.context( parent ? parent.scene : nil, parent ? parent.index : -1, lambda {render_render(self.root, 0,1)})
+      
+    end
+    
+    def context_apply(scene,index)
+      Mark.scene=scene
+      Mark.index=index
+      return if(!scene)
+      that=scene.mark
+      mark=that
+      ancestors=[]
+      begin
+        ancestors.push(mark)
+        Mark.stack.push(scene[index].data)
+        mark.index=index
+        mark.scene=scene
+        index=scene.parent_index
+        scene=scene.parent
+      end while(mark=mark.parent)
+      k=1
+      ancestors.size.times {|ic|
+        i=ancestors.size-ic-1
+        mark=ancestors[i]
+        mark.scale=k
+        k=k*mark.scene[mark.index].transform.k
+      }
+      if (that.children)
+        n=than.children.size
+        n.times {|i|
+          mark=that.children[i]
+          mark.scene=that.scene[that.index].children[i]
+          mark.scale=k
+        }
+        
+      end
+      
+    end
+    def context_clear(scene,index)
+      return if !scene
+      that=scene.mark
+      mark=nil
+      if(that.children)
+        that.children.size.times {|i|
+          mark=that.children[i]
+          mark.scene=nil
+          mark.scale=nil
+        }
+        
+      end
+      mark=that
+      begin
+        Mark.stack.pop
+        if(mark.parent)
+          mark.scene=nil
+          mark.scale=nil
+        end
+        mark.index=nil
+      end while(mark=mark.parent)
+    end
+    def context(scene,index,f)
+      proto=Mark
+      stack=Mark.stack
+      oscene=Mark.scene
+      oindex=Mark.index
+      context_clear(oscene,oindex)
+      context_apply(scene,index)
+      begin
+        f.js_apply(self, stack)
+      ensure
+        context_clear(scene,index)
+        context_apply(oscene,oindex)
+      end
+    end
+    
+    def build
+      scene=self.scene
+      stack=Mark.stack
+      #p self.type
+      if(!scene)
+        self.scene=SceneElement.new
+        scene=self.scene
+        scene.mark=self
+        scene.type=self.type
+        scene.child_index=self.child_index
+        if(self.parent)
+          scene.parent=self.parent.scene
+          scene.parent_index=self.parent.index
+        end
+      end
+      if(self.target)
+        scene.target=self.target.instances(scene)
+      end
+        
+      data=self.binds.data
+      #puts "stack:#{stack}"
+      #puts "data_value:#{data.value}"
+      
+      data=(data._type & 1)>0 ? data.value.js_apply(self, stack) : data.value
+      #puts "data:#{data}"
+      
+      stack.unshift(nil)
+      scene.size=data.size
+      data.each_with_index {|d,i|
+        Mark.index=self.index=i
+        s=scene[i]
+        if !s
+          scene[i]=s=SceneElement.new
+        end
+        stack[0]=data[i]
+        s.data=data[i]
+        build_instance(s)
+      }
+      Mark.index=-1
+      self.index=nil
+      stack.shift()
+      return self
+    end
+    def build_instance(s1)
+      build_properties(s1, self.binds.required)
+      if s1.visible
+        build_properties(s1,self.binds.optional)
+        build_implied(s1)
+      end
+    end
+    def build_properties(ss, props)
+      #p props
+      props.each do |prop|
+        v=prop.value
+
+        # p "#{prop.name}=#{v}"
+        
+        if prop._type==3
+          v=v.js_apply(self, Mark.stack)
+        end
+        ss.send((prop.name.to_s+"=").to_sym, v)
+      end
+      #p ss
+    end
+  end
+end
+
+require 'rubyvis/mark/bar'
+require 'rubyvis/mark/panel'
+require 'rubyvis/mark/rule'
+require 'rubyvis/mark/area'
+require 'rubyvis/mark/anchor'
+require 'rubyvis/mark/label'
+