rubyvis 0.1.2 → 0.1.3

data/lib/rubyvis/color/color.rb

@@ -27,7 +27,7 @@ module Rubyvis
         return Rubyvis.rgb(r,g,b,a)
       end
     end
-
+    
     named = Rubyvis::Color.names[format.to_sym]
 
 
@@ -60,7 +60,9 @@ module Rubyvis
       @color=color
       @opacity=opacity
     end
-
+    def darker(*args)
+      self.rgb.darker(*args)
+    end
 
     def self.names
       {
@@ -219,6 +221,7 @@ module Rubyvis
 
 
     class Rgb < Color
+      attr_reader :r, :b, :g, :a
       def initialize(r,g,b,a)
         @r=r
         @b=b
@@ -226,14 +229,39 @@ module Rubyvis
         @a=a
         @opacity=a
         if @a>0
-          @color="rgb(#{r},#{g},#{b})"
+          @color="rgb(#{r.to_i},#{g.to_i},#{b.to_i})"
         else
           @color="none"
         end
       end
+      def ==(v)
+        self.class==v.class and @r==v.r and @b==v.b and @g=v.g and @a=v.a
+      end
+      def red(r1)
+        pv.rgb(r1,g,b,a)
+      end
+      def green(g1)
+        pv.rgb(r,g1,b,a)
+      end
+      def blue(b1)
+        pv.rgb(r,g,b1,a)
+      end
+      def alpha(a1)
+        pv.rgb(r,g,b,a1)
+      end
+      
       def rgb
         self
       end
+      def darker(*arguments)
+        k,dummy=arguments
+        k = 0.7 ** ( arguments.size>0 ? k : 1)
+        return pv.rgb(
+          [0, (k * self.r).floor].max,
+          [0, (k * self.g).floor].max,
+          [0, (k * self.b).floor].max,
+          self.a)
+      end
       def to_s
         @color
       end

data/lib/rubyvis/color/colors.rb

@@ -15,7 +15,7 @@ module Rubyvis
       scale = pv.colors(
       "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
       "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf")
-      scale.domain(*arguments);
+      scale.domain(*arguments) if arguments.size>0
       scale
     end
     def self.category19(*arguments)
@@ -24,7 +24,7 @@ module Rubyvis
       "#8ca252", "#637939", "#e7cb94", "#e7ba52", "#bd9e39",
       "#8c6d31", "#e7969c", "#d6616b", "#ad494a", "#843c39",
       "#de9ed6", "#ce6dbd", "#a55194", "#7b4173")
-      scale.domain(*arguments);
+      scale.domain(*arguments) if arguments.size>0
       scale
     end
     def self.category20(*arguments)
@@ -33,7 +33,7 @@ module Rubyvis
       "#98df8a", "#d62728", "#ff9896", "#9467bd", "#c5b0d5",
       "#8c564b", "#c49c94", "#e377c2", "#f7b6d2", "#7f7f7f",
       "#c7c7c7", "#bcbd22", "#dbdb8d", "#17becf", "#9edae5")
-      scale.domain(*arguments);
+      scale.domain(*arguments) if arguments.size>0
       scale
     end
   end

data/lib/rubyvis/format/number.rb

@@ -2,10 +2,11 @@ module Rubyvis
   module Format
     class Number
       def initialize
+        @mini = 0
         @maxi = Infinity # default maximum integer digits
-        @mins = 0 # mini, including group separators
-        @minf = 0 # default minimum fraction digits
-        @maxf = 0 # default maximum fraction digits
+        @mins = 0.0 # mini, including group separators
+        @minf = 0.0 # default minimum fraction digits
+        @maxf = 0.0 # default maximum fraction digits
         @maxk = 1 # 10^maxf
         @padi = "0" # default integer pad
         @padf = "0" # default fraction pad
@@ -15,16 +16,85 @@ module Rubyvis
         @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
