axlsx 1.0.16 → 1.1.0

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,5 +1,6 @@
+# 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.  
+  # 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
@@ -11,14 +12,14 @@ module Axlsx
     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. 
+    # 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 The tag name to use in serialization
-    # @raise [ArgumentError] if all members of type are not Class objects    
+    # @raise [ArgumentError] if all members of type are not Class objects
     def initialize type, serialize_as=nil
       if type.is_a? Array
         type.each { |item| raise ArgumentError, "All members of type must be Class objects" unless item.is_a? Class }
@@ -38,7 +39,7 @@ module Axlsx
       @locked_at = @list.size
       self
     end
-    
+
     def to_ary
       @list
     end
@@ -57,7 +58,7 @@ module Axlsx
     def <<(v)
       DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
       @list << v
-      @list.size - 1      
+      @list.size - 1
     end
 
     # alternate of << method
@@ -103,14 +104,14 @@ module Axlsx
       return false unless @locked_at.is_a? Fixnum
       index < @locked_at
     end
-    
+
     # override the equality method so that this object can be compared to a simple array.
     # if this object's list is equal to the specifiec array, we return true.
     def ==(v)
       v == @list
     end
     # method_mission override to pass allowed methods to the list.
-    # @note 
+    # @note
     #  the following methods are not allowed
     #   :replace
     #   :insert
@@ -139,25 +140,34 @@ module Axlsx
     DELEGATES = Array.instance_methods - self.instance_methods - DESTRUCTIVE
 
     DELEGATES.each do |method|
-      class_eval %{ 
+      class_eval %{
         def #{method}(*args, &block)
           @list.send(:#{method}, *args, &block)
         end
       }
     end
 
+    def to_xml_string(str = '')
+      classname = @allowed_types[0].name.split('::').last
+      el_name = serialize_as || (classname[0,1].downcase + classname[1..-1])
+      str << '<' << el_name << ' count="' << @list.size.to_s << '">'
+      @list.each { |item| item.to_xml_string(str) }
+      str << '</' << el_name << '>'
+    end
+
     # Serializes the list
-    # If the serialize_as property is set, it is used as the parent node name. 
+    # If the serialize_as property is set, it is used as the parent node name.
     # If the serialize_as property is nil, the first item in the list of allowed_types will be used, having the first letter of the class changed to lower case.
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
     def to_xml(xml)
       classname = @allowed_types[0].name.split('::').last
-      el_name = serialize_as || (classname[0,1].downcase + classname[1..-1]).pluralize
+      el_name = serialize_as || (classname[0,1].downcase + classname[1..-1])
       xml.send(el_name, :count=>@list.size) {
         @list.each { |item| item.to_xml(xml) }
       }
     end
+
   end
 
 

data/lib/axlsx/util/storage.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
 
   # The Storage class represents a storage object or stream in a compound file.

data/lib/axlsx/util/validators.rb

@@ -1,14 +1,15 @@
+# encoding: UTF-8
 module Axlsx
   # Validate a value against a specific list of allowed values.
   class RestrictionValidator
     # Perform validation
     # @param [String] name The name of what is being validatied. This is included in the error message
     # @param [Array] choices The list of choices to validate against
-    # @param [Any] v The value to be validated  
+    # @param [Any] v The value to be validated
     # @raise [ArgumentError] Raised if the value provided is not in the list of choices.
     # @return [Boolean] true if validation succeeds.
     def self.validate(name, choices, v)
-      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)      
+      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)
       true
     end
   end
@@ -52,6 +53,14 @@ module Axlsx
     DataTypeValidator.validate(:unsigned_int, [Fixnum, Integer], v, lambda { |arg| arg.respond_to?(:>=) && arg >= 0 })
   end
 
+  # Requires that the value is a Fixnum Integer or Float and is greater or equal to 0
+  # @param [Any] v The value validated
+  # @raise [ArgumentError] raised if the value is not a Fixnun, Integer, Float value greater or equal to 0
+  # @return [Boolean] true if the data is valid
+  def self.validate_unsigned_numeric(v)
+    DataTypeValidator.validate("Invalid column width", [Fixnum, Integer, Float], v, lambda { |arg| arg.respond_to?(:>=) && arg >= 0 })
+  end
+
   # Requires that the value is a Fixnum or Integer
   # @param [Any] v The value validated
   def self.validate_int(v)
