rspreadsheet 0.2.14 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2f168c71e8ec1b014d48658b230c03780c6fb40
-  data.tar.gz: 11aaf6ed2a306be9eb3a2f3dcfa89dffed291f88
+  metadata.gz: 8c4d7239e35070d3406af3f5c7aadb872d5c0038
+  data.tar.gz: e06d7243078d7531984714f29ed403ce62fcc9df
 SHA512:
-  metadata.gz: fa517af98e5a410bd50f9bb62a878b8752bed69bc77eb1cff3d50dcb05839c4a81956417a64a8b3f32b55376c1906d3c983c3260e426ccdc69145768063e6639
-  data.tar.gz: 95e37cd4a06b66f107b612c8467ca91f2524bf61477208129e159dc0a479a476bc9be5e965eefd1b573c70919b2fd8cb28ce33d0eb5c299064cbef044bbe5a56
+  metadata.gz: dfe7532c19164f3f96611793df3eb75e2c5d67c9c3763cfaee72e88f1e060ec54d9c0978c3e59183520ddc05f0ab5a88d09f8e5e03d15fc4397de5a78740c81f
+  data.tar.gz: f84bbe8045dfe515ac18e50df5a7482e7e6ba0282b57ba2f1ffa50991d3aec3b45a60c7080d7183a867a3839bd7f639a801b0b7e90b9d7aec9a1a59ab1a5fa34

data/.travis.yml

@@ -7,6 +7,8 @@ rvm:
   - 2.0.0
   - 1.9.3
 script: 'bundle exec rake'
+before_install:
+  - gem update bundler
 notifications:
   email:
     recipients:

data/lib/helpers/class_extensions.rb

@@ -1,105 +1,49 @@
-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
+# @private
 
+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
     
-  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
+    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 equals?(node2)  #TODO redefine == with this
+    self.simplification_of?(node2) and node2.simplification_of?(self)
+  end
+end
 
-  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?
+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
-    # 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,10 +7,8 @@ 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.
@@ -42,7 +40,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.elements.first end
+  def valuexmlnode; self.xmlnode.children.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)
@@ -152,10 +150,10 @@ class Cell < XMLTiedItem
         when 'N/A' then :unassigned
         when 'currency' then :currency
         else 
-          if xmlnode.elements.size == 0
+          if xmlnode.children.size == 0
             nil
           else 
-            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}"
+            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}"
           end
       end
 

data/lib/rspreadsheet/row.rb

@@ -120,4 +120,353 @@ 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.14"
+  VERSION = "0.2.15"
 end

data/lib/rspreadsheet/workbook.rb

@@ -56,17 +56,23 @@ class Workbook
   end
   # @param [String] Optional new filename
   # Saves the worksheet. Optionally you can provide new filename.
-  def save(new_filename=nil)
-    if @filename.nil? and new_filename.nil? then raise 'New file should be named on first save.' end
-    # if the filename has changed than first copy the original file to new location (or template if it is a new file)
-    if new_filename
-      FileUtils.cp(@filename || File.dirname(__FILE__)+'/empty_file_template.ods', new_filename)
-      @filename = new_filename
-    end
-    Zip::File.open(@filename) do |zip|
-      # it is easy, because @xmlnode in in sync with contents all the time
-      zip.get_output_stream('content.xml') do |f|
-        f.write @content_xml.to_s(:indent => false)
+  def save(new_filename_or_io_object=nil)
+    if @filename.nil? and new_filename_or_io_object.nil? then raise 'New file should be named on first save.' end
+    
+    if new_filename_or_io_object.kind_of? StringIO
+      new_filename_or_io_object.write(@content_xml.to_s(indent: false))
+    elsif new_filename_or_io_object.nil? or new_filename_or_io_object.kind_of? String
+     
+      if new_filename_or_io_object.kind_of? String   # the filename has changed 
+        # first copy the original file to new location (or template if it is a new file)
+        FileUtils.cp(@filename || File.dirname(__FILE__)+'/empty_file_template.ods', new_filename_or_io_object)
+        @filename = new_filename_or_io_object
+      end
+      Zip::File.open(@filename) do |zip|
+        # it is easy, because @xmlnode in in sync with contents all the time
+        zip.get_output_stream('content.xml') do |f|
+          f.write @content_xml.to_s(:indent => false)
+        end
       end
     end
   end

