rubyvis 0.1.5 → 0.1.6

data/lib/rubyvis/nest.rb

@@ -1,15 +1,16 @@
 module Rubyvis
   ##
-  # Returns a {@link pv.Nest} operator for the specified array. This is a
-  # convenience factory method, equivalent to <tt>new pv.Nest(array)</tt>.
+  # Returns a Nest operator for the specified array. This is a
+  # convenience factory method, equivalent to <tt>Nest.new(array)</tt>.
   #
-  # @see pv.Nest
+  # @see Rubyvis::Nest
   # @param {array} array an array of elements to nest.
   # @returns {Nest} a nest operator for the specified array.
   ##
   def self.nest(array)
     Nest.new(array)
   end
+  # :stopdoc:
   class NestedArray
     attr_accessor :key, :values
     def initialize(opts)
@@ -20,20 +21,18 @@ module Rubyvis
       key==var.key and values=var.values
     end
   end
-  ##
-  # Constructs a nest operator for the specified array. This constructor should
-  # not be invoked directly; use {@link pv.nest} instead.
-  #
-  # @class Represents a {@link Nest} operator for the specified array. Nesting
+  # :startdoc: 
+  
+  # Represents a Nest operator for the specified array. Nesting
   # allows elements in an array to be grouped into a hierarchical tree
   # structure. The levels in the tree are specified by <i>key</i> functions. The
   # leaf nodes of the tree can be sorted by value, while the internal nodes can
   # be sorted by key. Finally, the tree can be returned either has a
-  # multidimensional array via {@link #entries}, or as a hierarchical map via
-  # {@link #map}. The {@link #rollup} routine similarly returns a map, collapsing
+  # multidimensional array via Nest.entries, or as a hierarchical map via
+  # Nest.map. The Nest.rollup routine similarly returns a map, collapsing
   # the elements in each leaf node using a summary function.
   #
-  # <p>For example, consider the following tabular data structure of Barley
+  # For example, consider the following tabular data structure of Barley
   # yields, from various sites in Minnesota during 1931-2:
   #
   #   { yield: 27.00, variety: "Manchuria", year: 1931, site: "University Farm" },
@@ -43,10 +42,10 @@ module Rubyvis
   # To facilitate visualization, it may be useful to nest the elements first by
   # year, and then by variety, as follows:
   #
-  # <pre>var nest = pv.nest(yields)
-  #     .key(function(d) d.year)
-  #     .key(function(d) d.variety)
-  #     .entries();</pre>
+  #     var nest = Rubyvis.nest(yields)
+  #     .key(lambda {|d|  d.year})
+  #     .key(lambda {|d| d.variety})
+  #     .entries();
   #
   # This returns a nested array. Each element of the outer array is a key-values
   # pair, listing the values for each distinct key:
@@ -68,11 +67,12 @@ module Rubyvis
   #
   # Further details, including sorting and rollup, is provided below on the
   # corresponding methods.
-  #
-  # @param {array} array an array of elements to nest.
-  #/
   class Nest
     attr_accessor :array, :keys, :order
+    ##
+    # Constructs a nest operator for the specified array. This constructor should
+    # not be invoked directly; use Rubyvis.nest instead.
+    
     def initialize(array)
       @array=array
       @keys=[]
@@ -83,11 +83,11 @@ module Rubyvis
       return self
     end
     def sort_keys(order=nil)
-      keys[keys.size-1].order = order.nil? ? pv.natural_order : order
+      keys[keys.size-1].order = order.nil? ? Rubyvis.natural_order : order
       return self
     end
     def sort_values(order=nil)
-      @order = order.nil? ? pv.natural_order : order
+      @order = order.nil? ? Rubyvis.natural_order : order
       return self
     end
     def map

data/lib/rubyvis/scale/linear.rb

@@ -1,5 +1,5 @@
 module Rubyvis
-
+  # See Quantitative for complete description of features
   class Scale::Linear < Rubyvis::Scale::Quantitative
   end
 end

