axlsx 1.3.6 → 2.0.0

data/lib/axlsx/rels/relationship.rb

@@ -3,7 +3,43 @@ module Axlsx
   # A relationship defines a reference between package parts.
   # @note Packages automatically manage relationships.
   class Relationship
+    
+    class << self
+      # Keeps track of all instances of this class.
+      # @return [Array]
+      def instances
+        @instances ||= []
+      end
+      
+      # Clear cached instances.
+      # 
+      # This should be called before serializing a package (see {Package#serialize} and
+      # {Package#to_stream}) to make sure that serialization is idempotent (i.e. 
+      # Relationship instances are generated with the same IDs everytime the package
+      # is serialized).
+      # 
+      # Also, calling this avoids memory leaks (cached instances lingering around 
+      # forever). 
+      def clear_cached_instances
+        @instances = []
+      end
+      
+      # Generate and return a unique id (eg. `rId123`) Used for setting {#Id}. 
+      #
+      # The generated id depends on the number of cached instances, so using
+      # {clear_cached_instances} will automatically reset the generated ids, too.
+      # @return [String]
+      def next_free_id
+        "rId#{@instances.size + 1}"
+      end
+    end
 
+    # The id of the relationship (eg. "rId123"). Most instances get their own unique id. 
+    # However, some instances need to share the same id – see {#should_use_same_id_as?}
+    # for details.
+    # @return [String]
+    attr_reader :Id
+    
     # The location of the relationship target
     # @return [String]
     attr_reader :Target
@@ -30,14 +66,26 @@ module Axlsx
     # Target mode must be :external for now.
     attr_reader :TargetMode
 
-    # creates a new relationship
+    # The source object the relations belongs to (e.g. a hyperlink, drawing, ...). Needed when
+    # looking up the relationship for a specific object (see {Relationships#for}).
+    attr_reader :source_obj
+    
+    # Initializes a new relationship. 
+    # @param [Object] source_obj see {#source_obj}
     # @param [String] type The type of the relationship
     # @param [String] target The target for the relationship
     # @option [Symbol] :target_mode only accepts :external.
-    def initialize(type, target, options={})
+    def initialize(source_obj, type, target, options={})
+      @source_obj = source_obj
       self.Target=target
       self.Type=type
-      self.TargetMode = options.delete(:target_mode) if options[:target_mode]
+      self.TargetMode = options[:target_mode] if options[:target_mode]
+      @Id = if (existing = self.class.instances.find{ |i| should_use_same_id_as?(i) })
+        existing.Id
+      else
+        self.class.next_free_id
+      end
+      self.class.instances << self
     end
 
     # @see Target
@@ -50,15 +98,32 @@ module Axlsx
 
     # serialize relationship
     # @param [String] str
-    # @param [Integer] rId the id for this relationship
     # @return [String]
-    def to_xml_string(rId, str = '')
-      h = self.instance_values
-      h[:Id] = 'rId' << rId.to_s
+    def to_xml_string(str = '')
+      h = self.instance_values.reject{|k, _| k == "source_obj"}
       str << '<Relationship '
       str << h.map { |key, value| '' << key.to_s << '="' << Axlsx::coder.encode(value.to_s) << '"'}.join(' ')
       str << '/>'
     end
-
+    
+    # Whether this relationship should use the same id as `other`.
+    #
+    # Instances designating the same relationship need to use the same id. We can not simply
+    # compare the {#Target} attribute, though: `foo/bar.xml`, `../foo/bar.xml`, 
+    # `../../foo/bar.xml` etc. are all different but probably mean the same file (this 
+    # is especially an issue for relationships in the context of pivot tables). So lets
+    # just ignore this attribute for now (except when {#TargetMode} is set to `:External` –
+    # then {#Target} will be an absolute URL and thus can safely be compared).
+    #
+    # @todo Implement comparison of {#Target} based on normalized path names.
+    # @param other [Relationship]
+    def should_use_same_id_as?(other)
+      result = self.source_obj == other.source_obj && self.Type == other.Type && self.TargetMode == other.TargetMode
+      if self.TargetMode == :External
+        result &&= self.Target == other.Target
+      end
+      result
+    end
+    
   end
 end