data/lib/rspreadsheet/worksheet.rb

@@ -1,7 +1,6 @@
 require 'rspreadsheet/row'
 require 'rspreadsheet/column'
 require 'rspreadsheet/tools'
-require 'helpers/class_extensions'
 # require 'forwardable'
 
 module Rspreadsheet 

data/lib/rspreadsheet/xml_tied.rb

@@ -1,9 +1,5 @@
-require 'helpers/class_extensions'
-
 module Rspreadsheet
 
-using ClassExtensions if RUBY_VERSION > '2.1'
-
 # @private
 class XMLTied
   def xml

data/spec/io_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Rspreadsheet do
+  it 'can open spreadsheet and save it to file, resulting file has same content as original' do
+    spreadsheet = Rspreadsheet.new($test_filename)                 # open a file
+    
+    # save it to temp file
+    tmp_filename = '/tmp/testfile1.ods'        
+    File.delete(tmp_filename) if File.exists?(tmp_filename)  # first delete temp file
+    spreadsheet.save(tmp_filename)                                  # and save spreadsheet as temp file
+    
+    # now compare content saved file to original
+    contents_of_files_are_identical($test_filename,tmp_filename)
+  end
+  
+#   it 'can open spreadsheet and store it to IO object', :xpending => 'Under development' do
+#     spreadsheet = Rspreadsheet.new($test_filename)                 # open a file
+#     
+#     stringio = StringIO.new
+#     spreadsheet.save(stringio)
+#     raise stringio.read
+#   
+#   end
+end
+
+def contents_of_files_are_identical(filename1,filename2)
+    @content_xml1 = Zip::File.open(filename1) do |zip|
+      LibXML::XML::Document.io zip.get_input_stream('content.xml')
+    end
+    @content_xml2 = Zip::File.open(filename2) do |zip|
+      LibXML::XML::Document.io zip.get_input_stream('content.xml')
+    end
+    
+    @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
+end

data/spec/rspreadsheet_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-using ClassExtensions if RUBY_VERSION > '2.1'
 
 describe Rspreadsheet do
   it 'can open ods testfile and reads its content correctly' do
@@ -26,25 +25,6 @@ describe Rspreadsheet do
       @sheet2[cell.rowi,cell.coli].should == cell.value
     end
   end
-  it 'can open and save file, and saved file is exactly same as original' do
-    tmp_filename = '/tmp/testfile1.ods'        # first delete temp file
-    File.delete(tmp_filename) if File.exists?(tmp_filename)
-    book = Rspreadsheet.new($test_filename)    # than open test file
-    book.save(tmp_filename)                    # and save it as temp file
-    
-    # now compare them
-    @content_xml1 = Zip::File.open($test_filename) do |zip|
-      LibXML::XML::Document.io zip.get_input_stream('content.xml')
-    end
-    @content_xml2 = Zip::File.open(tmp_filename) do |zip|
-      LibXML::XML::Document.io zip.get_input_stream('content.xml')
-    end
-    
-    @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.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
     File.delete(tmp_filename) if File.exists?(tmp_filename)
@@ -88,7 +68,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,5 +1,4 @@
 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.14
+  version: 0.2.15
 platform: ruby
 authors:
 - Jakub A.Těšínský
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-20 00:00:00.000000000 Z
+date: 2016-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libxml-ruby
@@ -191,8 +191,8 @@ files:
 - reinstall_local_gem.sh
 - rspreadsheet.gemspec
 - spec/cell_spec.rb
-- spec/class_extensions_spec.rb
 - spec/column_spec.rb
+- spec/io_spec.rb
 - spec/row_spec.rb
 - spec/rspreadsheet_spec.rb
 - spec/spec_helper.rb
@@ -220,15 +220,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Manipulating spreadsheets with Ruby (read / create / modify OpenDocument
   Spreadsheet).
 test_files:
 - spec/cell_spec.rb
-- spec/class_extensions_spec.rb
 - spec/column_spec.rb
+- spec/io_spec.rb
 - spec/row_spec.rb
 - spec/rspreadsheet_spec.rb
 - spec/spec_helper.rb

data/spec/class_extensions_spec.rb

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