rspreadsheet 0.0.5 → 0.0.6

data/lib/rspreadsheet/row.rb

@@ -1,17 +1,296 @@
 require('rspreadsheet/cell')
+include Forwardable
 
 # Currently this is only syntax sugar for cells and contains no functionality
 
 module Rspreadsheet
 
+class RowArray
+  def initialize(aworksheet_node)
+    @worksheet_node = aworksheet_node
+
+    # 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
+      end
+    end
+  end
+  def prepare_row_group(size_or_xmlnode)  # appends new RowGroup at the end
+    # reading params
+    if size_or_xmlnode.kind_of? LibXML::XML::Node
+      size = (size_or_xmlnode['number-rows-repeated'] || 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_row_index
+    
+    # construct result
+    RowGroup.new(self,index..index+size-1,node).normalize
+  end
+  def add_row_group(size_or_xmlnode)
+    result = prepare_row_group(size_or_xmlnode)
+    @rowgroups << result
+    @worksheet_node << 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
+  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
+    if fill_row_group_size>0
+      add_row_group(fill_row_group_size) 
+    end
+    add_row_group(1)
+    return get_row(rowi)
+  end
+  def first_unused_row_index
+    if @rowgroups.empty? 
+      1
+    else
+      @rowgroups.last.range.end+1
+    end
+  end
+  # This detaches row rowi 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
+
+    # 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)
+    
+    # put original range somewhere in replaceby and shorten it
+    if rowi>range.begin
+      replaceby[0] = row_group
+      row_group.range = range.begin..rowi-1
+    else
+      replaceby[2] = row_group
+      row_group.range = rowi+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')
+    row_group.xmlnode.next = marker
+    row_group.xmlnode.remove!
+    replaceby.each{ |rg| 
+      marker.prev = rg.xmlnode
+    } 
+    marker.remove!
+    
+    # do the replacement in array
+    @rowgroups[index..index]=replaceby
+    result
+  end
+  
+ private
+  def get_row_group_index(rowi)
+    @rowgroups.find_index{ |rowgroup| rowgroup.range.cover?(rowi) }
+  end
+end
+
 class Row
-  def initialize(workbook,rowi)
-    @rowi = rowi
-    @workbook = workbook
+  @readonly = :unknown
+  # ? @rowindex 
+  def self.empty_row_node
+    LibXML::XML::Node.new('table-row',nil, Tools.get_namespace('table'))
   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)
-    @workbook.cells(@rowi,coli)
+    coli = coli.to_i
+    return nil if coli.to_i<=0
+    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 used_col_range
+    1..first_unused_column_index-1
+  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 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
+    end
   end
 end
 
+class RowGroup < RowWithXMLNode
+  @readonly = :yes_always
+  attr_reader :range
+  attr_accessor :parent_array, :xmlnode
+  def initialize(aparent_array,arange,axmlnode=nil)
+    @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)
+    @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; true end
+  def row; @index end
+  
+end
+
+class LazyDetachableRow < Row
+  @readonly = :yes_but_detachable
+  def initialize(rowi)
+    @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' 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}
+  end
+  def nonemptycells
+    @row_group.nonemptycellsindexes.collect{ |coli| cells(coli) }
+  end
+end
+
+## this is a row outside the used bounds. the main purpose of this object is to magically synchronize to existing data, once they are created
+class UninitializedEmptyRow < LazyDetachableRow
+  @readonly = :yes_but_detachable
+  attr_reader :parent_array  # debug only
+  def initialize(aparent_array,arowi)
+    super(arowi)
+    @parent_array = aparent_array
+  end
+  def cells(coli)
+    if still_out_of_used_range?
+      Cell.new(self,coli,Cell.empty_cell_node).tap{|n| n.mode = :outbound}
+    else
+      @parent_array.get_row(@index).cells(coli)
+    end
+  end
+  def normalize
+    if still_out_of_used_range?
+      self
+    else
+      @parent_array.get_row(@index)
+    end
+  end
+  def detach; @parent_array.detach_of_bound_row_group(@index) 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
+end
+
+end

data/lib/rspreadsheet/tools.rb