@@ -59,7 +68,7 @@ module Axlsx
   end
 
   # Requires that the value is a form that can be evaluated as a boolean in an xml document.
-  # The value must be an instance of Fixnum, String, Integer, Symbol, TrueClass or FalseClass and 
+  # The value must be an instance of Fixnum, String, Integer, Symbol, TrueClass or FalseClass and
   # it must be one of 0, 1, "true", "false", :true, :false, true, false, "0", or "1"
   # @param [Any] v The value validated
   def self.validate_boolean(v)
@@ -70,13 +79,13 @@ module Axlsx
   # @param [Any] v The value validated
   def self.validate_string(v)
     DataTypeValidator.validate :string, String, v
-  end   
+  end
 
   # Requires that the value is a Float
   # @param [Any] v The value validated
   def self.validate_float(v)
     DataTypeValidator.validate :float, Float, v
-  end   
+  end
 
   # Requires that the value is valid pattern type.
   # valid pattern types must be one of :none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown,
@@ -94,6 +103,13 @@ module Axlsx
     RestrictionValidator.validate :gradient_type, [:linear, :path], v
   end
 
+  # Requires that the value is a valid scatterStyle
+  # must be one of :none | :line | :lineMarker | :marker | :smooth | :smoothMarker
+  # must be one of "none" | "line" | "lineMarker" | "marker" | "smooth" | "smoothMarker"
+  # @param [Symbol|String] the value to validate
+  def self.validate_scatter_style(v)
+    Axlsx::RestrictionValidator.validate "ScatterChart.scatterStyle", [:none, :line, :lineMarker, :marker, :smooth, :smoothMarker], v.to_sym
+  end
   # Requires that the value is a valid horizontal_alignment
   # :general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed are allowed
   # @param [Any] v The value validated
@@ -116,10 +132,10 @@ module Axlsx
   end
 
   # Requires that the value is a valid relationship_type
-  # XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R are allowed
+  # XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R are allowed
   # @param [Any] v The value validated
   def self.validate_relationship_type(v)
-    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R], v
+    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R, HYPERLINK_R, SHARED_STRINGS_R], v
   end
 
   # Requires that the value is a valid table element type

data/lib/axlsx/version.rb

@@ -1,9 +1,10 @@
+# encoding: UTF-8
 module Axlsx
 
   # The version of the gem
   # When using bunle exec rake and referencing the gem on github or locally
   # it will use the gemspec, which preloads this constant for the gem's version.
   # We check to make sure that it has not already been loaded
-  VERSION="1.0.16" unless Axlsx.const_defined? :VERSION
+  VERSION="1.1.0" unless defined? Axlsx::VERSION
 
 end