data/lib/rubyvis/scale/log.rb

@@ -25,7 +25,7 @@ module Rubyvis
     end
     def nice
       d=domain
-      domain(pv.log_floor(d[0],@b), pv.log_ceil(d[1],@b))
+      domain(Rubyvis.log_floor(d[0],@b), Rubyvis.log_ceil(d[1],@b))
     end
     def ticks
       d = domain

data/lib/rubyvis/scale/ordinal.rb

@@ -1,7 +1,60 @@
 module Rubyvis
+  # Represents an ordinal scale. <style
+  # type="text/css">sub{line-height:0}</style> An ordinal scale represents a
+  # pairwise mapping from <i>n</i> discrete values in the input domain to
+  # <i>n</i> discrete values in the output range. For example, an ordinal scale
+  # might map a domain of species ["setosa", "versicolor", "virginica"] to colors
+  # ["red", "green", "blue"]. Thus, saying
+  #
+  #   .fill_style(lambda {|d|
+  #         case (d.species)
+  #           when "setosa"
+  #             "red"
+  #           when "versicolor"
+  #             "green"
+  #           when "virginica"
+  #             "blue"
+  #         }
+  #       )
+  #
+  # is equivalent to
+  #
+  #   .fill_style(Rubyvis::Scale.ordinal("setosa", "versicolor", "virginica")
+  #         .range("red", "green", "blue")
+  #         .by(lambda {|d| d.species}))</pre>
+  #
+  # If the mapping from species to color does not need to be specified
+  # explicitly, the domain can be omitted. In this case it will be inferred
+  # lazily from the data:
+  #
+  #   .fill_style(Rubyvis.colors("red", "green", "blue")
+  #         .by(lambda {|d| d.species}))</pre>
+  #
+  # When the domain is inferred, the first time the scale is invoked, the first
+  # element from the range will be returned. Subsequent calls with unique values
+  # will return subsequent elements from the range. If the inferred domain grows
+  # larger than the range, range values will be reused. However, it is strongly
+  # recommended that the domain and the range contain the same number of
+  # elements.
+  #
+  # A range can be discretized from a continuous interval (e.g., for pixel
+  # positioning) by using split, split_flush or
+  # split_banded after the domain has been set. For example, if
+  # <tt>states</tt> is an array of the fifty U.S. state names, the state name can
+  # be encoded in the left position:
+  #
+  #   .left(Rubyvis::Scale.ordinal(states)
+  #         .split(0, 640)
+  #         .by(lambda {|d| d.state}))
+  #
+  # N.B.: ordinal scales are not invertible (at least not yet), since the
+  # domain and range and discontinuous. A workaround is to use a linear scale.
   class Scale::Ordinal
-    #include Rubyvis::Scale
+    # range band, after use split_banded
+    # equivalen to protovis scale.range().band
     attr_reader :range_band
+    # Returns an ordinal scale for the specified domain. The arguments to this
+    # constructor are optional, and equivalent to calling domain    
     def initialize(*args)
       @d=[] # domain
       @i={}
@@ -10,6 +63,14 @@ module Rubyvis
       @band=0
       domain(*args)
     end
+    
+    # Return 
+    #   lambda {|d| scale_object.scale(d)}
+    # Useful as value on dynamic properties
+    #   scale=Rubyvis.ordinal("red","blue","green")
+    #   bar.fill_style(scale)
+    # is the same as
+    #   bar.fill_style(lambda {|x| scale.scale(x)})
     def to_proc
       that=self
       lambda {|*args| args[0] ? that.scale(args[0]) : nil }
@@ -21,17 +82,60 @@ module Rubyvis
       end
       @r[@i[x] % @r.size]
     end
