rubyexcel 0.1.2 → 0.1.3

data/lib/README.md

@@ -137,20 +137,28 @@ Common Operations
 --------
 
 ```ruby
+#Some data to play with
+s = RubyExcel.sample_sheet
+
+#Have a look at the data
+puts s
+
 #Append a Column by adding a header
-s << 'Numbers'
-x = 1
+s << 'Number'
 
 #Iterate through the rest of the rows while appending data
+x = 1
 s.rows(2) { |row| row << x; x+=1 }
 
-#
+#Filter to specific part numbers
+s.filter!( 'Part', &/Type[1-3]/ )
+
+#Add the Number to the Cost in each row.
+s.rows(2) { |row| row.cell_h('Cost').value += row.cell_h('Number').value }
 
 #Split the data into multiple sheets by part number
 wb = s.split( 'Part' )
 
-#Will add more examples here later.
-
 ```
 
 Workbook
@@ -284,9 +292,8 @@ type_1_and_3, other = s.partition( 'Part', &/Type[13]/ )
 s.reverse_rows!
 s.reverse_columns!
 
-#Sort the rows by criteria (ignores headers)
-s.sort! { |r1,r2| r1['A'] <=> r2['A'] }
-s.sort_by! { |r| r['A'] }
+#Sort the rows by a header (ignores header rows)
+s.sort_by!( 'Part' )
 
 #Split a Sheet into a Workbook of Sheets by a column (selected by header)
 wb = s.split( 'Part' )
@@ -334,6 +341,10 @@ s.rows(2) { |r| r << 'Column' }
 s.column(1) << 'New'
 s.columns(2) { |c| c << 'Row' }
 
+#Access a cell by column header (Row only)
+s.row(2).cell_by_header( 'Part' ) #=> Element A2
+s.row(2).cell_h( 'Cost' ) #=> Element E2
+
 #Delete the data referenced by self.
 row.delete
 col.delete

data/lib/rubyexcel/rubyexcel_components.rb

@@ -1,7 +1,9 @@
 require_relative 'address.rb'
 require_relative 'data.rb'
 require_relative 'element.rb'
+require_relative 'excel_tools.rb'
 require_relative 'section.rb'
+require_relative 'sheet.rb'
 
 module RubyExcel
 

data/lib/rubyexcel/section.rb

@@ -35,11 +35,7 @@ module RubyExcel
     #
   
     def <<( value )
-      case self
-      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
+      data[ translate_address( ( col_index( idx ) == 1 ? data.cols + 1 : data.cols ) ) ] = value
     end
     
     #
@@ -58,7 +54,7 @@ module RubyExcel
       data.delete( self ); self
     end
   
-   #
+    #
     # Yields each value
     #
 
@@ -73,7 +69,7 @@ module RubyExcel
     
     def each_without_headers
       return to_enum( :each_without_headers ) unless block_given?
-      each_address_without_headers { |addr| yield data[ addr ] }
+      each_address( false ) { |addr| yield data[ addr ] }
     end
     alias each_wh each_without_headers
     
@@ -92,7 +88,7 @@ module RubyExcel
     
     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 ) }
+      each_address( false ) { |addr| yield Element.new( sheet, addr ) }
     end
     alias each_cell_wh each_cell_without_headers
   
@@ -149,7 +145,7 @@ module RubyExcel
   
     def map_without_headers!
       return to_enum( :map_without_headers! ) unless block_given?
-      each_address_without_headers { |addr| data[addr] = ( yield data[addr] ) }
+      each_address( false ) { |addr| data[addr] = ( yield data[addr] ) }
     end
   
     #
@@ -194,19 +190,6 @@ module RubyExcel
     end
     alias []= write
 
-    private
-    
-    def translate_address( addr )
-      case self
-      when Row
-        col_letter( addr ) + idx.to_s
-      when Column
-        addr = addr.to_s unless addr.is_a?( String )
-        fail ArgumentError, "Invalid address : #{ addr }" if addr =~ /[^\d]/
-        idx + addr
-      end
-    end
-
   end
 
   #
@@ -252,12 +235,16 @@ module RubyExcel
   
     def getref( header )
       sheet.header_rows.times do |t|
-        res = sheet.row( t + 1 ).find &/^#{header}$/
+        res = sheet.row( t + 1 ).find { |v| v == header }
         return column_id( res ) if res
       end
       fail ArgumentError, 'Invalid header: ' + header.to_s
     end
     
+    #
+    # The number of Columns in the Row
+    #
+    
     def length
       data.cols
     end
@@ -276,12 +263,15 @@ module RubyExcel
 
     private
 
-    def each_address
+    def each_address( unused=nil )
       return to_enum( :each_address ) unless block_given?
-      ( 'A'..col_letter( data.cols ) ).each { |col_id| yield "#{col_id}#{idx}" }
+      ( 'A'..col_letter( data.cols ) ).each { |col_id| yield translate_address( col_id ) }
     end
