rubyexcel 0.0.1 → 0.0.2

data/lib/rubyexcel/address.rb

@@ -0,0 +1,65 @@
+module RubyExcel
+
+  module Address
+  
+    def address_to_col_index( address )
+      col_index( column_id( address ) )
+    end
+    
+    def address_to_indices( address )
+      [ row_id( address ), address_to_col_index( address ) ]
+    end
+    
+    def col_index( letter )
+      return letter if letter.is_a? Fixnum
+      letter !~ /[^A-Z]/ && [1,2,3].include?( letter.length ) or fail ArgumentError, "Invalid column reference: #{ letter }"
+      idx, a = 1, 'A'
+      loop { return idx if a == letter; idx+=1; a.next! }
+    end
+  
+    def col_letter( index )
+      return index if index.is_a? String
+      index > 0 or fail ArgumentError, 'Indexing is 1-based'
+      a = 'A' ; return a if index == 1
+      (index - 1).times{ a.next! }; a
+    end
+  
+    def column_id( address )
+      address[/[A-Z]+/] or fail ArgumentError, "Invalid address: #{ address }"
+    end
+    
+    def expand( address )
+      return [[address]] unless address.include? ':'
+      start_col, end_col, start_row, end_row = [ address[/^[A-Z]+/], address[/(?<=:)[A-Z]+/] ].sort + [ address.match(/(\d+):/).captures.first, address[/\d+$/] ].sort
+      (start_row..end_row).map { |r| (start_col..end_col).map { |c| "#{ c }#{ r }" } }
+    end
+    
+    def indices_to_address( row_idx, column_idx )
+      [ row_idx, column_idx ].all? { |a| a.is_a?( Fixnum ) } or fail ArgumentError, 'Input must be Fixnum'
+      col_letter( column_idx ) + row_idx.to_s
+    end
+    
+    def multi_array?( obj )
+      obj.all? { |el| el.is_a?( Array ) } && obj.is_a?( Array ) rescue false
+    end
+    
+    def offset(address, row, col)
+      ( col_letter( address_to_col_index( address ) + col ) ) + ( row_id( address ) + row ).to_s
+    end
+    
+    def to_range_address( obj1, obj2 )
+      if obj2
+        obj2.is_a?( String ) ? ( obj1 + ':' + obj2 ) : "#{ obj1.address }:#{ obj2.address }"
+      else
+        obj1.is_a?( String ) ? obj1 : obj1.address
+      end
+    end
+    
+    def row_id( address )
+      return nil unless address
+      address[/\d+/].to_i
+    end
+    
+  end
+  
+end

data/lib/rubyexcel/data.rb