+    # Sets or gets the input domain. This method can be invoked several ways:
+    #
+    # <p>1. <tt>domain(values...)</tt>
+    #
+    # <p>Specifying the domain as a series of values is the most explicit and
+    # recommended approach. However, if the domain values are derived from data,
+    # you may find the second method more appropriate.
+    #
+    # <p>2. <tt>domain(array, f)</tt>
+    #
+    # <p>Rather than enumerating the domain values as explicit arguments to this
+    # method, you can specify a single argument of an array. In addition, you can
+    # specify an optional accessor function to extract the domain values from the
+    # array.
+    #
+    # <p>3. <tt>domain()</tt>
+    #
+    # <p>Invoking the <tt>domain</tt> method with no arguments returns the
+    # current domain as an array.
     def domain(*arguments)
       array, f=arguments[0],arguments[1]
       if(arguments.size>0)
-      array= (array.is_a? Array) ? ((arguments.size>1) ? pv.map(array,f) : array) : arguments.dup
+      array= (array.is_a? Array) ? ((arguments.size>1) ? Rubyvis.map(array,f) : array) : arguments.dup
         @d=array.uniq
-        @i=pv.numerate(@d)
+        @i=Rubyvis.numerate(@d)
         return self
       end
       @d
     end
-    def split_banded(*arguments)
+    
+    # Sets the range from the given continuous interval. The interval [<i>
+    # min</i>, <i>max</i>] is subdivided into <i>n</i> equispaced bands,
+    # where <i>n</i> is the number of (unique) values in the domain. The first
+    # and last band are offset from the edge of the range by the distance between
+    # bands.
+    #
+    # <p>The band width argument, <tt>band</tt>, is typically in the range [0, 1]
+    # and defaults to 1. This fraction corresponds to the amount of space in the
+    # range to allocate to the bands, as opposed to padding. A value of 0.5 means
+    # that the band width will be equal to the padding width. The computed
+    # absolute band width can be retrieved from the range as
+    # <tt>scale.range_band</tt>.
+    #
+    # <p>If the band width argument is negative, this method will allocate bands
+    # of a <i>fixed</i> width <tt>-band</tt>, rather than a relative fraction of
+    # the available space.
+    #
+    # <p>Tip: to inset the bands by a fixed amount <tt>p</tt>, specify a minimum
+    # value of <tt>min + p</tt> (or simply <tt>p</tt>, if <tt>min</tt> is
+    # 0). Then set the mark width to <tt>scale.range_band - p</tt>.
+    #
+    # <p>This method must be called <i>after</i> the domain is set.
+    
+    def split_banded(*arguments) # :args: (min,max,band=1)
       min,max,band=arguments
       band=1 if (arguments.size < 3)
       if (band < 0) 
@@ -40,11 +144,11 @@ module Rubyvis
         total = -band * n
         remaining = max - min - total
         padding = remaining / (n + 1).to_f
-        @r = pv.range(min + padding, max, padding - band);
+        @r = Rubyvis.range(min + padding, max, padding - band);
         @range_band = -band;
       else
         step = (max - min) / (self.domain().size + (1 - band))
-        @r = pv.range(min + step * (1 - band), max, step);
+        @r = Rubyvis.range(min + step * (1 - band), max, step);
         @range_band = step * band;
       end
       return self
@@ -54,15 +158,23 @@ module Rubyvis
       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)}
+          @r=@r.map {|i| Rubyvis.color(i)}
         end
         return self
       end
       @r
     end
+    
+    # Sets the range from the given continuous interval. The interval [<i>
+    # min</i>, <i>max</i>] is subdivided into <i>n</i> equispaced points,
+    # where <i>n</i> is the number of (unique) values in the domain. The first
+    # and last point are offset from the edge of the range by half the distance
+    # between points.
+    #
+    # <p>This method must be called <i>after</i> the domain is set.
     def split(min,max)
       step=(max-min).quo(domain().size)
-      @r=pv.range(min+step.quo(2),max,step)
+      @r=Rubyvis.range(min+step.quo(2),max,step)
       self
     end
     def by(f)