-    alias each_address_without_headers each_address
 
+    def translate_address( addr )
+      col_letter( addr ) + idx.to_s
+    end
+    
   end
 
   #
@@ -307,22 +297,27 @@ module RubyExcel
       super( sheet )
     end
     
+    #
+    # The number of Rows in the Column
+    #
+    
     def length
       data.rows
     end
 
     private
     
-    def each_address
+    def each_address( headers=true )
       return to_enum( :each_address ) unless block_given?
-      ( 1..data.rows ).each { |row_id| yield idx + row_id.to_s }
+      ( headers ? 1 : sheet.header_rows + 1 ).upto( data.rows ) { |row_id| yield translate_address( row_id ) }
     end
 
-    def each_address_without_headers
-      return to_enum( :each_address_without_headers ) unless block_given?
-      ( sheet.header_rows+1 ).upto( data.rows ) { |row_id| yield idx + row_id.to_s }
+    def translate_address( addr )
+      addr = addr.to_s unless addr.is_a?( String )
+      fail ArgumentError, "Invalid address : #{ addr }" if addr =~ /[^\d]/
+      idx + addr
     end
-
+    
   end
 
 end

data/lib/rubyexcel/sheet.rb

@@ -0,0 +1,582 @@
+#
+# Namespace for all RubyExcel Classes and Modules
+#
+
+module RubyExcel
+
+  #
+  # The front-end class for data manipulation and output.
+  #
+
+  class Sheet
+    include Address
+
+    # The Data underlying the Sheet
+    attr_reader :data
+    
+    # The name of the Sheet
+    attr_accessor :name
+    
+    # The number of rows treated as headers
+    attr_accessor :header_rows
+    
+    # The Workbook parent of this Sheet
+    attr_accessor :workbook
+
+    alias parent workbook; alias parent= workbook=
+    alias headers header_rows; alias headers= header_rows=    
+    
+    #
+    # Creates a RubyExcel::Sheet instance
+    #
+    # @param [String] name the name of the Sheet
+    # @param [RubyExcel::Workbook] workbook the Workbook which holds this Sheet
+    #
+    
+    def initialize( name, workbook )
+      @workbook = workbook
+      @name = name
+      @header_rows = nil
+      @data = Data.new( self, [[]] )
+    end
+    
+    #
+    # Read a value by address
+    #
+    # @example
+    #   sheet['A1']
+    #   #=> "Part"
+    #
+    # @example
+    #   sheet['A1:B2']
+    #   #=> [["Part", "Ref1"], ["Type1", "QT1"]]
+    #
+    # @param [String] addr the address to access
+    #
+
+    def[]( addr )
+      range( addr ).value
+    end
+    
+    #
+    # Write a value by address
+    #
+    # @example
+    #   sheet['A1'] = "Bart"
+    #   sheet['A1']
+    #   #=> "Bart"
+    #
+    # @param (see #[])
+    # @param [Object] val the value to write into the data
+    #
+
+    def []=( addr, val )
+      range( addr ).value = val
+    end
+
+    #
+    # Add data with the Sheet
+    #
+    # @param [Array<Array>, Hash<Hash>, RubyExcel::Sheet] other the data to add
+    # @return [RubyExcel::Sheet] returns a new Sheet
+    # @note When adding another Sheet it won't import the headers unless this Sheet is empty.
+    #
+ 
+    def +( other )
+      dup << other
+    end
+    
+    #
+    # Subtract data from the Sheet
+    #
+    # @param [Array<Array>, RubyExcel::Sheet] other the data to subtract
+    # @return [RubyExcel::Sheet] returns a new Sheet
+    #
+    
+    def -( other )
+      case other
+      when Array ; Workbook.new.load( data.all - other )
+      when Sheet ; Workbook.new.load( data.all - other.data.no_headers )
+      else       ; fail ArgumentError, "Unsupported class: #{ other.class }"
+      end
+    end
+    
+    #
+    # Append an object to the Sheet
+    #
+    # @param [Object] other the object to append
+    # @return [self]
+    # @note When adding another Sheet it won't import the headers unless this Sheet is empty.
+    # @note Anything other than an an Array, Hash, Row, Column or Sheet will be appended to the first row
+    #
+    
+    def <<( other )
+      data << other
+      self
+    end
+    
+    # @overload advanced_filter!( header, comparison_operator, search_criteria, ... )
+    #   Filter on multiple criteria
+    # @param [String] header a header to search under
+    # @param [Symbol] comparison_operator the operator to compare with
+    # @param [Object] search_criteria the value to filter by
+    # @raise [ArgumentError] 'Number of arguments must be a multiple of 3'
+    # @raise [ArgumentError] 'Operator must be a symbol'
+    # @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' )
+    #
+    
+    def advanced_filter!( *args )
+      data.advanced_filter!( *args ); self
+    end
+    
+    #
+    # Access an Element by indices.
+    #
+    # @param [Fixnum] row the row index
+    # @param [Fixnum] col the column index
+    # @return [RubyExcel::Element]
+    # @note Indexing is 1-based like Excel VBA
+    #
+    
+    def cell( row, col )
+      Element.new( self, indices_to_address( row, col ) )
+    end
+    alias cells cell
+    
+    #
+    # Access a Column (Section) by its reference.
+    #
+    # @param [String, Fixnum] index the Column reference
+    # @return [RubyExcel::Column]
+    # @note Index 'A' and 1 both select the 1st Column
+    #
+    
+    def column( index )
+      Column.new( self, col_letter( index ) )
+    end
+    
+    #
+    # Access a Column (Section) by its header.
+    #
+    # @param [String] header the Column header
+    # @return [RubyExcel::Column]
+    #
+    
+    def column_by_header( header )
+      header.is_a?( Column ) ? header : Column.new( self, data.colref_by_header( header ) )
+    end
+    alias ch column_by_header
+    
+    #
+    # Yields each Column to the block
+    #
+    # @param [String, Fixnum] start_column the Column to start looping from
+    # @param [String, Fixnum] end_column the Column to end the loop at
+    # @note Iterates to the last Column in the Sheet unless given a second argument.
+    #
+    
+    def columns( start_column = 'A', end_column = data.cols )
+      return to_enum( :columns, start_column, end_column ) unless block_given?
+      ( col_letter( start_column )..col_letter( end_column ) ).each { |idx| yield column( idx ) }
+      self
+    end
+    
+    #
+    # Removes empty Columns and Rows
+    #
+    
+    def compact!
+      data.compact!; self
+    end
+    
+    #
+    # Removes Sheet from the parent Workbook
+    #
+    
+    def delete
+      workbook.delete self
+    end
+    
+    #
+    # Deletes each Row where the block is true
+    #
+    
+    def delete_rows_if
+      return to_enum( :delete_rows_if ) unless block_given?
+      rows.reverse_each { |r| r.delete if yield r }; self
+    end
+    
+    #
+    # Deletes each Column where the block is true
+    #
+    
+    def delete_columns_if
+      return to_enum( :delete_columns_if ) unless block_given?
+      columns.reverse_each { |c| c.delete if yield c }; self
+    end
+    
+    #
+    # Return a copy of self
+    #
+    # @return [RubyExcel::Sheet]
+    #
+    
+    def dup
+      s = Sheet.new( name, workbook )
+      d = data
+      unless d.nil?
+        d = d.dup
+        s.load( d.all, header_rows )
+        d.sheet = s
+      end
+      s
+    end
+    
+    #
+    # Check whether the Sheet contains data
+    #
+    # @return [Boolean] if there is any data
+    #
+
+    def empty?
+      data.empty?
+    end
+    
+    #
+    # Removes all Rows (omitting headers) where the block is false
+    #
+    # @param [String] header the header of the Column to pass to the block
+    # @yield [Object] the value at the intersection of Column and Row
+    # @return [self]
+    #
+    
+    def filter!( header, &block )
+      data.filter!( header, &block ); self
+    end
+    
+    #
+    # 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
+    #
+
+    def get_columns!( *headers )
+      data.get_columns!( *headers ); self
+    end
+    alias gc! get_columns!
+    
+    # @overload insert_columns( before, number=1 )
+    #   Insert blank Columns into the data
+    #
+    #   @param [String, Fixnum] before the Column reference to insert before.
+    #   @param [Fixnum] number the number of new Columns to insert
+    #
+    
+    def insert_columns( *args )
+      data.insert_columns( *args ); self
+    end
+    
+    # @overload insert_rows( before, number=1 )
+    #   Insert blank Rows into the data
+    #
+    #   @param [Fixnum] before the Row index to insert before.
+    #   @param [Fixnum] number the number of new Rows to insert
+    #
+    
+    def insert_rows( *args )
+      data.insert_rows( *args ); self
+    end
+    
+    #
+    # View the object for debugging
+    #
+    
+    def inspect
+      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ name }"
+    end
+    
+    #
+    # Populate the Sheet with data (overwrite)
+    #
+    # @param [Array<Array>, Hash<Hash>] input_data the data to fill the Sheet with
+    # @param header_rows [Fixnum] the number of Rows to be treated as headers
+    #
+    
+    def load( input_data, header_rows=1 )
+      input_data = _convert_hash(input_data) if input_data.is_a?(Hash)
+      input_data.is_a?(Array) or fail ArgumentError, 'Input must be an Array or Hash'
+      @header_rows = header_rows
+      @data = Data.new( self, input_data ); self
+    end
+    
+    #
+    # Find the row number by looking up a value in a Column
+    #
+    # @param [String] header the header of the Column to pass to the block
+    # @yield yields each value in the Column to the block
+    # @return [Fixnum, nil] the row number of the first match or nil if nothing is found
+    #
+    
+    def match( header, &block )
+      row_id( column_by_header( header ).find( &block ) )
+    end
+    
+    #
+    # The highest currently used row number
+    #
+    
+    def maxrow
+      data.rows
+    end
+    
+    #
+    # The highest currently used column number
+    #
+    
+    def maxcol
+      data.cols
+    end
+    alias maxcolumn maxcol
+    
+    #
+    # Allow shorthand range references and non-bang versions of bang methods.
+    #
+    
+    def method_missing(m, *args, &block)
+      method_name = m.to_s
+      
+      if method_name[-1] != '!' && respond_to?( method_name + '!' )
+      
+        dup.send( method_name + '!', *args, &block )
+        
+      elsif method_name =~ /\A[A-Z]{1,3}\d+=?\z/i
+      
+        method_name.upcase!
+        if method_name[-1] == '='
+          range( method_name.chop ).value = ( args.length == 1 ? args.first : args )
+        else
+          range( method_name ).value
+        end
+        
+      else
+        super
+      end
+    end
+    
+    #
+    # Allow for certain method_missing calls
+    #
+    
+    def respond_to?(m)
+    
+      if m[-1] != '!' && respond_to?( m.to_s + '!' )
+        true
+      elsif m.to_s.upcase.strip =~ /\A[A-Z]{1,3}\d+=?\z/
+        true
+      else
+        super
+      end
+      
+    end
+    
+    #
+    # Split the Sheet into two Sheets by evaluating each value in a column
+    #
+    # @param [String] header the header of the Column which contains the yield value
+    # @yield [value] yields the value of each row under the given header
+    # @return [Array<RubyExcel::Sheet, RubyExcel::Sheet>] Two Sheets: true and false. Headers included.
+    #
+    
+    def partition( header, &block )
+      data.partition( header, &block ).map { |d| dup.load( d ) }
+    end
+    
+    #
+    # Access an Element by address.
+    #
+    # @param [String, Element] first_cell the first Cell or Address in the Range
+    # @param [String, Element] last_cell the last Cell or Address in the Range
+    # @return [RubyExcel::Element]
+    # @note These are all valid arguments:
+    #   ('A1') 
+    #   ('A1:B2') 
+    #   ('A:A')
+    #   ('1:1')
+    #   ('A1', 'B2') 
+    #   (cell1) 
+    #   (cell1, cell2) 
+    #
+    
+    def range( first_cell, last_cell=nil )
+      Element.new( self, to_range_address( first_cell, last_cell ) )
+    end
+    
+    #
+    # Reverse the Sheet Columns
+    #
+    
+    def reverse_columns!
+      data.reverse_columns!; self
+    end
+    
+    #
+    # Reverse the Sheet Rows (without affecting the headers)
+    #
+    
+    def reverse_rows!
+      data.reverse_rows!; self
+    end
+    
+    #
+    # Create a Row from an index
+    #
+    # @param [Fixnum] index the Row index
+    # @return [RubyExcel::Row]
+    #
+
+    def row( index )
+      Row.new( self, index )
+    end
+    
+    #
+    # Yields each Row to the block
+    #
+    # @param [Fixnum] start_row the Row to start looping from
+    # @param [Fixnum] end_row the Row to end the loop at
+    # @note Iterates to the last Row in the Sheet unless given a second argument.
+    #
+    
+    def rows( start_row = 1, end_row = data.rows )
+      return to_enum(:rows, start_row, end_row) unless block_given?
+      ( start_row..end_row ).each { |idx| yield row( idx ) }; self
+    end
+    alias each rows
+    
+    #
+    # Sort the data according to a block (avoiding headers)
+    #
+    
+    def sort!( &block )
+      data.sort!( &block ); self
+    end
+    
+    #
+    # Sort the data by a column, selected by header
+    #
+    # @param [String] header the header to sort the Sheet by
+    #
+    
+    def sort_by!( header )
+      raise ArgumentError, 'Sheet#sort_by! does not support blocks.' if block_given?
+      idx = data.index_by_header( header ) - 1
+      sort_method = lambda { |array| array[idx] }
+      data.sort_by!( &sort_method )
+      self
+    end
+    
+    #
+    # Break the Sheet into a Workbook with multiple Sheets, split by the values under a header.
+    #
+    # @param [String] header the header to split by
+    # @return [RubyExcel::Workbook] a new workbook containing the split Sheets (each with headers)
+    #
+    
+    def split( header )
+      wb = Workbook.new
+      ch( header ).each_wh.to_a.uniq.each { |name| wb.add( name ).load( data.headers ) }
+      rows( header_rows+1 ) do |row|
+        wb.sheets( row.val( header ) ) << row
+      end
+      wb
+    end
+    
+    #
+    # Sum the values in a Column by searching another Column
+    #
+    # @param [String] find_header the header of the Column to yield to the block
+    # @param [String] sum_header the header of the Column to sum
+    # @yield yields the find_header column values to the block
+    #
+    
+    def sumif( find_header, sum_header )
+      return to_enum( :sumif ) unless block_given?
+      find_col, sum_col  = ch( find_header ), ch( sum_header )
+      find_col.each_cell.inject(0) { |sum,ce| yield( ce.value ) && ce.row > header_rows ? sum + sum_col[ ce.row ] : sum }
+    end
+    
+    #
+    # Summarise the values of a Column into a Hash
+    #
+    # @param [String] header the header of the Column to summarise
+    # @return [Hash]
+    #
+    
+    def summarise( header )
+      ch( header ).summarise
+    end
+    
+    #
+    # The Sheet as a 2D Array
+    #
+    
+    def to_a
+      data.all
+    end
+    
+    #
+    # The Sheet as a WIN32OLE Excel Workbook
+    # @note This requires Windows and MS Excel
+    #
+    
+    def to_excel
+      workbook.dup.clear_all.add( self.dup ).workbook.to_excel
+    end
+    
+    #
+    # The Sheet as a String containing an HTML Table
+    #
+    
+    def to_html
+      "<table>\n" + data.map { |row| '<tr>' + row.map { |v| '<td>' + CGI.escapeHTML(v.to_s) }.join() + "\n" }.join() + '</table>'
+    end
+    
+    #
+    # The Sheet as a Tab Seperated Value String
+    #
+    
+    def to_s
+      data.map { |ar| ar.map { |v| v.to_s.gsub(/\t|\n/,' ') }.join "\t" }.join( $/ )
+    end
+    
+    #
+    # Remove any Rows with duplicate values within a Column
+    #
+    # @param [String] header the header of the Column to check for duplicates
+    #
+    
+    def uniq!( header )
+      data.uniq!( header ); self
+    end
+    alias unique! uniq!
+    
+    #
+    # Find a value within a Column by searching another Column
+    # 
+    # @param [String] find_header the header of the Column to search
+    # @param [String] return_header the header of the return value Column 
+    # @yield the first matching value
+    #
+    
+    def vlookup( find_header, return_header, &block )
+      find_col, return_col  = ch( find_header ), ch( return_header )
+      return_col[ row_id( find_col.find( &block ) ) ] rescue nil
+    end
+    
+  end # Sheet
+  
+end # RubyExcel