data/lib/axlsx/workbook/shared_strings_table.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The Shared String Table class is responsible for managing and serializing common strings in a workbook.
+  # While the ECMA-376 spec allows for both inline and shared strings it seems that at least some applications like iWorks Numbers
+  # and Google Docs require that the shared string table is populated in order to interoperate properly.
+  # As a developer, you should never need to directly work against this class. Simply set 'use_shared_strings'
+  # on the package or workbook to generate a package that uses the shared strings table instead of inline strings.
+  # @note Serialization performance is affected by using this serialization method so if you do not need interoperability
+  # it is recomended that you use the default inline string method of serialization.
+  class SharedStringsTable
+
+    # The total number of strings in the workbook including duplicates
+    # Empty cells are treated as blank strings
+    # @return [Integer]
+    attr_reader :count
+
+    # The total number of unique strings in the workbook.
+    # @return [Integer]
+    def unique_count
+      @unique_cells.size
+    end
+
+    # An array of unique cells. Multiple attributes of the cell are used in comparison
+    # each of these unique cells is parsed into the shared string table.
+    # @see Cell#sharable
+    attr_reader :unique_cells
+
+    # 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)
+      cells = cells.flatten.reject { |c| c.type != :string || c.value.nil? || c.value.start_with?('=') }
+      @count = cells.size
+      @unique_cells = []
+      @shared_xml_string = ""
+      resolve(cells)
+    end
+
+    # 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>'
+    end
+
+    private
+
+    # Interate over all of the cells in the array.
+    # if our unique cells array does not contain a sharable cell,
+    # add the cell to our unique cells array and set the ssti attribute on the index of this cell in the shared strings table
+    # if a sharable cell already exists in our unique_cells array, set the ssti attribute of the cell and move on.
+    # @return [Array] unique cells
+    def resolve(cells)
+      cells.each do |cell|
+        cell_hash = cell.shareable_hash
+        index = @unique_cells.index do |item|
+          item == cell_hash
+        end
+        if index == nil
+          cell.send :ssti=, @unique_cells.size
+          @shared_xml_string << '<si>' << cell.run_xml_string << '</si>'
+          @unique_cells << cell_hash
+        else
+          cell.send :ssti=, index
+        end
+      end
+    end
+  end
+end

data/lib/axlsx/workbook/shared_strings_table.rb~

@@ -0,0 +1,69 @@
+# encoding: UTF--8
+module Axlsx
+
+  # The Shared String Table class is responsible for managing and serializing common strings in a workbook.
+  # While the ECMA-376 spec allows for both inline and shared strings it seems that at least some applications like Numbers (Mac)
+  # and Google Docs require that the shared string table is populated in order to interoperate properly. 
+  # As a developer, you should never need to directly work against this class. Simply set 'use_shared_strings'
+  # on the package or workbook to generate a package that uses the shared strings table instead of inline strings.
+  # @note Serialization performance is affected by using this serialization method so if you do not need interoperability
+  # it is recomended that you use the default inline string method of serialization.
+  class SharedStringsTable
+
+    # The total number of strings in the workbook including duplicates
+    # Empty cells are treated as blank strings
+    # @return [Integer]
+    attr_reader :count
+
+    # The total number of unique strings in the workbook. 
+    # @return [Integer]
+    def unique_count
+      @unique_cells.size
+    end
+
+    # An array of unique cells. Multiple attributes of the cell are used in comparison
+    # each of these unique cells is parsed into the shared string table.     
+    # @see Cell#sharable
+    attr_reader :unique_cells
+
+    # 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)
+      cells = cells.reject { |c| c.type != :string }
+      @count = cells.size
+      @unique_cells = []
+      resolve cells
+    end
+
+    # Interate over all of the cells in the array. 
+    # if our unique cells array does not contain a sharable cell, 
+    # add the cell to our unique cells array and set the ssti attribute on the index of this cell in the shared strings table
+    # if a sharable cell already exists in our unique_cells array, set the ssti attribute of the cell and move on.
+    # @return [Array] unique cells
+    def resolve(cells)
+      cells.each do |cell|
+        index = @unique_cells.index { |item| item.sharable(cell) }
+        if index == nil
+          cell.ssti = @unique_cells.size
+          @unique_cells << cell
+        else
+          cell.ssti = index
+        end
+      end
+    end
+
+    # Generate the xml document for the Shared Strings Table
+    # @return [String]
+    def to_xml
+      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
+        xml.sst(:xmlns => Axlsx::XML_NS, :count => count, :uniqueCount => unique_count) {
+          @unique_cells.each do |cell|
+            xml.si { xml.t cell.value.to_s }
+          end
+        }
+      end
+      builder.to_xml(:save_with => 0)
+    end
+  end
+
+end

data/lib/axlsx/workbook/workbook.rb

@@ -1,13 +1,18 @@
 # -*- coding: utf-8 -*-
-module Axlsx 
+module Axlsx
 
+require 'axlsx/workbook/worksheet/date_time_converter.rb'
 require 'axlsx/workbook/worksheet/cell.rb'
+require 'axlsx/workbook/worksheet/page_margins.rb'
 require 'axlsx/workbook/worksheet/row.rb'
