rspreadsheet 0.2.0 → 0.2.3

data/lib/rspreadsheet/tools.rb

@@ -14,9 +14,18 @@ module Tools
     else
       raise 'Wrong number of arguments'
     end
-      
-    colname=colname.rjust(3,'@')
-    col = (colname[-1].ord-64)+(colname[-2].ord-64)*26+(colname[-3].ord-64)*26*26
+     
+    ## first possibility how to implement it
+#     colname=colname.rjust(3,'@')
+#     col = (colname[-1].ord-64)+(colname[-2].ord-64)*26+(colname[-3].ord-64)*26*26
+
+    ## second possibility how to implement it
+    # col=(colname.to_i(36)-('A'*colname.size).to_i(36)).to_s(36).to_i(26)+('1'*colname.size).to_i(26)
+    
+    ## third possibility how to implement it (second one little shortened)
+    s=colname.size
+    col=(colname.to_i(36)-(36**s-1).div(3.5)).to_s(36).to_i(26)+(26**s-1)/25
+    
     row = rowname.to_i
     return [row,col]
   end
@@ -115,8 +124,8 @@ module Tools
     node.attributes.get_attribute_ns(Tools.get_namespace(ns_prefix).href,key)
     attr.remove! unless attr.nil? 
   end
-  def self.create_ns_node(nodename,ns_prefix)
-    LibXML::XML::Node.new(nodename,nil, Tools.get_namespace(ns_prefix))
+  def self.create_ns_node(ns_prefix,nodename,value=nil)
+    LibXML::XML::Node.new(nodename,value, Tools.get_namespace(ns_prefix))
   end
 end
  

data/lib/rspreadsheet/version.rb

@@ -1,3 +1,3 @@
 module Rspreadsheet
-  VERSION = "0.2.0"
+  VERSION = "0.2.3"
 end

data/lib/rspreadsheet/worksheet.rb

@@ -5,145 +5,53 @@ require 'rspreadsheet/tools'
 module Rspreadsheet 
 
 class Worksheet
+  include XMLTiedArray
   attr_accessor :name, :xmlnode