+      
+      
+      def to_proc
+        that=self
+        lambda {|*args|  args[0] ? that.format(args[0]) : nil }
+      end
+      #/** @private */
+      def format(x) 
+        
+        # /* Round the fractional part, and split on decimal separator. */
+        x = (x * @maxk).round.quo(@maxk) if (Infinity > @maxf)
+        x = (x.to_f-x.to_i==0) ? x.to_i : x.to_f
+        s = x.abs.to_s.split(".")
+        
+        #/* Pad, truncate and group the integral part. */
+        i = s[0]
+        
+        i = i[i.size-@maxi, i.size] if (i.size > @maxi) 
+        if (@padg and (i.size < @mini))
+          i = Array.new(@mini - i.size + 1).join(@padi) + i.to_s
+        end
+        
+        if (i.size > 3)
+          i = i.gsub(/\B(?=(?:\d{3})+(?!\d))/, @group)
+        end
+        
+        if (@padg=="" and (i.size < @mins))
+          i = Array.new(mins - i.size + 1).join(@padi) + i.to_s
+        end
+        
+        s[0] = x < 0 ? np + i + ns : i
+        
+        #/* Pad the fractional part. */
+        f = s[1].nil? ? "" : s[1]
+        if (f.size < @minf)
+          s[1] = f + Array.new(@minf - f.size + 1).join(@padf)
+        end
+        s.join(@decimal)
+      end
+
+      # Sets or gets the minimum and maximum number of fraction digits. The
+      # controls the number of decimal digits to display after the decimal
+      # separator for the fractional part of the number. 
+      # If the number of digits is smaller than the minimum, the digits 
+      # are padded; if the number of digits is
+      # larger, the fractional part is rounded, showing only the higher-order
+      # digits. The default range is [0, 0].
+      #
+      # If only one argument is specified to this method, this value is used as
+      # both the minimum and maximum number. If no arguments are specified, a
+      # two-element array is returned containing the minimum and the maximum.
+      #
+      # @function
+      # @name pv.Format.number.prototype.fractionDigits
+      # @param {number} [min] the minimum fraction digits.
+      # @param {number} [max] the maximum fraction digits.
+      # @returns {pv.Format.number} <tt>this</tt>, or the current fraction digits.
+      
+      def fraction_digits(min=nil,max=nil)
+        if (!min.nil?)
+          max||=min
+          @minf = min
+          @maxf = max
           @maxk = 10**@maxf
           return self
         end
-        [minf, maxf]
+        [@minf, @maxf]
+      end
+      
+      
+      def integer_digits(min=nil,max=nil)
+        if (!min.nil?)
+          max||=min
+          @mini=min
+          @maxi=max
+          @mins=@mini+(@mini/3.0).floor*@group.size 
+          return self
+        end
+        [@mini, @maxi]
       end
     end
   end

data/lib/rubyvis/internals.rb

@@ -69,11 +69,11 @@ module Rubyvis
   def self.uniq(array, f=nil  )
     self.map(array,f).uniq
   end
-  def self.natural_order(a,b)
-    a<=>b
+  def self.natural_order()
+    lambda {|a,b| a<=>b}
   end
-  def self.reverse_order(a,b)
-    -(a<=>b)
+  def self.reverse_order()
+    lambda {|a,b| -(a<=>b)}
   end
 
   def self.search(array, value, f=nil)
@@ -173,7 +173,7 @@ module Rubyvis
   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)}
+    array = Rubyvis.map(array, f).sort
     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);
@@ -212,4 +212,10 @@ module Rubyvis
   def self.degrees(radians)
     ((180.0) / Math::PI)*radians
   end
+  # :section: /data/Objects.js
+  
+  def self.keys(map)
+    map.keys
+  end
+    
 end

data/lib/rubyvis/javascript_behaviour.rb

@@ -37,6 +37,7 @@ end
 # called +js_apply+ and +js_call+, respectivly.
 
 class Proc
+  attr_accessor :order
   # 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

data/lib/rubyvis/mark.rb

@@ -6,7 +6,8 @@ module Rubyvis
   class Mark
     @properties={}
 
-    def self.property_method(name,_def)
+    def self.property_method(name, _def, func=nil)
+      
       return if Mark.method_defined? name
       Mark.send(:define_method, name) do |*arguments|
         v,dummy = arguments
@@ -18,8 +19,13 @@ module Rubyvis
           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
+          v=v.to_proc if v.respond_to? :to_proc
+          type=(!_def).to_i<<1 | (v.is_a? Proc).to_i          
+          
+          property_value(name,(type & 1 !=0) ? lambda {|*args|
+              x=v.js_apply(self, args)
+              (func and x) ? func.call(x) : x
+          } : (func and v) ? func.call(v) : v)._type=type
           #@_properties_types[name]=type
           return self
         end
@@ -27,11 +33,15 @@ module Rubyvis
         if i.nil?
           raise "No instance for #{self} on #{name}"
         else
-          #puts "Instancia para #{name}"
-          #puts "index:#{self.index}, name:#{name}, val:#{i.send(name)}"
+#          puts "index:#{self.index}, name:#{name}, val:#{i.send(name)}"
           i.send(name)
         end
       end
+      
+      camel=name.to_s.gsub(/(_.)/) {|v| v[1,1].upcase}
+      if camel!=name
+        Mark.send(:alias_method, camel, name)
+      end
     end
     def property_value(name,v)
       prop=Property.new({:name=>name, :id=>Rubyvis.id, :value=>v})
@@ -55,17 +65,26 @@ module Rubyvis
 
     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)