data/lib/rubyvis/scale/quantitative.rb

@@ -1,7 +1,61 @@
 module Rubyvis
+  # Represents an abstract quantitative scale; a function that performs a
+  # numeric transformation. This class is typically not used directly; see one of
+  # the quantitative scale implementations (linear, log, root, etc.)
+  # instead. <style type="text/css">sub{line-height:0}</style> A quantitative
+  # scale represents a 1-dimensional transformation from a numeric domain of
+  # input data [<i>d<sub>0</sub></i>, <i>d<sub>1</sub></i>] to a numeric range of
+  # pixels [<i>r<sub>0</sub></i>, <i>r<sub>1</sub></i>]. In addition to
+  # readability, scales offer several useful features:
+  #
+  # <p>1. The range can be expressed in colors, rather than pixels. For example:
+  #
+  #   .fill_style(Scale.linear(0, 100).range("red", "green"))
+  #
+  # will fill the marks "red" on an input value of 0, "green" on an input value
+  # of 100, and some color in-between for intermediate values.
+  #
+  # <p>2. The domain and range can be subdivided for a non-uniform
+  # transformation. For example, you may want a diverging color scale that is
+  # increasingly red for negative values, and increasingly green for positive
+  # values:
+  #
+  #   .fill_style(Scale.linear(-1, 0, 1).range("red", "white", "green"))</pre>
+  #
+  # The domain can be specified as a series of <i>n</i> monotonically-increasing
+  # values; the range must also be specified as <i>n</i> values, resulting in
+  # <i>n - 1</i> contiguous linear scales.
+  #
+  # <p>3. Quantitative scales can be inverted for interaction. The
+  # invert() method takes a value in the output range, and returns the
+  # corresponding value in the input domain. This is frequently used to convert
+  # the mouse location (see Mark#mouse) to a value in the input
+  # domain. Note that inversion is only supported for numeric ranges, and not
+  # colors.
+  #
+  # <p>4. A scale can be queried for reasonable "tick" values. The ticks()
+  # method provides a convenient way to get a series of evenly-spaced rounded
+  # values in the input domain. Frequently these are used in conjunction with
+  # Rule to display tick marks or grid lines.
+  #
+  # <p>5. A scale can be "niced" to extend the domain to suitable rounded
+  # numbers. If the minimum and maximum of the domain are messy because they are
+  # derived from data, you can use nice() to round these values down and
+  # up to even numbers.
+  #
+  # @see Scale.linear
+  # @see Scale.log
+  # @see Scale.root
   class Scale::Quantitative
     include Rubyvis::Scale
     attr_reader :l
+    # Returns a default quantitative, linear, scale for the specified domain. The
+    # arguments to this constructor are optional, and equivalent to calling
+    # domain. The default domain and range are [0,1].
+    #
+    # This constructor is typically not used directly; see one of the
+    # quantitative scale implementations instead.
+    # @param {number...} domain... optional domain values.
     def initialize(*args)
       @d=[0,1] # domain
       @l=[0,1] # transformed domain
@@ -20,13 +74,23 @@ module Rubyvis
       }
       domain(*args)
     end
-    def new_date(x=nil)
+    
+    # Deprecated
+    def new_date(x=nil) # :nodoc:
       x.nil? ? Time.new() : Time.at(x)
     end
+    # Return 
+    #   lambda {|d| scale_object.scale(d)}
+    # Useful as value on dynamic properties
+    #   scale=Rubyvis.linear(0,1000)
+    #   bar.width(scale)
+    # is the same as
+    #   bar.width(lambda {|x| scale.scale(x)})
     def to_proc
       that=self
       lambda {|*args|  args[0] ? that.scale(args[0]) : nil }
     end
+    # Transform value +x+ according to domain and range
     def scale(x)
       x=x.to_f
       j=Rubyvis.search(@d, x)