+require 'axlsx/workbook/worksheet/col.rb'
 require 'axlsx/workbook/worksheet/worksheet.rb'
+require 'axlsx/workbook/shared_strings_table.rb'
+require 'axlsx/workbook/worksheet/table.rb'
 
   # The Workbook class is an xlsx workbook that manages worksheets, charts, drawings and styles.
   # The following parts of the Office Open XML spreadsheet specification are not implimented in this version.
-  # 
+  #
   #   bookViews
   #   calcPr
   #   customWorkbookViews
@@ -30,7 +35,20 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
   #   *workbookPr is only supported to the extend of date1904
   class Workbook
 
-    # A collection of worksheets associated with this workbook. 
+    # When true, the Package will be generated with a shared string table. This may be required by some OOXML processors that do not
+    # adhere to the ECMA specification that dictates string may be inline in the sheet.
+    # Using this option will increase the time required to serialize the document as every string in every cell must be analzed and referenced.
+    # @return [Boolean]
+    attr_reader :use_shared_strings
+
+    # @see use_shared_strings
+    def use_shared_strings=(v)
+      Axlsx::validate_boolean(v)
+      @use_shared_strings = v
+    end
+
+
+   # A collection of worksheets associated with this workbook.
     # @note The recommended way to manage worksheets is add_worksheet
     # @see Workbook#add_worksheet
     # @see Worksheet
@@ -58,6 +76,14 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
     # @return [SimpleTypedList]
     attr_reader :drawings
 
+    # A colllection of tables associated with this workbook
+    # @note The recommended way to manage drawings is Worksheet#add_table
+    # @see Worksheet#add_table
+    # @see Table
+    # @return [SimpleTypedList]
+    attr_reader :tables
+
+
     # The styles associated with this workbook
     # @note The recommended way to manage styles is Styles#add_style
     # @see Style#add_style
@@ -72,40 +98,35 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
     # Indicates if the epoc date for serialization should be 1904. If false, 1900 is used.
     @@date1904 = false
 
-    # lets come back to this later when we are ready for parsing. 
+
+    # lets come back to this later when we are ready for parsing.
     #def self.parse entry
     #  io = entry.get_input_stream
     #  w = self.new
     #  w.parser_xml = Nokogiri::XML(io.read)
-    #  w.parse_string :date1904, "//xmlns:workbookPr/@date1904"      
+    #  w.parse_string :date1904, "//xmlns:workbookPr/@date1904"
     #  w
     #end
 
     # Creates a new Workbook
-    #
-    # @option options [Boolean] date1904. If this is not specified, we try to determine if the platform is bsd/darwin and set date1904 to true automatically.
-    #
+    # The recomended way to work with workbooks is via Package#workbook
+    # @option options [Boolean] date1904. If this is not specified, date1904 is set to false. Office 2011 for Mac defaults to false.
     def initialize(options={})
       @styles = Styles.new
       @worksheets = SimpleTypedList.new Worksheet
       @drawings = SimpleTypedList.new Drawing
       @charts = SimpleTypedList.new Chart
       @images = SimpleTypedList.new Pic
-      self.date1904= options[:date1904].nil? ? is_bsd? : options[:date1904]
-      yield self if block_given?      
-    end
+      @tables = SimpleTypedList.new Table
+      @use_autowidth = true
 
-    # Uses RUBY_PLATFORM constant to determine if the OS is freebsd or darwin
-    # based on this value we attempt to set date1904.
-    # @return [Boolean]
-    def is_bsd?
-      platform = RUBY_PLATFORM.downcase
-      platform.include?('freebsd') || platform.include?('darwin')
+      self.date1904= !options[:date1904].nil? && options[:date1904]
+      yield self if block_given?
     end
 
     # Instance level access to the class variable 1904
     # @return [Boolean]
-    def date1904() @@date1904; end    
+    def date1904() @@date1904; end
 
     # see @date1904
     def date1904=(v) Axlsx::validate_boolean v; @@date1904 = v; end
