rubyXL-ptr 3.3.27

data/lib/rubyXL/objects/reference.rb

@@ -0,0 +1,110 @@
+module RubyXL
+  class Reference
+    ROW_MAX = 1024*1024
+    COL_MAX = 16393
+
+    attr_reader :row_range, :col_range
+
+    # RubyXL::Reference.new(row, col)
+    # RubyXL::Reference.new(row_from, row_to, col_from, col_to)
+    # RubyXL::Reference.new(reference_string)
+    def initialize(*params)
+      row_from = row_to = col_from = col_to = nil
+
+      case params.size
+      when 4 then row_from, row_to, col_from, col_to = params
+      when 2 then row_from, col_from = params
+      when 1 then
+        raise ArgumentError.new("invalid value for #{self.class}: #{params[0].inspect}") unless params[0].is_a?(String)
+        from, to = params[0].split(':')
+        row_from, col_from = self.class.ref2ind(from)
+        row_to, col_to = self.class.ref2ind(to) unless to.nil?
+      end
+
+      @row_range = Range.new(row_from || 0, row_to || row_from || ROW_MAX)
+      @col_range = Range.new(col_from || 0, col_to || col_from || COL_MAX)
+    end
+
+    def single_cell?
+      (@row_range.begin == @row_range.end) && (@col_range.begin == @col_range.end)
+    end
+
+    def first_row
+      @row_range.begin
+    end
+
+    def last_row
+      @row_range.end
+    end
+
+    def first_col
+      @col_range.begin
+    end
+
+    def last_col
+      @col_range.end
+    end
+
+    def ==(other)
+      !other.nil? && (@row_range == other.row_range) && (@col_range == other.col_range)
+    end
+
+    def cover?(other)
+      !other.nil? && (@row_range.cover?(other.row_range.begin) && @row_range.cover?(other.row_range.end) &&
+                      @col_range.cover?(other.col_range.begin) && @col_range.cover?(other.col_range.end))
+    end
+
+    def to_s
+      if single_cell? then
+        self.class.ind2ref(@row_range.begin, @col_range.begin)
+      else
+        self.class.ind2ref(@row_range.begin, @col_range.begin) + ':' + self.class.ind2ref(@row_range.end, @col_range.end)
+      end
+    end
+
+    def inspect
+      if single_cell? then
+        "#<#{self.class} @row=#{@row_range.begin} @col=#{@col_range.begin}>"
+      else
+        "#<#{self.class} @row_range=#{@row_range} @col_range=#{@col_range}>"
+      end
+    end
+
+    # Converts +row+ and +col+ zero-based indices to Excel-style cell reference
+    # (0) A...Z, AA...AZ, BA... ...ZZ, AAA... ...AZZ, BAA... ...XFD (16383)
+    def self.ind2ref(row = 0, col = 0)
+      str = ''
+
+      loop do
+        x = col % 26
+        str = ('A'.ord + x).chr + str
+        col = (col / 26).floor - 1
+        break if col < 0
+      end
+
+      str += (row + 1).to_s
+    end
+
+    # Converts Excel-style cell reference to +row+ and +col+ zero-based indices.
+    def self.ref2ind(str)
+      return [ -1, -1 ] unless str =~ /\A([A-Z]+)(\d+)\Z/
+
+      col = 0
+      $1.each_byte { |chr| col = col * 26 + (chr - 64) }
+      [ $2.to_i - 1, col - 1 ]
+    end
+
+  end
+
+  class Sqref < Array
+
+    def initialize(str)
+      str.split.each { |ref_str| self << RubyXL::Reference.new(ref_str) }
+    end
+
+    def to_s
+      self.collect{ |ref| ref.to_s }.join(' ')
+    end
+
+  end
+end

data/lib/rubyXL/objects/relationships.rb