@@ -37,6 +101,7 @@ module Rubyvis
       # puts "Segundo #{(@l[j + 1] - @l[j])}"
       @i[j].call((@f.call(x) - @l[j]) .quo(@l[j + 1] - @l[j]));
     end
+    # Alias for scale(x)
     def [](x)
       scale(x)
     end
@@ -46,14 +111,51 @@ module Rubyvis
       @l=@d.map{|v| @f.call(v)}
       self
     end
-    
-    
+    private :transform
+    # Sets or gets the input domain. This method can be invoked several ways:
+    #
+    # <p>1. <tt>domain(min, ..., max)</tt>
+    #
+    # <p>Specifying the domain as a series of numbers is the most explicit and
+    # recommended approach. Most commonly, two numbers are specified: the minimum
+    # and maximum value. However, for a diverging scale, or other subdivided
+    # non-uniform scales, multiple values can be specified. Values can be derived
+    # from data using Rubyvis.min and Rubyvis.max. For example:
+    #
+    #   .domain(0, Rubyvis.max(array))
+    #
+    # An alternative method for deriving minimum and maximum values from data
+    # follows.
+    #
+    # <p>2. <tt>domain(array, minf, maxf)</tt>
+    #
+    # <p>When both the minimum and maximum value are derived from data, the
+    # arguments to the <tt>domain</tt> method can be specified as the array of
+    # data, followed by zero, one or two accessor functions. For example, if the
+    # array of data is just an array of numbers:
+    #
+    #   .domain(array)
+    #
+    # On the other hand, if the array elements are objects representing stock
+    # values per day, and the domain should consider the stock's daily low and
+    # daily high:
+    #
+    #   .domain(array, lambda {|d|  d.low}, lambda {|d| d.high})
+    #
+    # The first method of setting the domain is preferred because it is more
+    # explicit; setting the domain using this second method should be used only
+    # if brevity is required.
+    #
+    # <p>3. <tt>domain()</tt>
+    #
+    # <p>Invoking the <tt>domain</tt> method with no arguments returns the
+    # current domain as an array of numbers.
     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)
+          min = Rubyvis.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)] : []
@@ -87,7 +189,29 @@ module Rubyvis
       }
     end
     
-    
+    # Sets or gets the output range. This method can be invoked several ways:
+    #
+    # <p>1. <tt>range(min, ..., max)</tt>
+    #
+    # <p>The range may be specified as a series of numbers or colors. Most
+    # commonly, two numbers are specified: the minimum and maximum pixel values.
+    # For a color scale, values may be specified as {@link Rubyvis.Color}s or
+    # equivalent strings. For a diverging scale, or other subdivided non-uniform
+    # scales, multiple values can be specified. For example:
+    #
+    #   .range("red", "white", "green")
+    #
+    # <p>Currently, only numbers and colors are supported as range values. The
+    # number of range values must exactly match the number of domain values, or
+    # the behavior of the scale is undefined.
+    #
+    # <p>2. <tt>range()</tt>
+    #
+    # <p>Invoking the <tt>range</tt> method with no arguments returns the current
+    # range as an array of numbers or colors.
+    # :call-seq:
+    #   range(min,...,max)
+    #   range()
     def range(*arguments)
       if (arguments.size>0) 
         @r = arguments.dup
@@ -122,7 +246,7 @@ module Rubyvis
           raise "Not implemented yet"
       end
     end
-    def ticks_floor(d,prec)
+    def ticks_floor(d,prec) # :nodoc:
       ar=d.to_a
       #p ar
       # [ sec, min, hour, day, month, year, wday, yday, isdst, zone ]
@@ -145,12 +269,19 @@ module Rubyvis
       to_date(ar)
     end
     
-    def to_date(d)
+    private :ticks_floor
+    
+    def to_date(d) # :nodoc:
       
       Time.utc(*d)
     end