data/lib/rubyexcel.rb

@@ -1,5 +1,4 @@
 require_relative 'rubyexcel/rubyexcel_components.rb'
-require_relative 'rubyexcel/excel_tools.rb'
 require 'cgi'
 
 #
@@ -185,612 +184,5 @@ module RubyExcel
     end
     
   end # Workbook
-  
-  #
-  # The front-end class for data manipulation and output.
-  #
-
-  class Sheet
-    include Address
-    include Enumerable
-
-    # The Data underlying the Sheet
-    attr_reader :data
-    
-    # The name of the Sheet
-    attr_accessor :name
-    
-    # The number of rows treated as headers
-    attr_accessor :header_rows
-    
-    # The Workbook parent of this Sheet
-    attr_accessor :workbook
-
-    alias parent workbook; alias parent= workbook=
-    alias headers header_rows; alias headers= header_rows=    
-    
-    #
-    # Creates a RubyExcel::Sheet instance
-    #
-    # @param [String] name the name of the Sheet
-    # @param [RubyExcel::Workbook] workbook the Workbook which holds this Sheet
-    #
-    
-    def initialize( name, workbook )
-      @workbook = workbook
-      @name = name
-      @header_rows = nil
-      @data = Data.new( self, [[]] )
-    end
-    
-    #
-    # Read a value by address
-    #
-    # @example
-    #   sheet['A1']
-    #   #=> "Part"
-    #
-    # @example
-    #   sheet['A1:B2']
-    #   #=> [["Part", "Ref1"], ["Type1", "QT1"]]
-    #
-    # @param [String] addr the address to access
-    #
-
-    def[]( addr )
-      range( addr ).value
-    end
-    
-    #
-    # Write a value by address
-    #
-    # @example
-    #   sheet['A1'] = "Bart"
-    #   sheet['A1']
-    #   #=> "Bart"
-    #
-    # @param (see #[])
-    # @param [Object] val the value to write into the data
-    #
-
-    def []=( addr, val )
-      range( addr ).value = val
-    end
-
-    #
-    # Add data with the Sheet
-    #
-    # @param [Array<Array>, Hash<Hash>, RubyExcel::Sheet] other the data to add
-    # @return [RubyExcel::Sheet] returns a new Sheet
-    # @note When adding another Sheet it won't import the headers unless this Sheet is empty.
-    #
- 
-    def +( other )
-      dup << other
-    end
-    
-    #
-    # Subtract data from the Sheet
-    #
-    # @param [Array<Array>, RubyExcel::Sheet] other the data to subtract
-    # @return [RubyExcel::Sheet] returns a new Sheet
-    #
-    
-    def -( other )
-      case other
-      when Array ; Workbook.new.load( data.all - other )
-      when Sheet ; Workbook.new.load( data.all - other.data.no_headers )
-      else       ; fail ArgumentError, "Unsupported class: #{ other.class }"
-      end
-    end
-    
-    #
-    # Append an object to the Sheet
-    #
-    # @param [Object] other the object to append
-    # @return [self]
-    # @note When adding another Sheet it won't import the headers unless this Sheet is empty.
-    # @note Anything other than an an Array, Hash, Row, Column or Sheet will be appended to the first row
-    #
-    
-    def <<( other )
-      data << other
-      self
-    end
-    
-    # {Sheet#advanced_filter!}
-    
-    def advanced_filter( *args )
-      dup.advanced_filter!( *args )
-    end
-
-    # @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' )
-    #
-    # @param [String] header a header to search under
-    # @param [Symbol] comparison_operator the operator to compare with
-    # @param [Object] search_criteria the value to filter by
-    # @raise [ArgumentError] 'Number of arguments must be a multiple of 3'
-    # @raise [ArgumentError] 'Operator must be a symbol'
-    #
-    
-    def advanced_filter!( *args )
-      data.advanced_filter!( *args ); self
-    end
-    
-    #
-    # Access an Element by indices.
-    #
-    # @param [Fixnum] row the row index
-    # @param [Fixnum] col the column index
-    # @return [RubyExcel::Element]
-    # @note Indexing is 1-based like Excel VBA
-    #
-    
-    def cell( row, col )
-      Element.new( self, indices_to_address( row, col ) )
-    end
-    alias cells cell
-    
-    #
-    # Access a Column (Section) by its reference.
-    #
-    # @param [String, Fixnum] index the Column reference
-    # @return [RubyExcel::Column]
-    # @note Index 'A' and 1 both select the 1st Column
-    #
-    
-    def column( index )
-      Column.new( self, col_letter( index ) )
-    end
-    
-    #
-    # Access a Column (Section) by its header.
-    #
-    # @param [String] header the Column header
-    # @return [RubyExcel::Column]
-    #
-    
-    def column_by_header( header )
-      header.is_a?( Column ) ? header : Column.new( self, data.colref_by_header( header ) )
-    end
-    alias ch column_by_header
-    
-    #
-    # Yields each Column to the block
-    #
-    # @param [String, Fixnum] start_column the Column to start looping from
-    # @param [String, Fixnum] end_column the Column to end the loop at
-    # @note Iterates to the last Column in the Sheet unless given a second argument.
-    #
-    
-    def columns( start_column = 'A', end_column = data.cols )
-      return to_enum( :columns, start_column, end_column ) unless block_given?
-      ( col_letter( start_column )..col_letter( end_column ) ).each { |idx| yield column( idx ) }
-      self
-    end
-    
-    # {Sheet#compact!}
-    
-    def compact
-      dup.compact!
-    end
-    
-    #
-    # Removes empty Columns and Rows
-    #
-    
-    def compact!
-      data.compact!; self
-    end
-    
-    #
-    # Removes Sheet from the parent Workbook
-    #
-    
-    def delete
-      workbook.delete self
-    end
-    
-    #
-    # Deletes each Row where the block is true
-    #
-    
-    def delete_rows_if
-      return to_enum( :delete_rows_if ) unless block_given?
-      rows.reverse_each { |r| r.delete if yield r }; self
-    end
-    
-    #
-    # Deletes each Column where the block is true
-    #
-    
-    def delete_columns_if
-      return to_enum( :delete_columns_if ) unless block_given?
-      columns.reverse_each { |c| c.delete if yield c }; self
-    end
-    
-    #
-    # Return a copy of self
-    #
-    # @return [RubyExcel::Sheet]
-    #
-    
-    def dup
-      s = Sheet.new( name, workbook )
-      d = data
-      unless d.nil?
-        d = d.dup
-        s.load( d.all, header_rows )
-        d.sheet = s
-      end
-      s
-    end
-    
-    #
-    # Check whether the Sheet contains data
-    #
-    # @return [Boolean] if there is any data
-    #
-
-    def empty?
-      data.empty?
-    end
-    
-    # {Sheet#filter!}
-    
-    def filter( header, &block )
-      dup.filter!( header, &block )
-    end
-
-    #
-    # Removes all Rows (omitting headers) where the block is false
-    #
-    # @param [String] header the header of the Column to pass to the block
-    # @yield [Object] the value at the intersection of Column and Row
-    # @return [self]
-    #
-    
-    def filter!( header, &block )
-      data.filter!( header, &block ); self
-    end
-    
-    # {Sheet#get_columns!}
-    
-    def get_columns( *headers )
-      dup.get_columns!( *headers )
-    end
-    alias gc get_columns
-    
-    #
-    # 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
-    #
-
-    def get_columns!( *headers )
-      data.get_columns!( *headers ); self
-    end
-    alias gc! get_columns!
-    
-    # @overload insert_columns( before, number=1 )
-    #   Insert blank Columns into the data
-    #
-    #   @param [String, Fixnum] before the Column reference to insert before.
-    #   @param [Fixnum] number the number of new Columns to insert
-    #
-    
-    def insert_columns( *args )
-      data.insert_columns( *args ); self
-    end
-    
-    # @overload insert_rows( before, number=1 )
-    #   Insert blank Rows into the data
-    #
-    #   @param [Fixnum] before the Row index to insert before.
-    #   @param [Fixnum] number the number of new Rows to insert
-    #
-    
-    def insert_rows( *args )
-      data.insert_rows( *args ); self
-    end
-    
-    #
-    # View the object for debugging
-    #
-    
-    def inspect
-      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ name }"
-    end
-    
-    #
-    # Populate the Sheet with data (overwrite)
-    #
-    # @param [Array<Array>, Hash<Hash>] input_data the data to fill the Sheet with
-    # @param header_rows [Fixnum] the number of Rows to be treated as headers
-    #
-    
-    def load( input_data, header_rows=1 )
-      input_data = _convert_hash(input_data) if input_data.is_a?(Hash)
-      input_data.is_a?(Array) or fail ArgumentError, 'Input must be an Array or Hash'
-      @header_rows = header_rows
-      @data = Data.new( self, input_data ); self
-    end
-    
-    #
-    # Find the row number by looking up a value in a Column
-    #
-    # @param [String] header the header of the Column to pass to the block
-    # @yield yields each value in the Column to the block
-    # @return [Fixnum, nil] the row number of the first match or nil if nothing is found
-    #
-    
-    def match( header, &block )
-      row_id( column_by_header( header ).find( &block ) )
-    end
-    
-    #
-    # The highest currently used row number
-    #
-    
-    def maxrow
-      data.rows
-    end
-    
-    #
-    # The highest currently used column number
-    #
-    
-    def maxcol
-      data.cols
-    end
-    alias maxcolumn maxcol
-    
-    #
-    # Allow shorthand range references
-    #
-    
-    def method_missing(m, *args, &block)
-      method_name = m.to_s.upcase.strip
-      if method_name =~ /\A[A-Z]{1,3}\d+=?\z/
-        if method_name[-1] == '='
-          range( method_name.chop ).value = ( args.length == 1 ? args.first : args )
-        else
-          range( method_name ).value
-        end
-      else
-        super
-      end
-    end
-    
-    #
-    # Allow for certain method_missing calls
-    #
-    
-    def respond_to?(meth)
-      if meth.to_s.upcase.strip =~ /\A[A-Z]{1,3}\d+=?\z/
-        true
-      else
-        super
-      end
-    end
-    
-    #
-    # Split the Sheet into two Sheets by evaluating each value in a column
-    #
-    # @param [String] header the header of the Column which contains the yield value
-    # @yield [value] yields the value of each row under the given header
-    # @return [Array<RubyExcel::Sheet, RubyExcel::Sheet>] Two Sheets: true and false. Headers included.
-    #
-    
-    def partition( header, &block )
-      data.partition( header, &block ).map { |d| dup.load( d ) }
-    end
-    
-    #
-    # Access an Element by address.
-    #
-    # @param [String, Element] first_cell the first Cell or Address in the Range
-    # @param [String, Element] last_cell the last Cell or Address in the Range
-    # @return [RubyExcel::Element]
-    # @note These are all valid arguments:
-    #   ('A1') 
-    #   ('A1:B2') 
-    #   ('A:A')
-    #   ('1:1')
-    #   ('A1', 'B2') 
-    #   (cell1) 
-    #   (cell1, cell2) 
-    #
-    
-    def range( first_cell, last_cell=nil )
-      Element.new( self, to_range_address( first_cell, last_cell ) )
-    end
-    
-    #
-    # Reverse the Sheet Columns
-    #
-    
-    def reverse_columns!
-      data.reverse_columns!; self
-    end
-    
-    #
-    # Reverse the Sheet Rows (without affecting the headers)
-    #
-    
-    def reverse_rows!
-      data.reverse_rows!; self
-    end
-    
-    #
-    # Create a Row from an index
-    #
-    # @param [Fixnum] index the Row index
-    # @return [RubyExcel::Row]
-    #
 