@@ -118,9 +139,18 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
     # @return [Boolean]
     def self.date1904() @@date1904; end
 
+    # Indicates if the workbook should use autowidths or not.
+    # this must be set before instantiating a worksheet to avoid Rmagix inclusion
+    # @return [Boolean]
+    def use_autowidth() @use_autowidth; end
+
+    # see @use_autowidth
+    def use_autowidth=(v) Axlsx::validate_boolean v; @use_autowidth = v; end
+
     # Adds a worksheet to this workbook
     # @return [Worksheet]
     # @option options [String] name The name of the worksheet.
+    # @option options [Hash] page_margins The page margins for the worksheet.
     # @see Worksheet#initialize
     def add_worksheet(options={})
       worksheet = Worksheet.new(self, options)
@@ -134,38 +164,54 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
       r = Relationships.new
       @worksheets.each do |sheet|
         r << Relationship.new(WORKSHEET_R, WORKSHEET_PN % (r.size+1))
-      end 
+      end
       r << Relationship.new(STYLES_R,  STYLES_PN)
+      if use_shared_strings
+          r << Relationship.new(SHARED_STRINGS_R,  SHARED_STRINGS_PN)
+      end
       r
     end
 
+    # generates a shared string object against all cells in all worksheets.
+    # @return [SharedStringTable]
+    def shared_strings
+      SharedStringsTable.new(worksheets.collect { |ws| ws.cells })
+    end
+
     # returns a range of cells in a worksheet
-    # @param [String] cell_def The excel style reference defining the worksheet and cells. The range must specify the sheet to 
+    # @param [String] cell_def The excel style reference defining the worksheet and cells. The range must specify the sheet to
     # retrieve the cells from. e.g. range('Sheet1!A1:B2') will return an array of four cells [A1, A2, B1, B2] while range('Sheet1!A1') will return a single Cell.
     # @return [Cell, Array]
     def [](cell_def)
       sheet_name = cell_def.split('!')[0] if cell_def.match('!')
       worksheet =  self.worksheets.select { |s| s.name == sheet_name }.first
-      raise ArgumentError, 'Unknown Sheet' unless sheet_name && worksheet.is_a?(Worksheet) 
+      raise ArgumentError, 'Unknown Sheet' unless sheet_name && worksheet.is_a?(Worksheet)
       worksheet[cell_def.gsub(/.+!/,"")]
     end
 
-    # Serializes the workbook document
+    # Serialize the workbook
+    # @param [String] str
     # @return [String]
-    def to_xml()
+    def to_xml_string(str='')
       add_worksheet unless worksheets.size > 0
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|        
-        xml.workbook(:xmlns => XML_NS, :'xmlns:r' => XML_NS_R) {
-          xml.workbookPr(:date1904=>@@date1904)
-          #<x:workbookProtection workbookPassword="xsd:hexBinary data" lockStructure="1" lockWindows="1" />
-          xml.sheets {
-            @worksheets.each_with_index do |sheet, index|              
-              xml.sheet(:name=>sheet.name, :sheetId=>index+1, :"r:id"=>sheet.rId)
-            end
-          }
-        }
-      end      
-      builder.to_xml(:save_with => 0)
+      str << '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<workbook xmlns="' << XML_NS << '" xmlns:r="' << XML_NS_R << '">'
+      str << '<workbookPr date1904="' << @@date1904.to_s << '"/>'
+      str << '<sheets>'
+      @worksheets.each_with_index do |sheet, index|
+         str << '<sheet name="' << sheet.name << '" sheetId="' << (index+1).to_s << '" r:id="' << sheet.rId << '"/>'
+      end
+      str << '</sheets>'
+      str << '<definedNames>'
+      @worksheets.each_with_index do |sheet, index|
+        if sheet.auto_filter
+          str << '<definedName name="_xlnm._FilterDatabase" localSheetId="' << index.to_s << '" hidden="1">'
+          str << sheet.abs_auto_filter << '</definedName>'
+        end
+      end
+      str << '</definedNames>'
+      str << '</workbook>'
     end
+
   end
 end