rubyvis 0.1.1 → 0.1.2

data/lib/rubyvis/mark/anchor.rb

@@ -2,11 +2,11 @@ module Rubyvis
   def self.Anchor(target)
     Rubyvis::Anchor.new(target)
   end
-  
+
   class Anchor < Mark
     @properties=Mark.properties.dup
-    attr_accessor_dsl :name, :text_align, :text_baseline
-    
+    attr_accessor_dsl :name
+
     def initialize(target)
       super()
       self.target=target
@@ -17,4 +17,4 @@ module Rubyvis
       return self
     end
   end
-end
+end

data/lib/rubyvis/mark/area.rb

@@ -3,14 +3,96 @@ module Rubyvis
     Rubyvis::Area
   end
   module AreaPrototype
+    def fixed
+      {
+        #  :line_width=> true,
+        :line_join=> 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;
+        #/* Determine which properties are fixed. */
+        if (!fixed)
+          binds.fixed=[]
+          fixed = binds.fixed
+          filter=lambda {|prop|
+            if prop.fixed
+              fixed.push(prop)
+              return false
+            else
+              return true
+            end
+          }
+          #      p binds.required
+          binds.required = binds.required.find_all(&filter)
+          #      p binds.required
+          if (!self.scene[0].segmented)
+            binds.optional = binds.optional.find_all(&filter)
+          end
+        end
+
+        #    p binds.required
+
+
+        #/* Copy fixed property values from the first instance. */
+        fixed.each {|prop|
+          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)
+    end
+
+
+
+    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)
+        end
+      }
+      optional.delete_if {|v| v.name=='segmented'}
+      # Cache the original arrays so they can be restored on build. */
+      @binds._required = required;
+      @binds._optional = optional;
+    end
+
+
     def area_anchor(name)
       scene=nil
