ruport 0.4.4 → 0.4.5

data/AUTHORS

@@ -12,3 +12,10 @@ Parse::Input which is the base for Ruport::Parser
 
 Francis Hwang:
 SQLSplit
+
+Simon Claret:
+PDF table support for Format::Builder
+
+Dudley Flanders:
+DataSet improvements
+

data/CHANGELOG

@@ -1,4 +1,27 @@
-The current version of Ruby Reports is 0.4.4
+The current version of Ruby Reports is 0.4.5 (Developmental)
+
+changes since 0.4.4:
+
+- DataRow constructor now matches DataSet style.
+
+- DataSet picked up a ton of array-like functionality
+
+- DataSet#load now optionally accepts a block that acts something
+  like inject.
+
+- Added a DataSet#select_columns!() method
+
+- What the heck was Format#filter_ruby?  It's gone now
+
+- DataSet#as() now hooked to the new formatting system.
+  note API breakage in block forms
+
+- DataSet set operations (DF)
+
+- Much smarter DataSet#<< (Dudley Flanders)
+
+- Ruport now has pseudo keyword support in DataSets.
+ (Thanks to Dudley Flanders!)
 
 changes since 0.4.2:
 

data/Rakefile

@@ -21,7 +21,7 @@ end
 
 spec = Gem::Specification.new do |spec|
 	spec.name = LEAN ? "ruport-lean" : "ruport"
-	spec.version = "0.4.4"
+	spec.version = "0.4.5"
 	spec.platform = Gem::Platform::RUBY
 	spec.summary = "A generalized Ruby report generation and templating engine."
 	spec.files =  Dir.glob("{examples,lib,test}/**/**/*") +

data/TODO

@@ -21,19 +21,16 @@ Immediate Goals:
 
     - Value modification predicate.
       DataRow#set_value_if("my_value") { # my_condition }
-    
+      (Update: What was I talking about here???)
+      
     - Column based default values
 
     - Integrate Ruport::Parser into Report#parse and Format#parser
 
     - Document the inner classes of Format
 
-    - Get unit tests up to 100% coverage
-
     - make the Fetchable module to abstract data acquisition
   
-    - DataSet subclasses Array
-
     - Calculated fields
 
 Other High Priority Goals:

data/lib/ruport.rb

@@ -14,7 +14,7 @@ module Ruport
   
   begin; require 'rubygems'; rescue LoadError; nil end
   
-  VERSION = "Ruby Reports Version 0.4.4"
+  VERSION = "Ruby Reports Version 0.4.5 (Developmental)"
   
   # Ruports logging and error interface.
   # Can generate warnings or raise fatal errors

data/lib/ruport/data_row.rb

@@ -12,8 +12,8 @@
 # ++
 module Ruport 
     
-  # DataRows are Enumerable lists which can be accessed by field name or ordinal
-  # position.  
+  # DataRows are Enumerable lists which can be accessed by field name or 
+  # ordinal position.  
   #
   # They feature a tagging system, allowing them to be easily
   # compared or recalled.  
@@ -24,38 +24,37 @@ module Ruport
   
       include Enumerable
     
-      # Takes data and field names as well as some optional parameters and
+      # Takes field names as well as some optional parameters and
       # constructs a DataRow.  
-      # 
-      #
-      # <tt>data</tt> can be specified in Hash, Array, or DataRow form
       #
       # Options: 
-      # <tt>:filler</tt>::  this will be used as a default value for empty
-      # <tt>:tags</tt>::    an initial set of tags for the row
+      # <tt>:data</tt>:: can be specified in Hash, Array, or DataRow form
+      # <tt>:default</tt>:: The default value for empty fields
+      # <tt>:tags</tt>:: an initial set of tags for the row
       # 
       #
       # Examples:
-      #   >> Ruport::DataRow.new [1,2,3,4,5], [:a,:b,:c,:d,:e], 
+      #   >> Ruport::DataRow.new [:a,:b,:c,:d,:e], :data => [1,2,3,4,5]
       #      :tags => %w[cat dog]
       #   => #<Ruport::DataRow:0xb77e4b04 @fields=[:a, :b, :c, :d, :e], 
       #      @data=[1, 2, 3, 4, 5], @tags=["cat", "dog"]>
       #
-      #   >> Ruport::DataRow.new({ :a => 'moo', :c => 'caw'} , [:a,:b,:c,:d,:e],
+      #   >> Ruport::DataRow.new([:a,:b,:c,:d,:e], 
+      #      :data => { :a => 'moo', :c => 'caw'} ,
       #      :tags => %w[cat dog])
       #   => #<Ruport::DataRow:0xb77c298c @fields=[:a, :b, :c, :d, :e],
       #      @data=["moo", nil, "caw", nil, nil], @tags=["cat", "dog"]>
       #
-      #   >> Ruport::DataRow.new [1,2,3], [:a,:b,:c,:d,:e], :tags => %w[cat dog],
-      #      :filler => 0
+      #   >> Ruport::DataRow.new [:a,:b,:c,:d,:e], :data => [1,2,3], 
+      #      :tags => %w[cat dog], :default => 0
       #   => #<Ruport::DataRow:0xb77bb4d4 @fields=[:a, :b, :c, :d, :e], 
       #       @data=[1, 2, 3, 0, 0], @tags=["cat", "dog"]>
       #
-      def initialize( data, fields, options={} )
+      def initialize(fields, options={})
         
         #checks to ensure data is convertable
-        verify data
-        data = data.dup
+        verify options[:data]
+        data = options[:data].dup
         
         @fields   = fields.dup
         @tags     = (options[:tags] || {}).dup
@@ -63,22 +62,21 @@ module Ruport
         
         nr_action = case(data)
           when Array
-            lambda { |key, index| @data[index] = data.shift || options[:filler] }
+            lambda {|key, index| @data[index] = data.shift || options[:default]}
           when DataRow
-            lambda { |key, index| @data = data.to_a }
+            lambda {|key, index| @data = data.to_a}
           else