-    def row( index )
-      Row.new( self, index )
-    end
-    
-    #
-    # Yields each Row to the block
-    #
-    # @param [Fixnum] start_row the Row to start looping from
-    # @param [Fixnum] end_row the Row to end the loop at
-    # @note Iterates to the last Row in the Sheet unless given a second argument.
-    #
-    
-    def rows( start_row = 1, end_row = data.rows )
-      return to_enum(:rows, start_row, end_row) unless block_given?
-      ( start_row..end_row ).each { |idx| yield row( idx ) }; self
-    end
-    alias each rows
-    
-    # {Sheet#sort!}
-    
-    def sort( &block )
-      dup.sort!( &block )
-    end
-    
-    #
-    # Sort the data according to a block (avoiding headers)
-    #
-    
-    def sort!( &block )
-      data.sort!( &block ); self
-    end
-    
-    # {Sheet#sort_by!}
-    
-    def sort_by( header )
-      dup.sort_by!( header )
-    end
-    
-    #
-    # Sort the data by a column, selected by header
-    #
-    # @param [String] header the header to sort the Sheet by
-    #
-    
-    def sort_by!( header )
-      idx = data.index_by_header( header ) - 1
-      sort_method = lambda { |array| array[idx] }
-      data.sort_by!( &sort_method )
-      self
-    end
-    
-    #
-    # Break the Sheet into a Workbook with multiple Sheets, split by the values under a header.
-    #
-    # @param [String] header the header to split by
-    # @return [RubyExcel::Workbook] a new workbook containing the split Sheets (each with headers)
-    #
-    
-    def split( header )
-      wb = Workbook.new
-      ch( header ).each_wh.to_a.uniq.each { |name| wb.add( name ).load( data.headers ) }
-      rows( header_rows+1 ) do |row|
-        wb.sheets( row.val( header ) ) << row
-      end
-      wb
-    end
-    
-    #
-    # Sum the values in a Column by searching another Column
-    #
-    # @param [String] find_header the header of the Column to yield to the block
-    # @param [String] sum_header the header of the Column to sum
-    # @yield yields the find_header column values to the block
-    #
-    
-    def sumif( find_header, sum_header )
-      return to_enum( :sumif ) unless block_given?
-      find_col, sum_col  = ch( find_header ), ch( sum_header )
-      find_col.each_cell.inject(0) { |sum,ce| yield( ce.value ) && ce.row > header_rows ? sum + sum_col[ ce.row ] : sum }
-    end
-    
-    #
-    # Summarise the values of a Column into a Hash
-    #
-    # @param [String] header the header of the Column to summarise
-    # @return [Hash]
-    #
-    
-    def summarise( header )
-      ch( header ).summarise
-    end
-    
-    #
-    # The Sheet as a 2D Array
-    #
-    
-    def to_a
-      data.all
-    end
-    
-    #
-    # The Sheet as a WIN32OLE Excel Workbook
-    # @note This requires Windows and MS Excel
-    #
-    
-    def to_excel
-      workbook.dup.clear_all.add( self.dup ).workbook.to_excel
-    end
-    
-    #
-    # The Sheet as a String containing an HTML Table
-    #
-    
-    def to_html
-      "<table>\n" + data.map { |row| '<tr>' + row.map { |v| '<td>' + CGI.escapeHTML(v.to_s) }.join() + "\n" }.join() + '</table>'
-    end
-    
-    #
-    # The Sheet as a Tab Seperated Value String
-    #
-    
-    def to_s
-      data.map { |ar| ar.map { |v| v.to_s.gsub(/\t|\n/,' ') }.join "\t" }.join( $/ )
-    end
-    
-    # {Sheet#uniq!}
-    
-    def uniq( header )
-      dup.uniq!( header )
-    end
-    
-    #
-    # Remove any Rows with duplicate values within a Column
-    #
-    # @param [String] header the header of the Column to check for duplicates
-    #
-    
-    def uniq!( header )
-      data.uniq!( header ); self
-    end
-    alias unique! uniq!
-    
-    #
-    # Find a value within a Column by searching another Column
-    # 
-    # @param [String] find_header the header of the Column to search
-    # @param [String] return_header the header of the return value Column 
-    # @yield the first matching value
-    #
-    
-    def vlookup( find_header, return_header, &block )
-      find_col, return_col  = ch( find_header ), ch( return_header )
-      return_col[ row_id( find_col.find( &block ) ) ] rescue nil
-    end
-    
-  end # Sheet
-  
 end # RubyExcel

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyexcel
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-03 00:00:00.000000000 Z
+date: 2013-05-07 00:00:00.000000000 Z
 dependencies: []
 description: A tabular data structure in Ruby, with header-based helper methods and
   some of Excel's API style.
@@ -24,6 +24,7 @@ files:
 - lib/rubyexcel/excel_tools.rb
 - lib/rubyexcel/rubyexcel_components.rb
 - lib/rubyexcel/section.rb
+- lib/rubyexcel/sheet.rb
 - lib/rubyexcel.rb
 - lib/README.md
 homepage: https://github.com/VirtuosoJoel