+        
+        if sym.is_a? Array
+          name,func=sym
+        else
+          name=sym
+          func=nil
+        end
+        
+        @properties[name]=true
+        self.property_method(name,false, func)        
+        define_method(name.to_s+"=") {|v|
+          self.send(name,v)
         }
       end
     end
 
     attr_accessor :parent, :root, :index, :child_index, :scene, :proto, :target, :scale
     attr_reader :_properties
+    
+    
     attr_accessor_dsl :data,:visible, :left, :right, :top, :bottom, :cursor, :title, :reverse, :antialias, :events, :id
 
     @scene=nil
@@ -155,13 +174,14 @@ module Rubyvis
       end
       return scene;
     end
-
-
-
-
-
-
-
+    def sibling
+      (self.index==0) ? nil: self.scene[self.index-1]
+    end
+    def cousin
+      par=self.parent
+      s= par ? par.sibling : nil
+      (s and s.children) ? s.children[self.child_index][self.index] : nil
+    end
     def add(type)
       parent.add(type).extend(self)
     end
@@ -218,8 +238,6 @@ module Rubyvis
           'bottom'
         end
       })
-
-
       return anchor
     end
 
@@ -542,6 +560,10 @@ module Rubyvis
       end
       # p ss
     end
+    def event(type,handler)
+      #@_handlers[type]=handler
+      return self
+    end
   end
 end
 
@@ -552,4 +574,5 @@ require 'rubyvis/mark/area'
 require 'rubyvis/mark/line'
 require 'rubyvis/mark/rule'
 require 'rubyvis/mark/label'
-
+require 'rubyvis/mark/dot'
+require 'rubyvis/mark/wedge'

data/lib/rubyvis/mark/anchor.rb

@@ -5,7 +5,7 @@ module Rubyvis
 
   class Anchor < Mark
     @properties=Mark.properties.dup
-    attr_accessor_dsl :name
+    attr_accessor_dsl [:name, lambda {|d| d.to_s}]
 
     def initialize(target)
       super()

data/lib/rubyvis/mark/area.rb

@@ -5,26 +5,26 @@ module Rubyvis
   module AreaPrototype
     def fixed
       {
-        #  :line_width=> true,
+        :line_width=> true,
         :line_join=> true,
-        # :stroke_style=> true,
-        # :fill_style=> true,
+        :stroke_style=> true,
+        :fill_style=> true,
         :segmented=> true,
         :interpolate=> true,
         :tension=> true
       }
     end
     def area_build_instance(s)
-
+      
       binds = self.binds
-
       # Handle fixed properties on secondary instances. */
-      if (self.index)
-        fixed = @binds.fixed;
+      if (self.index!=0)
+        fixed = @binds.fixed
         #/* Determine which properties are fixed. */
         if (!fixed)
           binds.fixed=[]
           fixed = binds.fixed
+          
           filter=lambda {|prop|
             if prop.fixed
               fixed.push(prop)
@@ -39,8 +39,9 @@ module Rubyvis
           if (!self.scene[0].segmented)
             binds.optional = binds.optional.find_all(&filter)
           end
+          
         end
-
+        
         #    p binds.required
 
 
@@ -49,13 +50,14 @@ module Rubyvis
           name=prop.name
           s[name]=self.scene[0][name]
         }
+        
+        
         #    p binds.fixed
         #/* Evaluate all properties on the first instance. */
       else
         binds.required = binds._required;
         binds.optional = binds._optional;
         binds.fixed = nil;
-
       end
       # pp binds
       mark_build_instance(s)
@@ -66,12 +68,11 @@ module Rubyvis
     def area_bind
       mark_bind()
       binds = self.binds
-
+      
       required = binds.required
       optional = binds.optional
       optional.size.times {|i|
         prop = optional[i]
-
         prop.fixed = fixed.include? prop.name
         if (prop.name == "segmented")
           required.push(prop)
@@ -94,12 +95,13 @@ module Rubyvis
       }).tension(lambda {
         self.scene.target[self.index].tension
       })
+      return anchor
     end
   end
   class Area < Mark
     include AreaPrototype
     @properties=Mark.properties.dup
-    attr_accessor_dsl :width, :height, :line_width, :stroke_style, :fill_style, :segmented, :interpolate, :tension
+    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}], :segmented, :interpolate, :tension
     def type
       'area'
     end
@@ -110,7 +112,7 @@ module Rubyvis
       area_build_instance(s)
     end
     def self.defaults
-      Area.new.extend(Mark.defaults).line_width(1.5).fill_style(pv.Colors.category20.by(pv.parent)).interpolate('linear').tension(0.7)
+      Area.new.extend(Mark.defaults).line_width(1.5).fill_style(lambda {pv.Colors.category20.scale(self.parent.index)}).interpolate('linear').tension(0.7)
     end
     def anchor(name)
       area_anchor(name)