-#   extend Forwardable
-#   def_delegators :nonemptycells
+  def subitem_xml_options; {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'} end
 
   def initialize(xmlnode_or_sheet_name)
-    @rowcache=[]
+    @itemcache = Hash.new  #TODO: move to module XMLTiedArray
     # 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
+        @xmlnode = Tools.create_ns_node('table','table')
+        Tools.set_ns_attribute(@xmlnode,'table','name', xmlnode_or_sheet_name)
       else raise 'Provide name or xml node to create a Worksheet object'
     end
   end
   
   def rowxmlnode(rowi)
-    find_subnode_respect_repeated(@xmlnode, rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
+    find_my_subnode_respect_repeated(rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
   end
- 
-  def rowrange(rowi)
-    find_subnode_range_respect_repeated(@xmlnode, rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
-  end
-
-  def row_nonempty_cells_col_indexes(rowi)
-    arowxmlnode = rowxmlnode(rowi)
-    if arowxmlnode.nil?
-      []
-    else
-      find_nonempty_subnode_indexes(arowxmlnode, {:xml_items_node_name => 'table-cell', :xml_repeated_attribute => 'number-columns-repeated'})
-    end
+    
+  def first_unused_row_index
+    find_first_unused_index_respect_repeated({:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
   end
   
-  def cellxmlnode(rowi,coli)
-    arowxmlnode = rowxmlnode(rowi)
-    if arowxmlnode.nil?
-      nil
-    else
-      find_subnode_respect_repeated(arowxmlnode, coli, {:xml_items_node_name => 'table-cell', :xml_repeated_attribute => 'number-columns-repeated'})
-    end
-  end
- 
-  def cellrange(coli)
-    find_subnode_range_respect_repeated(@xmlnode, rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
+  def insert_row_above(arowi)
+    insert_subitem_before(arowi)
   end
   
-  def first_unused_row_index
-    find_first_unused_index_respect_repeated(xmlnode, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
+  def insert_cell_before(arowi,acoli)
+    detach_row_in_xml(arowi)
+    rows(arowi).insert_subitem_before(acoli)
   end
   
   def detach_row_in_xml(rowi)
-    return detach_subnode_respect_repeated(xmlnode, rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
-  end
-  def detach_cell_in_xml(rowi,coli)
-    rownode = detach_row_in_xml(rowi)
-    return detach_subnode_respect_repeated(rownode, coli, {:xml_items_node_name => 'table-cell', :xml_repeated_attribute => 'number-columns-repeated'})
+    return detach_my_subnode_respect_repeated(rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
   end
   
-  def detach_subnode_respect_repeated(axmlnode,aindex, options)
-    index = 0
-    axmlnode.elements.select{|node| node.name == options[:xml_items_node_name]}.each do |node|
-      repeated = (node.attributes[options[:xml_repeated_attribute]] || 1).to_i
-      oldindex = index
-      index = index+repeated
-      if index>= aindex  # found the node, now do the detachement
-        ranges = [oldindex+1..aindex-1,aindex..aindex,aindex+1..index].reject {|range| range.size<1}
-        ranges.each do |range|
-          newnode = node.copy(true)
-          Tools.set_ns_attribute(newnode,'table',options[:xml_repeated_attribute],range.size,1)
-          node.prev = newnode
-        end
-        node.remove!
-        return find_subnode_respect_repeated(axmlnode, aindex, options)
-      end
-    end
-    # add outbound xmlnode
-    [index+1..aindex-1,aindex..aindex].reject {|range| range.size<1}.each do |range|
-      node = LibXML::XML::Node.new(options[:xml_items_node_name],nil, Tools.get_namespace('table'))
-      Tools.set_ns_attribute(node,'table',options[:xml_repeated_attribute],range.size, 1)
-      axmlnode << node
-    end  
-    find_subnode_respect_repeated(axmlnode, aindex, options)
-  end
-
-  def find_subnode_respect_repeated(axmlnode, aindex, options)
-    index = 0
-    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
-      return node if index>= aindex
-    end
-    return nil
-  end
-  def find_subnode_range_respect_repeated(axmlnode, aindex, options)
-    index = 0
-    axmlnode.elements.select{|node| node.name == options[:xml_items_node_name]}.each do |node|
-      repeated = (node.attributes[options[:xml_repeated_attribute]] || 1).to_i
-      if index+repeated >= aindex
-        return (index+1..index+repeated)
-      else
-        index = index+repeated
-      end
-    end
-    return (index+1..Float::INFINITY)
+  def nonemptycells
+    used_rows_range.collect{ |rowi| rows(rowi).nonemptycells }.flatten
   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
-  def find_first_unused_index_respect_repeated(axmlnode, options)
-    index = 0
-    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
-    end
-    return index+1
-  end
+  # rozšíření XMLTiedArray
+  def rows(rowi); subitem(rowi) end
+  def prepare_subitem(rowi); Row.new(self,rowi) end
+  def rowcache; @itemcache end
   
-  def cells(r,c)
-    rows(r).andand.cells(c)
-  end
-  def nonemptycells
-    used_rows_range.collect{ |rowi| rows(rowi) }.collect { |row| row.nonemptycells }.flatten
-  end
-  def rows(rowi)
-    @rowcache[rowi] ||= Row.new(self,rowi) unless rowi<=0
-  end
   ## syntactic sugar follows
   def [](r,c)
     cells(r,c).andand.value
@@ -151,6 +59,9 @@ class Worksheet
   def []=(r,c,avalue)
     cells(r,c).andand.value=avalue
   end
+  def cells(r,c)
+    rows(r).andand.cells(c)
+  end
   # allows syntax like sheet.F15
   def method_missing method_name, *args, &block
     if method_name.to_s.match(/^([A-Z]{1,3})(\d{1,8})(=?)$/)

data/lib/rspreadsheet/xml_tied.rb

@@ -0,0 +1,234 @@
+module Rspreadsheet
+
+class XMLTied
+  def xml
+    xmlnode.to_s
+  end
+end
+  
+# abstrac class. All successort MUST implement: set_index,xml_options,parent,index
+class XMLTiedItem < XMLTied
+  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_repeated_attribute) || 1 ).to_i end
+  def repeated?; mode==:repeated || mode==:outbound end
+  alias :is_repeated? :repeated?
+  def xmlnode
+    parentnode = parent.xmlnode
+    if parentnode.nil?
+      nil
+    else
+      parent.find_my_subnode_respect_repeated(index, xml_options)
+    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, xml_options)
+    self
+  end
+  def shift_by(diff)
+    set_index(index + diff)
+  end
+  def range
+    parent.find_my_subnode_range_respect_repeated(index,xml_options)
+  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
+#     self.instance_variables.each do |variable|
+#       instance_variable_set(variable,nil)
+#     end
+  end
+  def delete
+    parent.delete_subitem(index)
+    invalidate_myself
+  end
+end
+
+# abstrac class. All successort MUST implement: prepare_subitem
+# terminology
+#  item, subitem is object from @itemcache (quite often subclass of XMLTiedItem)
+#  node, subnode is LibXML::XML::Node object
+
+module XMLTiedArray
+  attr_reader :itemcache
+
+  def find_my_subnode_range_respect_repeated(aindex, options)
+    index = 0
+    xmlnode.elements.select{|node| node.name == options[:xml_items_node_name]}.each do |node|
+      repeated = (node.attributes[options[:xml_repeated_attribute]] || 1).to_i
+      if index+repeated >= aindex
+        return (index+1..index+repeated)
+      else
+        index = index+repeated
+      end
+    end
+    return (index+1..Float::INFINITY)
+  end
+  
+  # vrátí xmlnode na souřadnici aindex
+  def find_my_subnode_respect_repeated(aindex, options)
+    find_subnode_respect_repeated(xmlnode,aindex, options)
+  end
+  # vrátí item na souřadnici aindex
+  def subitem(aindex)
+    aindex = aindex.to_i
+    if aindex.to_i<=0
+      nil
+    else 
+      @itemcache[aindex] ||= prepare_subitem(aindex)
+    end
+  end
+  
+  def subitems_array
+    (1..(find_first_unused_index_respect_repeated(subitem_xml_options)-1)).collect do |i|
+      subitem(i)
+    end
+  end
+  
+  def find_subnode_respect_repeated(axmlnode, aindex, options)
+    result1, result2 = find_subnode_with_range_respect_repeated(axmlnode, aindex, options)
+    return result1
+  end  
+    
+  def find_subnode_with_range_respect_repeated(axmlnode, aindex, options)
+    index = 0
+    axmlnode.elements.select{|node| node.name == options[:xml_items_node_name]}.each do |node|
+      repeated = (node.attributes[options[:xml_repeated_attribute]] || 1).to_i
+      oldindex = index
+      index = index+repeated
+      if index>= aindex
+        return node, oldindex..index
+      end
+    end
+    return nil, index..Float::INFINITY
+  end
+  
+  def prepare_repeated_subnode(times_repeated,options)
+    result = LibXML::XML::Node.new(options[:xml_items_node_name],nil, Tools.get_namespace('table'))
+    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, options)
+    axmlnode = xmlnode
+    node,index_range = find_subnode_with_range_respect_repeated(axmlnode, aindex, options)
+    if index_range.size > 1 # pokud potřebuje vůbec detachovat
+      if !node.nil? # detach subnode
+        [index_range.begin+1..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+1..aindex-1,aindex..aindex].reject {|range| range.size<1}.each do |range|
+          axmlnode << prepare_repeated_subnode(range.size, options)
+        end
+      end
+    end
+    return find_subnode_respect_repeated(axmlnode, aindex, options)
+  end
+  
+  def insert_my_subnode_before_respect_repeated(aindex, options)
+    axmlnode = xmlnode
+    
+    node,index_range = find_subnode_with_range_respect_repeated(axmlnode, aindex, options)
+    
+    if !node.nil? # found the node, now do the insert
+      [index_range.begin+1..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
+      clone_before_and_set_repeated_attribute(node.prev,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.prepare_repeated_subnode(range.size, options)
+      end  
+    end
+    return find_subnode_respect_repeated(axmlnode, aindex, options)
+  end
+
+  def delete_my_subnode_respect_repeated(aindex,options)
+    detach_my_subnode_respect_repeated(aindex,options) #TODO: tohle neni uplne spravne, protoze to zanecha skupinu rozdelenou na dve casti
+    subitem(aindex).xmlnode.remove!
+  end
+  
+  def find_first_unused_index_respect_repeated(options)
+    index = 0
+    xmlnode.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
+    end
+    return index+1
+  end
+
+  def insert_subitem_before(aindex)
+    insert_subitem_before_with_options(aindex,subitem_xml_options)
+  end
+  def insert_subitem_before_with_options(aindex,options)
+    @itemcache.keys.sort.reverse.select{|i| i>=aindex }.each do |i| 
+      @itemcache[i+1]=@itemcache.delete(i)
+      @itemcache[i+1].shift_by(1)
+    end
+    insert_my_subnode_before_respect_repeated(aindex,options)  # nyní vlož node do xml
+    @itemcache[aindex] =  subitem(aindex)
+  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,options)  # 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
+  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
+
+end
+
+end 

data/lib/rspreadsheet.rb

@@ -1,4 +1,4 @@
-require "rspreadsheet/version"
+require 'rspreadsheet/version'
 require 'rspreadsheet/workbook'
 require 'rspreadsheet/worksheet'
 require 'class_extensions'

data/reinstall2.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+cd rspreadsheet
+#rm rspreadsheet-0.*.gem
+#rake build
+sudo rake install 
+cd ..

data/rspreadsheet.gemspec

@@ -22,19 +22,18 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'libxml-ruby', '~>2.7'   # parsing XML files
   spec.add_runtime_dependency 'rubyzip', '~>1.1'       # opening zip files
   spec.add_runtime_dependency 'andand', '~>1.3'
-  
-  
+
   # development dependencies
   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'             # testing
-  spec.add_development_dependency 'pry-nav', '~>0'           # enables pry 'next', 'step' commands
-  
+  spec.add_development_dependency "rspec", '~>2'       # testing
+  spec.add_development_dependency 'pry-nav', '~>0'     # enables pry 'next', 'step' commands
+
   # 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'
-#   spec.add_development_dependency 'equivalent-xml'         # implementing xml diff
-  
+#   spec.add_development_dependency 'equivalent-xml'     # implementing xml diff
+
 end