rspreadsheet 0.2.15 → 0.3

data/lib/rspreadsheet/xml_tied_item.rb

@@ -0,0 +1,111 @@
+require 'helpers/class_extensions'
+require 'rspreadsheet/xml_tied_array' # BASTL to je jen kvuli XMLTied class
+
+module Rspreadsheet
+
+using ClassExtensions if RUBY_VERSION > '2.1'
+  
+# Note for developers: In case you want to represent a node containing many identical subnodes
+# (like row contains cells, worksheet contains rows or images part includes images) than
+#   1. Include module XMLTiedArray into parent class
+#   2. Subclass XMLTiedItem by object which will represent individual items
+#   3. Implement methods which are mentioned at both of these and the rest should work itself.
+#   4. prepare_subitem calls method new of the item and usually sends index and parent + some
+#      more so subitem can implement parent and index methods.
+
+# @private
+# abstract class. All successors have some options. MUST implement: 
+#   * xml_options
+#
+# If you override intializer make sure you call initialize_xml_tied_item(aparent,aindex).
+# 
+# Optionally you may implement method which makes index accessible under more meaningful name
+# like column or so. Optionally you may implement method which makes parent accessible under 
+# more meaningful name like worksheet or so.
+#
+# By default parent is stored at initialization and never changed. If you do not want to cache
+# it like this (to prevent inconsistencies) just override parent method to dfind the parent 
+# dynamically (see Cell). If you do so you may want to disable the default parent handling by
+# calling initialize_xml_tied_item(nil,index) in initializer (or do not call it at all if you
+# have overridden index as well.
+#
+# Note: If there is a object representing parent (presumably using XMLTiedArray) than initialize
+# signature must be reflected in parent prepare_subitem method
+# 
+class XMLTiedItem < XMLTied
+  
+  def initialize(aparent,aindex)
+    initialize_xml_tied_item(aparent,aindex)
+  end
+  def parent; @xml_tied_parent end
+  def index; @xml_tied_item_index end
+  def set_index(aindex); @xml_tied_item_index=aindex end
+  def index=(aindex); @xml_tied_item_index=aindex end
+  
+  # `xml_options[:xml_items_node_name]` gives the name of the tag representing cell
+  # `xml_options[:number-columns-repeated]` gives the name of the previous tag which sais how many times the item is repeated
+  def xml_options; abstract end
+    
+  def initialize_xml_tied_item(aparent,aindex)
+    @xml_tied_parent = aparent unless aparent.nil?
+    @xml_tied_item_index = aindex unless aindex.nil?
+  end
+    
+  def mode
+   case
+     when xmlnode.nil? then :outbound
+     when repeated>1  then :repeated
+     else :regular
+   end
+  end
+  def repeated; (Tools.get_ns_attribute_value(xmlnode, 'table', xml_options[:xml_repeated_attribute]) || 1 ).to_i end
+  def repeated?; mode==:repeated || mode==:outbound end
+  alias :is_repeated? :repeated?
+  def xmlnode
+    if parent.xmlnode.nil?
+      nil
+    else
+      parent.my_subnode(index)
+    end
+  end
+  def detach_if_needed
+    detach if repeated? # item did not exist individually yet, detach it within its parent and therefore make it individally editable
+  end
+  def detach
+    parent.detach_if_needed if parent.respond_to?(:detach_if_needed)
+    parent.detach_my_subnode_respect_repeated(index)
+    self
+  end
+  def _shift_by(diff)
+    set_index(index + diff)
+  end
+  def range
+    parent.my_subnode_range(index)
+  end
+  def invalid_reference?; false end
+  # destroys the object so it can not be used, this is necessarry to prevent
+  # accessing cells and rows which has been long time ago deleted and do not represent
+  # any physical object anymore
+  def invalidate_myself
+    raise_destroyed_cell_error = Proc.new {|*params| raise "Calling method of already destroyed Cell."}
+    (self.methods - Object.methods + [:nil?]).each do |method| # "undefine" all methods
+      self.singleton_class.send(:define_method, method, raise_destroyed_cell_error)
+    end
+    self.singleton_class.send(:define_method, :inspect, -> { "#<%s:0x%x destroyed cell>" % [self.class,object_id] })  # define descriptive inspect
+    self.singleton_class.send(:define_method, :invalid_reference?, -> { true }) # define invalid_reference? method
+    # invalidate variables
+    @xml_tied_parent=nil
+    @xml_tied_item_index=nil
+#     self.instance_variables.each do |variable|
+#       instance_variable_set(variable,nil)
+#     end
+  end
+  def delete
+    parent.delete_subitem(index)
+    invalidate_myself
+  end
+
+end
+
+
+end 