-            lambda { |key, index| @data[index] = data[key] || options[:filler] }
+            lambda {|key, index| @data[index] = data[key] || options[:default]}
         end     
-        @fields.each_with_index { |key, index| nr_action.call(key,index) }
+        @fields.each_with_index {|key, index| nr_action.call(key,index)}
       end
 
       
       attr_accessor :fields, :tags
 
-      # Returns an array of values. Should probably return a DataRow.
-      # Loses field information.
+      # Returns a new DataRow
       def +(other)
-        DataRow.new @data + other.to_a, @fields + other.fields
+        DataRow.new @fields + other.fields, :data => (@data + other.to_a)
       end
 
       # Lets you access individual fields
@@ -164,7 +162,7 @@ module Ruport
       end
 
       def clone
-        self.class.new @data, @fields, :tags => @tags
+        self.class.new @fields, :data => @data, :tags => @tags
       end
 
       alias_method :dup, :clone 

data/lib/ruport/data_set.rb

@@ -1,9 +1,11 @@
 # data_set.rb : Ruby Reports core datastructure.
 #
 # Author: Gregory T. Brown (gregory.t.brown at gmail dot com)
-#
 # Copyright (c) 2006, All Rights Reserved.
 #
+# Pseudo keyword argument support, improved <<, and set operations submitted by
+# Dudley Flanders
+#
 # This is free software.  You may modify and redistribute this freely under
 # your choice of the GNU General Public License or the Ruby License. 
 #
@@ -15,42 +17,12 @@ module Ruport
   # and user-defined sets of data.  
   #
   # It is tightly integrated with Ruport's formatting and query systems, so if
-  # you'd like to take advantage of these models, you will probably find DataSet
-  # useful.
-  #
-  # Sample Usage:
-  #
-  #   my_data = [[1,2,3],[4,5,6],[7,8,9]]
-  #
-  #   ds = Ruport::DataSet.new([:col1, :col2, :col3],my_data)
-  #   ds << [ 10, 11, 12]
-  #   ds << { :col3 => 15, :col1 => 13, :col2 => 14 }
-  #   puts ds.select_columns(:col1, :col3).to_csv
-  # 
-  # Output:
-  #   
-  #     col1,col3
-  #     1,3
-  #     4,6
-  #     7,9
-  #     10,12
-  #     13,15
-  #
-  # The wild and crazy might want to try the Array hack:
-  #
-  #   puts [[1,2,3],[4,5,6],[7,8,9]].to_ds(%w[col1 col2 col3])
-  #
-  # Output:
-  #
-  #     fields: ( col1, col2, col3 )
-  #     row0: ( 1, 2, 3 )
-  #     row1: ( 4, 5, 6 )
-  #     row2: ( 7, 8, 9 )
-  #  
+  # you'd like to take advantage of these models, you will probably find 
+  # DataSet useful.
   class DataSet
     #FIXME: Add logging to this class 
     include Enumerable
-    
+    extend Forwardable 
     # DataSets must be given a set of fields to be defined.
     #
     # These field names will define the columns for the DataSet and how you
@@ -58,17 +30,19 @@ module Ruport
     #
     #    data = Ruport::DataSet.new %w[ id name phone ]
     #
-    # You can optionally pass in some content as well. (Must be Enumerable)
+    # Options:
+    # * <tt>:data</tt> - An Enumerable with the content for this DataSet
+    # * <tt>:default</tt> - The default value for empty cells
     #
-    #    content = [ %w[ a1 gregory 203-525-0523 ], 
-    #                %w[ a2 james   555-555-5555 ] ]
     #
-    #    data    = Ruport::DataSet.new(%w[ id name phone],content)
-    def initialize(fields=[], content=nil, default=nil)
+    # DataSet supports the following Array methods through delegators
+    # length, empty?, delete_at, first, last, pop
+    # 
+    def initialize(fields=[], options={})
       @fields = fields
+      @default = options[:default] || default
       @data = []
-      @default = default
-      content.each { |r| self << r } if content
+      options[:data].each { |r| self << r } if options[:data]
     end
     
     #an array which contains column names
@@ -79,35 +53,59 @@ module Ruport
     
     #data holds the elements of the Row
     attr_reader   :data
-   
+    
+    def_delegators :@data, :length, :[], :empty?, 
+                           :delete_at, :first, :last, :pop,
+                           :each, :reverse_each, :at, :clear
+    
+    def delete_if(&block)
+      @data.delete_if &block; self
+    end
+    
     #provides a deep copy of the DataSet. 
     def clone
-      DataSet.new(@fields,@data)
+      self.class.new(@fields, :data => @data)
     end
 
-    #Allows ordinal access to rows
-    #
-    #   my_data[2] -> Ruport::DataRow
-    def [](index)
-      @data[index]
+    # Creates a new DataSet with the same shape as this one, but empty.
+    def empty_clone
+      self.class.new(@fields)
     end
-    
-    #allows setting of rows (providing a DataRow is passed in)
+
+    #allows setting of rows
     def []=(index,data)
-      @data[index] = DataRow.new data, @fields 
+      @data[index] = DataRow.new @fields, :data => data
+    end
+
+    def [](index)
+      case(index)
+      when Range
+        self.class.new @fields, :data => @data[index] 
+      else
+       @data[index]
+      end
     end
 
-    # appends a row to the DataSet
-    # can be added as an array or a keyed hash-like object.
+    # Appends a row to the DataSet
+    # Can be added as an array, an array of DataRows, a DataRow, or a keyed 
+    # hash-like object.
     # 
     # Columns left undefined will be filled with DataSet#default values.
     # 
     #    data << [ 1, 2, 3 ]
     #    data << { :some_field_name => 3, :other => 2, :another => 1 }
     def << ( stuff, filler=@default )
-      @data << DataRow.new(stuff,@fields,:filler => filler); self;  
+      if stuff.kind_of?(DataRow)
+        @data << stuff
+      elsif stuff.kind_of?(Array) && stuff[0].kind_of?(DataRow)
+        @data.concat(stuff)
+      else
+        @data << DataRow.new(@fields, :data => stuff,:default => filler)
+      end
+	    return self
     end