@@ -0,0 +1,172 @@
+module RubyExcel
+
+require_relative 'address.rb'
+
+  class Data
+    attr_reader :rows, :cols
+    attr_accessor :sheet
+    alias parent sheet
+    
+    include Address
+    
+    def initialize( sheet, input_data )
+      @sheet = sheet
+      ( input_data.kind_of?( Array ) &&  input_data.all? { |el| el.kind_of?( Array ) } ) or fail ArgumentError, 'Input must be Array of Arrays'
+      @data = input_data.dup
+      calc_dimensions
+    end
+    
+    def all
+      @data.dup
+    end
+    
+    def append( multi_array )
+      @data
+      @data += multi_array
+      calc_dimensions
+    end
+    
+    def colref_by_header( header )
+      sheet.header_rows > 0 or fail NoMethodError, 'No header rows present'
+      @data[ 0..sheet.header_rows-1 ].each do |r|
+        if ( idx = r.index( header ) )
+          return col_letter( idx+1 ) 
+        end
+      end
+      fail IndexError, "#{ header } is not a valid header"
+    end
+    
+    def compact!
+      compact_columns!
+      compact_rows!
+    end
+    
+    def compact_columns!
+      ensure_shape
+      @data = @data.transpose.delete_if { |ar| ar.all? { |el| el.to_s.empty? } || ar.empty? }.transpose
+      calc_dimensions
+      @data
+    end
+    
+    def compact_rows!
+      @data.delete_if { |ar| ar.all? { |el| el.to_s.empty? } || ar.empty? }
+      calc_dimensions
+      @data
+    end
+    
+    def delete( object )
+      case object
+      when Row
+        @data.slice!( object.idx - 1 )
+      when Column
+        idx = col_index( object.idx ) - 1
+        @data.each { |r| r.slice! idx }
+      when Element
+        addresses = expand( object.address )
+        indices = [ address_to_indices( addresses.first.first ), address_to_indices( addresses.last.last ) ].flatten.map { |n| n-1 }
+        @data[ indices[0]..indices[2] ].each { |r| r.slice!( indices[1], indices[3] - indices[1] + 1 ) }
+        @data.delete_if.with_index { |r,i| r.empty? && i.between?( indices[0], indices[2] ) }
+      else
+        fail NoMethodError, "#{ object.class } is not supported"
+      end
+      self
+    end
+    
+    def delete_column( ref )
+      delete( Column.new( sheet, ref ) )
+    end
+  
+    def delete_row( ref )
+      delete( Row.new( sheet, ref ) )
+    end
+    
+    def delete_range( ref )
+      delete( Element.new( sheet, ref ) )
+    end
+    
+    def dup
+      Data.new( sheet, @data.dup )
+    end
+    
+    def empty?
+      no_headers.empty?
+    end
+
+    def filter!( header )
+      hrows = sheet.header_rows
+      idx = col_index( hrows > 0 ? colref_by_header( header ) : header )
+      @data = @data.select.with_index { |row, i| hrows > i || yield( row[ idx -1 ] ) }
+      calc_dimensions
+      self
+    end
+  
+    def get_columns!( *headers )
+      hrow = sheet.header_rows - 1
+      ensure_shape
+      @data = @data.transpose.select{ |col| headers.include?( col[hrow] ) }
+      ensure_shape
+      @data = @data.sort_by{ |col| headers.index( col[hrow] ) || col[hrow] }.transpose
+      calc_dimensions
+      self
+    end
+        
+    def insert_columns( before, number=1 )
+      a = Array.new( number, nil )
+      before = col_index( before ) - 1
+      @data.map! { |row|  row.insert( before, *a ) }
+    end
+    
+    def insert_rows( before, number=1 )
+      @data = @data.insert( ( col_index( before ) - 1 ), *Array.new( number, [nil] ) )
+    end
+    
+    def no_headers
+      if sheet.header_cols.zero?
+        @data[ sheet.header_rows..-1 ].dup
+      else
+        @data[ sheet.header_rows..-1 ].map { |row| row[ sheet.header_cols..-1 ] }
+      end
+    end
+    
+    def read( addr )
+      row_idx, col_idx = address_to_indices( addr )
+      @data[ row_idx-1 ][ col_idx-1 ]
+    end
+    alias [] read
+    
+    def uniq!( header )
+      column = col_index( colref_by_header( header ) )
+      @data = @data.uniq { |row| row[ column - 1 ] }
+      self
+    end
+    alias unique! uniq!
+    
+    def write( addr, val )
+      row_idx, col_idx = address_to_indices( addr )
+      ( row_idx - rows ).times { @data << [] }
+      @data[ row_idx-1 ][ col_idx-1 ] = val
+      calc_dimensions
+    end
+    alias []= write
+
+    include Enumerable
+    
+    def each
+      @data.each { |ar| yield ar }
+    end
+    
+    private
+    
+    def calc_dimensions
+      @rows, @cols = @data.length, @data.max_by(&:length).length
+    end
+    
+    def ensure_shape
+      calc_dimensions
+      @data.map! { |ar| ar.length == cols ? ar : ar + Array.new( cols - ar.length, nil) }
+      @data
+    end
+    
+  end
+
+end

