rspreadsheet 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b667a14fc5845f86995ec8f260650b47f92fc8b8
-  data.tar.gz: d8311461aeb22d2d801f8615bc8d3e43a1b35707
+  metadata.gz: a45451dc3599fbe6519acf7c0d27bb277743a782
+  data.tar.gz: 25b449a6d2efd44fcbf5396275bd0ebb22dbc85f
 SHA512:
-  metadata.gz: e742ce5a232d4d1e4a46c64bbffab4d4607ed3024cb327ad514f9c27f30053d86e2edaef6b3755927136719f667ea9076b9c79f35baf166431315e1fde0e18b7
-  data.tar.gz: 778a31e6b50ee4d15873ec6c416361f0f4ea24476608b2555004fb54fac070117612b4bff1747678ea6a25a6e3001176bcdb22866891a6ed13f6889074a5e50a
+  metadata.gz: b6ed38a381b781d6b543285a783fc54346a70f61d6c99c4e1c7e18ea5e1ab3674ec0fc27cc8af647298fcbc5cc2bc66c58dda0af127967eec2db9647894e46d7
+  data.tar.gz: 341cce44687eeb226acc0b27df38b00951d5d2067a28898962cf9aaee4216d1a5318cb3b54784a8661a4083b5f9ec8d9660701c1656a96666a9fc42cf14a793a

data/DEVEL_BLOG.md

