rubyexcel 0.1.5 → 0.1.6

data/lib/rubyexcel/element.rb

@@ -32,7 +32,6 @@ module RubyExcel
     #
     
     def initialize( sheet, addr )
-      fail ArgumentError, "Invalid range: #{ addr }" unless addr =~ /\A[A-Z]{1,3}\d+:[A-Z]{1,3}\d+\z|\A[A-Z]{1,3}\d+\z|\A[A-Z]{1,3}:[A-Z]{1,3}\z|\A\d+:\d+\z/
       @sheet = sheet
       @data = sheet.data
       @address = addr
@@ -63,7 +62,7 @@ module RubyExcel
     
     def each_cell
       return to_enum( :each_cell ) unless block_given?
-      expand( address ).flatten.each { |addr| yield Element.new( sheet, addr ) }
+      expand( address ).flatten.each { |addr| yield Cell.new( sheet, addr ) }
     end
     
     #
@@ -77,11 +76,11 @@ module RubyExcel
     #
     # Return the first cell in the Range
     #
-    # @return [RubyExcel::Element]
+    # @return [RubyExcel::Cell]
     #
     
     def first_cell
-      Element.new( sheet, expand( address ).flatten.first )
+      Cell.new( sheet, expand( address ).flatten.first )
     end
     
     #
@@ -89,17 +88,17 @@ module RubyExcel
     #
     
     def inspect
-      "#{ self.class }:0x#{ '%x' % ( object_id << 1 ) }: #{ address }"
+      "#{ self.class }:0x#{ '%x' % ( object_id << 1 ) }: '#{ address }'"
     end
     
     #
     # Return the last cell in the Range
     #
-    # @return [RubyExcel::Element]
+    # @return [RubyExcel::Cell]
     #
     
     def last_cell
-      Element.new( sheet, expand( address ).flatten.last )
+      Cell.new( sheet, expand( address ).flatten.last )
     end
     
     #
@@ -111,58 +110,105 @@ module RubyExcel
       expand( address ).flatten.each { |addr| data[ addr ] = yield data[ addr ] }
     end
     
+  end
+  
+  #
+  # A single Cell
+  #
+  
+  class Cell < Element
+  
+    def initialize( sheet, addr )
+      fail ArgumentError, "Invalid Cell address: #{ addr }" unless addr =~ /\A[A-Z]{1,3}\d+\z/
+      super
+    end
+
     #
-    # Return the value at this Element's address
+    # Return the value at this Cell's address
     #
-    # @return [Object, Array<Object>] the Object or Array of Objects within the data, referenced by the address
+    # @return [Object ] the Object within the data, referenced by the address
     #
   
     def value
-      address.include?( ':' ) ? expand( address ).map { |ar| ar.map { |addr| data[ addr ] } } : data[ address ]
+      data[ address ]
     end
   
     #
-    # Set the value at this Element's address
+    # Set the value at this Cell's address
+    #
+    # @param [Object] val the Object to write into the data
+    #
+  
+    def value=( val )
+      data[ address ] = val
+    end
+    
+    #
+    # The data at address as a String
+    #
+  
+    def to_s
+      val.to_s
+    end
+    
+  end
+
+  #
+  # A Range of Cells
+  #
+  
+  class Range < Element
+  
+    def initialize( sheet, addr )
+      fail ArgumentError, "Invalid Range address: #{ addr }" unless addr =~ /\A[A-Z]{1,3}\d+:[A-Z]{1,3}\d+\z|\A[A-Z]{1,3}:[A-Z]{1,3}\z|\A\d+:\d+\z/
+      super
+    end
+  
+    #
+    # Return the value at this Range's address
+    #
+    # @return [Array<Object>] the Array of Objects within the data, referenced by the address
+    #
+  
+    def value
+      expand( address ).map { |ar| ar.map { |addr| data[ addr ] } }
+    end
+  
+    #
+    # Set the value at this Range's address
     #
     # @param [Object, Array<Object>] val the Object or Array of Objects to write into the data
     #
   
     def value=( val )
     
-      #Range
-      if address.include? ':'
+      addresses = expand( address )
+      
+      # 2D Array of Values
+      if multi_array?( val ) && addresses.length > 1
       
-        addresses = expand( address )
+        # 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: #{val_rows}, columns: #{ val_cols }. Range - rows: #{ range_rows }, columns: #{ range_cols }"
         