-
+    alias_method :push, :<<
+    
     # checks if one dataset equals another
     # FIXME: expand this doc.
     def eql?(data2)
@@ -127,10 +125,38 @@ module Ruport
       eql?(data2)
     end
 
-    # Returns true if DataSet contains no rows, false otherwise.
-    def empty?
-      return @data.empty?
+    # Set union - returns a DataSet with the elements that are contained in
+    # in either of the two given sets, with no duplicates.
+    def |(other)
+      clone << other.reject { |x| self.include? x }
+    end 
+    alias_method :union, :|
+
+    # Set intersection
+    def &(other)
+      empty_clone << select { |x| other.include? x }
+    end
+    alias_method :intersection, :&
+    
+    # Set difference
+    def -(other)
+      empty_clone << reject { |x| other.include? x }      
+    end
+    alias_method :difference, :- 
+
+    # Checks if one DataSet has the same set of fields as another
+    def shaped_like?(other)
+      return true if @fields.eql?(other.fields)
+    end
+
+    # Concatenates one DataSet onto another if they have the same shape
+    def concat(other)      
+      if other.shaped_like?(self)
+        @data.concat(other.data) 
+        return self
+      end
     end
+    alias_method :+, :concat
 
     # Allows loading of CSV files or YAML dumps. Returns a DataSet
     #
@@ -139,34 +165,44 @@ module Ruport
     #   my_data = Ruport::DataSet.load("foo.csv")
     #   my_data = Ruport::DataSet.load("foo.yaml")
     #   my_data = Ruport::DataSet.load("foo.yml")
-    def self.load ( source, default="")
+    def self.load ( source, default="", &block)
       case source
       when /\.(yaml|yml)/
         return YAML.load(File.open(source))
       when /\.csv/ 
-        csv_klass = defined?(FasterCSV) ? FasterCSV : CSV
-        input = csv_klass.read(source) if source =~ /\.csv/
+        require "fastercsv"
+        input = FasterCSV.read(source) if source =~ /\.csv/
         loaded_data = self.new
+        
+        action = if block_given? 
+          lambda { |r| block[loaded_data,r] }
+        else 
+          lambda { |r| loaded_data << r } 
+        end
+        
         loaded_data.fields = input[0]
         loaded_data.default = default
-        input[1..-1].each { |row| loaded_data << row }
+        input[1..-1].each { |row| action[row] }
         return loaded_data	
       else
         raise "Invalid file type"
       end
     end
    
-    # Iterates through the rows, yielding a DataRow for each.
-    def each(&action)
-      @data.each(&action)
-    end
 
     # Returns a new DataSet composed of the fields specified.
     def select_columns(*fields)
       rows = fields.inject([]) { |s,e| s << map { |row| row[e] } }.transpose
-      my_data = DataSet.new(fields,rows)
+      my_data = DataSet.new(fields, :data => rows)
     end
     
+    # Prunes the dataset to contain only the fields specified. (DESTRUCTIVE)
+    def select_columns!(*fields)
+       a = select_columns(*fields)
+       @fields = a.fields; @data   = a.data
+    end
+      
+    
     # Returns a new DataSet with the specified fields removed
     def remove_columns(*fields)
       select_columns(*(@fields-fields))
@@ -193,10 +229,9 @@ module Ruport
     #
     # This will enable <tt>data.as(:my_format_name)</tt>
     def as(format,&action)
-      builder = Format::Builder.new( self )
-      builder.format = format
-      action.call(builder) if block_given?
-      builder.render
+      t = Format.table_object(:data => clone, :plugin => format)
+      action.call(t) if block_given?
+      t.render
     end
     
     # Will iterate row by row yielding each row
@@ -210,6 +245,11 @@ module Ruport
     end
     
     alias_method :sum, :sigma
+
+    # Converts a DataSet to an array of arrays 
+    def to_a
+      @data.map {|x| x.to_a }
+    end
          
     # Converts a DataSet to CSV
     def to_csv; as(:csv) end
@@ -219,11 +259,6 @@ module Ruport
     
     # Readable string representation of the DataSet
     def to_s; as(:text) end
-
-    def clone
-      self.class.new @fields.dup, @data.dup, @default 
-    end
-
     
   end
 end
@@ -232,8 +267,7 @@ class Array
   
   # Will convert Arrays of Enumerable objects to DataSets. 
   # May have dragons.
-  def to_ds(fields,default=nil)
-    Ruport::DataSet.new(fields,to_a,default)
-  end
- 
+  def to_ds(fields,options={})
+    Ruport::DataSet.new fields, :data => to_a, :default => options[:default]
+  end 
 end

data/lib/ruport/format.rb

@@ -112,22 +112,15 @@ module Ruport
     # Processes the ERB text in <tt>@content</tt> in the context
     # of the object that Format is bound to.
     def filter_erb  
-      ERB.new(@content).result(@binding)
+      self.class.document :data => @content, 
+                          :klass_binding => @binding,
+                          :plugin => :text
     end
     
     # Processes the RedCloth text in <tt>@content</tt> in the context
     # of the object that Format is bound to.
     def filter_red_cloth
-      require "redcloth"
-      RedCloth.new(@content).to_html
-    end
-    
-    # Processes the ruby code in <tt>@content</tt> in the context
-    # of the object that Format is bound to.
-    #
-    # (Does an eval on the binding)
-    def filter_ruby
-      eval(@content,@binding)
+      self.class.document :data => @content, :plugin => :html
     end
     
     # Takes a name and a block and creates a filter method

data/lib/ruport/format/engine.rb

@@ -120,6 +120,7 @@ module Ruport
       attr_accessor :erb_enabled
       
       def apply_red_cloth
+        require "redcloth"
         active_plugin.data = RedCloth.new(active_plugin.data).to_html
       end
 

data/lib/ruport/format/plugin.rb

@@ -60,6 +60,11 @@ module Ruport
     end
 
     class TextPlugin < Format::Plugin