@@ -20,13 +20,87 @@ module Tools
     row = rowname.to_i
     return [row,col]
   end
-  
-  # this object represents array which can contain repeated values
-  # inspired valuely by http://www-users.cs.umn.edu/~saad/software/SPARSKIT/paper.ps 
-  class SparseRepeatedArray < Array
+  def self.get_namespace(prefix)
+    ns_array = {
+      'office'=>"urn:oasis:names:tc:opendocument:xmlns:office:1.0",
+      'style'=>"urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+      'text'=>"urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+      'table'=>"urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+      'draw'=>"urn:oasis:names:tc:opendocument:xmlns:drawing:1.0",
+      'fo'=>"urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
+      'xlink'=>"http://www.w3.org/1999/xlink",
+      'dc'=>"http://purl.org/dc/elements/1.1/",
+      'meta'=>"urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
+      'number'=>"urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0",
+      'presentation'=>"urn:oasis:names:tc:opendocument:xmlns:presentation:1.0",
+      'svg'=>"urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0",
+      'chart'=>"urn:oasis:names:tc:opendocument:xmlns:chart:1.0",
+      'dr3d'=>"urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0",
+      'math'=>"http://www.w3.org/1998/Math/MathML",
+      'form'=>"urn:oasis:names:tc:opendocument:xmlns:form:1.0",
+      'script'=>"urn:oasis:names:tc:opendocument:xmlns:script:1.0",
+      'ooo'=>"http://openoffice.org/2004/office",
+      'ooow'=>"http://openoffice.org/2004/writer",
+      'oooc'=>"http://openoffice.org/2004/calc",
+      'dom'=>"http://www.w3.org/2001/xml-events",
+      'xforms'=>"http://www.w3.org/2002/xforms",
+      'xsd'=>"http://www.w3.org/2001/XMLSchema",
+      'xsi'=>"http://www.w3.org/2001/XMLSchema-instance",
+      'rpt'=>"http://openoffice.org/2005/report",
+      'of'=>"urn:oasis:names:tc:opendocument:xmlns:of:1.2",
+      'xhtml'=>"http://www.w3.org/1999/xhtml",
+      'grddl'=>"http://www.w3.org/2003/g/data-view#",
+      'tableooo'=>"http://openoffice.org/2009/table",
+      'drawooo'=>"http://openoffice.org/2010/draw",
+      'calcext'=>"urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0",
+      'loext'=>"urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0",
+      'field'=>"urn:openoffice:names:experimental:ooo-ms-interop:xmlns:field:1.0",
+      'formx'=>"urn:openoffice:names:experimental:ooxml-odf-interop:xmlns:form:1.0",
+      'css3t'=>"http://www.w3.org/TR/css3-text/"
+    }
+    if @pomnode.nil?
+      @pomnode = LibXML::XML::Node.new('xxx')
+    end
+    if @ns.nil? then @ns={} end
+    if @ns[prefix].nil?
+      @ns[prefix] = LibXML::XML::Namespace.new(@pomnode, prefix, ns_array[prefix])
+    end
+    return @ns[prefix]
+  end
+  # sets namespaced attribute "ns_prefix:key" in node to value. if value == delete_value then remove the attribute
+  def self.set_ns_attribute(node,ns_prefix,key,value,delete_value=nil)
+    ns = Tools.get_namespace(ns_prefix)
+    attr = node.attributes.get_attribute_ns(ns.href, key)
     
-  
+    unless value==delete_value # set attribute
+      if attr.nil? # create attribute if needed
+        attr = LibXML::XML::Attr.new(node, key,'temporarilyempty')
+        attr.namespaces.namespace = ns
+      end
+      attr.value = value.to_s
+      attr
+    else # remove attribute
+      attr.remove! unless attr.nil? 
+      nil
+    end
+  end
+  def self.get_ns_attribute(node,ns_prefix,key)
+    node.attributes.get_attribute_ns(Tools.get_namespace(ns_prefix).href,key)
+  end
+  def self.get_ns_attribute_value(node,ns_prefix,key)
+    Tools.get_ns_attribute(node,ns_prefix,key).andand.value
+  end
+  def self.remove_ns_attribute(node,ns_prefix,key)
+    node.attributes.get_attribute_ns(Tools.get_namespace(ns_prefix).href,key)
+    attr.remove! unless attr.nil? 
   end
 end
  