@@ -0,0 +1,213 @@
+require 'pathname'
+require 'rubyXL/objects/ooxml_object'
+
+module RubyXL
+
+  class RID < OOXMLObject
+    define_attribute(:'r:id', :string, :required => true)
+  end
+
+  class Relationship < OOXMLObject
+    define_attribute(:Id,         :string)
+    define_attribute(:Type,       :string)
+    define_attribute(:Target,     :string)
+    define_attribute(:TargetMode, :string)
+    define_element_name 'Relationship'
+  end
+
+  class OOXMLRelationshipsFile < OOXMLTopLevelObject
+    CONTENT_TYPE = 'application/vnd.openxmlformats-package.relationships+xml'
+    SAVE_ORDER = 100
+
+    define_child_node(RubyXL::Relationship, :collection => true, :accessor => :relationships)
+    define_element_name 'Relationships'
+    set_namespaces('http://schemas.openxmlformats.org/package/2006/relationships' => nil)
+
+    attr_accessor :related_files, :owner
+
+    @@debug_indent = ($DEBUG ? 0 : nil)
+
+    def new_relationship(target, type)
+      RubyXL::Relationship.new(:id => "rId#{relationships.size + 1}",
+                               :type => type,
+                               :target => target)
+    end
+    protected :new_relationship
+
+    def add_relationship(obj)
+      return if obj.nil? || !defined?(obj.class::REL_TYPE) || (obj.respond_to?(:empty?) && obj.empty?)
+
+      relationships << RubyXL::Relationship.new(:id => "rId#{relationships.size + 1}",
+                                                :type => obj.class::REL_TYPE,
+                                                :target => obj.xlsx_path.relative_path_from(owner.xlsx_path.dirname))
+    end
+    protected :add_relationship
+
+    def find_by_rid(r_id)
+      relationships.find { |r| r.id == r_id }
+    end
+
+    def find_by_target(target)
+      relationships.find { |r|
+        (r.target == target) || (r.target == target.relative_path_from(owner.xlsx_path.dirname))
+      }
+    end
+
+    def self.get_class_by_rel_type(rel_type)
+      unless defined?(@@rel_hash)
+        @@rel_hash = {}
+        RubyXL.constants.each { |c|
+          klass = RubyXL.const_get(c)
+
+          if klass.is_a?(Class) && klass.const_defined?(:REL_TYPE) then
+            @@rel_hash[klass::REL_TYPE] = klass
+          end
+        }
+      end
+
+      @@rel_hash[rel_type]
+    end
+
+    def load_related_files(zipdir_path, base_file_name)
+      self.related_files = {}
+
+      @@debug_indent += 2 if @@debug_indent
+
+      self.relationships.each { |rel|
+        next if rel.target_mode == 'External'
+
+        file_path = ::Pathname.new(rel.target)
+        file_path = (base_file_name.dirname + file_path).cleanpath if file_path.relative?
+
+        klass = RubyXL::OOXMLRelationshipsFile.get_class_by_rel_type(rel.type)
+
+        if klass.nil? then
+          puts "*** WARNING: storage class not found for #{rel.target} (#{rel.type})"
+          klass = GenericStorageObject
+        end
+
+        puts "--> DEBUG:#{'  ' * @@debug_indent}Loading #{klass} (#{rel.id}): #{file_path}" if @@debug_indent
+
+        obj = klass.parse_file(zipdir_path, file_path)
+        obj.load_relationships(zipdir_path, file_path) if obj.respond_to?(:load_relationships)
+        self.related_files[rel.id] = obj
+      }
+
+      @@debug_indent -=2 if @@debug_indent
+
+      related_files
+    end
+
+    def self.load_relationship_file(zipdir_path, base_file_path)
+      rel_file_path = rel_file_path(base_file_path)
+
+      puts "--> DEBUG:  #{'  ' * @@debug_indent}Loading .rel file: #{rel_file_path}" if @@debug_indent
+
+      parse_file(zipdir_path, rel_file_path)
+    end
+
+    def xlsx_path
+      self.class.rel_file_path(owner.xlsx_path)
+    end
+
+    def before_write_xml
+      case owner
+      when RubyXL::WorkbookRoot, RubyXL::Workbook then
+        # Fully implemented objects with no generic (unhandled) relationships -
+        #   (re)generating relationships from scratch.
+        related_objects = owner.related_objects
+        related_objects += owner.generic_storage if owner.generic_storage
+
+        self.relationships = []
+        related_objects.compact.each { |f| add_relationship(f) }
+      end
+      super
+    end
+
+    def self.rel_file_path(base_file_path)
+      basename = base_file_path.root? ? '' : base_file_path.basename
+      base_file_path.dirname.join('_rels', "#{basename}.rels").cleanpath
+    end
+
+  end
+
+  # +RelationshipSupport+ module enables automatic loading and saving of _rels for the respective file
+  module RelationshipSupport
+
+    module ClassMehods
+      def define_relationship(klass, accessor = nil)
+        class_variable_get(:@@ooxml_relationships)[klass] = accessor
+        attr_accessor(accessor) if accessor
+      end
+    end
+
+    def self.included(klass)
+      klass.class_variable_set(:@@ooxml_relationships, {})
+      klass.extend RubyXL::RelationshipSupport::ClassMehods
+    end
+
+    attr_accessor :generic_storage, :relationship_container
+
+    def related_objects # Override this method
+      []
+    end
+
+    def collect_related_objects
+      res = related_objects.compact # Avoid tainting +related_objects+ array
+      res.concat(generic_storage) if generic_storage
+
+      if relationship_container then
+        relationship_container.owner = self
+        res << relationship_container
+      end
+
+      related = []
+
+      res.each { |obj|
+        next if obj.respond_to?(:empty?) && obj.empty?
+        related << obj
+        related.concat(obj.collect_related_objects) if obj.respond_to?(:collect_related_objects)
+      }
+
+      related
+    end
+
+    def load_relationships(dir_path, base_file_name)
+      self.relationship_container = RubyXL::OOXMLRelationshipsFile.load_relationship_file(dir_path, base_file_name)
+      return if relationship_container.nil?
+
+      relationship_container.load_related_files(dir_path, base_file_name).each_pair { |rid, related_file|
+        attach_relationship(rid, related_file) if related_file
+      }
+    end
+
+    def attach_relationship(rid, rf)
+      relationships = self.class.class_variable_get(:@@ooxml_relationships)
+      klass = rf.class
+      if relationships.has_key?(klass) then
+        accessor = relationships[klass]
+        case accessor
+        when NilClass then
+          # Relationship is known, but we don't have a special accessor for it, store as generic
+          store_relationship(rf)
+        when false then
+          # Do nothing, the code will perform attaching on its own
+        else
+          container = self.send(accessor)
+          if container.is_a?(Array) then container << rf
+          else self.send("#{accessor}=", rf)
+          end
+        end
+      else store_relationship(rf, :unknown)
+      end
+    end
+
+    def store_relationship(related_file, unknown = false)
+      self.generic_storage ||= []
+      puts "WARNING: #{self.class} is not aware what to do with #{related_file.class}" if unknown
+      self.generic_storage << related_file
+    end
+
+  end
+
+end

