rubyexcel 0.0.1

data/lib/rubyexcel/excel_tools.rb

@@ -0,0 +1,54 @@
+
+module Excel_Tools
+
+  require 'win32ole'
+
+  def get_excel
+    excel = WIN32OLE::connect( 'excel.application' ) rescue WIN32OLE::new( 'excel.application' )
+    excel.visible = true
+    excel
+  end
+  
+  def get_workbook( excel=nil )
+    excel ||= get_excel
+    wb = excel.workbooks.add
+    ( ( wb.sheets.count.to_i ) - 1 ).times { |time| wb.sheets(2).delete }
+    wb
+  end
+  
+  def dump_to_sheet( data, sheet=nil )
+    fail ArgumentError, "Invalid data type: #{ data.class }" unless data.is_a?( Array ) || data.is_a?( RubyExcel )
+    data = data.to_a if data.is_a? RubyExcel
+    sheet ||= get_workbook.sheets(1)
+    sheet.range( sheet.cells( 1, 1 ), sheet.cells( data.length, data[0].length ) ).value = data
+    sheet
+  end
+  
+  def make_sheet_pretty( sheet )
+    c = sheet.cells
+    c.EntireColumn.AutoFit
+    c.HorizontalAlignment = -4108
+    c.VerticalAlignment = -4108
+    sheet
+  end
+  
+  def to_excel
+    fail NoMethodError, 'Duplicate sheet name' if self.sheets.count != self.sheets.map(&:name).uniq.length
+    wb = get_workbook
+    wb.parent.DisplayAlerts = false
+    first_time = true
+    self.each do |s|
+      sht = ( first_time ? wb.sheets(1) : wb.sheets.add( { 'after' => wb.sheets( wb.sheets.count ) } ) ); first_time = false
+      sht.name = s.name
+      make_sheet_pretty( dump_to_sheet( s.data.all, sht ) )
+    end
+    wb.sheets(1).select
+    wb
+  end
+
+  def save_excel( filename = 'Output.xlsx' )
+    filename = Dir.pwd.gsub('/','\\') + '\\' + filename unless filename.include?('\\')
+    to_excel.saveas filename
+  end
+  
+end

data/lib/rubyexcel/rubyexcel_advanced.rb

@@ -0,0 +1,164 @@
+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

data/lib/rubyexcel/rubyexcel_components.rb

@@ -0,0 +1,348 @@
+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
+
+    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
+
+  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
+
+  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.rb