+end
+
+class Range
+  def size
+    res = self.end-self.begin+1
+    res>0 ? res : 0
+  end
 end

data/lib/rspreadsheet/version.rb

@@ -1,3 +1,3 @@
 module Rspreadsheet
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/rspreadsheet/workbook.rb

@@ -4,22 +4,16 @@ require 'libxml'
 module Rspreadsheet
 class Workbook
   attr_reader :worksheets, :filename
+  attr_reader :xmlnode # debug
   def initialize(afilename=nil)
     @worksheets={}
     @filename = afilename
-    if filename.nil?
-    else
-      @content_xml = Zip::File.open(filename) do |zip|
-        LibXML::XML::Document.io zip.get_input_stream('content.xml')
-      end
-
-      ndx = 0
-      @content_xml.find_first('//office:spreadsheet').each_element { |node|
-        sheet = Worksheet.new(node)
-        @worksheets[ndx]=sheet
-        @worksheets[node.name]=sheet
-        ndx+=1
-      }
+    @content_xml = Zip::File.open(@filename || './lib/rspreadsheet/empty_file_template.ods') do |zip|
+      LibXML::XML::Document.io zip.get_input_stream('content.xml')
+    end
+    @xmlnode = @content_xml.find_first('//office:spreadsheet')
+    @xmlnode.find('./table:table').each do |node|
+      create_worksheet_from_node(node)
     end
   end
   def save(new_filename=nil)
@@ -30,20 +24,31 @@ class Workbook
       @filename = new_filename
     end
     Zip::File.open(@filename) do |zip|
-      # it is easy, because @content_xml in in sync with contents all the time
+      # 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
       end
     end
   end
-  def create_worksheet(node=nil)
-    sheet = Worksheet.new(node)
-    @worksheets[worksheets_count]=sheet
-    @worksheets[node.name]=sheet unless node.nil?
+  def create_worksheet_from_node(source_node)
+    sheet = Worksheet.new(source_node)
+    register_worksheet(sheet)
     return sheet
   end
-  def worksheets
-    @worksheets
+  def create_worksheet_with_name(name)
+    sheet = Worksheet.new(name)
+    register_worksheet(sheet)
+    return sheet
+  end
+  def create_worksheet
+    index = worksheets_count
+    create_worksheet_with_name("Strana #{index}")
+  end
+  def register_worksheet(worksheet)
+    index = worksheets_count+1
+    @worksheets[index]=worksheet
+    @worksheets[worksheet.name]=worksheet unless worksheet.name.nil?
+    @xmlnode << worksheet.xmlnode if worksheet.xmlnode.doc != @xmlnode.doc
   end
   def worksheets_count
     @worksheets.keys.select{ |k| k.kind_of? Numeric }.size #TODO: ?? max
@@ -51,5 +56,8 @@ class Workbook
   def worksheet_names
     @worksheets.keys.reject{ |k| k.kind_of? Numeric }
   end
+  def xmldoc
+    @xmlnode.doc
+  end
 end
 end

data/lib/rspreadsheet/worksheet.rb

@@ -1,47 +1,38 @@
 require 'rspreadsheet/row'
 require 'rspreadsheet/tools'
-require 'forwardable'
+# require 'forwardable'
 
 module Rspreadsheet
 
 class Worksheet
-  attr_accessor :name
-  extend Forwardable
-  def_delegators :nonemptycells
+  attr_accessor :name, :xmlnode
+#   extend Forwardable
+#   def_delegators :nonemptycells
 
