rubyvis 0.1.5 → 0.1.6

data/lib/rubyvis/color/colors.rb

@@ -1,4 +1,5 @@
 module Rubyvis
+  # Alias for Rubyvis::Colors
   def self.Colors
     Rubyvis::Colors
   end
@@ -8,18 +9,15 @@ module Rubyvis
     scale
   end
   module Colors
-    def pv
-      Rubyvis
-    end
     def self.category10(*arguments)
-      scale = pv.colors(
+      scale = Rubyvis.colors(
       "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
       "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf")
       scale.domain(*arguments) if arguments.size>0
       scale
     end
     def self.category19(*arguments)
-      scale = pv.colors(
+      scale = Rubyvis.colors(
       "#9c9ede", "#7375b5", "#4a5584", "#cedb9c", "#b5cf6b",
       "#8ca252", "#637939", "#e7cb94", "#e7ba52", "#bd9e39",
       "#8c6d31", "#e7969c", "#d6616b", "#ad494a", "#843c39",
@@ -28,7 +26,7 @@ module Rubyvis
       scale
     end
     def self.category20(*arguments)
-      scale = pv.colors(
+      scale = Rubyvis.colors(
       "#1f77b4", "#aec7e8", "#ff7f0e", "#ffbb78", "#2ca02c",
       "#98df8a", "#d62728", "#ff9896", "#9467bd", "#c5b0d5",
       "#8c564b", "#c49c94", "#e377c2", "#f7b6d2", "#7f7f7f",

data/lib/rubyvis/format/number.rb

@@ -69,10 +69,10 @@ module Rubyvis
       # two-element array is returned containing the minimum and the maximum.
       #
       # @function
-      # @name pv.Format.number.prototype.fractionDigits
+      # @name Rubyvis.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.
+      # @returns {Rubyvis.Format.number} <tt>this</tt>, or the current fraction digits.
       
       def fraction_digits(min=nil,max=nil)
         if (!min.nil?)

data/lib/rubyvis/internals.rb

@@ -1,14 +1,25 @@
 module Rubyvis
   # :section: /pv-internals.js
   @@id=0
+  # Return a unique id each time
   def self.id
     @@id+=1
   end
+  # Return a value as a Proc.
   def self.functor(f)
     (f.is_a? Proc) ? f : lambda {f}
   end
+  ##
   # :section: /data/Arrays.js
-
+  
+  ##
+  # A private variant of Array.map that supports the index property
+  # 
+  # :call-seq:
+  #   self.map(Array)
+  #   self.map(array,proc)
+  #
+  
   def self.map(array, f=nil)
     if f
       array.size.times.map {|i|
@@ -19,6 +30,7 @@ module Rubyvis
       array.dup
     end
   end
+  
   def self.repeat(array, n=2)
     array*n
   end
@@ -47,7 +59,7 @@ module Rubyvis
   end
   def self.normalize(array,f=nil)
     norm=Rubyvis.map(array,f)
-    sum=pv.sum(norm)
+    sum=Rubyvis.sum(norm)
     norm.map {|x| x.quo(sum)}
   end
   def self.o_index(i)
@@ -172,7 +184,7 @@ module Rubyvis
     Rubyvis.sum(array,f).quo(array.size)
   end
   def self.median(array,f=nil)
-    return (array.length - 1).quo(2) if (f == pv.index)
+    return (array.length - 1).quo(2) if (f == Rubyvis.index)
     array = Rubyvis.map(array, f).sort
     return array[array.size.quo(2).floor] if (array.length % 2>0)
     i = array.size.quo(2);

data/lib/rubyvis/javascript_behaviour.rb

@@ -1,15 +1,17 @@
 class TrueClass
+  # Return 1
   def to_i
     1
   end
 end
 class FalseClass
+  # Return 0
   def to_i
     0
   end
 end
 
-
+# :stopdoc:
 unless Object.public_method_defined? :instance_exec
   class Object
     module InstanceExecHelper; end
@@ -31,16 +33,26 @@ unless Object.public_method_defined? :instance_exec
       ret
     end
   end
-
 end
+# :startdoc:
+
 # Add javascript-like +apply+ and +call+ methods to Proc,
 # 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
+  # Used on Rubyvis::Nest
+  attr_accessor :order # :nodoc:
+  
+  # Emulation of +apply+ javascript method.
+  # +apply+ has this signature
+  #   my_proc.apply(my_obj, args)
+  # where
+  # [+my_proc+] a proc
+  # [+my_obj+]  object inside proc is eval'ed
+  # [args]      array of arguments for proc
+  # 
+  # +apply+ on javascript is very flexible. Can accept more or less
+  # variables than explicitly defined parameters on lambda, so this
+  # method adds or remove elements according to lambda arity
   #
   def js_apply(obj,args)
     arguments=args.dup
@@ -59,7 +71,7 @@ class Proc
     end
   end
   # Same as js_apply, but using explicit arguments
-  def js_call(obj,*args)
+  def js_call(obj, *args)
     js_apply(obj,args)
   end
 end

data/lib/rubyvis/layout/stack.rb

@@ -18,21 +18,21 @@ module Rubyvis
       @values=nil
       @_x=lambda {return 0}
       @_y=lambda {return 0}
-      @_values=pv.identity
+      @_values=Rubyvis.identity
     end
     def x(f)
-      @_x=pv.functor(f)
+      @_x=Rubyvis.functor(f)
       return self
     end
     def y(f)
-      @_y=pv.functor(f)
+      @_y=Rubyvis.functor(f)
       return self
     end
     def values(f=nil)
       if f.nil?
         @values
       else
-        @_values=pv.functor(f)
+        @_values=Rubyvis.functor(f)
         return self
       end
     end
@@ -96,9 +96,9 @@ module Rubyvis
       _index=nil
       case (s.order) 
       when "inside-out" 
-        max  = dy.map {|v| pv.max.index(v) }
+        max  = dy.map {|v| Rubyvis.max.index(v) }
         map  = pv.range(n).sort {|a,b| return max[a] - max[b]}
-        sums = dy.map {|v| pv.sum(v)}
+        sums = dy.map {|v| Rubyvis.sum(v)}
         top = 0
         bottom = 0
         tops = []
@@ -116,9 +116,9 @@ module Rubyvis
         _index = bottoms.reverse+tops
         
       when "reverse"
-        _index = pv.range(n - 1, -1, -1)
+        _index = Rubyvis.range(n - 1, -1, -1)
       else
-        _index = pv.range(n)
+        _index = Rubyvis.range(n)
       end
       
       #/* offset */
@@ -203,13 +203,10 @@ module Rubyvis
     
     def layer
       that=self
-      value = Rubyvis::Mark.new().data(lambda { that.values[self.parent.index] })
-      .top(proxy("t"))
-      .left(proxy("l"))
-      .right(proxy("r"))
-      .bottom(proxy("b"))
-      .width(proxy("w"))
-      .height(proxy("h"))
+      value = Rubyvis::Mark.new().data(lambda { that.values[self.parent.index] }).top(proxy("t")).left(proxy("l")).right(proxy("r")).
+        bottom(proxy("b")).
+      width(proxy("w")).
+      height(proxy("h"))
       
       class << value
         def that=(v)
@@ -217,7 +214,7 @@ module Rubyvis
         end
         def add(type)
           that  = @that
-          that.add( pv.Panel ).data(lambda { that.layers() }).add(type).extend( self )
+          that.add( Rubyvis.Panel ).data(lambda { that.layers() }).add(type).extend( self )
         end
       end
       value.that=self

data/lib/rubyvis/mark/anchor.rb

@@ -1,17 +1,79 @@
 module Rubyvis
+  # Alias por Rubyvis::Anchor.new(target)
   def self.Anchor(target)
     Rubyvis::Anchor.new(target)
   end
-
+  # Represents an anchor on a given mark. An anchor is itself a mark, but
+  # without a visual representation. It serves only to provide useful default
+  # properties that can be inherited by other marks. Each type of mark can define
+  # any number of named anchors for convenience. If the concrete mark type does
+  # not define an anchor implementation specifically, one will be inherited from
+  # the mark's parent class.
+  #
+  # For example, the bar mark provides anchors for its four sides: left,
+  # right, top and bottom. Adding a label to the top anchor of a bar,
+  #
+  #   bar.anchor("top").add(Rubyvis::Label)
+  #
+  # will render a text label on the top edge of the bar; the top anchor defines
+  # the appropriate position properties (top and left), as well as text-rendering
+  # properties for convenience (text_align and text_baseline).
+  #
+  # <p>Note that anchors do not <i>inherit</i> from their targets; the positional
+  # properties are copied from the scene graph, which guarantees that the anchors
+  # are positioned correctly, even if the positional properties are not defined
+  # deterministically. (In addition, it also improves performance by avoiding
+  # re-evaluating expensive properties.) If you want the anchor to inherit from
+  # the target, use Mark#extend before adding. For example:
+  #
+  #   bar.anchor("top").extend(bar).add(Rubyvis::Label)
+  #
+  # The anchor defines it's own positional properties, but other properties (such
+  # as the title property, say) can be inherited using the above idiom. Also note
+  # that you can override positional properties in the anchor for custom
+  # behavior.
   class Anchor < Mark
+    # List of properties common to all Anchors
     @properties=Mark.properties.dup
+    
+    ##
+    # :attr: name
+    # The anchor name. The set of supported anchor names is dependent on the
+    # concrete mark type; see the mark type for details. For example, bars support
+    # left, right, top and bottom anchors.
+    #
+    # While anchor names are typically constants, the anchor name is a true
+    # property, which means you can specify a function to compute the anchor name
+    # dynamically. For instance, if you wanted to alternate top and bottom anchors, saying
+    #
+    #   m.anchor(lambda {(index % 2) ? "top" : "bottom"}).add(Rubyvis::Dot)
+    #
+    # would have the desired effect.
+    
+    #
     attr_accessor_dsl [:name, lambda {|d| d.to_s}]
-
+    
+    # Create a new Anchor. Use Mark.add instead.
+    
     def initialize(target)
       super()
       self.target=target
       self.parent=target.parent
     end
+    
+    # Sets the prototype of this anchor to the specified mark. Any properties not
+    # defined on this mark may be inherited from the specified prototype mark, or
+    # its prototype, and so on. The prototype mark need not be the same type of
+    # mark as this mark. (Note that for inheritance to be useful, properties with
+    # the same name on different mark types should have equivalent meaning.)
+    #
+    # <p>This method differs slightly from the normal mark behavior in that the
+    # anchor's target is preserved.
+    #
+    # @param {Rubyvis::Mark} proto the new prototype.
+    # @returns {Rubyvis::Anchor} this anchor.
+    # @see Rubyvis.Mark#add
+    
     def extend(proto)
       @proto=proto
       self

data/lib/rubyvis/mark/area.rb

@@ -1,8 +1,10 @@
 module Rubyvis
+  # Alias for Rubyvis::Area
   def self.Area
     Rubyvis::Area
   end
-  module AreaPrototype
+  # Provides methods pertinents to area like-marks.
+  module AreaPrototype 
     def fixed
       {
         :line_width=> true,
@@ -15,7 +17,6 @@ module Rubyvis
       }
     end
     def area_build_instance(s)
-      
       binds = self.binds
       # Handle fixed properties on secondary instances. */
       if (self.index!=0)
@@ -101,7 +102,7 @@ module Rubyvis
   class Area < Mark
     include AreaPrototype
     @properties=Mark.properties.dup
-    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}], :segmented, :interpolate, :tension
+    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| Rubyvis.color(d)}], [:fill_style, lambda {|d| Rubyvis.color(d)}], :segmented, :interpolate, :tension
     def type
       'area'
     end

data/lib/rubyvis/mark/bar.rb

@@ -1,15 +1,64 @@
 module Rubyvis
+  # Alias for Rubyvis::Bar
   def self.Bar
     Rubyvis::Bar
   end
+  
+  # Represents a bar: an axis-aligned rectangle that can be stroked and
+  # filled. Bars are used for many chart types, including bar charts, histograms
+  # and Gantt charts. Bars can also be used as decorations, for example to draw a
+  # frame border around a panel; in fact, a panel is a special type (a subclass)
+  # of bar.
+  #
+  # Bars can be positioned in several ways. Most commonly, one of the four
+  # corners is fixed using two margins, and then the width and height properties
+  # determine the extent of the bar relative to this fixed location. For example,
+  # using the bottom and left properties fixes the bottom-left corner; the width
+  # then extends to the right, while the height extends to the top. As an
+  # alternative to the four corners, a bar can be positioned exclusively using
+  # margins; this is convenient as an inset from the containing panel, for
+  # example. See Mark for details on the prioritization of redundant
+  # positioning properties.
   class Bar < Mark
-    def type
+    
+    def type # :nodoc:
       "bar"
     end
 
     @properties=Mark.properties.dup
-    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
     
+    
+    ##
+    # :attr: width
+    # The width of the bar, in pixels. If the left position is specified, the bar
+    # extends rightward from the left edge; if the right position is specified, the
+    # bar extends leftward from the right edge.
+    
+    ##
+    # :attr: height
+    # The height of the bar, in pixels. If the bottom position is specified, the
+    # bar extends upward from the bottom edge; if the top position is specified,
+    # the bar extends downward from the top edge.
+    
+    ##
+    # :attr: line_width    
+    # The width of stroked lines, in pixels; used in conjunction with
+    # stroke_style to stroke the bar's border.
+    
+    ##
+    # :attr: stroke_style
+    # The style of stroked lines; used in conjunction with line_width to
+    # stroke the bar's border. The default value of this property is null, meaning bars are not stroked by default.
+    
+    ##
+    # :attr: fill_style
+    # The bar fill style; if non-null, the interior of the bar is filled with the
+    # specified color. The default value of this property is a categorical color.
+    
+    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| Rubyvis.color(d)}], [:fill_style, lambda {|d| Rubyvis.color(d)}]
+    
+    # Default properties for bars. By default, there is no stroke and the fill
+    # style is a categorical color.
     def self.defaults
       a=Rubyvis.Colors.category20()
       Bar.new.extend(Mark.defaults).line_width(1.5).fill_style( lambda {

data/lib/rubyvis/mark/dot.rb

@@ -1,24 +1,104 @@
 module Rubyvis
+  # Alias por Rubyvis::Dot
   def self.Dot
     Rubyvis::Dot
   end
+  # Represents a dot; a dot is simply a sized glyph centered at a given
+  # point that can also be stroked and filled. The <tt>size</tt> property is
+  # proportional to the area of the rendered glyph to encourage meaningful visual
+  # encodings. Dots can visually encode up to eight dimensions of data, though
+  # this may be unwise due to integrality. See Mark for details on the
+  # prioritization of redundant positioning properties.  
   class Dot < Mark
+    # Type of mark
     def type
       "dot"
     end
 
     @properties=Mark.properties.dup
     
-    attr_accessor_dsl :shape, :shape_angle, :shape_radius, :shape_size, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
+    ##
+    # :attr: shape_size
+    # The size of the shape, in square pixels. Square pixels are used such that the
+    # area of the shape is linearly proportional to the value of the
+    # <tt>shapeSize</tt> property, facilitating representative encodings. This is
+    # an alternative to using shape_radius
+    #
     
+    ##
+    # :attr: shape_radius 
+    # The radius of the shape, in pixels. This is an alternative to using
+    # shape_size
+    #
+    
+    ##
+    # :attr: shape
+    # The shape name. Several shapes are supported:<ul>
+    #
+    # <li>cross
+    # <li>triangle
+    # <li>diamond
+    # <li>square
+    # <li>circle
+    # <li>tick
+    # <li>bar
+    #
+    # </ul>These shapes can be further changed using the angle() property;
+    # for instance, a cross can be turned into a plus by rotating. Similarly, the
+    # tick, which is vertical by default, can be rotated horizontally. Note that
+    # some shapes (cross and tick) do not have interior areas, and thus do not
+    # support fill style meaningfully.
+    #
+    # <p>Note: it may be more natural to use the Rule mark for
+    # horizontal and vertical ticks. The tick shape is only necessary if angled
+    # ticks are needed.
+    
+    ##
+    # :attr: shape_angle
+    # The shape rotation angle, in radians. Used to rotate shapes, such as to turn
+    # a cross into a plus.
+    
+    ##
+    # :attr: line_width
+    # The width of stroked lines, in pixels; used in conjunction with
+    # +stroke_style+ to stroke the dot's shape.
+    
+    ##
+    # :attr: stroke_style
+    # The style of stroked lines; used in conjunction with +line_width+ to
+    # stroke the dot's shape. The default value of this property is a categorical color. See Rubyvis.color()
+    
+    ##
+    # :attr: fill_style
+    # The fill style; if non-null, the interior of the dot is filled with the
+    # specified color. The default value of this property is null, meaning dots are
+    # not filled by default. See Rubyvis.color()
+    
+    attr_accessor_dsl :shape, :shape_angle, :shape_radius, :shape_size, :line_width, [:stroke_style, lambda {|d| Rubyvis.color(d)}], [:fill_style, lambda {|d| Rubyvis.color(d)}]
+    # Default properties for dots. By default, there is no fill and the stroke
+    # style is a categorical color. The default shape is "circle" with radius 4.5.
     def self.defaults()
       a=Rubyvis::Colors.category10
       Dot.new().extend(Mark.defaults).shape("circle"). line_width(1.5). stroke_style(lambda {a.scale(self.parent.index)})
     end
-    
+    # Constructs a new dot anchor with default properties. Dots support five
+    # different anchors:<ul>
+    #
+    # <li>top
+    # <li>left
+    # <li>center
+    # <li>bottom
+    # <li>right
+    #
+    # </ul>In addition to positioning properties (left, right, top bottom), the
+    # anchors support text rendering properties (text-align, text-baseline). Text is
+    # rendered to appear outside the dot. Note that this behavior is different from
+    # other mark anchors, which default to rendering text <i>inside</i> the mark.
+    #
+    # <p>For consistency with the other mark types, the anchor positions are
+    # defined in terms of their opposite edge. For example, the top anchor defines
+    # the bottom property, such that a bar added to the top anchor grows upward.
     def anchor(name)
-      
-      
       mark_anchor(name).left(lambda {
         s=scene.target[self.index]
         case self.name
@@ -66,7 +146,10 @@ module Rubyvis
       
       })
     end
-    def build_implied(s)
+    
+    
+    # @private Sets radius based on size or vice versa. 
+    def build_implied(s) # :nodoc:
       r = s.shape_radius
       z = s.shape_size
       if (r.nil?) 

data/lib/rubyvis/mark/label.rb

@@ -1,16 +1,107 @@
 module Rubyvis
+  # Alias for Rubyvis::Label
   def self.Label
     Rubyvis::Label
   end
-
+  # Represents a text label, allowing textual annotation of other marks or
+  # arbitrary text within the visualization. The character data must be plain
+  # text (unicode), though the text can be styled using the {@link #font}
+  # property. If rich text is needed, external HTML elements can be overlaid on
+  # the canvas by hand.
+  #
+  # <p>Labels are positioned using the box model, similarly to {@link Dot}. Thus,
+  # a label has no width or height, but merely a text anchor location. The text
+  # is positioned relative to this anchor location based on the
+  # text_align, text_baseline and text_margin properties.
+  # Furthermore, the text may be rotated using text_angle
   class Label < Mark
     @properties=Mark.properties.dup
-    attr_accessor_dsl :text, :font, :text_angle, [:text_style, lambda {|d| pv.color(d)}], :text_align, :text_baseline, :text_margin, :text_decoration, :text_shadow
+    
+    ##
+    # :attr: text
+    # The character data to render; a string. The default value of the text
+    # property is the identity function, meaning the label's associated datum will
+    # be rendered using its to_s()
+    
+    ##
+    # :attr: font
+    # The font format, per the CSS Level 2 specification. The default font is "10px
+    # sans-serif", for consistency with the HTML 5 canvas element specification.
+    # Note that since text is not wrapped, any line-height property will be
+    # ignored. The other font-style, font-variant, font-weight, font-size and
+    # font-family properties are supported.
+    #
+    # @see {CSS2 fonts}[http://www.w3.org/TR/CSS2/fonts.html#font-shorthand]
+    
+    ##
+    # :attr: text_angle
+    # The rotation angle, in radians. Text is rotated clockwise relative to the
+    # anchor location. For example, with the default left alignment, an angle of
+    # Math.PI / 2 causes text to proceed downwards. The default angle is zero.
+    
+    ##
+    # :attr: text_style
+    # The text color. The name "text_style" is used for consistency with "fill_style"
+    # and "stroke_style", although it might be better to rename this property (and
+    # perhaps use the same name as "stroke_style"). The default color is black.
+    # See Rubyvis.color()
+    
+    ##
+    # :attr: text_align
+    # The horizontal text alignment. One of:<ul>
+    #
+    # <li>left
+    # <li>center
+    # <li>right
+    #
+    # </ul>The default horizontal alignment is left.
+    
+    
+    ##
+    # :attr: text_baseline
+    # The vertical text alignment. One of:<ul>
+    #
+    # <li>top
+    # <li>middle
+    # <li>bottom
+    #
+    # </ul>The default vertical alignment is bottom.
+    
+    
+    ##
+    # :attr: text_margin
+    # The text margin; may be specified in pixels, or in font-dependent units (such
+    # as ".1ex"). The margin can be used to pad text away from its anchor location,
+    # in a direction dependent on the horizontal and vertical alignment
+    # properties. For example, if the text is left- and middle-aligned, the margin
+    # shifts the text to the right. The default margin is 3 pixels.
+    
+    
+    ##
+    # :attr: text_shadow
+    # A list of shadow effects to be applied to text, per the CSS Text Level 3
+    # text-shadow property. An example specification is "0.1em 0.1em 0.1em
+    # rgba(0,0,0,.5)"; the first length is the horizontal offset, the second the
+    # vertical offset, and the third the blur radius.
+    #
+    # See {CSS3 text}[http://www.w3.org/TR/css3-text/#text-shadow]
+    
+    ##
+    # :attr: text_decoration
+    # A list of decoration to be applied to text, per the CSS Text Level 3
+    # text-decoration property. An example specification is "underline".
+    #
+    # See {CSS3 text}[http://www.w3.org/TR/css3-text/#text-decoration]
+    
+    
+    attr_accessor_dsl :text, :font, :text_angle, [:text_style, lambda {|d| Rubyvis.color(d)}], :text_align, :text_baseline, :text_margin, :text_decoration, :text_shadow
+    # Mark type
     def type
       'label'
     end
+    # Default properties for labels. See the individual properties for the default values.
     def self.defaults
-      Label.new.extend(Mark.defaults).events('none').text(pv.identity).font("10px sans-serif" ).text_angle( 0 ).text_style( 'black' ).text_align( 'left' ).text_baseline( 'bottom' ).text_margin(3)
+      Label.new.extend(Mark.defaults).events('none').text(Rubyvis.identity).font("10px sans-serif" ).text_angle( 0 ).text_style( 'black' ).text_align( 'left' ).text_baseline( 'bottom' ).text_margin(3)
     end
   end
 end

data/lib/rubyvis/mark/line.rb

@@ -1,8 +1,9 @@
 module Rubyvis
+  # Alias for Rubyvis::Line
   def self.Line
     Rubyvis::Line
   end
-  module LinePrototype
+  module LinePrototype 
     include AreaPrototype
     def line_anchor(name)
       anchor=area_anchor(name).text_align(lambda {|d|
@@ -17,7 +18,7 @@ module Rubyvis
     include AreaPrototype
     include LinePrototype
     @properties=Mark.properties.dup
-    attr_accessor_dsl :line_width, :line_join, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}], :segmented, :interpolate, :eccentricity, :tension
+    attr_accessor_dsl :line_width, :line_join, [:stroke_style, lambda {|d| Rubyvis.color(d)}], [:fill_style, lambda {|d| Rubyvis.color(d)}], :segmented, :interpolate, :eccentricity, :tension
     def type
       "line"
     end

data/lib/rubyvis/mark/panel.rb

@@ -1,4 +1,5 @@
 module Rubyvis
+  # Alias for Rubyvis::Panel
   def self.Panel
     Rubyvis::Panel
   end