data/lib/rspreadsheet/xml_tied_repeatable.rb

@@ -0,0 +1,151 @@
+require 'helpers/class_extensions'
+require 'rspreadsheet/xml_tied_array'
+
+module Rspreadsheet
+
+using ClassExtensions if RUBY_VERSION > '2.1'
+
+
+# Abstract class similar to XMLTiedArray but with support to "repeatable" items. This is notion specific
+# to OpenDocument files - whnewer a row repeats more times (or a cell), one can either make many identical
+# copies of the same xml or only make one xml representing one item and add attribute xml_repeated.
+#
+# This class is made to be included, not subclassed - the reason is in delete method which calls super.
+# This class is also made to handle automatic creation of outbound items.
+# @private
+
+module XMLTiedArray_WithRepeatableItems
+  include XMLTiedArray
+
+  def my_subnode_range(aindex)
+    node, range = find_subnode_with_range(aindex)
+    return range
+  end
+  
+  # vrátí xmlnode na souřadnici aindex
+  def my_subnode(aindex)
+    result1, result2 = find_subnode_with_range(aindex)
+    return result1
+  end
+
+  def find_subnode_with_range(aindex)
+    options = subitem_xml_options
+    rightindex = 0
+    xmlsubnodes.each do |node|
+      repeated = (node.attributes[options[:xml_repeated_attribute]] || 1).to_i
+      leftindex = rightindex + 1 
+      rightindex = rightindex+repeated
+      if rightindex>= aindex
+        return node, leftindex..rightindex
+      end
+    end
+    return nil, rightindex+1..Float::INFINITY
+  end
+  
+  # @!group inserting new subnodes
+  
+  def insert_new_empty_subnode_before(aindex)
+    insert_new_empty_subnode_before_respect_repeatable(aindex)
+  end
+  
+  def insert_new_empty_subnode_before_respect_repeatable(aindex)
+    axmlnode = xmlnode
+    options = subitem_xml_options
+    node,index_range = find_subnode_with_range(aindex)
+    
+    if !node.nil? # found the node, now do the insert
+      [index_range.begin..aindex-1,aindex..index_range.end].reject {|range| range.size<1}.each do |range| # split  original node by cloning
+        clone_before_and_set_repeated_attribute(node,range.size,options)
+      end
+      node.prev.prev =  prepare_repeated_subnode(1, options)   # insert new node
+      node.remove!                                             # remove the original node
+    else # insert outbound xmlnode
+      [index+1..aindex-1,aindex..aindex].reject {|range| range.size<1}.each do |range|
+        axmlnode << XMLTiedArray_WithRepeatableItems.prepare_repeated_subnode(range.size, options)
+      end  
+    end #TODO: Out of bounds indexes handling
+    return my_subnode(aindex)
+  end
+  
+  def prepare_repeated_subnode(times_repeated,options)
+    result = prepare_empty_subnode
+    Tools.set_ns_attribute(result,'table',options[:xml_repeated_attribute],times_repeated, 1)
+    result
+  end
+  
+  def clone_before_and_set_repeated_attribute(node,times_repeated,options)
+    newnode = node.copy(true)
+    Tools.set_ns_attribute(newnode,'table',options[:xml_repeated_attribute],times_repeated,1)
+    node.prev = newnode
+  end
+  
+  # detaches subnode with aindex  
+  def detach_my_subnode_respect_repeated(aindex)
+    axmlnode = xmlnode
+    options = subitem_xml_options
+    node,index_range = find_subnode_with_range(aindex)
+    if index_range.size > 1 # pokud potřebuje vůbec detachovat
+      if !node.nil? # detach subnode
+        [index_range.begin..aindex-1,aindex..aindex,aindex+1..index_range.end].reject {|range| range.size<1}.each do |range| # create new structure by cloning
+          clone_before_and_set_repeated_attribute(node,range.size,options)
+        end
+        node.remove! # remove the original node
+      else # add outbound xmlnode
+        [index_range.begin..aindex-1,aindex..aindex].reject {|range| range.size<1}.each do |range|
+          axmlnode << prepare_repeated_subnode(range.size, options)
+        end
+      end
+    end
+    return my_subnode(aindex)
+  end
+  
+  def delete_my_subnode_respect_repeated(aindex)
+    detach_my_subnode_respect_repeated(aindex) #TODO: tohle neni uplne spravne, protoze to zanecha skupinu rozdelenou na dve casti
+    subitem(aindex).xmlnode.remove!
+  end
+  
+  def how_many_times_node_is_repeated(node)   # adding respect to repeated nodes
+    (node.attributes[subitem_xml_options[:xml_repeated_attribute]] || 1).to_i
+  end
+  
+  
+  # clean up item from xml (handle possible detachments) and itemcache. leave the object invalidation on the object
+  # this should not be called from nowhere but XMLTiedItem.delete
+  def delete_subitem(aindex)
+    options = subitem_xml_options
+    delete_my_subnode_respect_repeated(aindex)  # vymaž node z xml
+    @itemcache.delete(aindex)
+    @itemcache.keys.sort.select{|i| i>=aindex+1 }.each do |i| 
+      @itemcache[i-1]=@itemcache.delete(i)
+      @itemcache[i-1]._shift_by(-1)
+    end
+  end
+  
+  def delete
+    @itemcache.each do |key,item| 
+      item.delete   # delete item - this destroys its subitems, xmlnode and invalidates it
+      @itemcache.delete(key)  # delete the entry from the hash, normally this would mean this ceases to exist, if user does not have reference stored somewhere. Of he does, the object is invalidated anyways
+    end
+    super # this for example for Row objects calls XMLTiedItem.delete because Row is subclass of XMLTiedItem
+  end
+
+  def find_nonempty_subnode_indexes(axmlnode, options)
+    index = 0
+    result = []
+    axmlnode.elements.select{|node| node.name == options[:xml_items_node_name]}.each do |node|
+      repeated = (node.attributes[options[:xml_repeated_attribute]] || 1).to_i
+      index = index + repeated
+      if !(node.content.nil? or node.content.empty? or node.content =='') and (repeated==1)
+        result << index
+      end
+    end
+    return result
+  end
+
+  # truncate the item completely, deleting all its subitems
+  def truncate
+    subitems.reverse.each{ |subitem| subitem.delete }  # reverse je tu jen kvuli performanci, aby to mazal zezadu
+  end  
+end
+
+end