data/lib/rubyexcel/element.rb

@@ -0,0 +1,68 @@
+module RubyExcel
+
+  class Element
+
+    attr_reader :sheet, :address, :data, :column, :row
+    alias parent sheet
+
+    def initialize( sheet, addr )
+      fail ArgumentError, "Invalid range: #{ addr }" unless addr =~ /\A[A-Z]+\d+:[A-Z]+\d+\z|\A[A-Z]+\d+\z/
+      @sheet = sheet
+      @data = sheet.data
+      @address = addr
+      @column = column_id( addr )
+      @row = row_id( addr )
+    end
+  
+    def delete
+      data.delete( self )
+    end
+  
+    include Address
+  
+    def value
+      if address.include? ':'
+        expand( address ).map { |ar| ar.map { |addr| data[ addr ] } }
+      else
+        data[ address ]
+      end
+    end
+  
+    def value=( val )
+      if address.include? ':'
+        if multi_array?( val )
+          expand( address ).each_with_index { |row,idx| row.each_with_index { |el,i| data[ el ] = val[idx][i] } }
+        else
+          expand( address ).each { |ar| ar.each { |addr| data[ addr ] = val } }
+        end
+      else
+        data[ address ] = val
+      end
+      self
+    end
+  
+    def to_s
+      value.is_a?( Array ) ? value.map { |ar| ar.join "\t" }.join($/) : value.to_s
+    end
+    
+    def inspect
+      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ address }"
+    end
+  
+    include Enumerable
+    
+    def each
+      expand( address ).flatten.each { |addr| yield data[ addr ] }
+    end
+    
+    def each_cell
+      expand( address ).flatten.each { |addr| yield Element.new( sheet, addr ) }
+    end
+  
+    def map!
+      expand( address ).flatten.each { |addr| data[ addr ] = yield data[ addr ] }
+    end
+  
+  end
+
+end

data/lib/rubyexcel/rubyexcel_components.rb