-      self.anchor(name).interpolate(lambda {
-          self.scene.target[self.index].interpolate
+      anchor=mark_anchor(name)
+      anchor.interpolate(lambda {
+        self.scene.target[self.index].interpolate
       }).eccentricity(lambda {
-      self.scene.target[self.index].eccentricity
+        self.scene.target[self.index].eccentricity
       }).tension(lambda {
-      self.scene.target[self.index].tension
+        self.scene.target[self.index].tension
       })
     end
   end
@@ -21,6 +103,12 @@ module Rubyvis
     def type
       'area'
     end
+    def bind
+      area_bind
+    end
+    def build_instance(s)
+      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)
     end
@@ -33,4 +121,4 @@ module Rubyvis
       super(s)
     end
   end
-end
+end

data/lib/rubyvis/mark/bar.rb

@@ -13,4 +13,4 @@ module Rubyvis
       Bar.new.extend(Mark.defaults).line_width(1.5).fill_style(Rubyvis.Colors.category20().by(Rubyvis.parent))
     end
   end
-end
+end

data/lib/rubyvis/mark/label.rb

@@ -2,7 +2,7 @@ module Rubyvis
   def self.Label
     Rubyvis::Label
   end
-  
+
   class Label < Mark
     @properties=Mark.properties.dup
     attr_accessor_dsl :text, :font, :text_angle, :text_style, :text_align, :text_baseline, :text_margin, :text_decoration, :text_shadow
@@ -13,4 +13,4 @@ module Rubyvis
       Label.new.extend(Mark.defaults).events('none').text(lambda{|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
+end

data/lib/rubyvis/mark/line.rb

@@ -3,12 +3,12 @@ module Rubyvis
     Rubyvis::Line
   end
   module LinePrototype
-    include AreaPrototype  
+    include AreaPrototype
     def line_anchor(name)
       area_anchor(name).text_align(lambda {|d|
-         {'left'=>'right','bottom'=>'center','top'=>'center','center'=>'center','right'=>'left'}[d]
+        {'left'=>'right','bottom'=>'center', 'top'=>'center','center'=>'center','right'=>'left'}[d]
       }).text_baseline(lambda{|d|
-         {'top'=>'bottom','right'=>'middle','left'=>'middle','center'=>'middle','bottom'=>'top'}[d]
+        {'top'=>'bottom','right'=>'middle', 'left'=>'middle','center'=>'middle','bottom'=>'top'}[d]
       })
     end
   end
@@ -16,15 +16,21 @@ module Rubyvis
     include AreaPrototype
     include LinePrototype
     @properties=Mark.properties.dup
-    attr_accessor_dsl :line_width, :line_join, :stroke_style, :fill_style, :segmented, :interporale, :eccentricity, :tension
+    attr_accessor_dsl :line_width, :line_join, :stroke_style, :fill_style, :segmented, :interpolate, :eccentricity, :tension
     def type
       "line"
     end
     def anchor(name)
       line_anchor(name)
     end
+    def bind(*args)
+      area_bind(*args)
+    end
+    def build_instance(*args)
+      area_build_instance(*args)
+    end
     def defaults
       Line.new.extend(Rubyvis::Mark).line_join('miter').line_width(1.5).stroke_style(RubyVis::Color.category10().by(pv.parent)).interpolate('linear').eccentricity(0).tension(7)
     end
   end
-end
+end

data/lib/rubyvis/mark/panel.rb

@@ -1,7 +1,7 @@
 module Rubyvis
   def self.Panel
     Rubyvis::Panel
-  end    
+  end
   class Panel < Bar
     def type
       "panel"
@@ -20,13 +20,13 @@ module Rubyvis
       @children.each do |c|
         out << ("  "*level)+"- #{c.type} (#{c.object_id}) proto:#{c.proto.object_id} target:#{c.target.object_id}"
         if c.respond_to? :children and c.children
-          out <<c.children_inspect(level+1)
+          out << c.children_inspect(level+1)
         end
       end
       out
-      
+
     end
-    
+
     def self.defaults
       Panel.new.extend(Bar.defaults).fill_style(nil).overflow('visible')
     end
@@ -38,7 +38,7 @@ module Rubyvis
       children.push(child)
       child
     end
-    
+
     attr_reader :_canvas
     def bind
       super
@@ -57,7 +57,7 @@ module Rubyvis
         child=children[i]
         child.scene=s.children[i]
         child.scale=scale
-        child.build()
+        child.build
       }
       n.times {|i|
         child=children[i]
@@ -66,7 +66,9 @@ module Rubyvis
         child.scale=nil
       }
       s.children=s.children[0,n]
+
     end
+
     def to_svg
       @_canvas.sort.map {|v|
         bar = REXML::Formatters::Default.new
@@ -92,7 +94,7 @@ module Rubyvis
             w=Rubyvis.css(c,'height')
             s.height=h-s.top-s.bottom
           end
-          
+
         else
           @_canvas||={}
           cache=@_canvas
@@ -102,11 +104,11 @@ module Rubyvis
         end
         s.canvas=c
       end
-     
+
       s.transform=Rubyvis.Transform.identity if (s.transform.nil?)
       super(s)
-      
+
     end
-    
+
   end
-end
+end

data/lib/rubyvis/mark/rule.rb

@@ -12,7 +12,7 @@ module Rubyvis
     def type
       'rule'
     end
-    
+
     def anchor(name)
       line_anchor(name)
     end
@@ -29,4 +29,4 @@ module Rubyvis
       super(s)
     end
   end
-end
+end

data/lib/rubyvis/property.rb

@@ -1,11 +1,12 @@
 module Rubyvis
   class Property
-    attr_accessor :name, :id, :value, :_type
+    attr_accessor :name, :id, :value, :_type, :fixed
     def initialize(opts=Hash.new)
       @id=opts[:id]
       @name=opts[:name]
       @value=opts[:value]
       @_type=opts[:_type]
+      @fixed=opts[:fixed]
     end
   end
-end
+end

data/lib/rubyvis/scale.rb

@@ -11,7 +11,7 @@ module Rubyvis
     end
     def self.ordinal(*args)
       Ordinal.new(*args)
-    end    
+    end
     def self.interpolator(start,_end)
       if start.is_a? Numeric
         return lambda {|t| t*(_end-start)+start}
@@ -22,9 +22,9 @@ module Rubyvis
         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))
+        (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

data/lib/rubyvis/scale/linear.rb

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

data/lib/rubyvis/scale/ordinal.rb

@@ -1,52 +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]
+
+    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
-      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
+      @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
-      def range(*arguments)
-        array, f = arguments[0],arguments[1]
-        if(arguments.size>0)
+      @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
+        if @r[0].is_a? String
+          @r=@r.map {|i| pv.color(i)}
         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
+      @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

@@ -2,201 +2,213 @@ 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); }
+    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? ? Time.new() : Time.at(x)
+    end
+  
+    def scale(x)
+      x=x.to_f
+      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
+      o=nil
+      if (arguments.size>0)
+        if array.is_a? Array 
+          min = pv.identity if (arguments.size < 2)
+          max = min if (arguments.size < 3)
+          o = [array[0]].min if array.size>0
+          @d = array.size>0 ? [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.to_f<0 or @d.last.to_f<0)
         @l=@d.map{|v| @f.call(v)}
-        self
+        
+        @type = (o.is_a? Time) ? :time : :number;
+        return 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
+      # TODO: Fix this.
+      @d.map{|v| 
+        case @type
+        when :number
+          v.to_f
+        when :time
+          Time.at(v)
+        else 
+          v
         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
+    
+    
+    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
-        @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]));
+        @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
       