@@ -10,6 +10,8 @@ See [GUIDE.md](GUIDE.md#conventions) for syntax conventions.
   * Allow any of these:
     * ``book['Spring 2014']`` as alternative to ``book.worksheets('Spring 2014')`` ?
     * ``sheet.cells.F13`` as alternative to ``sheet.cells[14,5]`` ?
+  * We may have problem with the @parent_row concept in cells. If cell has repeated row as parent and it is detached in some other code, the cell never finds out that its parent_row was changed. A cure to this might be, when there are no "unatacched" cells, and when all cells belong to some row. This way if row detaches it can let know to all its cells.
+  * Document that there is a little distinction betwean RSpreadsheet and RSpreadsheet::Workbook. The former delegates everythink to the other.
 
 Guiding ideas
   * xml document is always synchronized with the data. So the save is trivial.
@@ -31,15 +33,17 @@ Guiding ideas
 
 ### Local manual testing and releasing (to github released, ).
 
-    gem build rspreadsheet.gemspec
-    sudo gem install rspreadsheet-x.y.z.gem
-    gem push rspreadsheet-x.y.z.gem
+    gem build rspreadsheet.gemspec              -\   These two lines together are in install.sh
+    sudo gem install rspreadsheet-x.y.z.gem     -/   which should be invoked from parent directory
+    gem push rspreadsheet-x.y.z.gem             releases the gem, do not forgot to update version in rspreadsheet.gemspec before doing this
 
 alternative way using ``rake`` command - release is more automatic
 
-  * ``rake build`` - builds the gem to pkg directory. 
-  * ``sudo rake install`` - If this fails with "mkmf.rb can't find header files for ruby at /usr/lib/ruby/include/ruby.h" you may want to ``sudo aptitude install ruby-dev``
-  * Now can locally and manually use/test the gem. This should not be replacement for automated testing. 
+  1. build and install locally
+    * ``rake build`` - builds the gem to pkg directory. 
+    * ``sudo rake install`` - If this fails with "mkmf.rb can't find header files for ruby at /usr/lib/ruby/include/ruby.h" you may want to ``sudo aptitude install ruby-dev``
+  * Now can locally and manually use/test the gem. This should not be replacement for automated testing. If you make some changes, repeat step 1.
+  * When happy, increment the version number and deploy in next step.
   * ``rake release`` - creates a version tag in git and pushes the code to github + Rubygems. After this is succesfull the new version appears as release in Github and RubyGems.
 
 

data/README.md

@@ -53,6 +53,12 @@ Or install it yourself as:
     
 gem is hosted on Rubygems - https://rubygems.org/gems/rspreadsheet
 
+If you get this or similar error
+
+    mkmf.rb can't find header files for ruby at /usr/lib/ruby/include/ruby.h 
+    
+then you might not have installed libxml for ruby. I.e. in debian something like <code>sudo aptitude install ruby-libxml</code> or using equivalent command in other package managers.
+
 ## Motivation and Ideas
 
 This project arised from the necessity. Alhought it is not true that there are no ruby gems allowing to acess OpenDOcument spreadsheet, I did not find another decent one which would suit my needs. Most of them also look abandoned and inactive. I have investigated these options:

data/lib/rspreadsheet/cell.rb

@@ -2,110 +2,44 @@ require 'andand'
 
 module Rspreadsheet
 
-class Cell
-  attr_reader :col, :xmlnode
-  attr_reader  :parent_row  # for debug only
-  attr_accessor :mode
-  def self.empty_cell_node
-    LibXML::XML::Node.new('table-cell',nil, Tools.get_namespace('table'))
+class RowOrNode
+  def mode
+   case
+     when xmlnode.nil? then :outbound
+     when repeated>1  then :repeated
+     else :regular
+   end
   end
-  def initialize(aparent_row,coli,asource_node=nil)
-    raise "First parameter should be Row object not #{aparent_row.class}" unless aparent_row.kind_of?(Rspreadsheet::Row)
-    @mode = :regular
-    @parent_row = aparent_row
-    if asource_node.nil?
-      asource_node = Cell.empty_cell_node
-    end
-    @xmlnode = asource_node
-    @col = coli
+end
+
+class Cell < RowOrNode
+  attr_accessor :worksheet, :rowi, :coli
+  def initialize(aworksheet,arowi,acoli)
+    @worksheet = aworksheet
+    @rowi = arowi
+    @coli = acoli
   end
-  def ns_table; @parent_row.xmlnode.doc.root.namespaces.find_by_prefix('table') end
-  def ns_office; @parent_row.xmlnode.doc.root.namespaces.find_by_prefix('office') end
-  def ns_text; @parent_row.xmlnode.doc.root.namespaces.find_by_prefix('text') end
-  def to_s; value end
-  def cell_xml; self.xmlnode.to_s; end
-  def xml; self.xmlnode.children.first.andand.inner_xml end
-  def coordinates; [row,col]; end
-  def row; @parent_row.row; end
-  def worksheet; @parent_row.worksheet; end
+  def row; @worksheet.rows(rowi) end
+  def coordinates; [rowi,coli] end
+
+  def xmlnode; @worksheet.cellxmlnode(@rowi,@coli) end
   def value
     gt = guess_cell_type
-    if (@mode == :regular) or (@mode == @repeated)
+    if (self.mode == :regular) or (self.mode == :repeated)
       case 
         when gt == nil then nil
-        when gt == Float then @xmlnode.attributes['value'].to_f
-        when gt == String then @xmlnode.elements.first.andand.content.to_s
-        when gt == Date then Date.strptime(@xmlnode.attributes['date-value'].to_s, '%Y-%m-%d')
-        when gt == 'percentage' then @xmlnode.attributes['value'].to_f
+        when gt == Float then xmlnode.attributes['value'].to_f
+        when gt == String then xmlnode.elements.first.andand.content.to_s
+        when gt == Date then Date.strptime(xmlnode.attributes['date-value'].to_s, '%Y-%m-%d')
+        when gt == 'percentage' then xmlnode.attributes['value'].to_f
       end
-    elsif @mode == :outbound # needs to check whether it is still unbound
-      if parent_row.still_out_of_used_range?
-        nil
-      else
-        parent_row.normalize.cells(@col).value
-      end  
+    elsif self.mode == :outbound
+      nil
     else
-      raise "Unknown cell mode #{@mode}"
-    end
-  end
-  def value=(avalue)
-    if @mode == :regular
-      gt = guess_cell_type(avalue)
-      case
-        when gt == nil then raise 'This value type is not storable to cell'
-        when gt == Float 
-          set_type_attribute('float')
-          remove_all_value_attributes_and_content(@xmlnode)
-          Tools.set_ns_attribute(@xmlnode,'office','value', avalue.to_s) 
-          @xmlnode << LibXML::XML::Node.new('p', avalue.to_f.to_s, ns_text)
-        when gt == String then
-          set_type_attribute('string')
-          remove_all_value_attributes_and_content(@xmlnode)
-          @xmlnode << LibXML::XML::Node.new('p', avalue.to_s, ns_text)
-        when gt == Date then 
-          set_type_attribute('date')
-          remove_all_value_attributes_and_content(@xmlnode)
-          Tools.set_ns_attribute(@xmlnode,'office','date-value', avalue.strftime('%Y-%m-%d'))
-          @xmlnode << LibXML::XML::Node.new('p', avalue.strftime('%Y-%m-%d'), ns_text) 
-        when gt == 'percentage'
-          set_type_attribute('float')
-          remove_all_value_attributes_and_content(@xmlnode)
-          Tools.set_ns_attribute(@xmlnode,'office','value', avalue.to_f.to_s) 
-          @xmlnode << LibXML::XML::Node.new('p', (avalue.to_f*100).round.to_s+'%', ns_text)
-      end
-    elsif (@mode == :repeated) or (@mode == :outbound ) # Cell did not exist individually yet, detach row and create editable cell
-      row = @parent_row.detach
-      row.cells(@col).value = avalue
-    else
-      raise "Unknown cell mode #{@mode}"
-    end
-  end
-  def remove_all_value_attributes_and_content(node)
-    if att = Tools.get_ns_attribute(@xmlnode, 'office','value') then att.remove! end
-    if att = Tools.get_ns_attribute(@xmlnode, 'office','date-value') then att.remove! end
-    @xmlnode.content=''
-  end
-  def set_type_attribute(typestring)
-    Tools.set_ns_attribute(@xmlnode,'office','value-type',typestring)
-  end
-  def type
-    case 
-      when guess_cell_type == Float  then :float
-      when guess_cell_type == String then :string
-      when guess_cell_type == Date   then :date
-      when guess_cell_type == 'percentage' then :percentage
-      when guess_cell_type == nil then :empty
-      else :unknown
+      raise "Unknown cell mode #{self.mode}"
     end
   end
-  # use this to find node in cell xml. ex. xmlfind('.//text:a') finds all link nodes
-  def xmlfindall(path)
-    xmlnode.find(path)
-  end
-  def xmlfindfirst(path)
-    xmlfindall(path).first
-  end
-  # based on @xmlnode and optionally value which is about to be assigned, guesses which type the result should be
+  def repeated; (Tools.get_ns_attribute_value(xmlnode, 'table', 'number-columns-repeated') || 1 ).to_i end
   def guess_cell_type(avalue=nil)
     # try guessing by value
     valueguess = case avalue
@@ -115,23 +49,25 @@ class Cell
       else nil
     end
     result = valueguess
-    
+
     if valueguess.nil? # valueguess is most important
-      # if not succesfull then try guessing by type
-      type = @xmlnode.attributes['value-type'].to_s
-      typeguess = case type
+      # if not succesfull then try guessing by type from node xml
+      typ = xmlnode.nil? ? 'N/A' : xmlnode.attributes['value-type']
+      typeguess = case typ
+        when nil then nil
         when 'float' then Float
         when 'string' then String
         when 'date' then Date
         when 'percentage' then :percentage
+        when 'N/A' then :unassigned
         else 
-          if @xmlnode.children.size == 0
+          if xmlnode.children.size == 0
             nil
           else 
-            raise "Unknown type from #{@xmlnode.to_s} / children size=#{@xmlnode.children.size.to_s} / type=#{type}"
+            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
-      
+
       result =
       if !typeguess.nil? # if not certain by value, but have a typeguess
         if !avalue.nil?  # with value we may try converting
@@ -139,7 +75,7 @@ class Cell
             typeguess
           elsif (String(avalue) rescue false) # otherwise try string
             String
-          else # if not convertible to anyhing concious then nil
+          else # if not convertible to anything concious then nil
             nil 
           end
         else             # without value we just beleive typeguess
@@ -155,13 +91,111 @@ class Cell
     end
     result
   end
-  def inspect
-    "#<Cell:[#{row},#{col}]=#{value}(#{guess_cell_type.to_s})"
+  def detach_if_needed
+    if (self.mode == :repeated) or (self.mode == :outbound ) # Cell did not exist individually yet, detach row and create editable cell
+      @worksheet.detach_cell_in_xml(rowi,coli)
+    end
+ end
+  def value=(avalue)
+    detach_if_needed
+    if self.mode == :regular
+      gt = guess_cell_type(avalue)
+      case
+        when gt == nil then raise 'This value type is not storable to cell'
+        when gt == Float 
+          set_type_attribute('float')
+          remove_all_value_attributes_and_content(xmlnode)
+          Tools.set_ns_attribute(xmlnode,'office','value', avalue.to_s) 
+          xmlnode << LibXML::XML::Node.new('p', avalue.to_f.to_s, ns_text)
+        when gt == String then
+          set_type_attribute('string')
+          remove_all_value_attributes_and_content(xmlnode)
+          xmlnode << LibXML::XML::Node.new('p', avalue.to_s, ns_text)
+        when gt == Date then 
+          set_type_attribute('date')
+          remove_all_value_attributes_and_content(xmlnode)
+          Tools.set_ns_attribute(xmlnode,'office','date-value', avalue.strftime('%Y-%m-%d'))
+          xmlnode << LibXML::XML::Node.new('p', avalue.strftime('%Y-%m-%d'), ns_text) 
+        when gt == 'percentage'
+          set_type_attribute('float')
+          remove_all_value_attributes_and_content(xmlnode)
+          Tools.set_ns_attribute(xmlnode,'office','value', avalue.to_f.to_s) 
+          xmlnode << LibXML::XML::Node.new('p', (avalue.to_f*100).round.to_s+'%', ns_text)
+      end
+    else
+      raise "Unknown cell mode #{self.mode}"
+    end
+  end
+  def set_type_attribute(typestring)
+    Tools.set_ns_attribute(xmlnode,'office','value-type',typestring)
   end
+  def remove_all_value_attributes_and_content(node)
+    if att = Tools.get_ns_attribute(node, 'office','value') then att.remove! end
+    if att = Tools.get_ns_attribute(node, 'office','date-value') then att.remove! end
+    node.content=''
+  end
+  def ns_table; xmlnode.doc.root.namespaces.find_by_prefix('table') end
+  def ns_office; xmlnode.doc.root.namespaces.find_by_prefix('office') end
+  def ns_text; xmlnode.doc.root.namespaces.find_by_prefix('text') end
   def relative(rowdiff,coldiff)
-    worksheet.cells(self.row+rowdiff, self.col+coldiff)
+    @worksheet.cells(self.rowi+rowdiff, self.coli+coldiff)
+  end
+  def is_repeated?; mode == :repeated end
+  def type
+    gct = guess_cell_type
+    case 
+      when gct == Float  then :float
+      when gct == String then :string
+      when gct == Date   then :date
+      when gct == :percentage then :percentage
+      when gct == :unassigned then :unassigned
+      when gct == nil then :unknown
+      else :unknown
+    end
   end
 end
+  
+  
+# class Cell
+#   attr_reader :col, :xmlnode
+#   attr_reader  :parent_row  # for debug only
+#   attr_accessor :mode
+#   def self.empty_cell_node
+#     LibXML::XML::Node.new('table-cell',nil, Tools.get_namespace('table'))
+#   end
+#   def initialize(aparent_row,coli,axmlnode=nil)
+#     raise "First parameter should be Row object not #{aparent_row.class}" unless aparent_row.kind_of?(Rspreadsheet::Row)
+#     @parent_row = aparent_row
+#     if axmlnode.nil?
+#       axmlnode = Cell.empty_cell_node
+#     end
+#     @xmlnode = axmlnode
+#     @col = coli
+#     # set @mode
+#     @mode = case
+#       when !@parent_row.used_col_range.include?(coli) then :outbound
+#       when Tools.get_ns_attribute_value(@xmlnode, 'table', 'number-columns-repeated').to_i>1  then :repeated
+#       else:regular
+#     end
+#   end
+#   def to_s; value end
+#   def cell_xml; self.xmlnode.to_s end
+#   def xml; self.xmlnode.children.first.andand.inner_xml end
+#   def address; Rspreadsheet::Tools.c2a(row,col) end
+#   def row; @parent_row.row end
+#   def worksheet; @parent_row.worksheet end
+#   # use this to find node in cell xml. ex. xmlfind('.//text:a') finds all link nodes
+#   def xmlfindall(path)
+#     xmlnode.find(path)
+#   end
+#   def xmlfindfirst(path)
+#     xmlfindall(path).first
+#   end
+#   # based on @xmlnode and optionally value which is about to be assigned, guesses which type the result should be
+#   def inspect
+#     "#<Rspreadsheet::Cell:Cell\n row:#{row}, col:#{col} address:#{address}\n type: #{guess_cell_type.to_s}, value:#{value}\n mode: #{mode}\n>"
+#   end
+# end
 
 end
 

data/lib/rspreadsheet/row.rb

@@ -1,28 +1,120 @@
 require('rspreadsheet/cell')
 require('forwardable')
 
-
 # Currently this is only syntax sugar for cells and contains no functionality
 
 module Rspreadsheet
 
-class RowArray
-  def initialize(aworksheet,aworksheet_node)
+class Row < RowOrNode
+  attr_reader :worksheet, :rowi
+  def initialize(aworksheet,arowi)
     @worksheet = aworksheet
-    @worksheet_node = aworksheet_node
+    @rowi = arowi
+  end
+  def xmlnode; @worksheet.rowxmlnode(@rowi) end
+  def cells(coli)
+    coli = coli.to_i
+    if coli.to_i<=0
+      nil 
+    else 
+      Cell.new(@worksheet,@rowi,coli)
+    end
+  end
+  def self.empty_xmlnode(repeats=1)
+    node = LibXML::XML::Node.new('table-row',nil, Tools.get_namespace('table'))
+    Tools.set_ns_attribute(node,'table','number-rows-repeated',repeats, 1)
+    node
+  end
+  def detach_if_needed; 
+    detach if repeated?
+  end
+  def detach
+    @worksheet.detach_row_in_xml(@rowi)
+    self
+  end
+  def repeated
+    (Tools.get_ns_attribute_value(self.xmlnode, 'table', 'number-rows-repeated') || 1).to_i
+  end
+  def repeated?; mode==:repeated || mode==:outbound end
+  alias :is_repeated? :repeated?
+  def style_name=(value); 
+    detach_if_needed
+    Tools.set_ns_attribute(xmlnode,'table','style-name',value)
+  end
+  def used_range
+    @worksheet.rowrange(@rowi)
+  end
+  def nonemptycells
+    nonemptycellsindexes.collect{ |index| cells(index) }
+  end
+  def nonemptycellsindexes
+    @worksheet.row_nonempty_cells_col_indexes(@rowi)
+  end
+end
 
-    # initialize @rowgroups from @worksheet_node
-    @rowgroups = []
-    unless @worksheet_node.nil?
-      @worksheet_node.elements.select{|node| node.name == 'table-row'}.each do |row_source_node|
-        @rowgroups << prepare_row_group(row_source_node) # it is in @worksheet_node so suffices to add object to @rowgroups
+# 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
+  def range; @rowgroup.range end
+  def repeated?; self.range.size>1 end
+  def xmlnode; @rowgroup.xmlnode end
+
+  def initialize(aparent_array,arange,axmlnode=nil)
+    @rowgroup = RowGroup.new(aparent_array,arange,axmlnode)
+  end
+  def self.new_from_xml
+  end
+  def to_rowgroup
+    @rowgroup
+  end
+  def range=(arange)
+    
+  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 prepare_row_group(size_or_xmlnode)  # appends new RowGroup at the 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['number-rows-repeated'] || 1).to_i
+      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
@@ -30,66 +122,61 @@ class RowArray
     else
       return nil
     end
-    index = first_unused_row_index
-    
+    index = first_unused_index
     # construct result
-    RowGroup.new(self,index..index+size-1,node).normalize
+    Rspreadsheet::XmlTiedArrayItemGroup.new(self,index..index+size-1,node)
   end
-  def add_row_group(size_or_xmlnode)
-    result = prepare_row_group(size_or_xmlnode)
-    @rowgroups << result
-    @worksheet_node << result.xmlnode
+  def add_item_group(size_or_xmlnode)
+    result = parse_xml_to_group(size_or_xmlnode)
+    self << result
+    @xmlnode << result.xmlnode
     result
   end
-  def get_row_group(rowi)
-    @rowgroups.find{ |rowgroup| rowgroup.range.cover?(rowi) }
-  end
-  def get_row(rowi)
-    rg = get_row_group(rowi).andand.normalize
-    case rg
-      when SingleRow then rg
-      when RowGroup then MemberOfRowGroup.new(rowi, rg)
-      when nil
-       if rowi>0 then UninitializedEmptyRow.new(self,rowi) else nil end
-      else raise
-    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_row_group(rowi)
-    fill_row_group_size = rowi-first_unused_row_index
+  def detach_of_bound_item(index)
+    fill_row_group_size = index-first_unused_index
     if fill_row_group_size>0
-      add_row_group(fill_row_group_size) 
+      add_item_group(fill_row_group_size) 
     end
-    add_row_group(1)
-    return get_row(rowi)
+    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 first_unused_row_index
-    if @rowgroups.empty? 
-      1
+  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
-      @rowgroups.last.range.end+1
+      @itemcache[index] ||= Rspreadsheet::XmlTiedArrayItem.new(self,index)
     end
   end
-  # This detaches row rowi from the group and perhaps splits the RowGroup
+  # This detaches item index from the group and perhaps splits the RowGroup
   # into two pieces. This makes the row individually editable.
-  def detach(rowi)
-    index = get_row_group_index(rowi)
-    row_group = @rowgroups[index]
-    range = row_group.range
+  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..rowi-1)
-    replaceby << (result = SingleRow.new(self,rowi))
-    replaceby << RowGroup.new(self,rowi+1..range.end)
+    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 rowi>range.begin
-      replaceby[0] = row_group
-      row_group.range = range.begin..rowi-1
+    
+    if index>range.begin
+      replaceby[0] = item_group
+      item_group.range = range.begin..index-1
     else