+      
+      rendering_options :erb_enabled => true, :red_cloth_enabled => false
+
+      renderer :document
+      
       renderer :table do
         data.inject(rendered_field_names){ |s,r| 
           s << "   #{r.to_a.join(' | ')}   \n"
@@ -70,6 +75,7 @@ module Ruport
       end
 
       register_on :table_engine
+      register_on :document_engine
     end
 
     class PDFPlugin < Format::Plugin
@@ -98,13 +104,13 @@ module Ruport
    
       rendering_options :red_cloth_enabled => true, :erb_enabled => true
       
-      renderer :document
+      renderer :document 
       
       renderer :table do
         rc = data.inject(rendered_field_names) { |s,r| 
           s << "|#{r.to_a.join('|')}|\n" 
         }
-        Format.document :data => rc, :output_type => :html 
+        Format.document :data => rc, :plugin => :html 
       end
 
       format_field_names do

data/test/tc_builder.rb

@@ -23,7 +23,7 @@ class TestBuilder < Test::Unit::TestCase
     end
 
     assert_equal(DataSet.new( %w[ col1 col2 col3 ], 
-                              [ %w[ a b c ], %w[ d e f ]]),
+                              :data => [ %w[ a b c ], %w[ d e f ]]),
                               @builder.render_data_snatcher)
     
   end

data/test/tc_data_row.rb

@@ -33,10 +33,10 @@ class TestDataRow < Test::Unit::TestCase
   end
 
   def test_constructor
-    row  = Ruport::DataRow.new([1,2,3],%w[a b c])
-    row2 = Ruport::DataRow.new({"a" => 1, "b" => 2, "c" => 3}, %w[a b c])
-    row3 = Ruport::DataRow.new(row2, %w[ a b c])
-    row4 = Ruport::DataRow.new(row3, %w[ a b c], :tags => [:awesome, :cool])
+    row  = Ruport::DataRow.new(%w[a b c], :data => [1,2,3])
+    row2 = Ruport::DataRow.new(%w[a b c], :data => {"a" => 1, "b" => 2, "c" => 3})
+    row3 = Ruport::DataRow.new(%w[a b c], :data => row2)
+    row4 = Ruport::DataRow.new(%w[a b c], {:data => row3, :tags => [:awesome, :cool]})
     
     assert_equal(row, row2)
     assert_equal(row2, row3)
@@ -76,29 +76,29 @@ class TestDataRow < Test::Unit::TestCase
   end
 
   def test_equality
-    assert( Ruport::DataRow.new([1,2], %w[ a b ]) == 
-            Ruport::DataRow.new([1,2], %w[ a b ]) )
-    assert( Ruport::DataRow.new([1,2], %w[ a b ]) !=
-            Ruport::DataRow.new([1,2], %w[ c d ]) )
-    a = Ruport::DataRow.new([1,2,3], %w[ a b c ])
+    assert( Ruport::DataRow.new(%w[ a b ], :data => [1,2]) == 
+            Ruport::DataRow.new(%w[ a b ], :data => [1,2]) )
+    assert( Ruport::DataRow.new(%w[ a b ], :data => [1,2]) !=
+            Ruport::DataRow.new(%w[ c d ], :data => [1,2]) )
+    a = Ruport::DataRow.new(%w[ a b c ], :data => [1,2,3])
     a.tag_as :apple
-    b = Ruport::DataRow.new([1,2,3], %w[ a b c ])
+    b = Ruport::DataRow.new(%w[ a b c ], :data => [1,2,3])
     assert( a == b )
     assert( a.eql?(b) )
 
   end
   
   def test_addition
-    row1  = Ruport::DataRow.new [1,2,3], %w[ a b c ]
-    row2 = Ruport::DataRow.new [4,5,6], %w[ d e f ]
+    row1  = Ruport::DataRow.new %w[ a b c ], :data => [1,2,3]
+    row2 = Ruport::DataRow.new %w[ d e f ], :data => [4,5,6]
     
-    expected = Ruport::DataRow.new [1,2,3,4,5,6], %w[ a b c d e f ]
+    expected = Ruport::DataRow.new %w[ a b c d e f ], :data => [1,2,3,4,5,6]
     
     assert_equal( expected, row1 + row2 ) 
   end
   
   def test_clone 
-    row1 = Ruport::DataRow.new [1,2,3], %w[ a b c ]
+    row1 = Ruport::DataRow.new %w[ a b c ], :data => [1,2,3]
     row2 = row1.clone
 
     assert( row1.object_id != row2.object_id )
@@ -109,14 +109,14 @@ class TestDataRow < Test::Unit::TestCase
 
   #FIXME: add edge cases
   def test_to_h
-    row1 = Ruport::DataRow.new [1,2,3], %w[ a b c ]
+    row1 = Ruport::DataRow.new %w[ a b c ], :data => [1,2,3]
     assert_instance_of(Hash,row1.to_h)
     assert_equal({ "a" => 1, "b" => 2, "c" => 3},row1.to_h)
   end
 
   def test_ensure_arrays_not_modified
     arr = [1,2,3]
-    row1 = Ruport::DataRow.new arr, %w[ a b c ]
+    row1 = Ruport::DataRow.new %w[ a b c ], :data => arr
     assert_equal( [1,2,3], arr )
   end
 

data/test/tc_data_set.rb

@@ -11,8 +11,7 @@ class TestDataSet < Test::Unit::TestCase
     @data = DataSet.new
     @data.fields = %w[ col1 col2 col3 ]
     @data.default = ""
-    @data << %w[ a b c ]
-    @data << { "col1" => "d", "col3" => "e"}
+    @data << %w[ a b c ] << { "col1" => "d", "col3" => "e"}
   end
 
   def test_new
@@ -20,14 +19,14 @@ class TestDataSet < Test::Unit::TestCase
     my_data = DataSet.new(fields)
     assert_equal(fields,my_data.fields)
 
-    my_filled_data = DataSet.new( fields, [[1,2,3],[4,5,6]] )
+    my_filled_data = DataSet.new( fields, :data => [[1,2,3],[4,5,6]] )
     
     assert_equal( [[1,2,3],[4,5,6]], my_filled_data.map { |r| r.to_a } )
 
     hash_filling = [ { "col1" => 9, "col2" => 6, "col3" => 0 },
                      { "col1" => 54, "col3" => 1 } ]
     