-      def type(v=nil)
-        return @type if v.nil?
-        case @type
-          when Numeric
-            v.to_f
-          when Date
-            raise "Not implemented yet"
-          end
+      val=@g.call(@l[j] + (y - @r[j]).quo(@r[j + 1] - @r[j]) * (@l[j + 1] - @l[j]))
+      @type==:time ? Time.at(val) : val
+    end
+    
+    def type(v=nil)
+      return @type if v.nil?
+      case @type
+        when Numeric
+          v.to_f
+        when Date
+          raise "Not implemented yet"
       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) 
+    end
+    def ticks_floor(d,prec)
+      ar=d.to_a
+      #p ar
+      # [ sec, min, hour, day, month, year, wday, yday, isdst, zone ]
+      case(prec) 
         when 31536e6
-          d.setMonth(0);
+          ar[4]=1
         when 2592e6
-          d.setDate(1);
+          ar[3]=1
         when 6048e5
-          if (p == 6048e5) 
-            d.setDate(d.getDate() - d.getDay());
-          end
+          ar[3]=ar[3]-ar[6] if (prec == 6048e5)
         when 864e5
-          d.setHours(0);
+          ar[2]=0
         when 36e5
-          d.setMinutes(0);
+          ar[1]=0
         when 6e4
-          d.setSeconds(0);
+          ar[0]=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) 
+          # do nothing
+      end
+      to_date(ar)
+    end
+    
+    def to_date(d)
+      
+      Time.utc(*d)
+    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 == :time) 
+      #/* Floor the date d given the precision p. */
+      precision, format, increment, step = 1,1,1,1
+      if (span >= 3 * 31536e6 / 1000.0) 
+        precision = 31536e6
+        format = "%Y"
+        increment = lambda {|d|  Time.at(d.to_f+(step*365*24*60*60)) }
+      elsif (span >= 3 * 2592e6 / 1000.0) 
         precision = 2592e6;
         format = "%m/%Y";
-        increment = lambda {|d| d.setMonth(d.getMonth() + step); };
-        elsif (span >= 3 * 6048e5) 
+        increment = lambda {|d| Time.at(d.to_f+(step*30*24*60*60)) }
+      elsif (span >= 3 * 6048e5 / 1000.0) 
         precision = 6048e5;
         format = "%m/%d";
-        increment = lambda {|d| d.setDate(d.getDate() + 7 * step); };
-        elsif (span >= 3 * 864e5) 
+        increment = lambda {|d| Time.at(d.to_f+(step*7*24*60*60)) }
+      elsif (span >= 3 * 864e5 / 1000.0) 
         precision = 864e5;
         format = "%m/%d";
-        increment = lambda {|d| d.setDate(d.getDate() + step); };
-        elsif (span >= 3 * 36e5) 
+        increment = lambda {|d| Time.at(d.to_f+(step*24*60*60)) }
+      elsif (span >= 3 * 36e5 / 1000.0) 
         precision = 36e5;
         format = "%I:%M %p";
-        increment = lambda {|d| d.setHours(d.getHours() + step); };
-        elsif (span >= 3 * 6e4) 
+        increment = lambda {|d| Time.at(d.to_f+(step*60*60)) }
+      elsif (span >= 3 * 6e4 / 1000.0 ) 
         precision = 6e4;
         format = "%I:%M %p";
-        increment = lambda {|d| d.setMinutes(d.getMinutes() + step); };
-        elsif (span >= 3 * 1e3) 
+        increment = lambda {|d| Time.at(d.to_f+(step*60)) }
+      elsif (span >= 3 * 1e3 / 1000.0) 
         precision = 1e3;
         format = "%I:%M:%S";
-        increment = lambda {|d|  d.setSeconds(d.getSeconds() + step); };
-        else 
+        increment = lambda {|d|  Time.at(d.to_f+(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) 
+        increment = lambda {|d|  Time.at(d.to_f+(step/1000.0)) }
+      end
+      
+      @tick_format = pv.Format.date(format);
+      date = Time.at(min.to_f)
+      dates = []
+      date = ticks_floor(date,precision)
+      # If we'd generate too many ticks, skip some!.
+      n = span / (precision/1000.0)
+      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);
+          ar=date.to_a
+          ar[4]=(date.month/step.to_f).floor*step
+          date=to_date(ar)
         when 6e4
           step = (n > 30) ? 15 : ((n > 15) ? 10 : 5);
           date.setMinutes(Math.floor(date.getMinutes() / step) * step);
@@ -215,49 +227,49 @@ module Rubyvis
           end
           date.setFullYear((date.getFullYear().quo(step)).floor * step);
         end
-        end
-        
+      end
+      
         while (true)
-        increment(date);
-        break if (date > max)
-        dates.push(Date.new(date));
+          date=increment.call(date)
+          break if (date.to_f > max.to_f)
+          dates.push(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)}
+      
+      # 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