-      replaceby[2] = row_group
-      row_group.range = rowi+1..range.end
+      replaceby[2] = item_group
+      item_group.range = index+1..range.end
     end
     
     # normalize and delete empty parts
@@ -97,40 +184,98 @@ class RowArray
     
     # do the replacement in xml
     marker = LibXML::XML::Node.new('temporarymarker')
-    row_group.xmlnode.next = marker
-    row_group.xmlnode.remove!
+    item_group.xmlnode.next = marker
+    item_group.xmlnode.remove!
     replaceby.each{ |rg| 
       marker.prev = rg.xmlnode
     } 
     marker.remove!
     
     # do the replacement in array
-    @rowgroups[index..index]=replaceby
+    self[group_index..group_index]=replaceby
     result
   end
-  def worksheet; @worksheet end
- private
-  def get_row_group_index(rowi)
-    @rowgroups.find_index{ |rowgroup| rowgroup.range.cover?(rowi) }
+  private
+  def get_group_index(index)
+    self.find_index{ |rowgroup| rowgroup.range.cover?(index) }
   end
 end
 
-class Row
-  @readonly = :unknown
-  # ? @rowindex 
-  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
+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 => 'number-rows-repeated', :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 cells(coli)
-    coli = coli.to_i
-    return nil if coli.to_i<=0
+  def get_cell(coli)
     Cell.new(self,coli,cellnodes(coli))
   end
   def nonemptycells