-    my_filled_data = DataSet.new(fields,hash_filling)
+    my_filled_data = DataSet.new(fields, :data => hash_filling)
     
     assert_equal( [[9,6,0],[54,nil,1]], my_filled_data.map { |r| r.to_a } )
    
@@ -46,6 +45,11 @@ class TestDataSet < Test::Unit::TestCase
     assert_equal(  ['x','x','x'],
                     @data[2].to_a )
   end
+
+  def test_delete_if
+    @data.delete_if { |r| r.any? { |e| e.empty? } }
+    assert_equal([%w[a b c]],@data.to_a)
+  end
       
   def test_brackets
     row0 = { "col1" => "a", "col2" => "b", "col3" => "c" }
@@ -77,6 +81,71 @@ class TestDataSet < Test::Unit::TestCase
     assert(@data.eql?(data2) && data2.eql?(@data)) 
   end
 
+  def test_shaped_like?
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    assert(@data.shaped_like?(a))
+    assert(a.shaped_like?(@data))
+  end
+ 
+  def test_union
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ a b c ]
+    a << %w[ x y z ]
+    b = a | @data
+    assert_kind_of(DataSet, b)
+    assert_equal(b.data.length, 3)
+    assert_equal([ %w[a b c], %w[x y z], ["d","","e"] ], b.to_a)
+    assert_equal((a | @data), a.union(@data))
+  end
+
+  def test_difference
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ a b c ]
+    a << %w[ x y z ]
+    b = a - @data
+    assert_kind_of(DataSet, b)
+    assert_equal(b.data.length, 1)
+    assert_equal([ %w[x y z] ], b.to_a)
+    assert_equal((a - @data), a.difference(@data))
+  end
+  
+  def test_intersection
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ a b c ]
+    a << %w[ x y z ]
+    b = a & @data
+    assert_kind_of(DataSet, b)
+    assert_equal(b.data.length, 1)
+    assert_equal([ %w[a b c] ], b.to_a)
+    assert_equal((a & @data), a.intersection(@data))
+  end
+
+  def test_concatenation
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ x y z ]
+    newdata = @data.concat(a)
+    assert_equal([ %w[a b c], ["d","","e"], %w[x y z] ], newdata.to_a)
+  end
+  
+  def test_append_datarow
+    row = DataRow.new(%w[ x y z ], :data => %w[ col1 col2 col3 ])
+    @data << row
+    assert_equal(@data[2], row)
+  end
+
+  def test_append_datarows
+    row = DataRow.new(%w[ x y z ], :data => %w[ col1 col2 col3 ])
+    row2 = DataRow.new(%w[ u v w ], :data => %w[ col1, col2, col3 ])
+    @data << [row, row2]
+    assert_equal(@data[2], row)
+    assert_equal(@data[3], row2)
+  end
+  
   def test_empty?
     a = DataSet.new
     a.fields = %w[a b c]
@@ -87,14 +156,20 @@ class TestDataSet < Test::Unit::TestCase
     assert_equal(false,a.empty?)
   end
 
+  def test_length
+    assert_equal(2, @data.length)
+    @data << [1,2,3]
+    assert_equal(3, @data.length)
+  end
+
   def test_load
     loaded_data = DataSet.load("test/samples/data.csv")
-    @data.each_with_index do |row,r_index|
-      row.each_with_index do |field,f_index|
-        assert_equal(field,loaded_data[r_index][f_index])
-      end
+    assert_equal(@data,loaded_data)
+
+    loaded_data = DataSet.load("test/samples/data.csv") do |set,row| 
+      set << row if row.include? 'b' 
     end
-    #FIXME: add error edges
+    assert_equal([%w[a b c]],loaded_data.to_a)
   end
 
   def test_to_csv
@@ -104,11 +179,11 @@ class TestDataSet < Test::Unit::TestCase
   end
 
   def test_to_html
-    assert_equal("<table>\n  <tr>\n    <th>col1</th><th>col2</th>" +
-                 "<th>col3</th>\n  </tr>\n" +
-                 "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                 "  <tr>\n    <td>d</td><td></td><td>e</td>\n  </tr>\n" +
-                 "</table>", @data.to_html )
+    assert_equal("<table>\n\t\t<tr>\n\t\t\t<th>col1 </th>\n\t\t\t"+
+                 "<th>col2 </th>\n\t\t\t<th>col3</th>\n\t\t</tr>\n"+
+                 "\t\t<tr>\n\t\t\t<td>a</td>\n\t\t\t<td>b</td>\n\t\t\t"+
+                 "<td>c</td>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>d</td>\n\t"+
+                 "\t\t<td>e</td>\n\t\t</tr>\n\t</table>", @data.to_html )
   end
 
   def test_select_columns
@@ -123,6 +198,27 @@ class TestDataSet < Test::Unit::TestCase
     assert_equal( [["c","a"],["e","d"]],
                   @data.select_columns("col3","col1").map { |r| r.to_a } )
   end
+ 
+  def test_select_columns!
+    a = [[1,2],[3,4]].to_ds(%w[a b])
+    a.select_columns!(*%w[b a])
+
+    assert_equal(%w[b a],a.fields)
+    assert_equal([[2,1],[4,3]],a.to_a)
+
+    a.select_columns!('a')
+
+    assert_equal(%w[a], a.fields)
+    assert_equal([[1],[3]],a.to_a)
+
+    a.select_columns!('a','q')
+    assert_equal(%w[a q], a.fields)
+    assert_equal([[1,nil],[3,nil]],a.to_a)
+
+    a[0]['q'] =2
+    assert_equal([[1,2],[3,nil]],a.to_a)
+    
+  end
 
   def test_as
     data = DataSet.new
@@ -132,15 +228,16 @@ class TestDataSet < Test::Unit::TestCase
     assert_equal("col1,col2,col3\na,b,c\nd,e,f\n", 
                  data.as(:csv) )
 
