rubyvis 0.2.2 → 0.3.0

data/History.txt

@@ -1,3 +1,13 @@
+=== 0.3.0 / 2010-11-17
+* Network and Hierarchy classes on module Layout implemented. Require testing
+* Rubyvis::Layout::Treemap fully operational
+* Rubyvis::Dom almost complete, including spec
+* Mark.extend changed to Mark.mark_extend, to avoid clashes with ruby extend
+* Bug fix: Rubyvis::Dom::Node.sort doesn't set first_child and last_child correctly
+* Updated for hoe 1.7.0
+* Updated example of coordinate parallels
+* New example: treemap/treemap.rb
+
 === 0.2.2 / 2010-11-13
 
 * Updated to rspec 2. Bug fix: instance_eval raises an error on js_apply

data/Manifest.txt

@@ -30,16 +30,22 @@ examples/scatterplot.rb
 examples/second.rb
 examples/stacked_charts.rb
 examples/third.rb
+examples/treemap/treemap.rb
+examples/treemap/treemap_data.rb
 lib/rubyvis.rb
 lib/rubyvis/color/color.rb
 lib/rubyvis/color/colors.rb
+lib/rubyvis/dom.rb
 lib/rubyvis/format.rb
 lib/rubyvis/format/date.rb
 lib/rubyvis/format/number.rb
 lib/rubyvis/internals.rb
 lib/rubyvis/javascript_behaviour.rb
 lib/rubyvis/layout.rb
+lib/rubyvis/layout/hierarchy.rb
+lib/rubyvis/layout/network.rb
 lib/rubyvis/layout/stack.rb
+lib/rubyvis/layout/treemap.rb
 lib/rubyvis/mark.rb
 lib/rubyvis/mark/anchor.rb
 lib/rubyvis/mark/area.rb
@@ -75,6 +81,7 @@ lib/rubyvis/transform.rb
 spec/anchor_spec.rb
 spec/area_spec.rb
 spec/bar_spec.rb
+spec/dom_spec.rb
 spec/internal_spec.rb
 spec/javascript_behaviour_spec.rb
 spec/label_spec.rb

data/Rakefile

@@ -9,20 +9,12 @@ require 'rspec'
 require 'rspec/core/rake_task'
 
 
-
-
-RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
-  t.pattern = 'spec/**/*_spec.rb'
-end
-
-
 Hoe.plugin :git
 
 Hoe.spec 'rubyvis' do
   self.testlib=:rspec
-  self.test_globs="spec/*_spec.rb"
-#  self.rubyforge_name = 'rubyvis'
+  #self.test_globs="spec/*_spec.rb"
+  self.rspec_options << "-c" << "-b"
   self.developer('Claudio Bustos', 'clbustos_at_gmail.com')
   self.version=Rubyvis::VERSION
   self.extra_dev_deps << ["coderay",">=0"] << ["haml",">=0"] << ["nokogiri", ">=0"] << ["rspec",">=2.0"]

data/examples/antibiotics/antibiotics_scatter.rb

@@ -1,5 +1,4 @@
 # = Antibiotic Effectiveness : Scatterplot
-#
 # After World War II, antibiotics earned the moniker “wonder drugs” for quickly treating previously-incurable diseases. Data was gathered to determine which drug worked best for each bacterial infection. Comparing drug performance was an enormous aid for practitioners and scientists alike. In the fall of 1951, Will Burtin published this graph showing the effectiveness of three popular antibiotics on 16 different bacteria, measured in terms of minimum inhibitory concentration.
 # Recreating this display revealed some minor errors in the original: a missing grid line at 0.01 μg/ml, and an exaggeration of some values for penicillin. 
 $:.unshift(File.dirname(__FILE__)+"/../../lib")
@@ -51,7 +50,7 @@ tick = pv.Rule.new()
 
 #/* X-axis ticks. */
 xtick = plot.add(pv.Rule)
-    .extend(tick)
+    .mark_extend(tick)
     .left(z);
 
 #/* Bottom and top labels. */
@@ -62,7 +61,7 @@ xtick.anchor("top").add(pv.Label)
 
 #/* Y-axis ticks. */
 ytick = plot.add(pv.Rule)
-    .extend(tick)
+    .mark_extend(tick)
     .bottom(z);
 
 #/* Bottom and top labels. */
@@ -96,7 +95,7 @@ dot = plot.add(pv.Dot).
 
 #/* Legend. */
 vis.add(pv.Dot)