-  def initialize(source_node=nil)
-    @source_node = source_node
-    ## initialize cells
-    @cells = Hash.new do |hash, coords|
-      # we create empty cell and place it to hash, we do not have to check whether there is a cell in XML already, because it would be in hash as well
-      hash[coords]=Cell.new(coords[0],coords[1])
-      # TODO: create XML empty node here or upon save?
-    end
-    rowi = 1
-    unless @source_node.nil?
-      @source_node.elements.select{ |node| node.name == 'table-row'}.each do |row_source_node|
-        coli = 1
-        row_source_node.elements.select{ |node| node.name == 'table-cell'}.each do |cell_source_node|
-          initialize_cell(rowi,coli,cell_source_node)
-          coli += 1
-        end
-        rowi += 1
-      end
+  def initialize(xmlnode_or_sheet_name)
+    # set up the @xmlnode according to parameter
+    case xmlnode_or_sheet_name
+      when LibXML::XML::Node
+        @xmlnode = xmlnode_or_sheet_name
+      when String
+        @xmlnode = LibXML::XML::Node.new('table')
+        ns = LibXML::XML::Namespace.new(@xmlnode, 'table', 'urn:oasis:names:tc:opendocument:xmlns:table:1.0')
+        @xmlnode .namespaces.namespace = ns
+        @xmlnode['table:name'] = xmlnode_or_sheet_name
+      else raise 'Provide name or xml node to create a Worksheet object'
     end
+      
     ## initialize rows
-    @spredsheetrows=Array.new()
-  end
-  def initialize_cell(r,c,source_node)
-    @cells[[r,c]]=Cell.new(r,c,source_node)
+    @spredsheetrows=RowArray.new(@xmlnode)
   end
   def cells(r,c)
-    @cells[[r,c]]
+    rows(r).andand.cells(c)
   end
   def nonemptycells
-    @cells.values
+    used_rows_range.collect{ |rowi| rows(rowi) }.collect { |row| row.nonemptycells }.flatten
   end
   def rows(rowi)
-    @spredsheetrows[rowi] ||= Row.new(self,rowi)
+    @spredsheetrows.get_row(rowi)
   end
   ## syntactic sugar follows
   def [](r,c)
@@ -64,6 +55,9 @@ class Worksheet
       super
     end
   end
+  def used_rows_range
+    1..@spredsheetrows.first_unused_row_index-1
+  end
 end
 
 end

data/rspreadsheet.gemspec

@@ -28,12 +28,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake", '~>0.9'
   # testig - see http://bit.ly/1n5yM51
-  spec.add_development_dependency "rspec", '~>2'
+  spec.add_development_dependency "rspec", '~>2'       # testing
+  spec.add_development_dependency 'pry-nav'            # enables pry 'next', 'step' commands
   
   # optional and testing
   spec.add_development_dependency "coveralls", '~>0.7'
-  spec.add_development_dependency "test_notifier", '~>2.0' # test notifier for kde and other platforms
   spec.add_development_dependency "guard", '~>2.6'
   spec.add_development_dependency "guard-rspec", '~>2.6'
+#   spec.add_development_dependency 'equivalent-xml'         # implementing xml diff
   
 end

data/spec/cell_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+ 
+describe Rspreadsheet::Cell do
+  before do 
+    book1 = Rspreadsheet.new
+    @sheet1 = book1.create_worksheet
+    book2 = Rspreadsheet.new($test_filename)
+    @sheet2 = book2.worksheets[1]
+  end
+  it 'contains good row and col coordinates' do
+    @cell = @sheet1.cells(1,3)
+    @cell.row.should == 1
+    @cell.col.should == 3
+    @cell.coordinates.should == [1,3]
+    
+    @cell = @sheet2.cells(7,2)
+    @cell.row.should == 7
+    @cell.col.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)
+    @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)
+    @sheet1[2,2] = 'zaprve'
+    @cell.value.should == 'zaprve'
+    @sheet1.cells(2,2).value = 'zadruhe'
+    @cell.value.should == 'zadruhe'
+    @sheet1.B2 = 'zatreti'
+    @cell.value.should == 'zatreti'
+  end
+  it 'can include links' do
+    @sheet2.A12.should == '[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.value.should == 'afterrepeated'
+    @cell.row.should == 13
+    @cell.col.should == 5
+  end
+  it 'does not accept negative and zero coordinates' do
+    @sheet2.cells(0,5).should be(nil)
+    @sheet2.cells(2,-5).should be(nil)
+    @sheet2.cells(-2,-5).should be(nil)
+  end
+end