-    assert_equal("<table>\n  <tr>\n    <th>col1</th><th>col2</th>" +
-                 "<th>col3</th>\n  </tr>\n" +
-                 "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                 "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                 "</table>", data.as(:html) )
+    assert_equal("<table>\n\t\t<tr>\n\t\t\t<th>col1 </th>"+
+                 "\n\t\t\t<th>col2 </th>\n\t\t\t<th>col3</th>"+
+                 "\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>a</td>\n\t\t\t"+
+                 "<td>b</td>\n\t\t\t<td>c</td>\n\t\t</tr>\n\t\t<tr>"+
+                 "\n\t\t\t<td>d</td>\n\t\t\t<td>e</td>\n\t\t\t<td>f</td>"+
+                 "\n\t\t</tr>\n\t</table>", data.as(:html) )
   end
   
   def test_sigma
-    data = Ruport::DataSet.new(%w[x],[[3],[5],[8],[2]])
+    data = Ruport::DataSet.new(%w[x], :data => [[3],[5],[8],[2]])
     
     sum = data.sigma { |r| r["x"] if (r["x"] % 2).zero? }
     assert_equal(10, sum)
@@ -164,11 +261,11 @@ class TestDataSet < Test::Unit::TestCase
   end
 
   def test_bracket_equals
-    expected = DataRow.new(%w[apple banana orange], %w[col1 col2 col3])
+    expected = DataRow.new(%w[col1 col2 col3], :data => %w[apple banana orange])
     
     raw = [ %w[apple banana orange],
             { "col1" => "apple", "col2" => "banana", "col3" => "orange" },
-            DataRow.new(%w[apple banana orange], %w[col1 col2 col3])
+            DataRow.new(%w[col1 col2 col3], :data => %w[apple banana orange])
           ]
     raw.each do |my_row|
       @data[1] = my_row
@@ -205,17 +302,17 @@ class TestDataSet < Test::Unit::TestCase
      [1,2,3].to_ds(%w[foo bar soup])
     }
 