data/lib/axlsx/rels/relationships.rb

@@ -11,10 +11,17 @@ require 'axlsx/rels/relationship.rb'
       super Relationship
     end
     
+    # The relationship instance for the given source object, or nil if none exists.
+    # @see Relationship#source_obj
+    # @return [Relationship]
+    def for(source_obj)
+      @list.find{ |rel| rel.source_obj == source_obj }
+    end
+    
     def to_xml_string(str = '')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
       str << '<Relationships xmlns="' << RELS_R << '">'
-      each_with_index { |rel, index| rel.to_xml_string(index+1, str) }
+      each{ |rel| rel.to_xml_string(str) }
       str << '</Relationships>'
     end
 

data/lib/axlsx/stylesheet/color.rb

@@ -51,7 +51,7 @@ module Axlsx
     # @see color
     def rgb=(v)
       Axlsx::validate_string(v)
-      v.upcase!
+      v = v.upcase
       v = v * 3 if v.size == 2
       v = v.rjust(8, 'FF')
       raise ArgumentError, "Invalid color rgb value: #{v}." unless v.match(/[0-9A-F]{8}/)

data/lib/axlsx/stylesheet/num_fmt.rb

@@ -10,7 +10,7 @@ module Axlsx
     # Creates a new NumFmt object
     # @param [Hash] options Options for the number format object
     # @option [Integer] numFmtId The predefined format id or new format id for this format
-    # @option [String] fomratCode The format code for this number format
+    # @option [String] formatCode The format code for this number format
     def initialize(options={})
       @numFmtId = 0
       @formatCode = ""
@@ -23,7 +23,7 @@ module Axlsx
     # @see http://support.microsoft.com/kb/264372
     attr_reader :formatCode
 
-    # @return [Integer] An unsinged integer referencing a standard or custom number format.
+    # @return [Integer] An unsigned integer referencing a standard or custom number format.
     # @note
     #  These are the known formats I can dig up. The constant NUM_FMT_PERCENT is 9, and uses the default % formatting. Axlsx also defines a few formats for date and time that are commonly used in asia as NUM_FMT_YYYYMMDD and NUM_FRM_YYYYMMDDHHMMSS.
     #   1 0

data/lib/axlsx/stylesheet/styles.rb

@@ -183,7 +183,7 @@ module Axlsx
     #                                 :border=>Axlsx::STYLE_THIN_BORDER)
     #
     #   # build your rows
-    #   ws.add_row ["Genreated At:", Time.now], :styles=>[nil, date_time]
+    #   ws.add_row ["Generated At:", Time.now], :styles=>[nil, date_time]
     #   ws.add_row ["Previous Year Quarterly Profits (JPY)"], :style=>title
     #   ws.add_row ["Quarter", "Profit", "% of Total"], :style=>title
     #   ws.add_row ["Q1", 4000, 40], :style=>[title, currency, percent]
@@ -296,9 +296,11 @@ module Axlsx
     def parse_fill_options(options={})
       return unless options[:bg_color]
       color = Color.new(:rgb=>options[:bg_color])
-      pattern = PatternFill.new(:patternType =>:solid, :fgColor=>color)
+      dxf = options[:type] == :dxf
+      color_key = dxf ? :bgColor : :fgColor
+      pattern = PatternFill.new(:patternType =>:solid, color_key=>color)
       fill = Fill.new(pattern)
-      options[:type] == :dxf ? fill : fills << fill
+      dxf ? fill : fills << fill
     end
 
     # parses Style#add_style options for borders.

data/lib/axlsx/util/serialized_attributes.rb

@@ -40,18 +40,21 @@ module Axlsx
     # @param [Hash] additional_attributes An option key value hash for
     # defining values that are not serializable attributes list.
     def serialized_attributes(str = '', additional_attributes = {})