data/lib/rubyXL/objects/root.rb

@@ -0,0 +1,86 @@
+require 'zip'
+require 'rubyXL/objects/relationships'
+require 'rubyXL/objects/document_properties'
+require 'rubyXL/objects/content_types'
+require 'rubyXL/objects/workbook'
+
+module RubyXL
+
+  class WorkbookRoot
+    @@debug = $DEBUG
+
+    attr_accessor :source_file_path, :content_types, :rels_hash
+
+    include RubyXL::RelationshipSupport
+
+    define_relationship(RubyXL::ThumbnailFile,          :thumbnail)
+    define_relationship(RubyXL::CorePropertiesFile,     :core_properties)
+    define_relationship(RubyXL::DocumentPropertiesFile, :document_properties)
+    define_relationship(RubyXL::CustomPropertiesFile,   :custom_properties)
+    define_relationship(RubyXL::Workbook,               :workbook)
+
+    def related_objects
+      [ content_types, thumbnail, core_properties, document_properties, custom_properties, workbook ]
+    end
+
+    def self.default
+      obj = self.new
+      obj.document_properties    = RubyXL::DocumentPropertiesFile.new
+      obj.core_properties        = RubyXL::CorePropertiesFile.new
+      obj.relationship_container = RubyXL::OOXMLRelationshipsFile.new
+      obj.content_types          = RubyXL::ContentTypes.new
+      obj
+    end
+
+    # Write <tt>.xlsx</tt> to a stream (useful for sending over HTTP)
+    def stream
+      stream = Zip::OutputStream.write_buffer { |zipstream|
+        self.rels_hash = {}
+        self.relationship_container.owner = self
+        collect_related_objects.compact.each { |obj|
+          puts "<-- DEBUG: adding relationship to #{obj.class}" if @@debug
+          obj.root = self if obj.respond_to?(:root=)
+          self.rels_hash[obj.class] ||= []
+          self.rels_hash[obj.class] << obj
+        }
+
+        self.rels_hash.keys.sort_by{ |c| c::SAVE_ORDER }.each { |klass|
+          puts "<-- DEBUG: saving related #{klass} files" if @@debug
+          self.rels_hash[klass].select! { |obj|
+            puts "<-- DEBUG:   > #{obj.xlsx_path}" if @@debug
+            obj.add_to_zip(zipstream)
+          }
+        }
+      }
+      stream.rewind
+      stream
+    end
+
+    def xlsx_path
+      OOXMLTopLevelObject::ROOT
+    end
+
+    def self.parse_zip_file(zip_file)
+      root = self.new
+      root.content_types = RubyXL::ContentTypes.parse_file(zip_file, ContentTypes::XLSX_PATH)
+      root.load_relationships(zip_file, OOXMLTopLevelObject::ROOT)
+
+      wb = root.workbook
+      wb.root = root
+
+      wb.sheets.each_with_index { |sheet, i|
+        sheet_obj = wb.relationship_container.related_files[sheet.r_id]
+
+        wb.worksheets[i] = sheet_obj # Must be done first so the sheet becomes aware of its number
+        sheet_obj.workbook = wb
+
+        sheet_obj.sheet_name = sheet.name
+        sheet_obj.sheet_id = sheet.sheet_id
+        sheet_obj.state = sheet.state
+      }
+
+      root
+    end
+  end
+
+end