-    .extend(dot)
+    .mark_extend(dot)
     .data([{gram:"positive"}, {gram:"negative"}])
     .bottom(-30)
     .left(lambda { index * 100})
@@ -105,4 +104,4 @@ vis.add(pv.Dot)
     .text(lambda {|d| "Gram-" + d[:gram]});
 
 vis.render();
-puts vis.to_svg
+puts vis.to_svg

data/examples/antibiotics/antibiotics_wedge.rb

@@ -1,5 +1,4 @@
 # = Antibiotic Effectiveness : Pie chart
-#
 # After World War II, antibiotics earned the moniker “wonder drugs” for quickly treating previously-incurable diseases. Data was gathered to determine which drug worked best for each bacterial infection. Comparing drug performance was an enormous aid for practitioners and scientists alike. In the fall of 1951, Will Burtin published this graph showing the effectiveness of three popular antibiotics on 16 different bacteria, measured in terms of minimum inhibitory concentration.
 # Recreating this display revealed some minor errors in the original: a missing grid line at 0.01 μg/ml, and an exaggeration of some values for penicillin.
 $:.unshift(File.dirname(__FILE__)+"/../../lib")

data/examples/treemap/treemap.rb

@@ -0,0 +1,29 @@
+# = Treemap
+# Introduced by Ben Shneiderman in 1991, a treemap recursively subdivides area into rectangles. As with adjacency diagrams, the size of any node in the tree is quickly revealed. This example uses color to encode different packages of the Flare visualization toolkit, and area to encode file size. “Squarified” treemaps use approximately square rectangles, which offer better readability and size estimation than naive “slice-and-dice” subdivision. Fancier algorithms such as Voronoi and jigsaw treemaps also exist but are less common.
+
+$:.unshift(File.dirname(__FILE__)+"/../../lib")
+require 'rubyvis'
+load(File.dirname(__FILE__)+"/treemap_data.rb")
+color = pv.Colors.category19()
+nodes = pv.dom($flare).root("flare").nodes
+
+
+vis = pv.Panel.new()
+    .width(600)
+    .height(1000)
+
+treemap = vis.add(Rubyvis::Layout::Treemap).
+  nodes(nodes).mode("squarify").round(true)
+
+treemap.leaf.add(Rubyvis::Panel).
+  fill_style(lambda{|d| 
+   color.scale(d.parent_node.node_name)}).
+  stroke_style("#fff").
+  line_width(1).
+  antialias(false)
+
+treemap.node_label.add(Rubyvis::Label).
+  text_style(lambda {|d| pv.rgb(0, 0, 0, 1)})
+
+vis.render
+puts vis.to_svg

data/examples/treemap/treemap_data.rb