-        # 2D Array of Values
-        if multi_array?( val ) && addresses.length > 1
+        # Write the values in order
+        addresses.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: #{val_rows}, columns: #{ val_cols }. Range - rows: #{ range_rows }, columns: #{ range_cols }"
-          
-          #Write the values in order
-          addresses.each_with_index { |row,idx| row.each_with_index { |el,i| data[el] = val[idx][i] } }
-          
-        # Array of Values
-        elsif val.is_a?( Array )
-          
-          addresses.flatten.each_with_index { |addr, i| data[addr] = val[i] }
-          
-        # Single Value
-        else
+      # Array of Values
+      elsif val.is_a?( Array )
         
-          #Write the same value to every cell in the Range
-          addresses.each { |ar| ar.each { |addr| data[ addr ] = val } }
-          
-        end
-      
-      #Cell
+        # Write the values in order
+        addresses.flatten.each_with_index { |addr, i| data[addr] = val[i] }
+        
+      # Single Value
       else
-        data[ address ] = val
-      end
       
-      self
+        # Write the same value to every cell in the Range
+        addresses.each { |ar| ar.each { |addr| data[ addr ] = val } }
+        
+      end
+    
+      val
     end
     
     #
@@ -170,9 +216,11 @@ module RubyExcel
     #
   
     def to_s
-      value.is_a?( Array ) ? value.map { |ar| ar.join "\t" }.join($/) : value.to_s
+      value.map { |ar| ar.join "\t" }.join($/)
     end
   
+  
   end
+  
+end
 
-end

data/lib/rubyexcel/section.rb

@@ -43,7 +43,7 @@ module RubyExcel
     #
     
     def cell( ref )
-      Element.new( sheet, translate_address( ref ) )
+      Cell.new( sheet, translate_address( ref ) )
     end
   
     #
@@ -79,7 +79,7 @@ module RubyExcel
     
     def each_cell
       return to_enum( :each_cell ) unless block_given?
-      each_address { |addr| yield Element.new( sheet, addr ) }
+      each_address { |addr| yield Cell.new( sheet, addr ) }
     end
     
     #
@@ -88,7 +88,7 @@ module RubyExcel
     
     def each_cell_without_headers
       return to_enum( :each_cell_without_headers ) unless block_given?
-      each_address( false ) { |addr| yield Element.new( sheet, addr ) }
+      each_address( false ) { |addr| yield Cell.new( sheet, addr ) }
     end
     alias each_cell_wh each_cell_without_headers
   
@@ -123,11 +123,11 @@ module RubyExcel
     #
     # Return the last cell
     #
-    # @return [RubyExcel::Element]
+    # @return [RubyExcel::Cell]
     #
   
     def last_cell
-      Element.new( sheet, each_address.to_a.last )
+      Cell.new( sheet, each_address.to_a.last )
     end
   
     #
@@ -215,10 +215,10 @@ module RubyExcel
     end
     
     #
-    # Access a cell by its header
+    # Access a Cell by its header
     #
     # @param [String] header the header to search for
-    # @return [RubyExcel::Element] the cell
+    # @return [RubyExcel::Cell] the cell
     #
   
     def cell_by_header( header )

data/lib/rubyexcel/sheet.rb

@@ -133,16 +133,16 @@ module RubyExcel
     end
     
     #
-    # Access an Element by indices.
+    # Access an Cell by indices.
     #
     # @param [Fixnum] row the row index
     # @param [Fixnum] col the column index
-    # @return [RubyExcel::Element]
+    # @return [RubyExcel::Cell]
     # @note Indexing is 1-based like Excel VBA
     #
     
     def cell( row, col )
-      Element.new( self, indices_to_address( row, col ) )
+      Cell.new( self, indices_to_address( row, col ) )
     end
     alias cells cell
     
@@ -397,11 +397,11 @@ module RubyExcel
     end
     
     #
-    # Access an Element by address.
+    # Access a Range 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]
+    # @param [String, Cell, Range] first_cell the first Cell or Address in the Range
+    # @param [String, Cell, Range] last_cell the last Cell or Address in the Range
+    # @return [RubyExcel::Range]
     # @note These are all valid arguments:
     #   ('A1') 
     #   ('A1:B2') 
@@ -413,7 +413,8 @@ module RubyExcel
     #
     
     def range( first_cell, last_cell=nil )
-      Element.new( self, to_range_address( first_cell, last_cell ) )
+      addr = to_range_address( first_cell, last_cell )
+      addr.include?(':') ? Range.new( self, addr ) : Cell.new( self, addr )
     end
     
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyexcel
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-10 00:00:00.000000000 Z
+date: 2013-05-14 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. Designed for Windows + Excel.