-    # TODO: FIX this func
-    def ticks(*arguments) 
+    # Returns an array of evenly-spaced, suitably-rounded values in the input
+    # domain. This method attempts to return between 5 and 10 tick values. These
+    # values are frequently used in conjunction with Rule to display
+    # tick marks or grid lines.
+    #
+    # @todo: fix for dates and n>10
+    def ticks(*arguments) # :args: (number_of_ticks=nil)
       m = arguments[0]
       start = @d.first
       _end = @d.last
@@ -163,7 +294,7 @@ module Rubyvis
         @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. */
@@ -202,12 +333,13 @@ module Rubyvis
         increment = lambda {|d|  Time.at(d.to_f+(step/1000.0)) }
       end
       
-      @tick_format = pv.Format.date(format);
+      @tick_format = Rubyvis.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)
+      # FIX FROM HERE
       if (n > 10) 
         case (precision) 
         when 36e5
@@ -228,7 +360,7 @@ module Rubyvis
           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);
+          step = Rubyvis.logCeil(n / 15, 10);
           if (n / step < 2) 
             step =step.quo(5)
           elsif (n / step < 5)
@@ -249,7 +381,7 @@ module Rubyvis
       # Normal case: numbers. 
       m = 10 if (arguments.size==0)
       
-      step = pv.log_floor(span.quo(m), 10)
+      step = Rubyvis.log_floor(span.quo(m), 10)
       err = m.quo(span.quo(step))
       if (err <= 0.15)
       step = step*10
@@ -260,15 +392,27 @@ module Rubyvis
       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);
+      @tick_format= Rubyvis.Format.number.fraction_digits([0, -(Rubyvis.log(step, 10) + 0.01).floor].max)
+      ticks = Rubyvis.range(start, _end + step, step);
       return reverse ? ticks.reverse() : ticks;
     end
     
+    # Returns a Proc that formats the specified tick value using the appropriate precision, based on
+    # the step interval between tick marks. If ticks() has not been called,
+    # the argument is converted to a string, but no formatting is applied.
+    #   scale.tick_format.call(value)
+    #
     def tick_format
       @tick_format
     end
     
+    # "Nices" this scale, extending the bounds of the input domain to
+    # evenly-rounded values. Nicing is useful if the domain is computed
+    # dynamically from data, and may be irregular. For example, given a domain of
+    # [0.20147987687960267, 0.996679553296417], a call to <tt>nice()</tt> might
+    # extend the domain to [0.2, 1].
+    #
+    # This method must be invoked each time after setting the domain.
     def nice
       if (@d.size!=2)
         return self;

data/lib/rubyvis/scale.rb

@@ -24,7 +24,7 @@ module Rubyvis
       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(
+        return (start.a == 0) ? Rubyvis.rgb(_end.r, _end.g, _end.b, a) : ((_end.a == 0) ? Rubyvis.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))

data/lib/rubyvis/scene/svg_area.rb

@@ -64,14 +64,14 @@ module Rubyvis
         }
     
         if (s.interpolate == "basis") 
-          pathT = pv.SvgScene.curve_basis(pointsT);
-          pathB = pv.SvgScene.curve_basis(pointsB);
+          pathT = Rubyvis.SvgScene.curve_basis(pointsT);
+          pathB = Rubyvis.SvgScene.curve_basis(pointsB);
         elsif (s.interpolate == "cardinal") 
-            pathT = pv.SvgScene.curve_cardinal(pointsT, s.tension);
-            pathB = pv.SvgScene.curve_cardinal(pointsB, s.tension);
+            pathT = Rubyvis.SvgScene.curve_cardinal(pointsT, s.tension);
+            pathB = Rubyvis.SvgScene.curve_cardinal(pointsB, s.tension);
         elsif # monotone
-          pathT = pv.SvgScene.curve_monotone(pointsT);
-          pathB = pv.SvgScene.curve_monotone(pointsB);
+          pathT = Rubyvis.SvgScene.curve_monotone(pointsT);
+          pathB = Rubyvis.SvgScene.curve_monotone(pointsB);
         end
     
         "#{pointsT[0].left },#{ pointsT[0].top }#{ pathT }L#{ pointsB[0].left},#{pointsB[0].top}#{pathB}"
