rubyexcel 0.0.9 → 0.1.0

data/lib/README.md

@@ -3,13 +3,19 @@ RubyExcel
 
 Designed for Ruby on Windows with MS Excel
 
-Please feel free to log any bugs you find [here](https://github.com/VirtuosoJoel/RubyExcel/issues "Bug Tracker").
-
 Introduction
 ------------
 
 A Data-analysis tool for Ruby, with an Excel-style API.
 
+You can find the gem [here](https://rubygems.org/gems/rubyexcel "Rubygems").
+
+Main Documentation is [here](rubydoc.info/gems/rubyexcel "Rubydoc")
+
+For any requests, comments, etc. I keep an eye on [This forum](http://www.ruby-forum.com/forum/ruby "Ruby Mailing List"). If you have "RubyExcel" in the title I should see it.
+
+Please feel free to log any bugs you find [here](https://github.com/VirtuosoJoel/RubyExcel/issues "Bug Tracker").
+
 Details
 -----
 
@@ -36,7 +42,7 @@ As this works directly on the data, processing is faster than using Excel itself
 This was written out of the frustration of editing tabular data using Ruby's multidimensional arrays,
 without affecting headers and while maintaining code readability.
 Its API is designed to simplify moving code across from VBA into Ruby format when processing spreadsheet data.
-The combination of Ruby, WIN32OLE Excel, and extracting HTML table data is probably quite rare; but I thought I'd share what I came up with.
+The combination of Ruby, WIN32OLE Excel, and analysing table data is probably quite rare; but I thought I'd share what I came up with.
 
 Examples
 ========

data/lib/rubyexcel/data.rb

@@ -5,6 +5,8 @@ require_relative 'address.rb'
   #
   # The class which holds a Sheet's data
   #
+  # @note This class is exposed to the API purely for debugging.
+  #
 
   class Data
     include Address
@@ -71,24 +73,15 @@ require_relative 'address.rb'
     #
     # Returns a copy of the data
     #
+    # @return [Array<Array>]
+    #
     
     def all
       @data.dup
     end
-    
-    #
-    # Appends a multidimensional Array to the end of the data
-    #
-    # @param [Array<Array>] multi_array the multidimensional Array to add to the data
-    #
-    
-    def append( multi_array )
-      @data << multi_array
-      calc_dimensions
-    end
-    
+ 
     #
-    # Finds a Column reference bu a header
+    # Finds a Column reference by a header
     #
     # @param [String] header the header to search for
     # @return [String] the Column reference
@@ -162,7 +155,6 @@ require_relative 'address.rb'
     
     def delete_column( ref )
       delete( Column.new( sheet, ref ) )
-      calc_dimensions
     end
   
     #
@@ -171,7 +163,6 @@ require_relative 'address.rb'
   
     def delete_row( ref )
       delete( Row.new( sheet, ref ) )
-      calc_dimensions
     end
     
     #
@@ -180,7 +171,6 @@ require_relative 'address.rb'
     
     def delete_range( ref )
       delete( Element.new( sheet, ref ) )
-      calc_dimensions
     end
     
     #
@@ -194,7 +184,7 @@ require_relative 'address.rb'
     end
     
     #
-    # Check whether the data is empty
+    # Check whether the data (without headers) is empty
     #
     # @return [Boolean]
     #
@@ -208,6 +198,7 @@ require_relative 'address.rb'
     #
     
     def each
+      return to_enum( :each ) unless block_given?
       @data.each { |ar| yield ar }
     end
 
@@ -230,6 +221,7 @@ require_relative 'address.rb'
     # Select and re-order Columns by a list of headers
     #
     # @param [Array<String>] headers the ordered list of headers to keep
+    # @note This method can accept either a list of arguments or an Array
     # @note Invalid headers will be skipped
     #
   
@@ -258,7 +250,8 @@ require_relative 'address.rb'
     #
     
     def index_by_header( header )
-      col_index( sheet.header_rows > 0 ? colref_by_header( header ) : header )
+      sheet.header_rows > 0 or fail NoMethodError, 'No header rows present'
+      col_index(  colref_by_header( header ) )
     end
     
     #
@@ -365,7 +358,7 @@ require_relative 'address.rb'
     #
     
     def sort_by!( &block )
-      @data = skip_headers { |d| d.sort_by( &block ) }
+      @data = skip_headers { |d| d.sort_by( &block ) }; self
     end
     
     #
@@ -391,6 +384,7 @@ require_relative 'address.rb'
       ( row_idx - rows ).times { @data << [] }
       @data[ row_idx-1 ][ col_idx-1 ] = val
       calc_dimensions
+      val
     end
     alias []= write
     

data/lib/rubyexcel/element.rb

@@ -65,15 +65,35 @@ module RubyExcel
     #
   
     def value=( val )
+    
+      #Range
       if address.include? ':'
+      
+        addresses = expand( address )
+        
+        # 2D Array of Values
         if multi_array?( val )
-          expand( address ).each_with_index { |row,idx| row.each_with_index { |el,i| data[ el ] = val[idx][i] } }
+        
+          #Check the dimensions
+          val_rows, val_cols, range_rows, range_cols = val.length, val.max_by(&:length).length, addresses.length, addresses.max_by(&:length).length
+          val_rows == range_rows && val_cols == range_cols or fail ArgumentError, "Dimension mismatch! Value rows, columns: #{ val_rows }, #{ val_cols }. Range rows, columns: #{ range_rows }, #{ range_cols }"
+          
+          #Write the values in order
+          addresses.each_with_index { |row,idx| row.each_with_index { |el,i| data[ el ] = val[idx][i] } }
+          
+        # Single Value
         else
-          expand( address ).each { |ar| ar.each { |addr| data[ addr ] = val } }
+        
+          #Write the same value to every cell in the Range
+          addresses.each { |ar| ar.each { |addr| data[ addr ] = val } }
+          
         end
+      
+      #Cell
       else
         data[ address ] = val
       end
+      
       self
     end
     

data/lib/rubyexcel/section.rb

@@ -28,16 +28,16 @@ module RubyExcel
     
     #
     # Append a value to the Section. 
-    #   This only adds an extra cell if it is the first Row / Column.
-    #   This prevents a loop through Rows or Columns from extending diagonally away from the main data.
     #
     # @param [Object] value the object to append
+    # @note This only adds an extra cell if it is the first Row / Column.
+    #       This prevents a loop through Rows or Columns from extending diagonally away from the main data.
     #
   
     def <<( value )
       case self
-      when Row ; lastone = ( col_index( idx ) == 1 ? data.cols + 1 : data.cols )
-      else     ; lastone = ( col_index( idx ) == 1 ? data.rows + 1 : data.rows )
+      when Row ; lastone = ( idx == 1 ? data.cols + 1 : data.cols )
+      else     ; lastone = ( idx == 'A' ? data.rows + 1 : data.rows )
       end
       data[ translate_address( lastone ) ] = value
     end
@@ -58,6 +58,44 @@ module RubyExcel
       data.delete( self ); self
     end
   
+   #
+    # Yields each value
+    #
+
+    def each
+      return to_enum(:each) unless block_given?
+      each_address { |addr| yield data[ addr ] }
+    end
+    
+    #
+    # Yields each value, skipping headers
+    #
+    
+    def each_without_headers
+      return to_enum( :each_without_headers ) unless block_given?
+      each_address_without_headers { |addr| yield data[ addr ] }
+    end
+    alias each_wh each_without_headers
+    
+    #
+    # Yields each cell
+    #
+    
+    def each_cell
+      return to_enum( :each_cell ) unless block_given?
+      each_address { |addr| yield Element.new( sheet, addr ) }
+    end
+    
+    #
+    # Yields each cell, skipping headers
+    #
+    
+    def each_cell_without_headers
+      return to_enum( :each_cell_without_headers ) unless block_given?
+      each_address_without_headers { |addr| yield Element.new( sheet, addr ) }
+    end
+    alias each_cell_wh each_cell_without_headers
+  
     #
     # Check whether the data in self is empty
     #
@@ -86,6 +124,15 @@ module RubyExcel
       "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ idx }"
     end
   
+    #
+    # Replaces each value with the result of the block
+    #
+    
+    def map!
+      return to_enum( :map! ) unless block_given?
+      each_address { |addr| data[addr] = ( yield data[addr] ) }
+    end
+  
     #
     # Read a value by address
     #
@@ -128,53 +175,6 @@ module RubyExcel
     end
     alias []= write
 
-    #
-    # Yields each value
-    #
-
-    def each
-      return to_enum(:each) unless block_given?
-      each_address { |addr| yield data[ addr ] }
-    end
-    
-    #
-    # Yields each value, skipping headers
-    #
-    
-    def each_without_headers
-      return to_enum( :each_without_headers ) unless block_given?
-      each_address_without_headers { |addr| yield data[ addr ] }
-    end
-    alias each_wh each_without_headers
-    
-    #
-    # Yields each cell
-    #
-    
-    def each_cell
-      return to_enum( :each_cell ) unless block_given?
-      each_address { |addr| yield Element.new( sheet, addr ) }
-    end
-    
-    #
-    # Yields each cell, skipping headers
-    #
-    
-    def each_cell_without_headers
-      return to_enum( :each_cell_without_headers ) unless block_given?
-      each_address_without_headers { |addr| yield Element.new( sheet, addr ) }
-    end
-    alias each_cell_wh each_cell_without_headers
-    
-    #
-    # Replaces each value with the result of the block
-    #
-    
-    def map!
-      return to_enum( :map! ) unless block_given?
-      each_address { |addr| data[addr] = ( yield data[addr] ) }
-    end
-
     private
     
     def translate_address( addr )
@@ -192,11 +192,12 @@ module RubyExcel
 
   #
   # A Row in the Sheet
+  # @attr_reader [Fixnum] idx the Row index
+  # @attr_reader [Fixnum] length the Row length
   #
   
   class Row < Section
   
-    # The Row index
     attr_reader :idx
     
     #
@@ -238,6 +239,10 @@ module RubyExcel
       fail ArgumentError, 'Invalid header: ' + header.to_s
     end
     
+    def length
+      data.cols
+    end
+    
     #
     # Find a value in this Row by its header
     #
@@ -255,20 +260,19 @@ module RubyExcel
     def each_address
       ( 'A'..col_letter( data.cols ) ).each { |col_id| yield "#{col_id}#{idx}" }
     end
-    
-    def each_address_without_headers
-      ( 'A'..col_letter( data.cols ) ).each { |col_id| yield "#{col_id}#{idx}" }
-    end
+    alias each_address_without_headers each_address
 
   end
 
   #
   # A Column in the Sheet
   #
+  # @attr_reader [String] idx the Column index
+  # @attr_reader [Fixnum] length the Column length
+  #
   
   class Column < Section
   
-    # The Row index
     attr_reader :idx
     
     #
@@ -282,6 +286,10 @@ module RubyExcel
       @idx = idx
       super( sheet )
     end
+    
+    def length
+      data.rows
+    end
 
     private
     

data/lib/rubyexcel.rb

@@ -293,7 +293,7 @@ module RubyExcel
     def <<( other )
       case other
       when Array ; load( data.all + other, header_rows )
-      when Hash  ; load( data.all + _convert_hash( other ) )
+      when Hash  ; load( data.all + _convert_hash( other ), header_rows )
       when Sheet ; load( data.all + other.data.no_headers, header_rows )
       else       ; fail ArgumentError, "Unsupported class: #{ other.class }"
       end
@@ -308,10 +308,8 @@ module RubyExcel
 
     # @overload advanced_filter!( header, comparison_operator, search_criteria, ... )
     #   Filter on multiple criteria
-    #
     # @example Filter to 'Part': 'Type1' and 'Type3', with Qty greater than 1
     #   s.advanced_filter!( 'Part', :=~, /Type[13]/, 'Qty', :>, 1 )
-    #
     # @example Filter to 'Part': 'Type1', with 'Ref1' containing 'X'
     #   s.advanced_filter!( 'Part', :==, 'Type1', 'Ref1', :include?, 'X' )
     #
@@ -474,6 +472,7 @@ module RubyExcel
     # Select and re-order Columns by a list of headers
     #
     # @param [Array<String>] headers the ordered list of headers to keep
+    # @note This method can accept either a list of arguments or an Array
     # @note Invalid headers will be skipped
     #
 

data/lib/test/rubyexcel/tc_address.rb

@@ -0,0 +1,81 @@
+require_relative '../../rubyexcel'
+require 'test/unit'
+
+
+class TestAddress < Test::Unit::TestCase
+  
+  def setup
+    @s = RubyExcel.sample_sheet
+  end
+  
+  def teardown
+    @s = nil
+  end
+  
+  def test_address_to_col_index
+    
+    assert( @s.address_to_col_index( 'A1' ) == 1 )
+    
+  end
+  
+  def test_address_to_indices
+    
+    assert_equal( [ 1, 1 ], @s.address_to_indices( 'A1' ) )
+    
+  end
+  
+  def test_col_index
+  
+    assert_equal( 1, @s.col_index( 'A' ) )
+  
+  end
+
+  def test_col_letter
+
+    assert_equal( 'A', @s.col_letter( 1 ) )
+  
+  end
+
+  def test_column_id
+
+    assert_equal( 'A', @s.column_id( 'A1' ) )
+  
+  end
+  
+  def test_expand
+
+    assert_equal( [['A1','B1'],['A2', 'B2']], @s.expand( 'A1:B2' ) )
+  
+  end
+  
+  def test_indices_to_address
+  
+    assert_equal( 'A1', @s.indices_to_address( 1, 1 ) )
+  
+  end
+  
+  def test_multi_array?
+  
+    assert( @s.multi_array? RubyExcel.sample_data )
+  
+  end
+  
+  def test_offset
+    
+    assert_equal( 'B2', @s.offset( 'A1', 1, 1 ) )
+    
+  end
+  
+  def test_to_range_address
+
+    assert_equal( 'A1:B2', @s.to_range_address( @s.cell(1,1), @s.cell(2,2) ) )
+
+  end
+  
+  def test_row_id
+  
+    assert_equal( 2, @s.row_id( 'A2' ) )
+  
+  end
+  
+end

data/lib/test/rubyexcel/tc_data.rb

@@ -0,0 +1,153 @@
+require_relative '../../rubyexcel'
+require 'test/unit'
+
+class TestData < Test::Unit::TestCase
+  
+  def setup
+    @s = RubyExcel.sample_sheet
+  end
+  
+  def teardown
+    @s = nil
+  end
+  
+  def test_advanced_filter!
+    
+    assert_equal( 3, @s.data.advanced_filter!( 'Part', :=~, /Type[13]/, 'Qty', :>, 1 ).rows )
+    
+  end
+
+  def test_colref_by_header
+  
+    assert_equal( 'B', @s.data.colref_by_header( 'Ref1' ) )
+  
+  end
+  
+  def test_compact
+  
+    @s << [[1,2,3], [4,5,6]]
+    assert( @s.data.cols == 5 && @s.data.rows == 10 )
+  
+    @s.rows( 9 ) { |r| r.map! { nil } }
+    @s.data.compact!
+    assert_equal( 8, @s.data.rows )
+  
+  end
+  
+  def test_delete
+  
+    @s.data.delete( @s.row(1) )
+    assert_equal( 7, @s.data.rows )
+    
+    @s.data.delete( @s.column(1) )
+    assert_equal( 4, @s.data.cols )
+    
+    @s.data.delete( @s.range('A:A') )
+    assert_equal( 3, @s.data.cols )
+    
+    assert_raise( NoMethodError ) { @s.data.delete( [[]] ) }
+  
+  end
+  
+  def test_each
+  
+    assert_equal( 8, @s.data.each.count )
+  
+  end
+  
+  def test_filter!
+  
+    assert_equal( 3, @s.data.filter!( 'Part', &/Type2/ ).rows )
+  
+  end
+  
+  def test_get_columns!
+
+    assert_equal( [ 'Ref2', 'Part' ], @s.data.get_columns!( 'Ref2', 'Part' ).sheet.row(1).to_a )
+
+  end
+  
+  def test_headers
+  
+    assert_equal( 1, @s.data.headers.length )
+  
+    @s.headers = 0
+    assert_equal( nil, @s.data.headers )
+  
+  end
+  
+  def test_index_by_header
+
+    assert_equal( 1, @s.data.index_by_header( 'Part' ) )
+  
+    @s.headers = 0
+    assert_raise( NoMethodError ) { @s.data.index_by_header( 'Part' ) }
+
+  end
+  
+  def test_insert
+  
+    @s.data.insert_columns( 'A', 2 )
+    assert_equal( 7, @s.maxcol )
+    assert_equal( nil, @s['B2'] )
+    
+    @s.data.insert_rows( 2, 2 )
+    assert_equal( 10, @s.maxrow )
+    assert_equal( nil, @s['B4'] )
+  
+  end
+  
+  def test_no_headers
+
+    assert_equal( 7, @s.data.no_headers.length )
+
+  end
+  
+  def test_partition
+  
+    ar1, ar2 = @s.data.partition( 'Part', &/Type[13]/ )
+    assert_equal( 5, ar1.length )
+    assert_equal( 'Type1', ar1[1][0] )
+    assert_equal( 4, ar2.length )
+    
+  end
+  
+  def test_read_write
+  
+    assert_equal( '123', @s.data.read( 'C3' ) )
+    
+    @s.data.write( 'C3', '321' )
+    assert_equal( '321', @s.data.read( 'C3' ) )
+  
+  end
+  
+  def test_reverse
+  
+    @s.data.reverse_columns!
+    assert_equal( 'Cost', @s.A1 )
+    
+    @s.data.reverse_rows!
+    assert_equal( 'QT1', @s.d8 )
+    
+    @s.headers = 0
+    @s.data.reverse_rows!
+    assert_equal( 'Ref1', @s.d8 )
+  
+  end
+  
+  def test_skip_headers
+  
+    @s.load( @s.data.skip_headers { |data| data.map { |row| row.map { nil } } } )
+    assert_equal( 'Part', @s.a1 )
+    assert_equal( nil, @s.a2 )
+  
+  end
+  
+  def test_uniq!
+  
+    @s.data.uniq!( 'Part' )
+    assert_equal( 5, @s.maxrow )
+  
+  end
+  
+end

data/lib/test/rubyexcel/tc_element.rb

@@ -0,0 +1,42 @@
+require_relative '../../rubyexcel'
+require 'test/unit'
+
+class TestElement < Test::Unit::TestCase
+  
+  def setup
+    @s = RubyExcel.sample_sheet
+  end
+  
+  def teardown
+    @s = nil
+  end
+  
+  def test_initialize
+    
+    r = @s.range( 'A1:B2' )
+    assert_equal( @s, r.sheet )
+    assert_equal( 'A1:B2', r.address )
+    assert_equal( 'A', r.column )
+    assert_equal( 1, r.row )
+    
+  end
+
+  def test_value
+    
+    r = @s.range( 'A1' )
+    assert_equal( 'Part', r.value )
+    
+    r = @s.range( 'A1:B2' )
+    assert_equal( [['Part', 'Ref1'], ['Type1', 'QT1']], r.value )
+    
+    assert_raise( ArgumentError ) { r.value = [[1, 2]] }
+  
+  end
+  
+  def test_each
+  
+    assert_equal( 6, @s.range( 'A1:C2' ).each.count )
+  
+  end
+  
+end

data/lib/test/rubyexcel/tc_section.rb

@@ -0,0 +1,59 @@
+require_relative '../../rubyexcel'
+require 'test/unit'
+
+class TestRowColumn < Test::Unit::TestCase
+  
+  def setup
+    @s = RubyExcel.sample_sheet
+    @r = @s.row(2)
+    @c = @s.column(2)
+  end
+  
+  def teardown
+    @s = nil
+    @r = nil
+  end
+  
+  def test_shovel
+  
+    @r << 1
+    assert_equal( 5, @r.length )
+    
+    @r = @s.row(1)
+    @r << 1
+    assert_equal( 6, @r.length )
+    
+  end
+  
+  def test_cell
+  
+    assert_equal( @r.cell(2).address, @c.cell(2).address )
+  
+  end
+  
+  def test_find
+    
+    assert_equal( 'B2', @r.find( &/QT1/ ) )
+  
+  end
+  
+  def test_summarise
+  
+    h = { 'Type1' => 3, 'Type2' => 2, 'Type3' => 1, 'Type4' => 1 }
+    assert_equal( h, @s.column(1).summarise )
+  
+  end
+  
+  def test_getref
+  
+    assert_equal( 'A', @r.getref( 'Part' ) )
+  
+  end
+  
+  def test_value_by_header
+  
+    assert_equal( 'Type1', @r.val( 'Part' ) )
+  
+  end
+  
+end

data/lib/test/tc_rubyexcel.rb

@@ -0,0 +1,272 @@
+require_relative '../rubyexcel'
+require 'test/unit'
+
+class TestRegexp < Test::Unit::TestCase
+ 
+  def test_to_proc
+    assert_equal(0, /a/.to_proc.call('a') )
+  end
+ 
+end
+ 
+class TestWorkbook < Test::Unit::TestCase
+  
+  def setup
+    @wb = RubyExcel::Workbook.new
+    3.times { @wb.add.load RubyExcel.sample_data }
+  end
+  
+  def teardown
+    @wb = nil
+  end
+
+  def test_shovel
+  
+    @wb << @wb.dup
+    assert_equal( 6, @wb.sheets.count )
+    
+    @wb << @wb.sheets(1)
+    assert_equal( 7, @wb.sheets.count )
+    
+    @wb << @wb.sheets(1).data.all
+    assert_equal( 8, @wb.sheets.count )
+    
+  end
+  
+  def test_add
+    
+    @wb.add 'Sheet4'
+    assert_equal( 4, @wb.sheets.count )
+    
+    @wb.add
+    assert_equal( 5, @wb.sheets.count )
+    
+    @wb.add @wb.sheets(1)
+    assert_equal( 6, @wb.sheets.count )
+    
+    assert_raise( TypeError ) { @wb.add 1 }
+    
+  end
+  
+  def test_clear_all
+    
+    assert_equal( 0, @wb.clear_all.sheets.count )
+    
+  end
+  
+  def test_delete
+    
+    assert_equal( 2, @wb.delete(1).sheets.count )
+    
+    assert_equal( 1, @wb.delete( 'Sheet2' ).sheets.count )
+    
+    assert_equal( 0, @wb.delete( /Sheet/ ).sheets.count )
+    
+    assert_equal( 0, @wb.delete( @wb.add ).sheets.count )
+    
+  end
+  
+  def test_dup
+  
+    dup_wb = @wb.dup
+    
+    assert_equal( @wb.sheets(1).to_a, dup_wb.sheets(1).to_a )
+    
+    assert_not_equal( @wb.object_id, dup_wb.object_id )
+  
+  end
+  
+  def test_empty?
+  
+    assert( !@wb.empty? )
+    
+    assert( @wb.clear_all.empty? )
+  
+  end
+  
+  def test_load
+  
+    assert( @wb.load( [[]] ).class == RubyExcel::Sheet )
+    
+    assert( @wb.load( RubyExcel.sample_data )['A1'] == 'Part' )
+    
+  end
+  
+  def test_sheets
+    
+    assert( @wb.sheets.class == Enumerator )
+    
+    assert( @wb.sheets(2) == @wb.sheets('Sheet2') )
+    
+  end
+
+end
+
+class TestSheet < Test::Unit::TestCase
+  
+  def setup
+    @s = RubyExcel.sample_sheet
+  end
+  
+  def teardown
+    @s = nil
+  end
+
+  def test_basics
+    
+    assert( @s['A1'] == @s.A1 )
+    
+    @s << RubyExcel.sample_hash
+    assert( @s.maxrow == 20 && @s.maxcol == 5 )
+    
+    @s << RubyExcel.sample_data
+    assert( @s.maxrow == 28 && @s.maxcol == 5 )
+    
+    @s << @s
+    assert( @s.maxrow == 55 && @s.maxcol == 5 )
+    
+  end
+  
+  def test_advanced_filter
+    
+    @s.advanced_filter!( 'Part', :=~, /Type[13]/, 'Qty', :>, 1 )
+    assert( @s.maxrow == 3 )
+  
+    setup
+    @s.advanced_filter!( 'Part', :==, 'Type1', 'Ref1', :include?, 'X' )
+    assert( @s.maxrow == 2 )
+    
+  end
+  
+  def test_cell
+  
+    assert( @s.cell(1,1).value == 'Part' && @s.cell(1,1).address == 'A1' )
+    
+  end
+  
+  def test_column
+  
+    assert( @s.column('A')[1] == 'Part' )
+  
+  end
+  
+  def test_column_by_header
+  
+    assert( @s.ch( 'Part' )[1] == @s.ch( @s.column(1) )[1] )
+    
+  end
+  
+  def test_columns
+  
+    assert( @s.columns.class == Enumerator )
+    
+    assert( @s.columns( 'B' ).count == 4 )
+    
+    assert( @s.columns( 'B', 'D' ).to_a[0][1] == 'Ref1' )
+  
+  end
+  
+  def test_filter
+  
+    assert( @s.filter( 'Part', &/Type[13]/ ).maxrow == 5 )
+  
+  end
+  
+  def test_get_columns
+  
+    assert_equal( @s.get_columns( 'Ref2', 'Part' ).row(1).to_a, [ 'Ref2', 'Part' ] )
+    
+  end
+  
+  def test_insert_columns
+    
+    assert( @s.insert_columns( 2, 2 ).columns.count == 7 )
+    
+  end
+  
+  def test_insert_rows
+  
+    assert( @s.insert_rows( 2, 2 ).rows.count == 10 )
+  
+  end
+  
+  def test_match
+  
+    assert( @s.match( 'Part', &/Type2/ ) == 3 )
+  
+  end
+  
+  def test_method_missing
+  
+    assert( @s.a1 == 'Part' )
+  
+    assert_raise( NoMethodError ) { @s.abcd123 }
+  
+  end
+  
+  def test_respond_to?
+  
+    assert( @s.respond_to?(:A1) )
+  
+  end
+  
+  def test_partition
+  
+    s1, s2 = @s.partition( 'Qty' ) { |v| v > 1 }
+    assert_equal( s1.maxrow + 1, s2.maxrow )
+
+  end
+  
+  def test_range
+  
+    assert( @s.range( 'A1:A1' ).value == @s.range( @s.cell(1,1), @s.cell( 1,1 ) ).value )
+    
+    assert( @s.range( 'A1' ).value == @s.range( @s.cell(1,1) ).value )
+ 
+  end
+  
+  def test_reverse
+  
+    assert( @s.reverse_columns!['A1'] == 'Cost' )
+    
+    assert( @s.reverse_rows!['A2'] == 104 )
+    
+  end
+  
+  def test_row
+  
+    assert( @s.row(1)['A'] == 'Part' )
+  
+  end
+  
+  def test_rows
+  
+    assert( @s.rows.class == Enumerator )
+    
+    assert( @s.rows( 2 ).count == 7 )
+    
+    assert( @s.rows( 2, 4 ).to_a[0]['A'] == 'Type1' )
+  
+  end  
+  
+  def test_sumif
+  
+    assert( @s.sumif( 'Part', 'Cost', &/Type1/ ) == 169.15 )
+  
+  end
+  
+  def test_uniq
+  
+    assert( @s.uniq( 'Part' ).maxrow ==  5 )
+
+  end
+
+  def test_
+  
+    assert( @s.vlookup( 'Part', 'Ref2', &/Type1/ ) == '231' )
+  
+  end
+  
+  
+  
+end

data/lib/test/test_all.rb

@@ -0,0 +1,5 @@
+require_relative 'tc_rubyexcel'
+require_relative 'rubyexcel/tc_address'
+require_relative 'rubyexcel/tc_data'
+require_relative 'rubyexcel/tc_element'
+require_relative 'rubyexcel/tc_section'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyexcel
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-30 00:00:00.000000000 Z
+date: 2013-05-01 00:00:00.000000000 Z
 dependencies: []
 description: A tabular data structure, mixing Ruby with some of Excel's API style.
 email: VirtuosoJoel@gmail.com
@@ -24,6 +24,12 @@ files:
 - lib/rubyexcel/rubyexcel_components.rb
 - lib/rubyexcel/section.rb
 - lib/rubyexcel.rb
+- lib/test/rubyexcel/tc_address.rb
+- lib/test/rubyexcel/tc_data.rb
+- lib/test/rubyexcel/tc_element.rb
+- lib/test/rubyexcel/tc_section.rb
+- lib/test/tc_rubyexcel.rb
+- lib/test/test_all.rb
 - lib/README.md
 homepage: https://github.com/VirtuosoJoel
 licenses: []