rspreadsheet 0.2.15 → 0.3

data/lib/rspreadsheet/tools.rb

@@ -117,7 +117,8 @@ module Tools
       '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/"
+      'css3t'=>"http://www.w3.org/TR/css3-text/",
+      'manifest'=>"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
     }
     if @pomnode.nil?
       @pomnode = LibXML::XML::Node.new('xxx')
@@ -148,6 +149,7 @@ module Tools
   end
   def self.get_ns_attribute(node,ns_prefix,key,default=:undefined_default)
     if default==:undefined_default
+      raise 'Nil does not have any attributes' if node.nil?
       node.attributes.get_attribute_ns(Tools.get_namespace(ns_prefix).href,key)
     else
       node.nil? ? default : node.attributes.get_attribute_ns(Tools.get_namespace(ns_prefix).href,key) || default
@@ -167,6 +169,23 @@ module Tools
   def self.prepare_ns_node(ns_prefix,nodename,value=nil)
     LibXML::XML::Node.new(nodename,value, Tools.get_namespace(ns_prefix))
   end
+  def self.insert_as_first_node_child(node,subnode)
+    if node.first?
+      node.first.prev = subnode
+    else
+      node << subnode
+    end
+  end
+  
+  
+  def self.get_unused_filename(zip,prefix, extension)
+    (1000..9999).each do |ndx|
+      filename = prefix + ndx.to_s + ((Time.now.to_r*1000000000).to_i.to_s(16)) + extension
+      return filename if zip.find_entry(filename).nil?
+    end
+    raise 'Could not get unused filename within sane times of iterations'
+  end
+  
 end
  
 end

data/lib/rspreadsheet/version.rb

@@ -1,3 +1,3 @@
 module Rspreadsheet
-  VERSION = "0.2.15"
+  VERSION = "0.3"
 end

data/lib/rspreadsheet/workbook.rb

@@ -9,15 +9,16 @@ class Workbook
   
   #@!group Worskheets methods
   def create_worksheet_from_node(source_node)
-    sheet = Worksheet.new(source_node)
+    sheet = Worksheet.new(source_node,self)
     register_worksheet(sheet)
     return sheet
   end
   def create_worksheet(name = "Sheet#{worksheets_count+1}")
-    sheet = Worksheet.new(name)
+    sheet = Worksheet.new(name,self)
     register_worksheet(sheet)
     return sheet
   end
+  alias :add_worksheet :create_worksheet 
   # @return [Integer] number of sheets in the workbook
   def worksheets_count; @worksheets.length end
   # @return [String] names of sheets in the workbook
@@ -28,10 +29,10 @@ class Workbook
     case index_or_name
       when Integer then begin
         case index_or_name
-          when 0 then nil 
+          when 0 then nil
           when 1..Float::INFINITY then @worksheets[index_or_name-1]
           when -Float::INFINITY..-1 then @worksheets[index_or_name]    # zaporne indexy znamenaji pocitani zezadu
-        end  
+        end
       end
       when String then @worksheets.select{|ws| ws.name == index_or_name}.first
       when NilClass then nil
@@ -42,47 +43,107 @@ class Workbook
   alias :sheet :worksheets
   alias :sheets :worksheets
   def [](index_or_name); self.worksheets(index_or_name) end
-  #@!group Loading and saving related methods  
+  #@!group Loading and saving related methods
+  
+  # @return Mime of the file
+  def mime; 'application/vnd.oasis.opendocument.spreadsheet'.freeze end
+  # @return [String] Prefered file extension
+  def mime_preferred_extension; 'ods'.freeze end
+  alias :mime_default_extension :mime_preferred_extension
+  
   def initialize(afilename=nil)
     @worksheets=[]
     @filename = afilename
-    @content_xml = Zip::File.open(@filename || File.dirname(__FILE__)+'/empty_file_template.ods') do |zip|
-      LibXML::XML::Document.io zip.get_input_stream('content.xml')
+    @content_xml = Zip::File.open(@filename || TEMPLATE_FILE) do |zip|
+      LibXML::XML::Document.io zip.get_input_stream(CONTENT_FILE_NAME)
     end
     @xmlnode = @content_xml.find_first('//office:spreadsheet')
     @xmlnode.find('./table:table').each do |node|
       create_worksheet_from_node(node)
     end
   end