@@ -132,14 +132,14 @@ module Rubyvis
             }
         
             if (s.interpolate == "basis") 
-              pathT = pv.SvgScene.curve_basis_segments(pointsT);
-              pathB = pv.SvgScene.curve_basis_segments(pointsB);
+              pathT = Rubyvis.SvgScene.curve_basis_segments(pointsT);
+              pathB = Rubyvis.SvgScene.curve_basis_segments(pointsB);
             elsif (s.interpolate == "cardinal") 
-                pathT = pv.SvgScene.curve_cardinal_segments(pointsT, s.tension);
-                pathB = pv.SvgScene.curve_cardinal_segments(pointsB, s.tension);
+                pathT = Rubyvis.SvgScene.curve_cardinal_segments(pointsT, s.tension);
+                pathB = Rubyvis.SvgScene.curve_cardinal_segments(pointsB, s.tension);
             elsif # monotone
-              pathT = pv.SvgScene.curve_monotone_segments(pointsT);
-              pathB = pv.SvgScene.curve_monotone_segments(pointsB);
+              pathT = Rubyvis.SvgScene.curve_monotone_segments(pointsT);
+              pathB = Rubyvis.SvgScene.curve_monotone_segments(pointsB);
             end
           end
           n=scenes.size-1

data/lib/rubyvis/scene/svg_line.rb

@@ -72,7 +72,7 @@ module Rubyvis
         next if (!s1.visible and !s2.visible)
 
         stroke = s1.stroke_style
-        fill = pv.Color.transparent
+        fill = Rubyvis.Color.transparent
 
         next if stroke.opacity==0.0
 
@@ -80,7 +80,7 @@ module Rubyvis
         d=nil
         if ((s1.interpolate == "linear") and (s1.lineJoin == "miter"))
           fill = stroke;
-          stroke = pv.Color.transparent;
+          stroke = Rubyvis.Color.transparent;
           d = path_join(scenes[i - 1], s1, s2, scenes[i + 2]);
         elsif(paths)
           d = paths[i];
@@ -142,9 +142,9 @@ module Rubyvis
       # no joins).
       #
 
-      p1 = pv.vector(s1.left, s1.top)
+      p1 = Rubyvis.vector(s1.left, s1.top)
 
-      p2 = pv.vector(s2.left, s2.top)
+      p2 = Rubyvis.vector(s2.left, s2.top)
 
       p = p2.minus(p1)
 
@@ -172,7 +172,7 @@ module Rubyvis
 
       #/* Similarly, for end join. */
       if (s3 && s3.visible)
-        v2 = pv.vector(s3.left, s3.top).minus(p2).perp().norm().plus(v);
+        v2 = Rubyvis.vector(s3.left, s3.top).minus(p2).perp().norm().plus(v);
         c = line_intersect(p2, v2, c, p);
         b = line_intersect(p2, v2, b, p);
       end

data/lib/rubyvis/scene/svg_panel.rb

@@ -110,7 +110,7 @@ module Rubyvis
           "y"=> s.top,
           "width"=> [1E-10, s.width].max,
           "height"=>[1E-10, s.height].max,
-          "fill"=>nil,
+          "fill"=>"none",
           "stroke"=> stroke.color,
           "stroke-opacity"=> stroke.opacity,
           "stroke-width"=> s.line_width / self.scale.to_f

data/lib/rubyvis/scene/svg_scene.rb

@@ -45,7 +45,7 @@ module Rubyvis
         "dy"=> 0,
         "text-anchor"=> "start",
         "transform"=> "translate(0,0)",
-        "fill"=> "none",
+        #"fill"=> "none",
         "fill-opacity"=> 1,
         "stroke"=> "none",
         "stroke-opacity"=> 1,