@@ -1,348 +1,16 @@
-module RubyExcel
-
-  module Address
-  
-    def address_to_col_index( address )
-      col_index( column_id( address ) )
-    end
-    
-    def address_to_indices( address )
-      [ row_id( address ), address_to_col_index( address ) ]
-    end
-    
-    def col_index( letter )
-      return letter if letter.is_a? Fixnum
-      letter !~ /[^A-Z]/ && [1,2,3].include?( letter.length ) or fail ArgumentError, "Invalid column reference: #{ letter }"
-      idx, a = 1, 'A'
-      loop { return idx if a == letter; idx+=1; a.next! }
-    end
-  
-    def col_letter( index )
-      return index if index.is_a? String
-      index > 0 or fail ArgumentError, 'Indexing is 1-based'
-      a = 'A' ; return a if index == 1
-      (index - 1).times{ a.next! }; a
-    end
-  
-    def column_id( address )
-      address[/[A-Z]+/] or fail ArgumentError, "Invalid address: #{ address }"
-    end
-    
-    def expand( address )
-      return [[address]] unless address.include? ':'
-      start_col, end_col, start_row, end_row = [ address[/^[A-Z]+/], address[/(?<=:)[A-Z]+/] ].sort + [ address.match(/(\d+):/).captures.first, address[/\d+$/] ].sort
-      (start_row..end_row).map { |r| (start_col..end_col).map { |c| "#{ c }#{ r }" } }
-    end
-    
-    def indices_to_address( row_idx, column_idx )
-      [ row_idx, column_idx ].all? { |a| a.is_a?( Fixnum ) } or fail ArgumentError, 'Input must be Fixnum'
-      col_letter( column_idx ) + row_idx.to_s
-    end
-    
-    def multi_array?( obj )
-      obj.all? { |el| el.is_a?( Array ) } && obj.is_a?( Array ) rescue false
-    end
-    
-    def offset(address, row, col)
-      ( col_letter( address_to_col_index( address ) + col ) ) + ( row_id( address ) + row ).to_s
-    end
-    
-    def to_range_address( obj1, obj2 )
-      if obj2
-        obj2.is_a?( String ) ? ( obj1 + ':' + obj2 ) : "#{ obj1.address }:#{ obj2.address }"
-      else
-        obj1.is_a?( String ) ? obj1 : obj1.address
-      end
-    end
-    
-    def row_id( address )
-      return nil unless address
-      address[/\d+/].to_i
-    end
-    
-  end
-
-  class Data
-    attr_reader :rows, :cols
-    attr_accessor :sheet
-    alias parent sheet
-    
-    include Address
-    
-    def initialize( sheet, input_data )
-      @sheet = sheet
-      ( input_data.kind_of?( Array ) &&  input_data.all? { |el| el.kind_of?( Array ) } ) or fail ArgumentError, 'Input must be Array of Arrays'
-      @data = input_data.dup
-      calc_dimensions
-    end
-    
-    def all
-      @data.dup
-    end
-    
-    def append( multi_array )
-      @data
-      @data += multi_array
-      calc_dimensions
-    end
-    
-    def colref_by_header( header )
-      sheet.header_rows > 0 or fail NoMethodError, 'No header rows present'
-      @data[ 0..sheet.header_rows-1 ].each do |r|
-        if ( idx = r.index( header ) )
-          return col_letter( idx+1 ) 
-        end
-      end
-      fail IndexError, "#{ header } is not a valid header"
-    end
-    
-    def compact!
-      compact_columns!
-      compact_rows!
-    end
-    
-    def compact_columns!
-      ensure_shape
-      @data = @data.transpose.delete_if { |ar| ar.all? { |el| el.to_s.empty? } || ar.empty? }.transpose
-      calc_dimensions
-      @data
-    end
-    
-    def compact_rows!
-      @data.delete_if { |ar| ar.all? { |el| el.to_s.empty? } || ar.empty? }
-      calc_dimensions
-      @data
-    end
-
-    def dup
-      Data.new( sheet, @data.dup )
-    end
-    
-    def empty?
-      no_headers.empty?
-    end
-    
-    def insert_columns( before, number=1 )
-      a = Array.new( number, nil )
-      before = col_index( before ) - 1
-      @data.map! { |row|  row.insert( before, *a ) }
-    end
-    
-    def insert_rows( before, number=1 )
-      @data = @data.insert( ( col_index( before ) - 1 ), *Array.new( number, [nil] ) )
-    end
-    
-    def no_headers
-      if sheet.header_cols.zero?
-        @data[ sheet.header_rows..-1 ].dup
-      else
-        @data[ sheet.header_rows..-1 ].map { |row| row[ sheet.header_cols..-1 ] }
-      end
-    end
-    
-    def read( addr )
-      row_idx, col_idx = address_to_indices( addr )
-      @data[ row_idx-1 ][ col_idx-1 ]
-    end
-    alias [] read
-    
-    def write( addr, val )
-      row_idx, col_idx = address_to_indices( addr )
-      ( row_idx - rows ).times { @data << [] }
-      @data[ row_idx-1 ][ col_idx-1 ] = val
-      calc_dimensions
-    end
-    alias []= write
-
-    include Enumerable
-    
-    def each
-      @data.each { |ar| yield ar }
-    end
-    
-    private
-    
-    def calc_dimensions
-      @rows, @cols = @data.length, @data.max_by(&:length).length
-    end
-    
-    def ensure_shape
-      calc_dimensions
-      @data.map! { |ar| ar.length == cols ? ar : ar + Array.new( cols - ar.length, nil) }
-      @data
-    end
-    
-  end
-
-  class Section
-  
-    include Address
+require_relative 'address.rb'
+require_relative 'data.rb'
+require_relative 'element.rb'
+require_relative 'section.rb'
 