data/reinstall_local_gem.sh

@@ -1,8 +1,8 @@
 #!/bin/sh
 
 # remove previously build gems
-rm -f pkg/rspreadsheet-0.*.gem
-rm -f Gemfile.lock
+sudo rm -f pkg/rspreadsheet-0.*.gem
+sudo rm -f Gemfile.lock
 
 # this is to update git index, because git lsfiles is used in .gemspec
 git add .

data/rspreadsheet.gemspec

@@ -18,8 +18,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  def self.package_installed?(pkgname)
+    system("dpkg-query -l #{pkgname} | grep -q '^i'")
+  end
+  
   # runtime dependencies
-  spec.add_runtime_dependency 'libxml-ruby', '~>2.7'   # parsing XML files
+  unless package_installed?('ruby-libxml')
+    spec.add_runtime_dependency 'libxml-ruby', '~>2.7'   # parsing XML files
+  end
   spec.add_runtime_dependency 'rubyzip', '~>1.1'       # opening zip files
   spec.add_runtime_dependency 'andand', '~>1.3'
 
@@ -32,8 +38,14 @@ Gem::Specification.new do |spec|
 
   # optional and testing
   spec.add_development_dependency "coveralls", '~>0.7'
-  spec.add_development_dependency "guard", '~>2.6'
-  spec.add_development_dependency "guard-rspec", '~>2.6'
+
+  if RUBY_VERSION.split('.')[0] !=  "1"
+    # ruby_dep starts to require ruby 2.2.5 which raises errors with ruby 1.9.3
+#     spec.add_development_dependency "guard", '~>2.13'
+#     spec.add_development_dependency "guard-rspec", '~>4.6'
+  end
+  
 #   spec.add_development_dependency 'equivalent-xml'     # implementing xml diff
 
 end
+

data/spec/cell_spec.rb

@@ -269,6 +269,21 @@ describe Rspreadsheet::Cell do
     @cell.value.month.should eq 1
     @cell.value.day.should eq 2
   end