@@ -0,0 +1,285 @@
+$flare = {
+  analytics: {
+    cluster: {
+      AgglomerativeCluster: 3938,
+      CommunityStructure: 3812,
+      HierarchicalCluster: 6714,
+      MergeEdge: 743
+    },
+    graph: {
+      BetweennessCentrality: 3534,
+      LinkDistance: 5731,
+      MaxFlowMinCut: 7840,
+      ShortestPaths: 5914,
+      SpanningTree: 3416
+    },
+    optimization: {
+      AspectRatioBanker: 7074
+    }
+  },
+  animate: {
+    Easing: 17010,
+    FunctionSequence: 5842,
+    interpolate: {
+      ArrayInterpolator: 1983,
+      ColorInterpolator: 2047,
+      DateInterpolator: 1375,
+      Interpolator: 8746,
+      MatrixInterpolator: 2202,
+      NumberInterpolator: 1382,
+      ObjectInterpolator: 1629,
+      PointInterpolator: 1675,
+      RectangleInterpolator: 2042
+    },
+    ISchedulable: 1041,
+    Parallel: 5176,
+    Pause: 449,
+    Scheduler: 5593,
+    Sequence: 5534,
+    Transition: 9201,
+    Transitioner: 19975,
+    TransitionEvent: 1116,
+    Tween: 6006
+  },
+  data: {
+    converters: {
+      Converters: 721,
+      DelimitedTextConverter: 4294,
+      GraphMLConverter: 9800,
+      IDataConverter: 1314,
+      JSONConverter: 2220
+    },
+    DataField: 1759,
+    DataSchema: 2165,
+    DataSet: 586,
+    DataSource: 3331,
+    DataTable: 772,
+    DataUtil: 3322
+  },
+  display: {
+    DirtySprite: 8833,
+    LineSprite: 1732,
+    RectSprite: 3623,
+    TextSprite: 10066
+  },
+  flex: {
+    FlareVis: 4116
+  },
+  physics: {
+    DragForce: 1082,
+    GravityForce: 1336,
+    IForce: 319,
+    NBodyForce: 10498,
+    Particle: 2822,
+    Simulation: 9983,
+    Spring: 2213,
+    SpringForce: 1681
+  },
+  query: {
+    AggregateExpression: 1616,
+    And: 1027,
+    Arithmetic: 3891,
+    Average: 891,
+    BinaryExpression: 2893,
+    Comparison: 5103,
+    CompositeExpression: 3677,
+    Count: 781,
+    DateUtil: 4141,
+    Distinct: 933,
+    Expression: 5130,
+    ExpressionIterator: 3617,
+    Fn: 3240,
+    If: 2732,
+    IsA: 2039,
+    Literal: 1214,
+    Match: 3748,
+    Maximum: 843,
+    methods: {
+      add: 593,
+      and: 330,
+      average: 287,
+      count: 277,
+      distinct: 292,
+      div: 595,
+      eq: 594,
+      fn: 460,
+      gt: 603,
+      gte: 625,
+      iff: 748,
+      isa: 461,
+      lt: 597,
+      lte: 619,
+      max: 283,
+      min: 283,
+      mod: 591,
+      mul: 603,
+      neq: 599,
+      not: 386,
+      or: 323,
+      orderby: 307,
+      range: 772,
+      select: 296,
+      stddev: 363,
+      sub: 600,
+      sum: 280,
+      update: 307,
+      variance: 335,
+      where: 299,
+      xor: 354,
+      _: 264
+    },
+    Minimum: 843,
+    Not: 1554,
+    Or: 970,
+    Query: 13896,
+    Range: 1594,
+    StringUtil: 4130,
+    Sum: 791,
+    Variable: 1124,
+    Variance: 1876,
+    Xor: 1101
+  },
+  scale: {
+    IScaleMap: 2105,
+    LinearScale: 1316,
+    LogScale: 3151,
+    OrdinalScale: 3770,
+    QuantileScale: 2435,
+    QuantitativeScale: 4839,
+    RootScale: 1756,
+    Scale: 4268,
+    ScaleType: 1821,
+    TimeScale: 5833
+  },
+  util: {
+    Arrays: 8258,
+    Colors: 10001,
+    Dates: 8217,
+    Displays: 12555,
+    Filter: 2324,
+    Geometry: 10993,
+    heap: {
+      FibonacciHeap: 9354,
+      HeapNode: 1233
+    },
+    IEvaluable: 335,
+    IPredicate: 383,
+    IValueProxy: 874,
+    math: {
+      DenseMatrix: 3165,
+      IMatrix: 2815,
+      SparseMatrix: 3366
+    },
+    Maths: 17705,
+    Orientation: 1486,
+    palette: {
+      ColorPalette: 6367,
+      Palette: 1229,
+      ShapePalette: 2059,
+      SizePalette: 2291
+    },
+    Property: 5559,
+    Shapes: 19118,
+    Sort: 6887,
+    Stats: 6557,
+    Strings: 22026
+  },
+  vis: {
+    axis: {
+      Axes: 1302,
+      Axis: 24593,
+      AxisGridLine: 652,
+      AxisLabel: 636,
+      CartesianAxes: 6703
+    },
+    controls: {
+      AnchorControl: 2138,
+      ClickControl: 3824,
+      Control: 1353,
+      ControlList: 4665,
+      DragControl: 2649,
+      ExpandControl: 2832,
+      HoverControl: 4896,
+      IControl: 763,
+      PanZoomControl: 5222,
+      SelectionControl: 7862,
+      TooltipControl: 8435
+    },
+    data: {
+      Data: 20544,
+      DataList: 19788,
+      DataSprite: 10349,
+      EdgeSprite: 3301,
+      NodeSprite: 19382,
+      render: {
+        ArrowType: 698,
+        EdgeRenderer: 5569,
+        IRenderer: 353,
+        ShapeRenderer: 2247
+      },
+      ScaleBinding: 11275,
+      Tree: 7147,
+      TreeBuilder: 9930
+    },
+    events: {
+      DataEvent: 2313,
+      SelectionEvent: 1880,
+      TooltipEvent: 1701,
+      VisualizationEvent: 1117
+    },
+    legend: {
+      Legend: 20859,
+      LegendItem: 4614,
+      LegendRange: 10530
+    },
+    operator: {
+      distortion: {
+        BifocalDistortion: 4461,
+        Distortion: 6314,
+        FisheyeDistortion: 3444
+      },
+      encoder: {
+        ColorEncoder: 3179,
+        Encoder: 4060,
+        PropertyEncoder: 4138,
+        ShapeEncoder: 1690,
+        SizeEncoder: 1830
+      },
+      filter: {
+        FisheyeTreeFilter: 5219,
+        GraphDistanceFilter: 3165,
+        VisibilityFilter: 3509
+      },
+      IOperator: 1286,
+      label: {
+        Labeler: 9956,
+        RadialLabeler: 3899,
+        StackedAreaLabeler: 3202
+      },
+      layout: {
+        AxisLayout: 6725,
+        BundledEdgeRouter: 3727,
+        CircleLayout: 9317,
+        CirclePackingLayout: 12003,
+        DendrogramLayout: 4853,
+        ForceDirectedLayout: 8411,
+        IcicleTreeLayout: 4864,
+        IndentedTreeLayout: 3174,
+        Layout: 7881,
+        NodeLinkTreeLayout: 12870,
+        PieLayout: 2728,
+        RadialTreeLayout: 12348,
+        RandomLayout: 870,
+        StackedAreaLayout: 9121,
+        TreeMapLayout: 9191
+      },
+      Operator: 2490,
+      OperatorList: 5248,
+      OperatorSequence: 4190,
+      OperatorSwitch: 2581,
+      SortOperator: 2023
+    },
+    Visualization: 16540
+  }
+};
+