-    attr_reader :sheet, :idx, :data
-    alias parent sheet
-
-    def initialize( sheet )
-      @sheet = sheet
-      @data = sheet.data
-    end
-  
-    def delete
-      data.delete( self )
-    end
-  
-    def empty?
-      all? { |val| val.to_s.empty? }
-    end
-  
-    def find
-      each.with_index { |val,i| return translate_address( i + 1 ) if yield val }; nil
-    end
-  
-    def inspect
-      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ idx }"
-    end
-  
-    def read( id )
-      data[ translate_address( id ) ]
-    end
-    alias [] read
-    
-    def to_s
-      to_a.join ( self.is_a?( Row ) ? "\t" : "\n" )
-    end
-
-    def write( id, val )
-      data[ translate_address( id ) ] = val
-    end
-    alias []= write
-
-    include Enumerable
-
-    def each
-      return to_enum(:each) unless block_given?
-      each_address { |addr| yield data[ addr ] }
-    end
-    
-    def each_cell
-      return to_enum(:each_cell) unless block_given?
-      each_address { |addr| yield Element.new( sheet, addr ) }
-    end
-    
-    def map!
-      return to_enum(:map!) unless block_given?
-      each_address { |addr| data[addr] = ( yield data[addr] ) }
-    end
-
-    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
-
-  class Row < Section
-  
-    attr_reader :idx
-
-    def initialize( sheet, idx )
-      @idx = idx.to_i
-      super( sheet )
-    end
-  
-    private
-
-    def each_address
-      ( 'A'..col_letter( data.cols ) ).each { |col_id| yield "#{col_id}#{idx}" }
-    end
+module RubyExcel
 
+  def self.sample_data
+    a=[];8.times{|t|b=[];c='A';5.times{b<<"#{c}#{t+1}";c.next!};a<<b};a
   end
-
-  class Column < Section
   
-    attr_reader :idx
-    
-    def initialize( sheet, idx )
-      @idx = idx
-      super( sheet )
-    end
-
-    private
-
-    def each_address
-      1.upto( data.rows ) { |row_id| yield idx + row_id.to_s }
-    end
-
+  def self.sample_sheet
+    Workbook.new.load RubyExcel.sample_data
   end
-
-  class Element
-
-    attr_reader :sheet, :address, :data
-    alias parent sheet
-
-    def initialize( sheet, addr )
-      fail ArgumentError, "Invalid range: #{ addr }" unless addr =~ /\A[A-Z]+\d+:[A-Z]+\d+\z|\A[A-Z]+\d+\z/
-      @sheet = sheet
-      @data = sheet.data
-      @address = addr
-    end
-  
-    def delete
-      data.delete( self )
-    end
-  
-    include Address
-  
-    def value
-      if address.include? ':'
-        expand( address ).map { |ar| ar.map { |addr| data[ addr ] } }
-      else
-        data[ address ]
-      end
-    end
-  
-    def value=( val )
-      if address.include? ':'
-        if multi_array?( val )
-          expand( address ).each_with_index { |row,idx| row.each_with_index { |el,i| data[ el ] = val[idx][i] } }
-        else
-          expand( address ).each { |ar| ar.each { |addr| data[ addr ] = val } }
-        end
-      else
-        data[ address ] = val
-      end
-      self
-    end
-  
-    def to_s
-      value.is_a?( Array ) ? value.map { |ar| ar.join "\t" }.join($/) : value.to_s
-    end
-    
-    def inspect
-      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ address }"
-    end
-  
-    include Enumerable
-    
-    def each
-      expand( address ).flatten.each { |addr| yield data[ addr ] }
-    end
-    
-    def each_cell
-      expand( address ).flatten.each { |addr| yield Element.new( sheet, addr ) }
-    end
-  
-    def map!
-      expand( address ).flatten.each { |addr| data[ addr ] = yield data[ addr ] }
-    end
-  
-  end
-
+ 
 end