+  
   # @param [String] Optional new filename
   # Saves the worksheet. Optionally you can provide new filename.
+
   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
+    @par = new_filename_or_io_object
+    if @filename.nil? and @par.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 @par.kind_of? StringIO
+      @par.write(@content_xml.to_s(indent: false))
+    elsif @par.nil? or @par.kind_of? String
      
-      if new_filename_or_io_object.kind_of? String   # the filename has changed 
+      if @par.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
+        FileUtils.cp(@filename || File.dirname(__FILE__)+'/empty_file_template.ods', @par)
+        @filename = @par
       end
+      
+
       Zip::File.open(@filename) do |zip|
-        # it is easy, because @xmlnode in in sync with contents all the time
+        # open manifest
+        @manifest_xml = LibXML::XML::Document.io zip.get_input_stream('META-INF/manifest.xml')
+
+        # save all pictures - iterate through sheets and pictures and check if they are saved and if not, save them
+        @worksheets.each do |sheet|
+          sheet.images.each do |image|
+            # check if it is saved
+            @ifname = image.internal_filename
+            if @ifname.nil? or zip.find_entry(@ifname).nil?   
+              # if it does not have name -> make up unused name 
+              if @ifname.nil?
+                @ifname = image.internal_filename = Rspreadsheet::Tools.get_unused_filename(zip,'Pictures/',File.extname(image.original_filename))
+              end
+              raise 'Could not set up internal_filename correctly.' if @ifname.nil?
+              
+              # save it to zip file
+              zip.add(@ifname, image.original_filename)
+              
+              # make sure it is in manifest
+              if @manifest_xml.find("//manifest:file-entry[@manifest:full-path='#{@ifname}']").empty?
+                node = Tools.prepare_ns_node('manifest','file-entry')
+                Tools.set_ns_attribute(node,'manifest','full-path',@ifname)
+                Tools.set_ns_attribute(node,'manifest','media-type',image.mime)
+                @manifest_xml.find_first("//manifest:manifest") << node
+              end  
+            end
+          end
+        end
+
         zip.get_output_stream('content.xml') do |f|
           f.write @content_xml.to_s(:indent => false)
         end
+        
+        zip.get_output_stream('META-INF/manifest.xml') do |f|
+          f.write @manifest_xml.to_s
+        end
       end
     end
   end
-  # @return Mime of the file
-  def mime; 'application/vnd.oasis.opendocument.spreadsheet' end
-  # @return [String] Prefered file extension
-  def mime_preferred_extension; 'ods' end
-  alias :mime_default_extension :mime_preferred_extension
+  
+  # Saves the worksheet to IO stream.
+  def save_to_io(io = ::StringIO.new)
+    ::Zip::OutputStream.write_buffer(io) do |output|
+      ::Zip::File.open(TEMPLATE_FILE) do |input|
+        input.
+          select { |entry| entry.file? }.
+          select { |entry| entry.name != CONTENT_FILE_NAME }.
+          each do |entry|
+            output.put_next_entry(entry.name)
+            output.write(entry.get_input_stream.read)
+          end
+      end
+
+      output.put_next_entry(CONTENT_FILE_NAME)
+      output.write(@content_xml.to_s(indent: false))
+    end
+  end
+  alias :to_io :save_to_io 
   
   private 
+  CONTENT_FILE_NAME = 'content.xml'
+  TEMPLATE_FILE = (File.dirname(__FILE__)+'/empty_file_template.ods').freeze
   def register_worksheet(worksheet)
     index = worksheets_count+1
     @worksheets[index-1]=worksheet

data/lib/rspreadsheet/worksheet.rb

@@ -1,17 +1,19 @@
 require 'rspreadsheet/row'
 require 'rspreadsheet/column'
+require 'rspreadsheet/image'
 require 'rspreadsheet/tools'
+require 'helpers/class_extensions'
 # require 'forwardable'
 
 module Rspreadsheet 
 
 class Worksheet