-      key_value_pairs = instance_values
-      key_value_pairs.each do |key, value|
-        key_value_pairs.delete(key) if value == nil
-        key_value_pairs.delete(key) unless self.class.xml_attributes.include?(key.to_sym)
-      end
-      key_value_pairs.merge! additional_attributes
-      key_value_pairs.each do |key, value|
-        str << "#{Axlsx.camel(key, false)}=\"#{value}\" "
+      attributes = declared_attributes.merge! additional_attributes
+      attributes.each do |key, value|
+        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(value, false)}\" "
       end
       str
     end
 
+    # A hash of instance variables that have been declared with
+    # seraialized_attributes and are not nil.
+    # This requires ruby 1.9.3 or higher
+    def declared_attributes
+      instance_values.select do |key, value|
+        value != nil && self.class.xml_attributes.include?(key.to_sym)
+      end
+    end
 
     # serialized instance values at text nodes on a camelized element of the
     # attribute name. You may pass in a block for evaluation against non nil

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,21 +1,9 @@
 # encoding: UTF-8
 module Axlsx
+
   # A SimpleTypedList is a type restrictive collection that allows some of the methods from Array and supports basic xml serialization.
   # @private
   class SimpleTypedList
-    # The class constants of allowed types
-    # @return [Array]
-    attr_reader :allowed_types
-
-    # The index below which items cannot be removed
-    # @return [Integer]
-    attr_reader :locked_at
-
-    # The tag name to use when serializing this object
-    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase.
-    # @return [String]
-    attr_reader :serialize_as
-
     # Creats a new typed list
     # @param [Array, Class] type An array of Class objects or a single Class object
     # @param [String] serialize_as The tag name to use in serialization
@@ -33,6 +21,39 @@ module Axlsx
       @serialize_as = serialize_as
     end
 
+    # The class constants of allowed types
+    # @return [Array]
+    attr_reader :allowed_types
+
+    # The index below which items cannot be removed
+    # @return [Integer]
+    attr_reader :locked_at
+
+    # The tag name to use when serializing this object
+    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase.
+    # @return [String]
+    attr_reader :serialize_as
+
+    # Transposes the list (without blowing up like ruby does)
+    # any non populated cell in the matrix will be a nil value
+    def transpose
+      return @list.clone if @list.size == 0
+      row_count = @list.size
+      max_column_count = @list.map{|row| row.cells.size}.max
+      result = Array.new(max_column_count) { Array.new(row_count) }
+      # yes, I know it is silly, but that warning is really annoying
+      row_count.times do |row_index|
+         max_column_count.times do |column_index|
+          datum = if @list[row_index].cells.size >= max_column_count
+                    @list[row_index].cells[column_index]
+                  elsif block_given?
+                    yield(column_index, row_index)
+                  end
+          result[column_index][row_index] = datum
+        end
+      end
+      result
+    end
     # Lock this list at the current size
     # @return [self]
     def lock

data/lib/axlsx/util/validators.rb

@@ -290,4 +290,11 @@ module Axlsx
   def self.validate_split_state_type(v)
     RestrictionValidator.validate :split_state_type, [:frozen, :frozen_split, :split], v
   end
+
+  # Requires that the value is a valid "display blanks as" type.
+  # valid types must be one of gap, span, zero
+  # @param [Any] v The value validated
+  def self.validate_display_blanks_as(v)
+    RestrictionValidator.validate :display_blanks_as, [:gap, :span, :zero], v
+  end
 end

data/lib/axlsx/version.rb

@@ -1,5 +1,5 @@
 module Axlsx
 
   # The current version
-  VERSION = "1.3.6"
+  VERSION = "2.0.0"
 end

data/lib/axlsx/workbook/defined_name.rb

@@ -105,7 +105,7 @@ module Axlsx
     attr_reader :local_sheet_id
 
     # The local sheet index (0-based)
-    # @param [Integer] value the unsinged integer index of the sheet this defined_name applies to.
+    # @param [Integer] value the unsigned integer index of the sheet this defined_name applies to.
     def local_sheet_id=(value)
       Axlsx::validate_unsigned_int(value)
       @local_sheet_id = value