data/lib/rubyexcel/section.rb

@@ -0,0 +1,144 @@
+module RubyExcel
+
+  class Section
+  
+    include Address
+
+    attr_reader :sheet, :idx, :data
+    alias parent sheet
+
+    def initialize( sheet )
+      @sheet = sheet
+      @data = sheet.data
+    end
+  
+    def <<( value )
+      if self.is_a? Row
+        lastone = ( col_index( idx ) == 1 ? data.cols + 1 : data.cols )
+      else
+        lastone = ( col_index( idx ) == 1 ? data.rows + 1 : data.rows )
+      end
+      data[ translate_address( lastone ) ] = value
+    end
+  
+    def delete
+      data.delete( self )
+    end
+  
+    def empty?
+      all? { |val| val.to_s.empty? }
+    end
+  
+    def find
+      each_cell { |ce| return ce.address if yield ce.value }; nil
+    end
+  
+    def inspect
+      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ idx }"
+    end
+  
+    def read( id )
+      data[ translate_address( id ) ]
+    end
+    alias [] read
+    
+    def summarise
+      h = Hash.new(0)
+      each_wh { |v| h[v]+=1 }; h
+    end
+    alias summarize summarise
+    
+    def to_s
+      to_a.join ( self.is_a?( Row ) ? "\t" : "\n" )
+    end
+
+    def write( id, val )
+      data[ translate_address( id ) ] = val
+    end
+    alias []= write
+
+    include Enumerable
+
+    def each
+      return to_enum(:each) unless block_given?
+      each_address { |addr| yield data[ addr ] }
+    end
+    
+    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
+    
+    def each_cell
+      return to_enum(:each_cell) unless block_given?
+      each_address { |addr| yield Element.new( sheet, addr ) }
+    end
+    
+    def map!
+      return to_enum(:map!) unless block_given?
+      each_address { |addr| data[addr] = ( yield data[addr] ) }
+    end
+
+    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
+
+  class Row < Section
+  
+    attr_reader :idx
+
+    def initialize( sheet, idx )
+      @idx = idx.to_i
+      super( sheet )
+    end
+  
+    def getref( header )
+      column_id( sheet.row(1).find &/#{header}/ )
+    end
+
+    private
+
+    def each_address
+      ( 'A'..col_letter( data.cols ) ).each { |col_id| yield "#{col_id}#{idx}" }
+    end
+    
+    def each_address_without_headers
+      ( col_letter( sheet.header_cols+1 )..col_letter( data.cols ) ).each { |col_id| yield "#{col_id}#{idx}" }
+    end
+
+  end
+
+  class Column < Section
+  
+    attr_reader :idx
+    
+    def initialize( sheet, idx )
+      @idx = idx
+      super( sheet )
+    end
+
+    private
+    
+    def each_address
+      ( 1..data.rows ).each { |row_id| yield idx + row_id.to_s }
+    end
+
+    def each_address_without_headers
+      ( sheet.header_rows+1 ).upto( data.rows ) { |row_id| yield idx + row_id.to_s }
+    end
+
+  end
+
+end

data/lib/rubyexcel.rb

@@ -1,5 +1,4 @@
 require_relative 'rubyexcel/rubyexcel_components.rb'
-require_relative 'rubyexcel/rubyexcel_advanced.rb'
 require_relative 'rubyexcel/excel_tools.rb'
 
 class Regexp
@@ -18,8 +17,8 @@ module RubyExcel
     
     def <<( other )
       case other
-      when RubyExcel
-        other.each { |s| @sheets << s }
+      when Workbook
+        other.inject( @sheets, :<< )
       when Sheet
         @sheets << other
       end
@@ -124,6 +123,33 @@ module RubyExcel
       range( addr ).value = val
     end
 
+ 
+    def +( other )
+      dup << other
+    end
+    
+    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
+    
+    def <<( other )
+      case other
+      when Array
+        load( data.all + other, header_rows, header_cols )
+      when Sheet
+        load( data.all + other.data.no_headers, header_rows, header_cols )
+      else
+        fail ArgumentError, "Unsupported class: #{ other.class }"
+      end
+    end
+    
     def cell( row, col )
       Element.new( self, indices_to_address( row, col ) )
     end
@@ -133,24 +159,21 @@ module RubyExcel
       Column.new( self, col_letter( index ) )
     end
     
+    def column_by_header( header )
+      Column.new( self, data.colref_by_header( header ) )
+    end
+    alias ch column_by_header
+    
     def columns( start_column = 'A', end_column = data.cols )
       start_column, end_column = col_letter( start_column ), col_letter( end_column )
       return to_enum(:columns, start_column, end_column) unless block_given?
       ( start_column..end_column ).each { |idx| yield column( idx ) }
     end
     
-    def get_columns( *headers )
-      s = dup
-      s.data.get_columns!( *headers )
-      s
-    end
-    alias gc get_columns
-    
-    def get_columns!( *headers )
-      data.get_columns!( *headers )
+    def compact!
+      data.compact!
       self
     end
-    alias gc! get_columns!
     
     def delete
       workbook.delete self
@@ -167,6 +190,32 @@ module RubyExcel
       s
     end
     
+    def empty?
+      data.empty?
+    end
+    
+    def filter( ref, &block )
+      dup.filter!( ref, &block )
+    end
+
+    def filter!( ref, &block )
+      data.filter!( ref, &block )
+      self
+    end
+    
+    def get_columns( *headers )
+      s = dup
+      s.data.get_columns!( *headers )
+      s
+    end
+    alias gc get_columns
+    
+    def get_columns!( *headers )
+      data.get_columns!( *headers )
+      self
+    end
+    alias gc! get_columns!
+    
     def insert_columns( *args )
       data.insert_columns( *args )
       self
@@ -213,6 +262,16 @@ module RubyExcel
       ( start_row..end_row ).each { |idx| yield row( idx ) }
     end
     
+    def sumif( find_header, sum_header )
+      col1 = column_by_header( find_header )
+      col2 = column_by_header( sum_header )
+      total = 0
+      col1.each_cell do |ce|
+        total += col2[ ce.row ].to_i if yield( ce.value ) && ce.row >= header_rows
+      end
+      total
+    end
+    
     def to_a
       data.all
     end
@@ -225,6 +284,12 @@ module RubyExcel
       data.nil? ? '' : data.map { |ar| ar.join "\t" }.join( $/ )
     end
     
+    def uniq!( header )
+      data.uniq!( header )
+      self
+    end
+    alias unique! uniq!
+    
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyexcel
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-23 00:00:00.000000000 Z
+date: 2013-04-02 00:00:00.000000000 Z
 dependencies: []
 description: A tabular data structure, mixing Ruby with some of Excel's API.
 email: 
@@ -20,7 +20,10 @@ files:
 - lib/rubyexcel.rb
 - lib/rubyexcel/excel_tools.rb
 - lib/rubyexcel/rubyexcel_components.rb
-- lib/rubyexcel/rubyexcel_advanced.rb
+- lib/rubyexcel/data.rb
+- lib/rubyexcel/element.rb
+- lib/rubyexcel/section.rb
+- lib/rubyexcel/address.rb
 homepage: 
 licenses: []
 post_install_message: 

data/lib/rubyexcel/rubyexcel_advanced.rb

@@ -1,164 +0,0 @@
-module RubyExcel
-
-  def self.sample_data
-    a=[];8.times{|t|b=[];c='A';5.times{b<<"#{c}#{t+1}";c.next!};a<<b};a
-  end
-  
-  def self.sample_sheet
-    Workbook.new.load RubyExcel.sample_data
-  end
-
-  class Sheet
-  
-    def +( other )
-      dup << other
-    end
-    
-    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
-    
-    def <<( other )
-      case other
-      when Array
-        load( data.all + other, header_rows, header_cols )
-      when Sheet
-        load( data.all + other.data.no_headers, header_rows, header_cols )
-      else
-        fail ArgumentError, "Unsupported class: #{ other.class }"
-      end
-    end
-    
-    def compact!
-      data.compact!
-      self
-    end
-    
-    def empty?
-      data.empty?
-    end
-    
-    def column_by_header( header )
-      Column.new( self, data.colref_by_header( header ) )
-    end
-    alias ch column_by_header
-
-    def filter!( ref, &block )
-      data.filter!( ref, &block )
-      self
-    end
-    
-    def sumif( find_header, sum_header )
-      col1 = column_by_header( find_header )
-      col2 = column_by_header( sum_header )
-      total = 0
-      col1.each.with_index do |val,idx|
-        total += ( ( n = col2[ idx + 1 ] ).is_a?( String ) ? n.to_i : n ) if yield( val ) && idx >= header_rows
-      end
-      total
-    end
-    
-    def uniq!( header )
-      data.uniq!( header )
-      self
-    end
-    alias unique! uniq!
-    
-  end
-  
-  class Data
-  
-    def delete( object )
-      case object
-      when Row
-        @data.slice!( object.idx - 1 )
-      when Column
-        idx = col_index( object.idx ) - 1
-        @data.each { |r| r.slice! idx }
-      when Element
-        addresses = expand( object.address )
-        indices = [ address_to_indices( addresses.first.first ), address_to_indices( addresses.last.last ) ].flatten.map { |n| n-1 }
-        @data[ indices[0]..indices[2] ].each { |r| r.slice!( indices[1], indices[3] - indices[1] + 1 ) }
-        @data.delete_if.with_index { |r,i| r.empty? && i.between?( indices[0], indices[2] ) }
-      else
-        fail NoMethodError, "#{ object.class } is not supported"
-      end
-      self
-    end
-    
-    def delete_column( ref )
-      delete( Column.new( sheet, ref ) )
-    end
-  
-    def delete_row( ref )
-      delete( Row.new( sheet, ref ) )
-    end
-    
-    def delete_range( ref )
-      delete( Element.new( sheet, ref ) )
-    end
-  
-    def filter!( header )
-      hrows = sheet.header_rows
-      idx = col_index( hrows > 0 ? colref_by_header( header ) : header )
-      @data = @data.select.with_index { |row, i| hrows > i || yield( row[ idx -1 ] ) }
-      calc_dimensions
-      self
-    end
-  
-    def get_columns!( *headers )
-      hrow = sheet.header_rows - 1
-      ensure_shape
-      @data = @data.transpose.select{ |col| headers.include?( col[hrow] ) }
-      ensure_shape
-      @data = @data.sort_by{ |col| headers.index( col[hrow] ) || col[hrow] }.transpose
-      calc_dimensions
-      self
-    end
-    
-    def uniq!( header )
-      column = col_index( colref_by_header( header ) )
-      @data = @data.uniq { |row| row[ column - 1 ] }
-      self
-    end
-    alias unique! uniq!
-
-  end
-  
-  class Section
-  
-    def <<( value )
-      if self.is_a? Row
-        lastone = ( col_index( idx ) == 1 ? data.cols + 1 : data.cols )
-      else
-        lastone = ( col_index( idx ) == 1 ? data.rows + 1 : data.rows )
-      end
-      data[ translate_address( lastone ) ] = value
-    end
-
-  end
-
-  class Row < Section
-  
-    def getref( header )
-      column_id( sheet.row(1).find &/#{header}/ )
-    end
-
-  end
-
-  class Column < Section
-
-  end
-
-  class Element
-
-  end
-
-end