data/lib/rubyvis.rb

@@ -17,6 +17,7 @@ require 'rubyvis/color/color'
 require 'rubyvis/color/colors'
 
 require 'rubyvis/layout'
+require 'rubyvis/dom'
 
 require 'rubyvis/scene/svg_scene'
 require 'rubyvis/transform'
@@ -25,7 +26,7 @@ require 'rubyvis/transform'
 module Rubyvis
   @document=nil
   # Rubyvis version
-  VERSION = '0.2.2' 
+  VERSION = '0.3.0' 
   # Protovis API on which current Rubyvis is based
   PROTOVIS_API_VERSION='3.3'
   # You actually can do it! http://snipplr.com/view/2137/uses-for-infinity-in-ruby/

data/lib/rubyvis/dom.rb

@@ -0,0 +1,313 @@
+module Rubyvis
+  # Returns a Rubyvis::Dom operator for the given map. This is a convenience
+  # factory method, equivalent to Rubyvis::Dom.new(map). To apply the operator
+  # and retrieve the root node, call Rubyvis::Dom.root() to retrieve all nodes
+  # flattened, use Rubyvis::Dom.nodes
+  #
+  # @see pv.Dom
+  # @param map a map from which to construct a DOM.
+  # @returns {pv.Dom} a DOM operator for the specified map.
+  def self.dom(map) 
+    Rubyvis::Dom.new(map)
+  end
+
+  # Constructs a DOM operator for the specified map. This constructor should not
+  # be invoked directly; use {@link pv.dom} instead.
+  #
+  # @class Represets a DOM operator for the specified map. This allows easy
+  # transformation of a hierarchical JavaScript object (such as a JSON map) to a
+  # W3C Document Object Model hierarchy. For more information on which attributes
+  # and methods from the specification are supported, see {@link pv.Dom.Node}.
+  #
+  # <p>Leaves in the map are determined using an associated <i>leaf</i> function;
+  # see {@link #leaf}. By default, leaves are any value whose type is not
+  # "object", such as numbers or strings.
+  #
+  # @param map a map from which to construct a DOM.
+  class Dom
+    def initialize(map)
+      @_map=map
+      @leaf=lambda {|n| !n.respond_to? :each }
+    end
+    # Sets or gets the leaf function for this DOM operator. The leaf function
+    # identifies which values in the map are leaves, and which are internal nodes.
+    # By default, objects are considered internal nodes, and primitives (such as
+    # numbers and strings) are considered leaves.
+    #
+    # @param {function} f the new leaf function.
+    # @returns the current leaf function, or <tt>this</tt>.    
+    def leaf(f=nil)
+      if !f.nil?
+        @leaf=f
+        self
+      end
+      @leaf
+    end
+    
+    def root_recurse(map)
+      n = Rubyvis::Dom::Node.new
+      map.each {|k,v|
+        n.append_child(@leaf.call(v) ? Rubyvis::Dom::Node.new(v) : root_recurse(v)).node_name = k
+      }
+      return n
+    end
+    
+    # Applies the DOM operator, returning the root node.
+    def root(node_name=nil)
+      root=root_recurse(@_map)
+      root.node_name=node_name
+      root
+    end
+    
+   # Applies the DOM operator, returning the array of all nodes in preorder
+   # traversal.
+   # @returns {array} the array of nodes in preorder traversal.
+   def nodes
+     self.root.nodes
+   end
+   
+   def self.Node(value)
+     Node.new(value)
+   end
+   # Represents a <tt>Node</tt> in the W3C Document Object Model.
+    class Node
+      # The node name. When generated from a map, the node name corresponds to the
+      # key at the given level in the map. Note that the root node has no associated
+      # key, and thus has an undefined node name (and no <tt>parentNode</tt>).
+      attr_accessor :node_name
+      
+      # The node value. When generated from a map, node value corresponds to 
+      # the leaf value for leaf nodes, and is undefined for internal nodes.
+      attr_reader :node_value
+      
+      # The array of child nodes. This array is empty for leaf nodes. An easy way to
+      # check if child nodes exist is to query <tt>firstChild</tt>.    
+      attr_accessor :child_nodes
+      attr_accessor :parent_node
+      # The first child, which is null for leaf nodes.
+      
+      attr_accessor :first_child
+      attr_accessor :last_child
+      attr_accessor :previous_sibling
+      attr_accessor :next_sibling
+      
+      attr_accessor :index
+      attr_accessor :link_degree
+      attr_accessor :depth
+      attr_accessor :dx
+      attr_accessor :dy
+      attr_accessor :x
+      attr_accessor :y
+      attr_accessor :size
+      
+      
+      # Constructs a DOM node for the specified value. Instances of this class are
+      # not typically created directly; instead they are generated from a JavaScript 
+      # map using the {@link pv.Dom} operator.
+      def initialize(value=nil)
+        @node_value = value
+        @child_nodes=[]
+        @parent_node=nil
+        @first_child=nil
+        @last_child=nil
+        @previous_sibling=nil
+        @next_sibling=nil
+        
+      end
+      # Removes the specified child node from this node.
+      def remove_child(n)
+        i=@child_nodes.index n
+        raise "child not found" if i.nil?
+        @child_nodes.delete_at i
+        if n.previous_sibling
+         n.previous_sibling.next_sibling=n.next_sibling 
+        else
+          @first_child=n.next_sibling
+        end
+        if n.next_sibling
+         n.next_sibling.previous_sibling=n.previous_sibling 
+        else
+         @last_child=n.previous_sibling
+        end
+        n.next_sibling=nil
+        n.previous_sibling=nil
+        n.parent_node=nil
+        n
+      end
+      
+      # Appends the specified child node to this node. If the specified child is
+      # already part of the DOM, the child is first removed before being added to
+      # this node.
+      def append_child(n)
+        if n.parent_node
+         n.parent_node.remove_child(n)
+        end
+        n.parent_node=self
+        n.previous_sibling=last_child
+        if self.last_child
+          @last_child.next_sibling = n
+        else
+          @first_child=n
+        end
+        @last_child=n
+        child_nodes.push(n)
+        n
+      end
+      
+      # Inserts the specified child <i>n</i> before the given reference child
+      # <i>r</i> of this node. If <i>r</i> is null, this method is equivalent to
+      # {@link #appendChild}. If <i>n</i> is already part of the DOM, it is first
+      # removed before being inserted.
+      #
+      # @throws Error if <i>r</i> is non-null and not a child of this node.
+      # @returns {pv.Dom.Node} the inserted child.
+      def insert_before(n, r)
+        return append_child(n) if !r
+        i=@child_nodes.index r
+        raise "child not found" if i.nil?
+        n.parent_node.remove_child(n) if n.parent_node
+        n.parent_node=self
+        n.next_sibling=r
+        n.previous_sibling = r.previous_sibling
+        if r.previous_sibling
+          r.previous_sibling.next_sibling=n
+          r.previous_sibling=n
+        else
+          @last_child=n if r==@last_child
+          @first_child=n
+        end
+        @child_nodes = @child_nodes[0,i] + [n] + @child_nodes[i, child_nodes.size-i]
+        n
+      end
+      # Replaces the specified child <i>r</i> of this node with the node <i>n</i>. If
+      # <i>n</i> is already part of the DOM, it is first removed before being added.
+      
+      def replace_child(n,r)
+        i=child_nodes.index r
+        raise "child not found" if i.nil?
+        n.parent_node.remove_child(n) if n.parent_node
+        n.parent_node=self
+        n.next_sibling=r.next_sibling
+        n.previous_sibling=r.previous_sibling
+        if r.previous_sibling
+          r.previous_sibling.next_sibling=n
+        else
+          @first_child=n
+        end
+        if r.next_sibling
+          r.next_sibling.previous_sibling=n
+        else
+          @last_child=n
+        end
+        
+        @child_nodes[i]=n
+        r
+      end
+      
+      def visit_visit(n,i,block,moment)
+        block.call(n,i) if moment==:before
+        c=n.first_child
+        while c
+          visit_visit(c,i+1, block,moment)
+          c=c.next_sibling
+        end
+        block.call(n,i) if moment==:after
+      end
+      private :visit_visit
+      
+      # Visits each node in the tree in preorder traversal, applying the specified
+      # proc <i>block</i>. The arguments to the function are:<ol>
+      #
+      # <li>The current node.
+      # <li>The current depth, starting at 0 for the root node.</ol>
+      
+      def visit_before(f=nil,&block)
+        block=f unless f.nil?
+        raise "Should pass a Proc" if block.nil?
+        visit_visit(self,0,block, :before)
+      end
+      # Visits each node in the tree in postorder traversal, applying the specified
+      # function <i>f</i>. The arguments to the function are:<ol>
+      #
+      # <li>The current node.
+      # <li>The current depth, starting at 0 for the root node.</ol>    
+      def visit_after(f=nil,&block)
+        block=f unless f.nil?
+        raise "Should pass a Proc" if block.nil?
+        visit_visit(self,0,block, :after)
+      end
+      
+      
+      # Sorts child nodes of this node, and all descendent nodes recursively, using
+      # the specified comparator function <tt>f</tt>. The comparator function is
+      # passed two nodes to compare.
+      #
+      # <p>Note: during the sort operation, the comparator function should not rely
+      # on the tree being well-formed; the values of <tt>previousSibling</tt> and
+      # <tt>nextSibling</tt> for the nodes being compared are not defined during the
+      # sort operation.
+      #
+      # @param {function} f a comparator function.
+      # @returns this.
+      def sort(f_a=nil,&f)
+        f=f_a unless f_a.nil?
+        raise "Should pass a Proc" if f.nil?
+        if @first_child
+          @child_nodes.sort!(&f)
+          _p=@first_child = child_nodes[0]
+          _p.previous_sibling=nil
+          (1...@child_nodes.size).each {|i|
+            _p.sort(&f)
+            c=@child_nodes[i]
+            c.previous_sibling=_p
+            _p=_p.next_sibling=c
+          }
+          @last_child=_p
+          _p.next_sibling=nil
+          _p.sort(f)
+        end
+        self
+      end
+      # Reverses all sibling nodes.
+      def reverse
+        child_nodes=[]
+        visit_after {|n,dummy|
+        while(n.last_child) do
+          child_nodes.push(n.remove_child(n.last_child)) 
+        end
+        c=nil
+        while(c=child_nodes.pop)
+          n.insert_before(c,n.first_child)
+        end
+        }
+        self
+      end
+      def nodes_flatten(node,array)
+        array.push(node)
+        node.child_nodes.each {|n|
+        nodes_flatten(n,array)
+        }
+      end
+      private :nodes_flatten
+      def nodes
+        array=[]
+        nodes_flatten(self,array)
+        array
+      end
+    # toggle missing
+      def inspect
+        childs=@child_nodes.map{|e| e.inspect}.join(",")
+        "#<#{self.class} #{object_id.to_s(16)} (#{}), name: #{@node_name}, value: #{@node_value} child_nodes: [#{childs}]>"
+      end
+    end # End Node
+  end # End Dom
+  # Given a flat array of values, returns a simple DOM with each value wrapped by
+  # a node that is a child of the root node.  
+  def self.nodes(values)
+    root=Rubyvis::Dom::Node.new
+    values.each do |v,i|
+      root.append_child(Rubyvis::Dom::Node.new(v))
+    end
+    root.nodes()
+  end
+end