data/lib/rubyXL/objects/shared_strings.rb

@@ -0,0 +1,70 @@
+require 'rubyXL/objects/ooxml_object'
+require 'rubyXL/objects/text'
+require 'rubyXL/objects/extensions'
+
+module RubyXL
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_sst.html
+  class SharedStringsTable < OOXMLTopLevelObject
+    CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
+    REL_TYPE     = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings'
+
+    # According to http://msdn.microsoft.com/en-us/library/office/gg278314.aspx,
+    # +count+ and +uniqueCount+ may be either both missing, or both present. Need to validate.
+    define_attribute(:uniqueCount,  :int)
+    define_child_node(RubyXL::RichText, :collection => :with_count, :node_name => 'si', :accessor => :strings)
+    define_child_node(RubyXL::ExtensionStorageArea)
+    define_element_name 'sst'
+    set_namespaces('http://schemas.openxmlformats.org/spreadsheetml/2006/main' => nil)
+
+    def initialize(*params)
+      super
+      # So far, going by the structure that the original creator had in mind. However,
+      # since the actual implementation is now extracted into a separate class,
+      # we will be able to transparrently change it later if needs be.
+      @index_by_content = {}
+    end
+
+    def before_write_xml
+      super
+      self.unique_count = self.count
+      self.count > 0
+    end
+
+    def [](index)
+      strings[index]
+    end
+
+    def empty?
+      strings.empty?
+    end
+
+    def add(v, index = nil)
+      index ||= strings.size
+
+      strings[index] =
+        case v
+        when RubyXL::RichText then v
+        when String then RubyXL::RichText.new(:t => RubyXL::Text.new(:value => v))
+        when RubyXL::Text               then RubyXL::RichText.new(:t => v)
+        when RubyXL::RichTextRun        then RubyXL::RichText.new(:r => [ v ])
+        when RubyXL::PhoneticRun        then RubyXL::RichText.new(:r_ph => [ v ])
+        when RubyXL::PhoneticProperties then RubyXL::RichText.new(:phonetic_pr => v)
+        end
+
+      @index_by_content[v.to_s] = index
+    end
+
+    def get_index(str, add_if_missing = false)
+      index = @index_by_content[str]
+      index = add(str) if index.nil? && add_if_missing
+      index
+    end
+
+    def xlsx_path
+      ROOT.join('xl', 'sharedStrings.xml')
+    end
+
+  end
+
+end