-  include XMLTiedArray
+  include XMLTiedArray_WithRepeatableItems
   attr_accessor :xmlnode
   def subitem_xml_options; {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'} end
 
-  def initialize(xmlnode_or_sheet_name)
-    @itemcache = Hash.new  #TODO: move to module XMLTiedArray
+  def initialize(xmlnode_or_sheet_name,workbook) # workbook is here ONLY because of inserting images - to find unique name - it would be much better if it should bot be there
+    initialize_xml_tied_array
     # set up the @xmlnode according to parameter
     case xmlnode_or_sheet_name
       when LibXML::XML::Node
@@ -29,31 +31,50 @@ class Worksheet
   def name=(value); Tools.set_ns_attribute(@xmlnode,'table','name', value) end
   
   def rowxmlnode(rowi)
-    find_my_subnode_respect_repeated(rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
+    my_subnode(rowi)
   end
     
   def first_unused_row_index
-    find_first_unused_index_respect_repeated({:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
+    first_unused_subitem_index
   end
   
   def add_row_above(arowi)
-    add_empty_subitem_before(arowi)
+    insert_new_empty_subitem_before(arowi)
   end
   
-  def insert_cell_before(arowi,acoli)
+  def insert_cell_before(arowi,acoli)        # TODO: maybe move this to row level
     detach_row_in_xml(arowi)
-    rows(arowi).add_empty_subitem_before(acoli)
+    rows(arowi).insert_new_item(acoli)  
   end
   
   def detach_row_in_xml(rowi)
-    return detach_my_subnode_respect_repeated(rowi, {:xml_items_node_name => 'table-row', :xml_repeated_attribute => 'number-rows-repeated'})
+    return detach_my_subnode_respect_repeated(rowi)
   end
   
   def nonemptycells
     used_rows_range.collect{ |rowi| rows(rowi).nonemptycells }.flatten
   end
   
-  #@!group XMLTiedArray connected methods
+  #@!group images
+  def worksheet_images
+    @worksheet_images ||= WorksheetImages.new(self)
+  end
+  def images_count
+    worksheet_images.size
+  end
+  def images(*params)
+    worksheet_images.subitems(*params) 
+  end  
+  def insert_image(filename,mime='image/png')
+    worksheet_images.insert_image(filename,mime)
+  end
+  def insert_image_to(x,y,filename,mime='image/png')
+    img = insert_image(filename,mime)
+    img.move_to(x,y)
+    img
+  end
+  
+  #@!group XMLTiedArray_WithRepeatableItems connected methods
   def rows(*params); subitems(*params) end
   alias :row :rows
   def prepare_subitem(rowi); Row.new(self,rowi) end

data/lib/rspreadsheet/xml_tied_array.rb

@@ -0,0 +1,179 @@
+require 'helpers/class_extensions'
+
+module Rspreadsheet
+
+using ClassExtensions if RUBY_VERSION > '2.1'
+
+# @private
+class XMLTied
+  def xml
+    xmlnode.to_s
+  end
+end
+  
+# Abstract class representing and array which is tied to a particular element of XML file.
+# It uses cashing to make access to array more effective. Implements the following methods:
+#
+#   * subitems(index) - returns subitem object on index 
+#   * subitems - returns array of all subitems. Please note that first item is always nil so 
+#     the array can be accessed using 1-based indexes.
+#   
+# Importer must provide:
+#
+#   * prepare_subitem(aindex) - must return newly created object representing item on aindex
+#   * delete - ???
+#   * xmlnode - must return xmlnode to which the array is tied. If speed is not a concern, 
+#               consider not cashing it into variable, but finding it through document or parent. 
+#               This prevents "broken" links. Sometimes when array is empty, the node does note
+#               necessarily exists. That is fine, XMLTiedArray behaves correctly even with nil xmlnode,
+#               of course util you want to insert something. If this may happens, importer must
+#               provide method prepare_empty_xmlnode which prepares (and returns) empty xml node.
+#               It is lazy called, as late as possible.
+#   * subitem_xml_options - returns hash of options used to locate subitems in xml (TODO: rewrite in clear way)
+#   * intilize must call initialize_xml_tied_array
+#
+# Terminology
+#   * item, subitem is object from @itemcache (quite often subclass of XMLTiedItem)
+#   * node, subnode is LibXML::XML::Node object
+#
+# this class is made to be included.
+#
+# Note for developers:
+# Beware that the implementation of methods needs to be done in a way that it continues to
+# work when items are "repeatable" - see XMLTiedArray_WithRepeatableItems. When impractical or impossible
+# please implement the corresponding method in XMLTiedArray_WithRepeatableItems or at least override it there
+# and make it raise exception.
+# 
+# @private
+module XMLTiedArray
+  attr_reader :itemcache
+  
+  def initialize_xml_tied_array
+    @itemcache = Hash.new
+  end
+  
+  # @!group accessing items
+  
+  # Returns item with index aindex
+  def subitem(aindex)
+    aindex = aindex.to_i
+    if aindex.to_i<=0
+      raise 'Item index should be greater then 0' if Rspreadsheet.raise_on_negative_coordinates
+      nil 
+    else 
+      @itemcache[aindex] ||= prepare_subitem(aindex)
+    end
+  end
+  
+  def last
+    subitem(size)
+  end
+  
+  # Returns an array of subitems (when called without parameter) or an item on paricular index (when called with parameter). 
+  def subitems(*params)
+    case params.length 
+      when 0 then subitems_array
+      when 1 then subitem(params[0]) 
+      else raise Exception.new('Wrong number of arguments.')
+    end
+  end
+
+  # Returns array of subitems (repeated friendly)
+  def subitems_array
+    (1..self.size).collect do |i|
+      subitem(i)
+    end
+  end
+  
+  # Number of subitems
+  def size; first_unused_subitem_index-1 end
+  alias :lenght :size
+      
+  # Finds first unused subitem index
+  def first_unused_subitem_index
+    (1 + xmlsubnodes.sum { |node| how_many_times_node_is_repeated(node) }).to_i
+  end
+  
+  # @!group inserting new items  
+  # Inserts empty subitem at the index position. Item currently on this position and all items 
+  # after are shifter by index one.
+  def insert_new_item(aindex)
+    @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_new_empty_subnode_before(aindex)  # nyní vlož node do xml
+    @itemcache[aindex] =  subitem(aindex)
+  end
+  alias :insert_new_empty_subitem_before :insert_new_item
+  
+  def push_new
+    insert_new_item(first_unused_subitem_index)
+  end
+  
+  # @!group other subitems methods
+  # This is used (i.e. in first_unused_subitem_index) so it is flexible and can be reused in XMLTiedArray_WithRepeatableItems
+  # @private
+  def how_many_times_node_is_repeated(node); 1 end
+  
+#   # @!supergroup XML STRUCTURE internal handling methods #######################################
+
+#   # @!group accessing subnodes
+  # returns xmlnode with index
+  # DOES not respect repeated_attribute
+  def my_subnode(aindex)
+    raise 'Using method which does not respect repeated_attribute with options that are using it. You probably donot want to do that.' unless subitem_xml_options[:xml_repeated_attribute].nil?
+    return xmlsubnodes[aindex-1]
+  end
+
+  # @!group inserting new subnodes TODO: refactor out repeatable connected code
+  def insert_new_empty_subnode_before(aindex)
+    node_after = my_subnode(aindex)
+    
+    if !node_after.nil?
+      node_after.prev = prepare_empty_subnode
+      return node_after.prev
+    elsif aindex==size+1
+      # check whether xmlnode is ready for insetion
+      if xmlnode.nil?
+        prepare_empty_xmlnode
+        if xmlnode.nil?
+          raise 'Attempted call prepare_empty_xmlnode, but it did not created xmlnode correctly (it is still nil).'
+        end
+      end
+      # do the insertion
+      xmlnode <<  prepare_empty_subnode
+      return xmlnode.last
+    else
+      raise IndexError.new("Index #{aindex} out of bounds (1..#{self.size})")
+    end
+  end    
+ 
+  def prepare_empty_subnode
+    Tools.prepare_ns_node(
+      subitem_xml_options[:xml_items_node_namespace] || 'table',
+      subitem_xml_options[:xml_items_node_name]
+    )
+  end
+  
+  # @!supergroup internal procedures dealing solely with xml structure ==========
+
+  # importer must provide this only if it may happen that xmlnode is empty AND we will want to insert subitems
+  def prepare_empty_xmlnode
+    raise 'xmlnode is empty and I do not know how to create empty xmlnode. Please provide prepare_empty_xmlnode method in your object.'
+  end
+  
+  # @!group finding and accessing subnodes
+  # array containing subnodes of xmlnode which represent subitems
+  def xmlsubnodes
+    return [] if xmlnode.nil?
+    so = subitem_xml_options[:xml_items_node_name]
+    
+    xmlnode.elements.select do |node| 
+      node.andand.name == so
+    end
+  end
+    
+end
+
+end