-    assert_equal( DataSet.new(%w[a b], [[1,2],[3,4]]),
+    assert_equal( DataSet.new(%w[a b], :data => [[1,2],[3,4]]),
                   [[1,2],[3,4]].to_ds(%w[a b]) )
 
-    assert_equal( DataSet.new(%w[a b], [{ "a" => 1 },{ "b" => 2}]),
+    assert_equal( DataSet.new(%w[a b], :data => [{ "a" => 1 },{ "b" => 2}]),
                   [{"a" => 1}, {"b" => 2}].to_ds(%w[a b]) )
-    assert_equal( DataSet.new(%w[a b], [DataRow.new([1,2],%w[a b])]),
-                  [DataRow.new([1,2],%w[a b])].to_ds(%w[a b]) )
+    assert_equal( DataSet.new(%w[a b], :data => [DataRow.new(%w[a b], :data => [1,2])]),
+                  [DataRow.new(%w[a b], :data => [1,2])].to_ds(%w[a b]) )
    
    # FIXME: Decide whether this test should pass or fail.               
-   #  assert_equal( DataSet.new(%w[a b], [DataRow.new([1,2],%w[a b])]),
-   #               [DataRow.new([1,2],%w[a q])].to_ds(%w[a b]) ) 
+   #  assert_equal( DataSet.new(%w[a b], [DataRow.new(%w[a b], [1,2])]),
+   #               [DataRow.new(%w[a q], [1,2])].to_ds(%w[a b]) ) 
     
   end
 

data/test/tc_data_set.rb~

@@ -0,0 +1,326 @@
+#!/usr/local/bin/ruby -w
+
+require "test/unit"
+require "ruport"
+
+class TestDataSet < Test::Unit::TestCase
+  
+  include Ruport
+    
+  def setup
+    @data = DataSet.new
+    @data.fields = %w[ col1 col2 col3 ]
+    @data.default = ""
+    @data << %w[ a b c ] << { "col1" => "d", "col3" => "e"}
+  end
+
+  def test_new
+    fields = %w[ col1 col2 col3 ]
+    my_data = DataSet.new(fields)
+    assert_equal(fields,my_data.fields)
+
+    my_filled_data = DataSet.new( fields, :content => [[1,2,3],[4,5,6]] )
+    
+    assert_equal( [[1,2,3],[4,5,6]], my_filled_data.map { |r| r.to_a } )
+
+    hash_filling = [ { "col1" => 9, "col2" => 6, "col3" => 0 },
+                     { "col1" => 54, "col3" => 1 } ]
+    
+    my_filled_data = DataSet.new(fields, :content => hash_filling)
+    
+    assert_equal( [[9,6,0],[54,nil,1]], my_filled_data.map { |r| r.to_a } )
+   
+    cloned_set = @data.clone
+   
+    assert_equal( [ %w[a b c], ["d","","e"] ], cloned_set.map { |r| r.to_a } )
+  end
+  
+  def test_fields 
+    assert_equal(%w[ col1 col2 col3 ], @data.fields )
+  end
+
+  def test_default
+    @data.default = "x"
+    @data << { }
+    assert_equal(  ['x','x','x'],
+                    @data[2].to_a )
+  end
+
+  def test_delete_if
+    @data.delete_if { |r| r.any? { |e| e.empty? } }
+    assert_equal([%w[a b c]],@data.to_a)
+  end
+      
+  def test_brackets
+    row0 = { "col1" => "a", "col2" => "b", "col3" => "c" }
+    row1 = { "col1" => "d", "col2" => "", "col3" => "e" }
+    row0.each do |key,value|
+      assert_equal( value, @data[0][key] )
+    end
+    row1.each do |key,value|
+      assert_equal( value, @data[1][key] )
+    end       
+  end
+
+  def test_eql?
+    data2 = DataSet.new
+    data2.fields = %w[ col1 col2 col3 ]
+    data2.default = ""
+    data2 << %w[ a b c ]
+    data2 << { "col1" => "d", "col3" => "e" }
+
+    #FIXME: This looks like some shady discrete math assignment
+    assert(@data.eql?(data2) && data2.eql?(@data)) 
+    data2 << [2, 3, 4]
+    assert(!( @data.eql?(data2) || data2.eql?(@data) ))
+    @data << [2, 3, 4]
+    assert(@data.eql?(data2) && data2.eql?(@data))
+    @data << [8, 9, 10]
+    assert(!( @data.eql?(data2) || data2.eql?(@data) ))
+    data2 << [8, 9, 10]
+    assert(@data.eql?(data2) && data2.eql?(@data)) 
+  end
+
+  def test_shaped_like?
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    assert(@data.shaped_like?(a))
+    assert(a.shaped_like?(@data))
+  end
+ 
+  def test_union
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ a b c ]
+    a << %w[ x y z ]
+    b = a | @data
+    assert_kind_of(DataSet, b)
+    assert_equal(b.data.length, 3)
+    assert_equal([ %w[a b c], %w[x y z], ["d","","e"] ], b.to_a)
+    assert_equal((a | @data), a.union(@data))
+  end
+
+  def test_difference
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ a b c ]
+    a << %w[ x y z ]
+    b = a - @data
+    assert_kind_of(DataSet, b)
+    assert_equal(b.data.length, 1)
+    assert_equal([ %w[x y z] ], b.to_a)
+    assert_equal((a - @data), a.difference(@data))
+  end
+  
+  def test_intersection
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ a b c ]
+    a << %w[ x y z ]
+    b = a & @data
+    assert_kind_of(DataSet, b)
+    assert_equal(b.data.length, 1)
+    assert_equal([ %w[a b c] ], b.to_a)
+    assert_equal((a & @data), a.intersection(@data))
+  end
+
+  def test_concatenation
+    a = DataSet.new
+    a.fields = %w[ col1 col2 col3 ]
+    a << %w[ x y z ]
+    newdata = @data.concat(a)
+    assert_equal([ %w[a b c], ["d","","e"], %w[x y z] ], newdata.to_a)
+  end
+  
+  def test_append_datarow
+    row = DataRow.new(%w[ x y z ],%w[ col1 col2 col3 ])
+    @data << row
+    assert_equal(@data[2], row)
+  end
+
+  def test_append_datarows
+    row = DataRow.new(%w[ x y z ],%w[ col1 col2 col3 ])
+    row2 = DataRow.new(%w[ u v w ], %w[ col1, col2, col3 ])
+    @data << [row, row2]
+    assert_equal(@data[2], row)
+    assert_equal(@data[3], row2)
+  end
+  
+  def test_empty?
+    a = DataSet.new
+    a.fields = %w[a b c]
+    assert_equal(true,a.empty?)
+    assert_equal(false,@data.empty?)
+    
+    a << [1,2,3]
+    assert_equal(false,a.empty?)
+  end
+
+  def test_length
+    assert_equal(2, @data.length)
+    @data << [1,2,3]
+    assert_equal(3, @data.length)
+  end
+
+  def test_load
+    loaded_data = DataSet.load("test/samples/data.csv")
+    assert_equal(@data,loaded_data)
+
+    loaded_data = DataSet.load("test/samples/data.csv") do |set,row| 
+      set << row if row.include? 'b' 
+    end
+    assert_equal([%w[a b c]],loaded_data.to_a)
+  end
+
+  def test_to_csv
+    loaded_data = DataSet.load("test/samples/data.csv" )
+    csv = loaded_data.to_csv
+    assert_equal("col1,col2,col3\na,b,c\nd,\"\",e\n",csv)
+  end
+
+  def test_to_html
+    assert_equal("<table>\n\t\t<tr>\n\t\t\t<th>col1 </th>\n\t\t\t"+
+                 "<th>col2 </th>\n\t\t\t<th>col3</th>\n\t\t</tr>\n"+
+                 "\t\t<tr>\n\t\t\t<td>a</td>\n\t\t\t<td>b</td>\n\t\t\t"+
+                 "<td>c</td>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>d</td>\n\t"+
+                 "\t\t<td>e</td>\n\t\t</tr>\n\t</table>", @data.to_html )
+  end
+
+  def test_select_columns
+    assert_equal( [["a"],["d"]],
+                  @data.select_columns("col1").map { |r| r.to_a } )
+    assert_equal( [["b"],[""]] , 
+                  @data.select_columns("col2").map { |r| r.to_a } )
+    assert_equal( [["c"],["e"]],
+                  @data.select_columns("col3").map { |r| r.to_a } )
+    assert_equal( [["a","b","c"],["d","","e"]],
+                  @data.select_columns("col1","col2","col3").map { |r| r.to_a })
+    assert_equal( [["c","a"],["e","d"]],
+                  @data.select_columns("col3","col1").map { |r| r.to_a } )
+  end
+ 
+  def test_select_columns!
+    a = [[1,2],[3,4]].to_ds(%w[a b])
+    a.select_columns!(*%w[b a])
+
+    assert_equal(%w[b a],a.fields)
+    assert_equal([[2,1],[4,3]],a.to_a)
+
+    a.select_columns!('a')
+
+    assert_equal(%w[a], a.fields)
+    assert_equal([[1],[3]],a.to_a)
+
+    a.select_columns!('a','q')
+    assert_equal(%w[a q], a.fields)
+    assert_equal([[1,nil],[3,nil]],a.to_a)
+
+    a[0]['q'] =2
+    assert_equal([[1,2],[3,nil]],a.to_a)
+    
+  end
+
+  def test_as
+    data = DataSet.new
+    data.fields = %w[ col1 col2 col3]
+    data << %w[ a b c]
+    data << %w[ d e f]
+    assert_equal("col1,col2,col3\na,b,c\nd,e,f\n", 
+                 data.as(:csv) )
+
+    assert_equal("<table>\n\t\t<tr>\n\t\t\t<th>col1 </th>"+
+                 "\n\t\t\t<th>col2 </th>\n\t\t\t<th>col3</th>"+
+                 "\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>a</td>\n\t\t\t"+
+                 "<td>b</td>\n\t\t\t<td>c</td>\n\t\t</tr>\n\t\t<tr>"+
+                 "\n\t\t\t<td>d</td>\n\t\t\t<td>e</td>\n\t\t\t<td>f</td>"+
+                 "\n\t\t</tr>\n\t</table>", data.as(:html) )
+  end
+  
+  def test_sigma
+    data = Ruport::DataSet.new(%w[x], :content => [[3],[5],[8],[2]])
+    
+    sum = data.sigma { |r| r["x"] if (r["x"] % 2).zero? }
+    assert_equal(10, sum)
+
+    sum = data.sigma { |r| r["x"] }
+    assert_equal(18,sum)
+
+    #check alias
+    sum = data.sum { |r| r["x"] }
+    assert_equal(18,sum)
+    
+  end
+
+  def test_remove_columns
+   data = @data.remove_columns("col1","col3")
+   assert_equal(["col2"],data.fields)
+
+   data.remove_columns!("col2")
+   assert_equal([],data.fields)
+   assert(data.empty?)
+  end
+
+  def test_bracket_equals
+    expected = DataRow.new(%w[apple banana orange], %w[col1 col2 col3])
+    
+    raw = [ %w[apple banana orange],
+            { "col1" => "apple", "col2" => "banana", "col3" => "orange" },
+            DataRow.new(%w[apple banana orange], %w[col1 col2 col3])
+          ]
+    raw.each do |my_row|
+      @data[1] = my_row
+      assert_instance_of(DataRow, @data[1])
+      assert_equal(expected, @data[1])
+    end
+
+    assert_raise(ArgumentError) { @data[1] = "apple" }
+  end
+ 
+  def test_clone
+    data2 = @data.clone
+    assert( @data.object_id != data2.object_id )
+    assert_equal( @data, data2 )
+    data2 << %w[ f o o ]
+    assert( @data != data2 )
+    assert( data2 != @data )
+  end
+
+  def test_array_hack
+    assert_nothing_raised {
+      [ { :a => :b, :c => :d }, { :e => :f, :g => :h } ].to_ds(%w[a e])
+    }
+    assert_nothing_raised {
+      [ [1,2,3], [4,5,6], [7,8,9] ].to_ds(%w[a b c])
+    }
+    assert_raise(ArgumentError) {
+     %w[d e f].to_ds(%w[a b c])
+    }
+    assert_raise(ArgumentError) {
+     [:foo,:bar,:dog].to_ds(%w[tree cat animal])
+    }
+    assert_raise(ArgumentError) {
+     [1,2,3].to_ds(%w[foo bar soup])
+    }
+
+    assert_equal( DataSet.new(%w[a b], :content => [[1,2],[3,4]]),
+                  [[1,2],[3,4]].to_ds(%w[a b]) )
+
+    assert_equal( DataSet.new(%w[a b], :content => [{ "a" => 1 },{ "b" => 2}]),
+                  [{"a" => 1}, {"b" => 2}].to_ds(%w[a b]) )
+    assert_equal( DataSet.new(%w[a b], :content => [DataRow.new([1,2],%w[a b])]),
+                  [DataRow.new([1,2],%w[a b])].to_ds(%w[a b]) )
+   
+   # FIXME: Decide whether this test should pass or fail.               
+   #  assert_equal( DataSet.new(%w[a b], [DataRow.new([1,2],%w[a b])]),
+   #               [DataRow.new([1,2],%w[a q])].to_ds(%w[a b]) ) 
+    
+  end
+
+  def test_append_chain
+    data2 = DataSet.new(%w[col1 col2 col3])
+    data2.default=""
+    data2 << %w[ a b c ] << { "col1" => "d", "col3" => "e" }
+    assert_equal @data, data2
+  end
+          
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruport
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
-date: 2006-06-06 00:00:00 -04:00
+  version: 0.4.5
+date: 2006-06-09 00:00:00 -04:00
 summary: A generalized Ruby report generation and templating engine.
 require_paths: 
 - lib