data/lib/axlsx/workbook/shared_strings_table.rb

@@ -26,10 +26,16 @@ module Axlsx
     # @see Cell#sharable
     attr_reader :unique_cells
 
+    # The xml:space attribute
+    # @see Workbook#xml_space
+    attr_reader :xml_space
+
     # Creates a new Shared Strings Table agains an array of cells
     # @param [Array] cells This is an array of all of the cells in the workbook
-    def initialize(cells)
+    # @param [Symbol] xml_space The xml:space behavior for the shared string table.
+    def initialize(cells, xml_space=:preserve)
       @index = 0
+      @xml_space = xml_space
       @unique_cells = {}
       @shared_xml_string = ""
       shareable_cells = cells.flatten.select{ |cell| cell.plain_string? }
@@ -40,8 +46,11 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string
-      '<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '" count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '">' << @shared_xml_string << '</sst>'
+    def to_xml_string(str='')
+      str << '<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '"'
+      str << ' count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '"'
+      str << ' xml:space="' << xml_space.to_s << '">' << @shared_xml_string << '</sst>'
+      str = Axlsx::sanitize(str)
     end
 
     private

data/lib/axlsx/workbook/workbook.rb

@@ -34,6 +34,12 @@ require 'axlsx/workbook/worksheet/worksheet_drawing.rb'
 require 'axlsx/workbook/worksheet/worksheet_comments.rb'
 require 'axlsx/workbook/worksheet/worksheet_hyperlink'
 require 'axlsx/workbook/worksheet/worksheet_hyperlinks'
+require 'axlsx/workbook/worksheet/break'
+require 'axlsx/workbook/worksheet/row_breaks'
+require 'axlsx/workbook/worksheet/col_breaks'
+
+
+
 require 'axlsx/workbook/worksheet/worksheet.rb'
 require 'axlsx/workbook/shared_strings_table.rb'
 require 'axlsx/workbook/defined_name.rb'
@@ -270,14 +276,14 @@ require 'axlsx/workbook/worksheet/selection.rb'
     def relationships
       r = Relationships.new
       @worksheets.each do |sheet|
-        r << Relationship.new(WORKSHEET_R, WORKSHEET_PN % (r.size+1))
+        r << Relationship.new(sheet, WORKSHEET_R, WORKSHEET_PN % (r.size+1))
       end
       pivot_tables.each_with_index do |pivot_table, index|
-        r << Relationship.new(PIVOT_TABLE_CACHE_DEFINITION_R, PIVOT_TABLE_CACHE_DEFINITION_PN % (index+1))
+        r << Relationship.new(pivot_table.cache_definition, PIVOT_TABLE_CACHE_DEFINITION_R, PIVOT_TABLE_CACHE_DEFINITION_PN % (index+1))
       end
-      r << Relationship.new(STYLES_R,  STYLES_PN)
+      r << Relationship.new(self, STYLES_R,  STYLES_PN)
       if use_shared_strings
-          r << Relationship.new(SHARED_STRINGS_R,  SHARED_STRINGS_PN)
+          r << Relationship.new(self, SHARED_STRINGS_R,  SHARED_STRINGS_PN)
       end
       r
     end
@@ -285,7 +291,25 @@ require 'axlsx/workbook/worksheet/selection.rb'
     # generates a shared string object against all cells in all worksheets.
     # @return [SharedStringTable]
     def shared_strings
-      SharedStringsTable.new(worksheets.collect { |ws| ws.cells })
+      SharedStringsTable.new(worksheets.collect { |ws| ws.cells }, xml_space)
+    end
+
+    # The xml:space attribute for the worksheet.
+    # This determines how whitespace is handled withing the document.
+    # The most relevant part being whitespace in the cell text.
+    # allowed values are :preserve and :default. Axlsx uses :preserve unless
+    # you explicily set this to :default.
+    # @return Symbol
+    def xml_space
+      @xml_space ||= :preserve
+    end
+
+    # Sets the xml:space attribute for the worksheet
+    # @see Worksheet#xml_space
+    # @param [Symbol] space must be one of :preserve or :default
+    def xml_space=(space)
+      Axlsx::RestrictionValidator.validate(:xml_space, [:preserve, :default], space)
+      @xml_space = space;
     end
 
     # returns a range of cells in a worksheet