@@ -143,9 +288,6 @@ class RowWithXMLNode < Row
       !cellnode.attributes.to_a.reject{ |attr| attr.name == 'number-columns-repeated'}.empty?
     end
   end
-  def used_col_range
-    1..first_unused_column_index-1
-  end
   def cellnodes(coli)
     cellnode = nil
     while true 
@@ -167,10 +309,6 @@ class RowWithXMLNode < Row
     @xmlnode << cell.xmlnode
     cell
   end
-  def used_range
-    fu = first_unused_column_index
-    (fu>1) ? 1..fu : nil
-  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
@@ -183,6 +321,7 @@ class RowGroup < RowWithXMLNode
   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?
@@ -212,6 +351,7 @@ class SingleRow < RowWithXMLNode
   attr_accessor :xmlnode
   # index  Integer
   def initialize(aparent_array,aindex,axmlnode=nil)
+    super()
     @parent_array = aparent_array
     @index = aindex
     if axmlnode.nil?
@@ -222,21 +362,21 @@ class SingleRow < RowWithXMLNode
   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; true 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
@@ -256,13 +396,18 @@ class MemberOfRowGroup < LazyDetachableRow
   def initialize(arowi,arow_group)
     super(arowi)
     @row_group = arow_group
-    raise 'Wrong parameter given' unless @row_group.is_a? RowGroup
+    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 cells(coli)
-    Cell.new(self,coli,@row_group.cellnodes(coli)).tap{|n| n.mode = :repeated}
+  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) }
@@ -277,9 +422,9 @@ class UninitializedEmptyRow < LazyDetachableRow
     super(arowi)
     @parent_array = aparent_array
   end
-  def cells(coli)
+  def get_cell(coli)
     if still_out_of_used_range?
-      Cell.new(self,coli,Cell.empty_cell_node).tap{|n| n.mode = :outbound}
+      Cell.new(self,coli,nil)
     else
       @parent_array.get_row(@index).cells(coli)
     end
@@ -291,10 +436,13 @@ class UninitializedEmptyRow < LazyDetachableRow
       @parent_array.get_row(@index)
     end
   end
-  def detach; @parent_array.detach_of_bound_row_group(@index) end
+  def detach; @parent_array.detach_item(@index) end
+  def detach_cell(col)
+    self.detach.detach_cell(col)
+  end
   def still_out_of_used_range?; @index >= @parent_array.first_unused_row_index end
   def xmlnode; Row.empty_row_node end
-  def nonemptycells; [] end
+  def first_unused_column_index; 1 end
 end
 
 end