@@ -0,0 +1,230 @@
+require_relative 'rubyexcel/rubyexcel_components.rb'
+require_relative 'rubyexcel/rubyexcel_advanced.rb'
+require_relative 'rubyexcel/excel_tools.rb'
+
+class Regexp
+  def to_proc
+    proc { |s| self =~ s.to_s }
+  end
+end
+
+module RubyExcel
+
+  class Workbook
+
+    def initialize
+      @sheets = []
+    end
+    
+    def <<( other )
+      case other
+      when RubyExcel
+        other.each { |s| @sheets << s }
+      when Sheet
+        @sheets << other
+      end
+    end
+    
+    def add( ref=nil )
+      case ref
+      when nil
+        s = Sheet.new( 'Sheet' + ( @sheets.count + 1 ).to_s, self )
+      when Sheet
+        s = ref
+        s.workbook = self
+      when String
+        s = Sheet.new( ref, self )
+      else
+        fail TypeError, "Unsupported Type: #{ ref.class }"
+      end
+      @sheets << s
+      s
+    end
+    alias add_sheet add
+    
+    def clear_all
+      @sheets = []
+      self
+    end
+    
+    def delete( ref )
+      case ref
+      when Fixnum
+        @sheets.delete_at( ref - 1 )
+      when String
+        @sheets.reject! { |s| s.name == ref }
+      when Regexp
+        @sheets.reject! { |s| s.name =~ ref }
+      when Sheet
+        @sheets.reject! { |s| s == ref }
+      else
+        fail ArgumentError, "Unrecognised Argument Type: #{ ref.class }"
+      end
+    end
+    
+    def dup
+      wb = Workbook.new
+      self.each {|s| wb.add s.dup }
+      wb
+    end
+    
+    def empty?
+      @sheets.empty?
+    end
+    
+    def load( *args )
+      add.load( *args )
+    end
+    
+    def sheets( ref=nil )
+      return to_enum (:each) if ref.nil?
+      ref.is_a?( Fixnum ) ? @sheets[ ref - 1 ] : @sheets.find { |s| s.name =~ /^#{ ref }$/i }
+    end
+    
+    def sort_by!( &block )
+      if block_given?
+        @sheets = @sheets.sort_by(&block)
+      else
+        @sheets = @sheets.sort_by(&:name)
+      end
+    end
+    alias sort! sort_by!
+    
+    include Enumerable
+    
+    def each
+      return to_enum(:each) unless block_given?
+      @sheets.each { |s| yield s }
+    end
+    
+    include Excel_Tools
+    
+  end
+
+  class Sheet
+
+    attr_reader :data
+    attr_accessor :name, :header_rows, :header_cols, :workbook
+    alias parent workbook
+    
+    include Address
+    
+    def initialize( name, workbook )
+      @workbook = workbook
+      @name = name
+      @header_rows, @header_cols = nil, nil
+      @data = Data.new( self, [[]] )
+    end
+
+    def[]( addr )
+      range( addr ).value
+    end
+
+    def []=( addr, val )
+      range( addr ).value = val
+    end
+
+    def cell( row, col )
+      Element.new( self, indices_to_address( row, col ) )
+    end
+    alias cells cell
+    
+    def column( index )
+      Column.new( self, col_letter( index ) )
+    end
+    
+    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 )
+      self
+    end
+    alias gc! get_columns!
+    
+    def delete
+      workbook.delete self
+    end
+    
+    def dup
+      s = Sheet.new( name, workbook )
+      d = data
+      unless d.nil?
+        d = d.dup
+        s.load( d.all, header_rows, header_cols )
+        d.sheet = s
+      end
+      s
+    end
+    
+    def insert_columns( *args )
+      data.insert_columns( *args )
+      self
+    end
+    
+    def insert_rows( *args )
+      data.insert_rows( *args )
+      self
+    end
+    
+    def inspect
+      "#{ self.class }:0x#{ '%x' % (object_id << 1) }: #{ name }"
+    end
+    
+    def load( input_data, header_rows=1, header_cols=0 )
+      @header_rows, @header_cols = header_rows, header_cols
+      @data = Data.new( self, input_data )
+      self
+    end
+    
+    def match( header, &block )
+      row_id( column_by_header( header ).find( &block ) )
+    end
+    
+    def maxrow
+      data.rows
+    end
+    
+    def maxcol
+      data.cols
+    end
+    alias maxcolumn maxcol
+    
+    def range( first_cell, last_cell=nil )
+      Element.new( self, to_range_address( first_cell, last_cell ) )
+    end
+
+    def row( index )
+      Row.new( self, index )
+    end
+    
+    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 ) }
+    end
+    
+    def to_a
+      data.all
+    end
+    
+    def to_excel
+      workbook.dup.clear_all.add( self.dup ).workbook.to_excel
+    end
+    
+    def to_s
+      data.nil? ? '' : data.map { |ar| ar.join "\t" }.join( $/ )
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: rubyexcel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joel Pearson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-23 00:00:00.000000000 Z
+dependencies: []
+description: A tabular data structure, mixing Ruby with some of Excel's API.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rubyexcel.rb
+- lib/rubyexcel/excel_tools.rb
+- lib/rubyexcel/rubyexcel_components.rb
+- lib/rubyexcel/rubyexcel_advanced.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Spreadsheets in Ruby
+test_files: []
+has_rdoc: