rspreadsheet 0.2.12 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e934c460d044d82af82b8cb6aa7fb8d9336ef961
-  data.tar.gz: fc75adfff414efcfbf0649b9262c4faf23bfb292
+  metadata.gz: d2f168c71e8ec1b014d48658b230c03780c6fb40
+  data.tar.gz: 11aaf6ed2a306be9eb3a2f3dcfa89dffed291f88
 SHA512:
-  metadata.gz: 35d61b752404f07748c738225895d61d5bfe11aeb2512042e272075a48b6b44112cb849671231d05bcbffe70fa74b188fd92c18f52545aa95dbe488ce0c1e374
-  data.tar.gz: ae2c7fe343d5a75c469a36b594ead4551faf341bcb2c2ade99c3cf4c046c54aa66074d08cb689bcd4cd3fa042ce430543133cf7dc5af066513370255a81cd501
+  metadata.gz: fa517af98e5a410bd50f9bb62a878b8752bed69bc77eb1cff3d50dcb05839c4a81956417a64a8b3f32b55376c1906d3c983c3260e426ccdc69145768063e6639
+  data.tar.gz: 95e37cd4a06b66f107b612c8467ca91f2524bf61477208129e159dc0a479a476bc9be5e965eefd1b573c70919b2fd8cb28ce33d0eb5c299064cbef044bbe5a56

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.1.2
+  - 2.2.3
+  - 2.2.0
+  - 2.1.7
   - 2.0.0
   - 1.9.3
 script: 'bundle exec rake'

data/DEVEL_BLOG.md

@@ -49,6 +49,10 @@ RSpreadsheet.generate('pricelist.ods') do
   * Range#merge() - Merges the cells in the range together into a single block.
 * @book.sheet_names - Array of names of sheets.
 
+
+* array returned by rows of cells can have predefined dummy object as defaults for out of range indexes
+
+
 ##Guiding ideas
   * xml document is always synchronized with the data. So the save is trivial.
   * no duplication of data. Objects like RowArray should containg minimum information. This one exists solely to speed up cell search. Taken to extream it is questionable, whether we need such objects at all, it might be possible to always work with xml directly.

data/GUIDE.md

@@ -7,14 +7,14 @@ You can open ODS file like this
 ````
 and access its first sheet like this
 ````ruby
-@sheet = @workbook.worksheets(1)
+@sheet = @workbook.worksheet(1)
 ````
 ### Accessing cells
 
 you can get and set contents of cells using "verbatim" syntax like
 ````ruby
-@sheet.rows(5).cells(4).value 
-@sheet.rows(5).cells(4).value = 10
+@sheet.row(5).cell(4).value 
+@sheet.row(5).cell(4).value = 10
 ````
 or using "brief" syntax like
 ````ruby
@@ -24,7 +24,7 @@ or using "brief" syntax like
 
 You can mix these two at will, for example like this
 ````ruby
-@row = @sheet.rows(5)
+@row = @sheet.row(5)
 @row[4] = 10
 ````
 
@@ -37,5 +37,6 @@ You can mix these two at will, for example like this
   * **all indexes are 1-based**. This applies to rows, cells cordinates, and all array like structures like list od  worksheets etc. Spreadsheet world is 1-based, ruby is 0-based do I had to make a decision. I intend to make an global option for this, but in early stage I need to keep things simple. 
   * with numeric coordinates row always comes before col as in  (row,col)
   * with alphanumerical col always comes before row as in F12
-  * Shorter syntax worksheet[x,y] returns value, longer syntax worksheet.cells(x,y) return cell objects. This allows to work conviniently with values using short syntax and access the cell object if needed (to access formatting for example).
+  * Shorter syntax worksheet[x,y] returns value, longer syntax worksheet.cell(x,y) return cell objects. This allows to work conviniently with values using short syntax and access the cell object if needed (to access formatting for example).
+  * Note: currently plural and singular like sheet/sheets, row/rows, cell/cells can be used intergangebly, but there is a (discussion)[https://github.com/gorn/rspreadsheet/issues/10] about this and in future versions we might use singular style for methods and plural for array style.
 

data/README.md

@@ -16,20 +16,20 @@ sheet = book.worksheets(1)
 # get value of a cell B5 (there are more ways to do this)
 sheet.B5                       # => 'cell value'
 sheet[5,2]                     # => 'cell value'
-sheet.rows(5).cells(2).value   # => 'cell value'
+sheet.row(5).cell(2).value   # => 'cell value'
 
 # set value of a cell B5
 sheet.F5 = 'text'
 sheet[5,2] = 7
-sheet.cells(5,2).value = 1.78
+sheet.cell(5,2).value = 1.78
 
 # working with cell format
-sheet.cells(5,2).format.bold = true
-sheet.cells(5,2).format.background_color = '#FF0000'
+sheet.cell(5,2).format.bold = true
+sheet.cell(5,2).format.background_color = '#FF0000'
 
 # calculate sum of cells in row
-sheet.rows(5).cellvalues.sum
-sheet.rows(5).cells.sum{ |cell| cell.value.to_f }
+sheet.row(5).cellvalues.sum
+sheet.row(5).cells.sum{ |cell| cell.value.to_f }
 
 # or set formula to a cell
 sheet.A1.formula='=SUM(A2:A9)'

data/lib/helpers/class_extensions.rb

@@ -1,49 +1,105 @@
-# @private
+if  RUBY_VERSION > '2.1'
+
+  module ClassExtensions
+
+    refine Array do
+      def sum(identity = 0, &block)
+        if block_given?
+          map(&block).sum(identity)
+        else
+          inject(0){ |sum, element| sum.to_f + element.to_f } || identity
+        end
+      end
+    end
+
+    refine LibXML::XML::Node do
+      def ==(node2)  
+        self.simplification_of?(node2) and node2.simplification_of?(self)
+      end
+      # if node2 contains at least all that I do
+      def simplification_of?(node2)
+        first_diff(node2).nil?
+      end
+      # return first difference where self has something more than node2 does
+      def first_diff(node2)
+        where = self.path.split('/').last
+        
+        return "#{where}> Equivalent node does not exist: #{self.name} != NOTHING" if node2.nil?
+        return "#{where}> Names are different: #{self.name} != #{node2.name}" if (self.name != node2.name)
+        self.attributes.each do |attr|
+          return "#{where}> Attribute #{attr} have diffent values: #{attr.value} != #{node2.attributes[attr.name]}" unless node2.attributes[attr.name] == attr.value
+        end
+        
+        elems1 = self.elements
+        elems2 = node2.elements
+    #     return "#{where}> elements have different number of subelements #{elems1.length} !=  #{elems2.length}" if (elems1.length != elems2.length) 
+        elems1.length.times do |i|
+          if (elems1[i].node_type_name == 'text') && ((elems1[i].to_s != elems2[i].to_s) )
+            return  "#{where}> #{i+1}th text subelements are different: #{elems1[i].to_s} != #{elems2[i].to_s}"
+          elsif (elems1[i].node_type_name == 'element') && (!elems1[i].simplification_of?(elems2[i]))
+            return "#{where}/[#{i+1}]#{elems1[i].first_diff(elems2[i])}"
+          end
+        end
+          
+        return nil
+      end
+      def elements
+        result = []
+        each_element { |e| result << e }
+        return result
+      end
 
-class LibXML::XML::Node
-  def elements
-    result = []
-    each_element { |e| result << e }
-    return result
-  end
-  # if node2 contains at least all that I do
-  def simplification_of?(node2)
-    first_diff(node2).nil?
-  end
-  # return first difference where self has something more than node2 does
-  def first_diff(node2)
-    where = self.path.split('/').last
-    
-    return "#{where}> Equivalent node does not exist: #{self.name} != NOTHING" if node2.nil?
-    return "#{where}> Names are different: #{self.name} != #{node2.name}" if (self.name != node2.name)
-    self.attributes.each do |attr|
-      return "#{where}> Attribute #{attr} have diffent values: #{attr.value} != #{node2.attributes[attr.name]}" unless node2.attributes[attr.name] == attr.value
     end
     
-    elems1 = self.elements
-    elems2 = node2.elements
-#     return "#{where}> elements have different number of subelements #{elems1.length} !=  #{elems2.length}" if (elems1.length != elems2.length) 
-    elems1.length.times do |i|
-      if (elems1[i].node_type_name == 'text') && ((elems1[i].to_s != elems2[i].to_s) )
-        return  "#{where}> #{i+1}th text subelements are different: #{elems1[i].to_s} != #{elems2[i].to_s}"
-      elsif (elems1[i].node_type_name == 'element') && (!elems1[i].simplification_of?(elems2[i]))
-        return "#{where}/[#{i+1}]#{elems1[i].first_diff(elems2[i])}"
+  end # module ClassExtensions
+
+else # Monkeypatching
+  class Array
+    def sum(identity = 0, &block)
+      if block_given?
+        map(&block).sum(identity)
+      else
+        inject(0){ |sum, element| sum.to_f + element.to_f } || identity
       end
     end
-       
-    return nil
   end
-  def equals?(node2)  #TODO redefine == with this
-    self.simplification_of?(node2) and node2.simplification_of?(self)
-  end
-end
 
-class Array
-  def sum(identity = 0, &block)
-    if block_given?
-      map(&block).sum(identity)
-    else
-      inject(0){ |sum, element| sum.to_f + element.to_f } || identity
+  class LibXML::XML::Node
+    def ==(node2)  
+      self.simplification_of?(node2) and node2.simplification_of?(self)
+    end
+    # if node2 contains at least all that I do
+    def simplification_of?(node2)
+      first_diff(node2).nil?
     end
+    # return first difference where self has something more than node2 does
+    def first_diff(node2)
+      where = self.path.split('/').last
+      
+      return "#{where}> Equivalent node does not exist: #{self.name} != NOTHING" if node2.nil?
+      return "#{where}> Names are different: #{self.name} != #{node2.name}" if (self.name != node2.name)
+      self.attributes.each do |attr|
+        return "#{where}> Attribute #{attr} have diffent values: #{attr.value} != #{node2.attributes[attr.name]}" unless node2.attributes[attr.name] == attr.value
+      end
+      
+      elems1 = self.elements
+      elems2 = node2.elements
+  #     return "#{where}> elements have different number of subelements #{elems1.length} !=  #{elems2.length}" if (elems1.length != elems2.length) 
+      elems1.length.times do |i|
+        if (elems1[i].node_type_name == 'text') && ((elems1[i].to_s != elems2[i].to_s) )
+          return  "#{where}> #{i+1}th text subelements are different: #{elems1[i].to_s} != #{elems2[i].to_s}"
+        elsif (elems1[i].node_type_name == 'element') && (!elems1[i].simplification_of?(elems2[i]))
+          return "#{where}/[#{i+1}]#{elems1[i].first_diff(elems2[i])}"
+        end
+      end
+        
+      return nil
+    end
+    def elements
+      result = []
+      each_element { |e| result << e }
+      return result
+    end
+
   end
 end

data/lib/rspreadsheet/cell.rb

@@ -7,8 +7,10 @@ require 'rspreadsheet/xml_tied'
 require 'date'
 require 'bigdecimal'
 require 'bigdecimal/util' # for to_d method
+require 'helpers/class_extensions'
 
 module Rspreadsheet
+using ClassExtensions if RUBY_VERSION > '2.1'
 
 ###
 # Represents a cell in spreadsheet which has coordinates, contains value, formula and can be formated.
@@ -40,7 +42,7 @@ class Cell < XMLTiedItem
   def coordinates; [rowi,coli] end
   def to_s; value.to_s end
   def valuexml; self.valuexmlnode.andand.inner_xml end
-  def valuexmlnode; self.xmlnode.children.first end
+  def valuexmlnode; self.xmlnode.elements.first end
   # use this to find node in cell xml. ex. xmlfind('.//text:a') finds all link nodes
   def valuexmlfindall(path)
     valuexmlnode.nil? ? [] : valuexmlnode.find(path)
@@ -150,10 +152,10 @@ class Cell < XMLTiedItem
         when 'N/A' then :unassigned
         when 'currency' then :currency
         else 
-          if xmlnode.children.size == 0
+          if xmlnode.elements.size == 0
             nil
           else 
-            raise "Unknown type at #{coordinates.to_s} from #{xmlnode.to_s} / children size=#{xmlnode.children.size.to_s} / type=#{xmlnode.attributes['value-type'].to_s}"
+            raise "Unknown type at #{coordinates.to_s} from #{xmlnode.to_s} / elements size=#{xmlnode.elements.size.to_s} / type=#{xmlnode.attributes['value-type'].to_s}"
           end
       end
 

data/lib/rspreadsheet/column.rb

@@ -0,0 +1,17 @@
+module Rspreadsheet
+
+# Represents a columns in a spreadsheet. Similar to Row object, but 
+# currently only partly implemented
+
+class Column
+  def initialize(aworksheet,acoli)
+    @worksheet = aworksheet
+    @coli = acoli
+  end
+  def cell(rowi)
+    @worksheet.row(rowi).cell(@coli)
+  
+  end
+end
+
+end

data/lib/rspreadsheet/row.rb

@@ -7,7 +7,7 @@ module Rspreadsheet
 # Represents a row in a spreadsheet which has coordinates, contains value, formula and can be formated.
 # You can get this object like this (suppose that @worksheet contains {Rspreadsheet::Worksheet} object)
 #
-#     @row = @worksheet.rows(5)
+#     @row = @worksheet.row(5)
 #
 # Mostly you will this object to access row cells values
 #
@@ -15,7 +15,7 @@ module Rspreadsheet
 #
 # or directly row `Cell` objects
 #
-#     @row.cells(2)     # => identical to @worksheet.rows(5).cells(2)
+#     @row.cell(2)     # => identical to @worksheet.rows(5).cells(2)
 #
 # You can use it to manipulate rows
 #
@@ -43,6 +43,7 @@ class Row < XMLTiedItem
     
  # @!group Syntactic sugar
   def cells(*params); subitems(*params) end
+  alias :cell :cells
   
   ## @return [String or Float or Date] value of the cell
   # @param coli [Integer] colum index of the cell 
@@ -119,353 +120,4 @@ class Row < XMLTiedItem
   def set_index(value); @rowi=value end      
 end
 
-# class Row
-#   def initialize
-#     @readonly = :unknown
-#     @cells = {}
-#   end
-#   def worksheet; @parent_array.worksheet end
-#   def parent_array; @parent_array end  # for debug only
-#   def used_col_range; 1..first_unused_column_index-1  end
-#   def used_range; used_col_range  end
-#   def first_unused_column_index; raise 'this should be redefined in subclasses' end
-# end
-
-  
-#  -------------------------- 
-  
-  
-# # XmlTiedArrayItemGroup is internal representation of repeated items in XmlTiedArray.
-# class XmlTiedArrayItemGroup
-# #   extend Forwardable
-# #   delegate [:normalize ] => :@row_group
-# 
-#   def normalize; @rowgroup.normalize  end
-
-# end
-
-# array which synchronizes with xml structure and reflects. number-xxx-repeated attributes
-# also caches returned objects for indexes.
-# options must contain
-#   :xml_items, :xml_repeated_attribute, :object_type
-
-# class XmlTiedArray < Array
-#   def initialize(axmlnode, options={}) # TODO get rid of XmlTiedArray
-#     @xmlnode = axmlnode
-#     @options = options
-#     
-#     missing_options = [:xml_repeated_attribute,:xml_items_node_name,:object_type]-@options.keys
-#     raise "Some options missing (#{missing_options.inspect})" unless missing_options.empty?
-#     
-#     unless @xmlnode.nil?
-#       @xmlnode.elements.select{|node| node.name == options[:xml_items_node_name]}.each do |group_source_node|
-#         self << parse_xml_to_group(group_source_node) # it is in @xmlnode so suffices to add object to @rowgroups
-#       end
-#     end
-#     @itemcache=Hash.new()
-#   end
-#   def parse_xml_to_group(size_or_xmlnode) # parses xml to new RowGroup which can be added at the end
-#     # reading params
-#     if size_or_xmlnode.kind_of? LibXML::XML::Node
-#       size = (size_or_xmlnode[@options[:xml_repeated_attribute]] || 1).to_i
-#       node = size_or_xmlnode
-#     elsif size_or_xmlnode.to_i>0
-#       size = size_or_xmlnode.to_i
-#       node = nil
-#     else
-#       return nil
-#     end
-#     index = first_unused_index
-#     # construct result
-#     Rspreadsheet::XmlTiedArrayItemGroup.new(self,index..index+size-1,node)
-#   end
-#   def add_item_group(size_or_xmlnode)
-#     result = parse_xml_to_group(size_or_xmlnode)
-#     self << result
-#     @xmlnode << result.xmlnode
-#     result
-#   end
-#   def first_unused_index
-#     empty? ? 1 : last.range.end+1
-#   end
-#   # prolonges the RowArray to cantain rowi and returns it
-#   def detach_of_bound_item(index)
-#     fill_row_group_size = index-first_unused_index
-#     if fill_row_group_size>0
-#       add_item_group(fill_row_group_size) 
-#     end
-#     add_item_group(1)
-#     get_item(index)   # aby se odpoved nacacheovala
-#   end
-#   def get_item_group(index)
-#     find{ |item_group| item_group.range.cover?(index) }
-#   end
-#   def detach_item(index); get_item(index) end # TODO předělat do lazy podoby, kdy tohle nebude stejny
-#   def get_item(index)
-#     if index>= first_unused_index
-#       nil
-#     else
-#       @itemcache[index] ||= Rspreadsheet::XmlTiedArrayItem.new(self,index)
-#     end
-#   end
-#   # This detaches item index from the group and perhaps splits the RowGroup
-#   # into two pieces. This makes the row individually editable.
-#   def detach(index)
-#     group_index = get_group_index(index)
-#     item_group = self[group_index]
-#     range = item_group.range
-#     return self if range==(index..index)
-# 
-#     # prepare new components
-#     replaceby = []
-#     replaceby << RowGroup.new(self,range.begin..index-1)
-#     replaceby << (result = SingleRow.new(self,index))
-#     replaceby << RowGroup.new(self,index+1..range.end)
-#     
-#     # put original range somewhere in replaceby and shorten it
-#     
-#     if index>range.begin
-#       replaceby[0] = item_group
-#       item_group.range = range.begin..index-1
-#     else
-#       replaceby[2] = item_group
-#       item_group.range = index+1..range.end
-#     end
-#     
-#     # normalize and delete empty parts
-#     replaceby = replaceby.map(&:normalize).compact
-#     
-#     # do the replacement in xml
-#     marker = LibXML::XML::Node.new('temporarymarker')
-#     item_group.xmlnode.next = marker
-#     item_group.xmlnode.remove!
-#     replaceby.each{ |rg| 
-#       marker.prev = rg.xmlnode
-#     } 
-#     marker.remove!
-#     
-#     # do the replacement in array
-#     self[group_index..group_index]=replaceby
-#     result
-#   end
-#   private
-#   def get_group_index(index)
-#     self.find_index{ |rowgroup| rowgroup.range.cover?(index) }
-#   end
-# end
-
-# class XmlTiedArrayItem
-#   attr_reader :index
-#   def initialize(aarray,aindex)
-#     @array = aarray
-#     @index = aindex
-#     if self.virtual?
-#       @object = nil
-#     else
-#       @object = @array.options[:object_type].new(group.xmlnode)
-#     end
-#   end
-#   def group; @array.get_item_group(index) end
-#   def repeated?; group.repeated? end
-#   def virtual?; ! self.repeated? end
-#   def array
-#     raise 'Group empty' if @group.nil? 
-#     @array
-#   end
-# end
-
-# class RowArray < XmlTiedArray
-#   attr_reader :row_array_cache
-#   def initialize(aworksheet,aworksheet_node)
-#     @worksheet = aworksheet
-#     @row_array_cache = Hash.new()
-#     super(aworksheet_node, :xml_items_node_name => 'table-row', :xml_repeated_attribute => xml_repeated_attribute, :object_type=>Row)
-#   end
-#   def get_row(rowi)
-#     if @row_array_cache.has_key?(rowi)
-#       return @row_array_cache[rowi]
-#     end
-#     item = self.get_item(rowi)
-#     @row_array_cache[rowi] = if item.nil?
-#       if rowi>0 then Rspreadsheet::UninitializedEmptyRow.new(self,rowi) else nil end
-#     else
-#       if item.repeated?
-# 	Rspreadsheet::MemberOfRowGroup.new(item.index, item.group.to_rowgroup)
-#       else
-# 	Rspreadsheet::SingleRow.new_from_rowgroup(item.group.to_rowgroup)
-#       end
-#     end
-#   end
-#   # aliases
-#   def first_unused_row_index; first_unused_index end
-#   def worksheet; @worksheet end
-#   def detach_of_bound_row_group(index)
-#     super(index)
-#     return get_row(index)
-#   end
-# end
-
-# class Row
-#   def initialize
-#     @readonly = :unknown
-#     @cells = {}
-#   end
-#   def self.empty_row_node
-#     LibXML::XML::Node.new('table-row',nil, Tools.get_namespace('table'))
-#   end
-#   def worksheet; @parent_array.worksheet end
-#   def parent_array; @parent_array end  # for debug only
-#   def used_col_range; 1..first_unused_column_index-1  end
-#   def used_range; used_col_range  end
-#   def first_unused_column_index; raise 'this should be redefined in subclasses' end
-#   def cells(coli)
-#     coli = coli.to_i
-#     return nil if coli.to_i<=0
-#     @cells[coli] ||= get_cell(coli)
-#   end
-# end
-
-# class RowWithXMLNode < Row
-#   attr_accessor :xmlnode
-#   def style_name=(value); Tools.set_ns_attribute(@xmlnode,'table','style-name',value)  end
-#   def get_cell(coli)
-#     Cell.new(self,coli,cellnodes(coli))
-#   end
-#   def nonemptycells
-#     nonemptycellsindexes.collect{ |index| cells(index) }
-#   end
-#   def nonemptycellsindexes
-#     used_col_range.to_a.select do |coli|
-#       cellnode = cellnodes(coli)
-#       !(cellnode.content.nil? or cellnode.content.empty? or cellnode.content =='') or
-#       !cellnode.attributes.to_a.reject{ |attr| attr.name == 'number-columns-repeated'}.empty?
-#     end
-#   end
-#   def cellnodes(coli)
-#     cellnode = nil
-#     while true 
-#       curr_coli=1
-#       cellnode = @xmlnode.elements.select{|n| n.name=='table-cell'}.find do |el|
-#         curr_coli += (Tools.get_ns_attribute_value(el, 'table', 'number-columns-repeated') || 1).to_i
-#         curr_coli > coli
-#       end
-#       unless cellnode.nil? 
-#         return cellnode
-#       else
-#         add_cell
-#       end
-#     end
-#   end
-#   def add_cell(repeated=1)
-#     cell = Cell.new(self,first_unused_column_index)
-#     Tools.set_ns_attribute(cell.xmlnode,'table','number-columns-repeated',repeated) if repeated>1
-#     @xmlnode << cell.xmlnode
-#     cell
-#   end
-#   def first_unused_column_index
-#     1 + @xmlnode.elements.select{|n| n.name=='table-cell'}.reduce(0) do |sum, el|
-#       sum + (Tools.get_ns_attribute_value(el, 'table', 'number-columns-repeated') || 1).to_i
-#     end
-#   end
-# end
-
-# class RowGroup < RowWithXMLNode
-#   @readonly = :yes_always
-#   attr_reader :range
-#   attr_accessor :parent_array, :xmlnode
-#   def initialize(aparent_array,arange,axmlnode=nil)
-#     super()
-#     @parent_array = aparent_array
-#     @range = arange
-#     if axmlnode.nil?
-#       axmlnode = Row.empty_row_node
-#       Tools.set_ns_attribute(axmlnode,'table','number-rows-repeated',range.size) if range.size>1
-#     end
-#     @xmlnode = axmlnode
-#   end
-#   # returns SingleRow if size of range is 1 and nil if it is 0 or less
-#   def normalize
-#     case range.size
-#       when 2..Float::INFINITY then self
-#       when 1 then SingleRow.new_from_rowgroup(self)
-#       else nil
-#     end
-#   end
-#   def repeated;  range.size   end
-#   def repeated?; range.size>1 end
-#   def range=(arange)
-#     @range=arange
-#     Tools.set_ns_attribute(@xmlnode,'table','number-rows-repeated',range.size, 1)
-#   end
-# end
-
-# class SingleRow < RowWithXMLNode
-#   @readonly = :no
-#   attr_accessor :xmlnode
-#   # index  Integer
-#   def initialize(aparent_array,aindex,axmlnode=nil)
-#     super()
-#     @parent_array = aparent_array
-#     @index = aindex
-#     if axmlnode.nil?
-#       axmlnode = Row.empty_row_node
-#     end
-#     @xmlnode = axmlnode
-#   end
-#   def self.new_from_rowgroup(rg)
-#     anode = rg.xmlnode
-#     Tools.remove_ns_attribute(anode,'table','number-rows-repeated')
-#     SingleRow.new(rg.parent_array,rg.range.begin,anode)
-#   end
-#   def normalize; self end
-#   def repeated?; false end
-#   def repeated; 1 end
-#   def range; (@index..@index) end
-#   def detach; self end
-#   def row; @index end
-#   def still_out_of_used_range?; false end
-# end
-
-# class LazyDetachableRow < Row
-#   @readonly = :yes_but_detachable
-#   def initialize(rowi)
-#     super()
-#     @index = rowi.to_i
-#   end
-#   def add_cell; detach.add_cell end
-#   def style_name=(value); detach.style_name=value end
-#   def row; @index end
-# end
-
-# ## there are not data in this object, they are taken from RowGroup, but this is only readonly
-# class MemberOfRowGroup < LazyDetachableRow
-#   @readonly = :yes_but_detachable
-#   extend Forwardable
-#   delegate [:repeated?, :repeated, :xmlnode, :parent_array] => :@row_group
-#   attr_accessor :row_group # for dubugging
-# 
-#   # @index  Integer
-#   # @row_group   RepeatedRow
-#   def initialize(arowi,arow_group)
-#     super(arowi)
-#     @row_group = arow_group
-#     raise 'Wrong parameter given - class is '+@row_group.class.to_a unless @row_group.is_a? RowGroup
-#   end
-#   def detach  # detaches MemberOfRowGroup from its RowGroup perhaps splitting RowGroup
-#     @row_group.parent_array.detach(@index)
-#   end
-#   def get_cell(coli)
-#     c = Cell.new(self,coli,@row_group.cellnodes(coli))
-#     c.mode = :repeated
-#     c
-#   end
-#   def first_unused_column_index
-#     @row_group.first_unused_column_index
-#   end
-#   def nonemptycells
-#     @row_group.nonemptycellsindexes.collect{ |coli| cells(coli) }
-#   end
-# end
-
-
 end

data/lib/rspreadsheet/version.rb

@@ -1,3 +1,3 @@
 module Rspreadsheet
-  VERSION = "0.2.12"
+  VERSION = "0.2.14"
 end

data/lib/rspreadsheet/worksheet.rb

@@ -1,5 +1,7 @@
 require 'rspreadsheet/row'
+require 'rspreadsheet/column'
 require 'rspreadsheet/tools'
+require 'helpers/class_extensions'
 # require 'forwardable'
 
 module Rspreadsheet 
@@ -54,6 +56,7 @@ class Worksheet
   
   #@!group XMLTiedArray connected methods
   def rows(*params); subitems(*params) end
+  alias :row :rows
   def prepare_subitem(rowi); Row.new(self,rowi) end
   def rowcache; @itemcache end
   
@@ -82,10 +85,15 @@ class Worksheet
       when 0 then raise 'Not implemented yet' #TODO: return list of all cells
       when 1..2
         r,c = Rspreadsheet::Tools.a2c(*params)
-        rows(r).andand.cells(c)
+        row(r).andand.cell(c)
       else raise Exception.new('Wrong number of arguments.')
     end
   end
+  alias :cell :cells
+  def column(param)
+    r,coli = Rspreadsheet::Tools.a2c(1,param)
+    Column.new(self,coli)
+  end
   # Allows syntax like sheet.F15. TO catch errors easier, allows only up to three uppercase letters in colum part, althought it won't be necessarry to restrict.
   def method_missing method_name, *args, &block
     if method_name.to_s.match(/^([A-Z]{1,3})(\d{1,8})(=?)$/)

data/lib/rspreadsheet/xml_tied.rb

@@ -1,5 +1,9 @@
+require 'helpers/class_extensions'
+
 module Rspreadsheet
 
+using ClassExtensions if RUBY_VERSION > '2.1'
+
 # @private
 class XMLTied
   def xml
@@ -66,8 +70,8 @@ end
 
 # abstract class. All importers MUST implement: prepare_subitem (and delete)
 # terminology
-#  item, subitem is object from @itemcache (quite often subclass of XMLTiedItem)
-#  node, subnode is LibXML::XML::Node object
+#   item, subitem is object from @itemcache (quite often subclass of XMLTiedItem)
+#   node, subnode is LibXML::XML::Node object
 #
 # this class is made to be included, not subclassed - the reason is in delete method which calls super
 # @private

data/spec/cell_spec.rb

@@ -8,115 +8,119 @@ describe Rspreadsheet::Cell do
     @sheet2 = book2.worksheets(1)
   end
   it 'contains good row and col coordinates' do
-    @cell = @sheet1.cells(1,3)
+    @cell = @sheet1.cell(1,3)
     @cell.rowi.should == 1
     @cell.coli.should == 3
     @cell.coordinates.should == [1,3]
-    @cell = @sheet2.cells(7,2)
+    @cell = @sheet2.cell(7,2)
     @cell.rowi.should == 7
     @cell.coli.should == 2
     @cell.coordinates.should == [7,2]
   end
   it 'can be referenced by more vars and both are synchronized' do
-    @cell = @sheet1.cells(1,1)
+    @cell = @sheet1.cell(1,1)
     @sheet1[1,1] = 'novinka'
     @cell.value.should == 'novinka'
   end
   it 'can be modified by more ways and all are identical' do
-    @cell = @sheet1.cells(2,2)
+    @cell = @sheet1.cell(2,2)
     @sheet1[2,2] = 'zaprve'
     @cell.value.should == 'zaprve'
-    @sheet1.cells(2,2).value = 'zadruhe'
+    @sheet1.cell(2,2).value = 'zadruhe'
     @cell.value.should == 'zadruhe'
     @sheet1.B2 = 'zatreti'
     @cell.value.should == 'zatreti'
-    @sheet1.rows(2).cells(2).value = 'zactvrte'
+    @sheet1.row(2).cell(2).value = 'zactvrte'
     @cell.value.should == 'zactvrte'
-    @sheet1.rows(2)[2] = 'zapate'
+    @sheet1.rows[1].cell(2).value = 'zactvrte s arrayem'
+    @cell.value.should == 'zactvrte s arrayem'
+    @sheet1.row(2)[2] = 'zapate'
     @cell.value.should == 'zapate'
+    @sheet1.rows[1][2] = 'zaseste'  ## tohle je divoka moznost
+    @cell.value.should == 'zaseste'
   end
   it 'can include links' do
     @sheet2.A12.should == '[http://example.org/]'
-    @sheet2.cells(12,2).valuexmlfindall('.//text:a').size.should eq 0
-    @sheet2.cells(12,1).valuexmlfindall('.//text:a').size.should eq 1
-    @sheet2.cells(12,1).valuexmlfindfirst('.//text:a').attributes['href'].should eq 'http://example.org/'
+    @sheet2.cell(12,2).valuexmlfindall('.//text:a').size.should eq 0
+    @sheet2.cell(12,1).valuexmlfindall('.//text:a').size.should eq 1
+    @sheet2.cell(12,1).valuexmlfindfirst('.//text:a').attributes['href'].should eq 'http://example.org/'
   end
   it 'contains good row and col coordinates even after table:number-columns-repeated cells' do
-    @cell = @sheet2.cells(13,5)
+    @cell = @sheet2.cell(13,5)
     @cell.value.should == 'afterrepeated'
     @cell.rowi.should == 13
     @cell.coli.should == 5
   end
   it 'reports good range of coordinates for repeated cells' do
-    @cell = @sheet2.cells(13,2)
+    @cell = @sheet2.cell(13,2)
     @cell.range.should == (1..4)
     @cell.mode.should == :repeated
   end
   it 'returns nil on negative and zero cell indexes or raises exception depending on configuration' do
     pom = Rspreadsheet.raise_on_negative_coordinates
     # default is to raise error
-    expect {@sheet2.cells(0,5) }.to raise_error
+    expect {@sheet2.cell(0,5) }.to raise_error
   
     # return nil if configured to do so
     Rspreadsheet.raise_on_negative_coordinates = false
-    @sheet2.cells(0,5).should be_nil
-    @sheet2.cells(2,-5).should be(nil)
-    @sheet2.cells(-2,-5).should be(nil)
+    @sheet2.cell(0,5).should be_nil
+    @sheet2.cell(2,-5).should be(nil)
+    @sheet2.cell(-2,-5).should be(nil)
     
     Rspreadsheet.raise_on_negative_coordinates = pom  # reset the setting back
   end
   it 'has nonempty parents' do
-    @cell = @sheet2.cells(13,5)
+    @cell = @sheet2.cell(13,5)
     @cell.row.should_not be_nil
     @cell.worksheet.should_not be_nil
 
-    @cell = @sheet1.cells(2,2)
+    @cell = @sheet1.cell(2,2)
     @cell.row.should_not be_nil
     @cell.worksheet.should_not be_nil
   end
   it 'handles relative correctly' do
-    @sheet2.cells(3,3).relative(-1,+2).coordinates.should == [2,5]
-    @sheet2.cells(3,3).relative(0,0).coordinates.should == [3,3]
+    @sheet2.cell(3,3).relative(-1,+2).coordinates.should == [2,5]
+    @sheet2.cell(3,3).relative(0,0).coordinates.should == [3,3]
   end
   it 'is automatically "unrepeated" on value assignement' do
-    @cell = @sheet2.cells(13,2)
+    @cell = @sheet2.cell(13,2)
     @cell.is_repeated?.should == true
     @cell.value = 'cokoli'
     @cell.is_repeated?.should == false
     @cell.value.should == 'cokoli'
-    @sheet2.cells(13,1).should_not == 'cokoli'
-    @sheet2.cells(13,3).should_not == 'cokoli'
-    @sheet2.cells(13,4).should_not == 'cokoli'
+    @sheet2.cell(13,1).should_not == 'cokoli'
+    @sheet2.cell(13,3).should_not == 'cokoli'
+    @sheet2.cell(13,4).should_not == 'cokoli'
   end
   it 'returns correct type for the cell' do
-    @sheet2.cells(1,2).type.should eq :string
-    @sheet2.cells(2,2).type.should eq :date
-    @sheet2.cells(3,1).type.should eq :float
-    @sheet2.cells(3,2).type.should eq :percentage
-    @sheet2.cells(4,2).type.should eq :string
-    @sheet2.cells('B22').type.should eq :currency
-    @sheet2.cells('B23').type.should eq :currency
-    @sheet2.cells(200,200).type.should eq :unassigned
+    @sheet2.cell(1,2).type.should eq :string
+    @sheet2.cell(2,2).type.should eq :date
+    @sheet2.cell(3,1).type.should eq :float
+    @sheet2.cell(3,2).type.should eq :percentage
+    @sheet2.cell(4,2).type.should eq :string
+    @sheet2.cell('B22').type.should eq :currency
+    @sheet2.cell('B23').type.should eq :currency
+    @sheet2.cell(200,200).type.should eq :unassigned
   end
   it 'returns value of correct type' do
     @sheet2[1,2].should be_kind_of(String)
     @sheet2[2,2].should be_kind_of(Date)
     @sheet2[3,1].should be_kind_of(Float)
     @sheet2[3,2].should be_kind_of(Float)
-    @sheet2.cells(3,2).type.should eq :percentage
-    @sheet2.cells(3,2).guess_cell_type.should eq :percentage
-    @sheet2.cells(3,2).guess_cell_type(1).should eq :percentage
+    @sheet2.cell(3,2).type.should eq :percentage
+    @sheet2.cell(3,2).guess_cell_type.should eq :percentage
+    @sheet2.cell(3,2).guess_cell_type(1).should eq :percentage
     @sheet2[3,2]=0.1
-    @sheet2.cells(3,2).type.should eq :percentage
+    @sheet2.cell(3,2).type.should eq :percentage
     @sheet2[4,2].should be_kind_of(String)
   end
   it 'is the same object no matter how you access it' do
-    @cell1 = @sheet2.cells(5,5)
-    @cell2 = @sheet2.rows(5).cells(5)
+    @cell1 = @sheet2.cell(5,5)
+    @cell2 = @sheet2.rows(5).cell(5)
     @cell1.should equal(@cell2)
   end
   it 'splits correctly cells if written in the middle of repeated group' do
-    @cell = @sheet2.cells(4,6)
+    @cell = @sheet2.cell(4,6)
     @cell.range.should == (4..7)
     @cell.value.should == 7
     
@@ -124,16 +128,16 @@ describe Rspreadsheet::Cell do
     @cell.range.should == (6..6)
     @cell.value.should == 'nebesa'
     
-    @cellA = @sheet2.cells(4,5)
+    @cellA = @sheet2.cell(4,5)
     @cellA.range.should == (4..5)
     @cellA.value.should == 7
     
-    @cellB = @sheet2.cells(4,7)
+    @cellB = @sheet2.cell(4,7)
     @cellB.range.should == (7..7)
     @cellB.value.should == 7
   end
   it 'inserts correctly cell in the middle of repeated group' do
-    @cell = @sheet2.cells(4,6)
+    @cell = @sheet2.cell(4,6)
     @cell.range.should == (4..7)
     @cell.value.should == 7
     @cell.coli.should == 6
@@ -141,15 +145,15 @@ describe Rspreadsheet::Cell do
     @sheet2.insert_cell_before(4,6)
     @cell.coli.should == 7
     
-    @cellA = @sheet2.cells(4,5)
+    @cellA = @sheet2.cell(4,5)
     @cellA.range.should == (4..5)
     @cellA.value.should == 7
     
-    @cellB = @sheet2.cells(4,7)
+    @cellB = @sheet2.cell(4,7)
     @cellB.range.should == (7..8)
     @cellB.value.should == 7
     
-    @cell = @sheet2.cells(16,4)
+    @cell = @sheet2.cell(16,4)
     @cell.range.should == (1..7)
     @cell.value.should == nil
     
@@ -157,45 +161,45 @@ describe Rspreadsheet::Cell do
     @sheet2.rows(16).range.should == (14..18)
     @sheet2.rows(17).range.should == (14..18)
     @sheet2.insert_cell_before(16,3)
-    @sheet2.cells(16,3).value = 'baf'
-    @sheet2.cells(17,3).value.should_not == 'baf'
+    @sheet2.cell(16,3).value = 'baf'
+    @sheet2.cell(17,3).value.should_not == 'baf'
     @sheet2.rows(15).range.should == (14..15)
     @sheet2.rows(16).range.should == (16..16)
     @sheet2.rows(17).range.should == (17..18)
     
-    @cellA = @sheet2.cells(16,1)
+    @cellA = @sheet2.cell(16,1)
     @cellA.range.should == (1..2)
     @cellA.value.should be_nil
     
-    @cellB = @sheet2.cells(16,5)
+    @cellB = @sheet2.cell(16,5)
     @cellB.range.should == (4..8)
     @cellB.value.should be_nil
 
   end
   it 'inserted has correct class' do # based on real error
     @sheet2.insert_cell_before(1,1)
-    @sheet2.rows(1).cells(1).should be_kind_of(Rspreadsheet::Cell)
+    @sheet2.rows(1).cell(1).should be_kind_of(Rspreadsheet::Cell)
   end
   it 'can have different formats' do
-    @cell = @sheet2.cells(6,3)
+    @cell = @sheet2.cell(6,3)
     @cell.format.bold.should == true
-    @cell = @sheet2.cells(6,4)
+    @cell = @sheet2.cell(6,4)
     @cell.format.bold.should == false
     @cell.format.italic.should == true
-    @cell = @sheet2.cells(6,5)
+    @cell = @sheet2.cell(6,5)
     @cell.format.italic.should == false
     @cell.format.color.should == '#ff3333'
-    @cell = @sheet2.cells(6,6)
+    @cell = @sheet2.cell(6,6)
     @cell.format.color.should_not == '#ff3333'
     @cell.format.background_color.should == '#6666ff'
-    @cell = @sheet2.cells(6,7)
+    @cell = @sheet2.cell(6,7)
     @cell.format.font_size.should == '7pt'
         
     # after fresh create
     @cell.xmlnode.attributes['style-name'].should_not be_nil
   end
-  it 'can set formats of the cells in new file' do
-    @cell = @sheet1.cells(1,1)
+  it 'can set formats of the cell in new file' do
+    @cell = @sheet1.cell(1,1)
     @cell.value = '1'
     # bold
     @cell.format.bold.should be_falsey
@@ -226,15 +230,15 @@ describe Rspreadsheet::Cell do
   
   end
   it 'changes coordinates when row inserted above' do
-    @sheet1.cells(2,2).detach
-    @cell = @sheet1.cells(2,2)
+    @sheet1.cell(2,2).detach
+    @cell = @sheet1.cell(2,2)
     @cell.rowi.should == 2
     @sheet1.add_row_above(1)
     @cell.rowi.should == 3
   end
   it 'switches to invalid_reference cell when deleted' do
     @sheet1[2,5] = 'nejaka data'
-    @cell = @sheet1.cells(2,2)
+    @cell = @sheet1.cell(2,2)
     @cell.value = 'data'
     @cell.invalid_reference?.should be false
     @cell.delete
@@ -242,11 +246,11 @@ describe Rspreadsheet::Cell do
     expect { @cell.rowi }.to raise_error
     expect { @cell.address }.to raise_error
     
-    @sheet1.cells(2,2).type.should == :empty
-    @sheet1.cells(3,2).type.should == :unassigned
+    @sheet1.cell(2,2).type.should == :empty
+    @sheet1.cell(3,2).type.should == :unassigned
   end
   it 'switches to invalid_reference cell when its row is deleted' do
-    @cell = @sheet1.cells(6,2)
+    @cell = @sheet1.cell(6,2)
     @cell.value = 'data'
     @cell.rowi.should == 6
     @sheet1.rows(6).delete
@@ -254,35 +258,35 @@ describe Rspreadsheet::Cell do
     @cell.invalid_reference?.should be true
   end
   it 'has inspect method returning something good' do
-    @cell = @sheet1.cells(6,2)
+    @cell = @sheet1.cell(6,2)
     @cell.value = 'abcde'
     expect(@cell.inspect).to include('abcde','::Cell','6','2','row')
   end
   it 'stores date correctly' do
-    @cell = @sheet1.cells(1,1)
+    @cell = @sheet1.cell(1,1)
     @cell.value= Date.parse('2014-01-02')
     @cell.value.year.should eq 2014
     @cell.value.month.should eq 1
     @cell.value.day.should eq 2
   end
   it 'can be addressed by even more ways and all are identical' do
-    @cell = @sheet1.cells(2,2)
-    @sheet1.cells('B2').value = 'zaseste'
-    @sheet1.cells('B2').value.should == 'zaseste'
+    @cell = @sheet1.cell(2,2)
+    @sheet1.cell('B2').value = 'zaseste'
+    @sheet1.cell('B2').value.should == 'zaseste'
     @cell.value.should == 'zaseste'
-    @sheet1.cells(2,'B').value.should == 'zaseste'
-    @sheet1.cells(2,'B').value = 'zasedme'
+    @sheet1.cell(2,'B').value.should == 'zaseste'
+    @sheet1.cell(2,'B').value = 'zasedme'
     @cell.value.should == 'zasedme'
     @sheet1['B2'].should == 'zasedme'
     @sheet1['B2'] = 'zaosme'
     @cell.value.should == 'zaosme'
     
-    @sheet2.cells('F2').should be @sheet2.cells(2,6)
-    @sheet2.cells('BA177').should be @sheet2.cells(177,53)
-    @sheet2.cells('ADA2').should be @sheet2.cells(2,781)
+    @sheet2.cell('F2').should be @sheet2.cell(2,6)
+    @sheet2.cell('BA177').should be @sheet2.cell(177,53)
+    @sheet2.cell('ADA2').should be @sheet2.cell(2,781)
   end
   it 'setting format in new file detaches the cell' do
-    @cell = @sheet1.cells(1,1)
+    @cell = @sheet1.cell(1,1)
     # bold
     @cell.format.bold.should be_falsey
     @cell.format.bold = true
@@ -290,14 +294,14 @@ describe Rspreadsheet::Cell do
     @cell.mode.should eq :regular
   end
   it 'remembers formula when set' do
-    @cell = @sheet1.cells(1,1)
+    @cell = @sheet1.cell(1,1)
     # bold
     @cell.formula.should be_nil
     @cell.formula='=1+5'
     @cell.formula.should eq '=1+5'
   end
   it 'unsets cell type when formula set - we can not guess it correctly', :focus do
-    @cell = @sheet1.cells(1,1)
+    @cell = @sheet1.cell(1,1)
     @cell.value = 'ahoj'
     @cell.type.should eq :string
     @cell.formula='=1+5'
@@ -306,7 +310,7 @@ describe Rspreadsheet::Cell do
     @cell.type.should eq :empty
   end
   it 'wipes out formula after assiging value' do
-    @cell = @sheet1.cells(1,1)
+    @cell = @sheet1.cell(1,1)
     @cell.formula='=1+5'
     @cell.formula.should_not be_nil
     @cell.value = 'baf'
@@ -314,19 +318,13 @@ describe Rspreadsheet::Cell do
     @cell.formula.should be_nil
   end
   it 'works well with currency types' do
-    @usdcell = @sheet2.cells('B22')
+    @usdcell = @sheet2.cell('B22')
     @usdcell.type.should eq :currency
     @usdcell.value.should == -147984.84
     @usdcell.format.currency.should == 'USD'
     
-    @czkcell = @sheet2.cells('B23')
+    @czkcell = @sheet2.cell('B23')
     @czkcell.value.should == 344.to_d
     @czkcell.format.currency.should == 'CZK'
   end
 end
-
-
-
-
-
-

data/spec/class_extensions_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+if RUBY_VERSION > '2.1'
+  using ClassExtensions 
+
+  describe Array do
+    it 'can sum simple array' do
+      a = [1,2,3,4]
+      a.sum.should == 10
+    end
+    it 'ignores text and nils while summing' do
+      a = [1,nil, nil,2,3,'foo',5.0]
+      a.sum.should == 11
+      [nil, 'nic'].sum.should == 0
+      [].sum.should == 0
+    end
+  end
+
+  describe LibXML::XML::Node do
+    before do 
+      @n = LibXML::XML::Node.new('a')
+      @n << LibXML::XML::Node.new('i','italic')
+      b = LibXML::XML::Node.new('p','paragraph')
+      b << LibXML::XML::Node.new('b','boldtext')
+      @n << b
+      @n << LibXML::XML::Node.new_text('textnode')
+      
+      @m = LibXML::XML::Node.new('a')
+      @m << LibXML::XML::Node.new('i','italic')
+      c = LibXML::XML::Node.new('p','paragraph')
+      c << LibXML::XML::Node.new('b','boldtext')
+      @m << c
+      @m << LibXML::XML::Node.new_text('textnode')
+      
+      @m2 = LibXML::XML::Node.new('a')
+    end
+    it 'can compare nodes' do
+      @n.should == @m
+      @n.should_not == @m2
+    end
+    it 'has correct elements' do
+  #     raise @n.first_diff(@m).inspect
+    end
+  end
+
+end

data/spec/column_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+ 
+describe Rspreadsheet::Cell do
+  before do 
+    book1 = Rspreadsheet.new
+    @sheet = book1.create_worksheet
+  end
+  it 'contains the right cells' do
+    @sheet[1,1] = '11'
+    @sheet[1,2] = '12'
+    @sheet[2,1] = '21'
+    @sheet[2,2] = '22'
+    @sheet.column(1).cell(2).value.should eq('21')
+    @sheet.column(2).cell(2).value.should eq('22')
+    @sheet.column(2).cell(1).should eq(@sheet.cell(1,2))
+  end
+  
+end

data/spec/rspreadsheet_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+using ClassExtensions if RUBY_VERSION > '2.1'
 
 describe Rspreadsheet do
   it 'can open ods testfile and reads its content correctly' do
@@ -42,7 +43,7 @@ describe Rspreadsheet do
     @content_xml2.root.first_diff(@content_xml1.root).should be_nil
     @content_xml1.root.first_diff(@content_xml2.root).should be_nil
     
-    @content_xml1.root.equals?(@content_xml2.root).should == true
+    @content_xml1.root.should == @content_xml2.root
   end
   it 'when open and save file modified, than the file is different' do
     tmp_filename = '/tmp/testfile1.ods'        # first delete temp file
@@ -87,7 +88,7 @@ describe Rspreadsheet do
       sheet.cells(5,2).format.bold = true
       sheet.cells(5,2).format.background_color = '#FF0000'
     }.not_to raise_error
-    
+
     sheet.rows(4).cellvalues.sum{|val| val.to_f}.should eq 4+7*4
     sheet.rows(4).cells.sum{ |cell| cell.value.to_f }.should eq 4+7*4
 

data/spec/worksheet_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+using ClassExtensions if RUBY_VERSION > '2.1'
 
 describe Rspreadsheet::Worksheet do
   describe "from test workbook file" do 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspreadsheet
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.14
 platform: ruby
 authors:
 - Jakub A.Těšínský
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-16 00:00:00.000000000 Z
+date: 2015-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libxml-ruby
@@ -180,6 +180,7 @@ files:
 - lib/helpers/configuration.rb
 - lib/rspreadsheet.rb
 - lib/rspreadsheet/cell.rb
+- lib/rspreadsheet/column.rb
 - lib/rspreadsheet/empty_file_template.ods
 - lib/rspreadsheet/row.rb
 - lib/rspreadsheet/tools.rb
@@ -190,6 +191,8 @@ files:
 - reinstall_local_gem.sh
 - rspreadsheet.gemspec
 - spec/cell_spec.rb
+- spec/class_extensions_spec.rb
+- spec/column_spec.rb
 - spec/row_spec.rb
 - spec/rspreadsheet_spec.rb
 - spec/spec_helper.rb
@@ -224,6 +227,8 @@ summary: Manipulating spreadsheets with Ruby (read / create / modify OpenDocumen
   Spreadsheet).
 test_files:
 - spec/cell_spec.rb
+- spec/class_extensions_spec.rb
+- spec/column_spec.rb
 - spec/row_spec.rb
 - spec/rspreadsheet_spec.rb
 - spec/spec_helper.rb