@@ -318,9 +342,8 @@ require 'axlsx/workbook/worksheet/selection.rb'
       defined_names.to_xml_string(str)
       unless pivot_tables.empty?
         str << '<pivotCaches>'
-        pivot_tables.each_with_index do |pivot_table, index|
-          rId = "rId#{@worksheets.size + index + 1  }"
-          str << '<pivotCache cacheId="' << pivot_table.cache_definition.cache_id.to_s << '" r:id="' << rId << '"/>'
+        pivot_tables.each do |pivot_table|
+          str << '<pivotCache cacheId="' << pivot_table.cache_definition.cache_id.to_s << '" r:id="' << pivot_table.cache_definition.rId << '"/>'
         end
         str << '</pivotCaches>'
       end

data/lib/axlsx/workbook/worksheet/break.rb

@@ -0,0 +1,37 @@
+module Axlsx
+
+  # The Break class stores the details for row and column page breaks.
+  # @see RowBreaks, ColBreaks
+  class Break
+
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+    include Axlsx::SerializedAttributes
+
+    # Creates a new Break object
+    # @param options A hash of attribute options for this break.
+    # @option options [Integer] id Zero-based row or column Id of the page break. Breaks occur above the specified row and left of the specified column.
+    # @option options [Integer] min Zero-based index of start row or column of the break. For row breaks, specifies column index; for column breaks, specifies row index.
+    # @option options [Integer] max Zero-based index of end row or column of the break. For row breaks, specifies column index; for column breaks, specifies row index.
+    # @option options [Boolean] man Manual Break flag. 1 means the break is a manually inserted break.
+    # @option option [Boolean] pt Flag indicating that a PivotTable created this break.
+    def initialize(options={})
+      parse_options options
+      yield self if block_given?
+    end
+
+    unsigned_int_attr_accessor :id, :min, :max
+
+    boolean_attr_accessor :man, :pt
+
+    serializable_attributes :id, :min, :max, :man, :pt
+
+    # serializes the break to xml
+    def to_xml_string(str='')
+      str << '<brk '
+      serialized_attributes str
+      str << '></brk>'
+    end
+  end
+end
+

data/lib/axlsx/workbook/worksheet/cell.rb

@@ -302,7 +302,7 @@ module Axlsx
     def to_xml_string(r_index, c_index, str = '')
       CellSerializer.to_xml_string r_index, c_index, self, str
     end
-   
+
     def is_formula?
       @type == :string && @value.to_s.start_with?('=')
     end
@@ -318,9 +318,9 @@ module Axlsx
     end
 
     # returns the absolute or relative string style reference for
-    # this cell. 
+    # this cell.
     # @param [Boolean] absolute -when false a relative reference will be
-    # returned. 
+    # returned.
     # @return [String]
     def reference(absolute=true)
       absolute ? r_abs : r
@@ -353,7 +353,7 @@ module Axlsx
 
     # assigns the owning row for this cell.
     def row=(v) @row=v end
-    
+
     # Determines the cell type based on the cell value.
     # @note This is only used when a cell is created but no :type option is specified, the following rules apply:
     #   1. If the value is an instance of Date, the type is set to :date
@@ -375,7 +375,7 @@ module Axlsx
         :float
         # \A(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[0-1]|0[1-9]|[1-2][0-9])
         # T(2[0-3]|[0-1][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?
-        # (Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?\Z 
+        # (Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?\Z
       elsif v.to_s =~/\A(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[0-1]|0[1-9]|[1-2][0-9])T(2[0-3]|[0-1][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?\Z/
         :iso_8601
       else