@@ -28,11 +28,11 @@ cert_chain:
 authors: 
 - Gregory Brown
 files: 
+- examples/fieldless_table.rb
 - examples/line_plotter.rb
 - examples/pdf.rb
 - examples/long.txt
 - examples/new_plugin.rb
-- examples/fieldless_table.rb
 - lib/ruport
 - lib/ruport.rb
 - lib/ruport/query
@@ -53,12 +53,12 @@ files:
 - lib/ruport/format/plugin.rb
 - lib/ruport/report/mailer.rb
 - test/samples
+- test/tc_format_engine.rb
 - test/tc_element.rb
 - test/tc_format.rb
 - test/ts_all.rb
 - test/tc_data_row.rb
 - test/tc_ruport.rb
-- test/unit.log
 - test/tc_section.rb
 - test/tc_database.rb
 - test/tc_query.rb
@@ -73,7 +73,7 @@ files:
 - test/tc_state.rb
 - test/tc_data_set.rb
 - test/tc_builder.rb
-- test/tc_format_engine.rb
+- test/tc_data_set.rb~
 - test/tc_plugin.rb
 - test/samples/five_paragraphs.txt
 - test/samples/ross_report.txt

data/test/unit.log

@@ -1,8 +0,0 @@
-# Logfile created on Tue Jun 06 00:16:40 EDT 2006 by logger.rb/1.5.2.7
-F, [2006-06-06T00:16:40.836111 #10456] FATAL -- : Missing host for mailer bar
-F, [2006-06-06T00:16:40.837386 #10456] FATAL -- : Missing DSN for source foo!
-F, [2006-06-06T00:16:40.855495 #10456] FATAL -- : Cannot convert data to DataRow
-F, [2006-06-06T00:16:40.855965 #10456] FATAL -- : Cannot convert data to DataRow
-F, [2006-06-06T00:16:40.856380 #10456] FATAL -- : Cannot convert data to DataRow
-F, [2006-06-06T00:16:40.859864 #10456] FATAL -- : Cannot convert data to DataRow
-F, [2006-06-06T00:16:40.915668 #10456] FATAL -- : no block given!