+  it 'stores time correctly' do
+    @cell = @sheet1.cell(1,1)
+    @cell.value= Time.parse('2:42 pm')
+    @cell.value.hour.should eq 14
+    @cell.value.min.should eq 42
+    @cell.value.sec.should eq 0
+  end
+  it 'can read various types of times', :pending => 'see is' do
+    raise @sheet2.cell('D23').xml.inspect
+    expect {@cell = @sheet2.cell('D22'); @cell.value }.not_to raise_error
+    expect {@cell = @sheet2.cell('D23'); @cell.value }.not_to raise_error
+    
+    @cell.value.should == Time.new(2005,5,5,3,33,00)
+  end
+  
   it 'can be addressed by even more ways and all are identical' do
     @cell = @sheet1.cell(2,2)
     @sheet1.cell('B2').value = 'zaseste'
@@ -292,10 +307,14 @@ describe Rspreadsheet::Cell do
     @cell.format.bold = true
     @cell.format.bold.should be_truthy
     @cell.mode.should eq :regular
+
+    @cell = @sheet1.cell(2,2)
+    @cell.format.background_color = '#ffeeaa'
+    @cell.format.background_color.should == '#ffeeaa'
+    @cell.mode.should eq :regular
   end
   it 'remembers formula when set' do
     @cell = @sheet1.cell(1,1)
-    # bold
     @cell.formula.should be_nil
     @cell.formula='=1+5'
     @cell.formula.should eq '=1+5'
@@ -327,4 +346,66 @@ describe Rspreadsheet::Cell do
     @czkcell.value.should == 344.to_d
     @czkcell.format.currency.should == 'CZK'
   end
+  it 'is possible to manipulate borders of cells' do
+    @cell = @sheet1.cell(1,1)
+    
+    [@cell.format.top,@cell.format.left,@cell.format.right,@cell.format.bottom].each do |border|
+      border.style = 'dashed'
+      border.style.should == 'dashed'
+      border.width = 0.5 
+      border.width.should == 0.5
+      border.color = '#005500'
+      border.color.should == '#005500'
+    end    
+  end
+  it 'returns correct border parameters for the cell' do
+    @sheet2.cell('C8').format.top.style.should == 'solid'
+    @sheet2.cell('E8').format.left.color.should == '#ff3333'
+    @sheet2.cell('E8').format.left.style.should == 'solid'
+    @sheet2.cell('F8').format.top.color.should == '#009900'
+    @sheet2.cell('F8').format.top.style.should == 'dotted'
+  end
+  it 'modifies borders correctly' do
+    ## initially solid everywhere
+    @sheet2.cell('C8').format.top.style.should == 'solid'
+    @sheet2.cell('C8').format.bottom.style.should == 'solid'
+    @sheet2.cell('C8').format.left.style.should == 'solid'
+    @sheet2.cell('C8').format.right.style.should == 'solid'
+    ## change top and right to dotted and observe
+    @sheet2.cell('C8').format.top.style = 'dotted'
+    @sheet2.cell('C8').format.right.style = 'dotted'
+    @sheet2.cell('C8').format.bottom.style.should == 'solid'
+    @sheet2.cell('C8').format.left.style.should == 'solid'
+    @sheet2.cell('C8').format.top.style.should == 'dotted'
+    @sheet2.cell('C8').format.right.style.should == 'dotted'
+  end
+  it 'deletes borders correctly', :pending=> 'consider how to deal with deleted borders' do
+    @cell = @sheet1.cell(1,1)
+    
+    [@cell.format.top,@cell.format.left,@cell.format.right,@cell.format.bottom].each do |border|
+      border.style = 'dashed'
+      border.should_not be_nil
+      border.delete
+      border.should be_nil
+    end 
+    
+    # delete right border in existing file and observe
+    @sheet2.cell('C8').format.right.delete
+    @sheet2.cell('C8').format.right.should == nil
+  end
+  
+  it 'can delete borders in many ways', :pending => 'consider what syntax to support' do
+    @cell=@sheet2.cell('C8')
+    @cell.border_right.should_not be_nil
+    @cell.border_right.delete
+    @cell.border_right.should be_nil
+    
+    @cell.border_left.should_not be_nil
+    @cell.border_left = nil
+    @cell.border_left.should be_nil
+    
+    @cell.format.top.should_not_be_nil
+    @cell.format.top.style = 'none'
+    @cell.border_top.should_not be_nil ## ?????
+  end
 end

data/spec/class_extensions_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+if RUBY_VERSION > '2.1'
+  # testing ClassExtensionsForSpec
+  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
+
+  # testing ClassExtensions
+  begin
+    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
+  end
+end