axlsx 1.2.0 → 2.0.0

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

@@ -0,0 +1,144 @@
+module Axlsx
+
+  # The Cell Serializer class contains the logic for serializing cells based on their type.
+  class CellSerializer
+    class << self
+
+
+      # Calls the proper serialization method based on type.
+      # @param [Integer] row_index The index of the cell's row
+      # @param [Integer] column_index The index of the cell's column
+      # @param [String] str The string to apend serialization to.
+      # @return [String]
+      def to_xml_string(row_index, column_index, cell, str='')
+        str << '<c r="' << Axlsx::cell_r(column_index, row_index) << '" s="' << cell.style.to_s << '" '
+        return str << '/>' if cell.value.nil?
+        method = (cell.type.to_s << '_type_serialization').to_sym
+        self.send(method, cell, str)
+        str << '</c>'
+      end 
+
+
+      # builds an xml text run based on this cells attributes.
+      # @param [String] str The string instance this run will be concated to.
+      # @return [String]
+      def run_xml_string(cell, str = '')
+        if cell.is_text_run?
+          data = cell.instance_values.reject{|key, value| value == nil || key == 'value' || key == 'type' }
+          keys = data.keys & Cell::INLINE_STYLES
+          str << "<r><rPr>"
+          keys.each do |key|
+            case key
+            when 'font_name'
+              str << "<rFont val='"<< cell.font_name << "'/>"
+            when 'color'
+              str << data[key].to_xml_string
+            else
+              str << "<" << key.to_s << " val='" << data[key].to_s << "'/>"
+            end
+          end
+          str << "</rPr>" << "<t>" << cell.value.to_s << "</t></r>"
+        else
+          str << "<t>" << cell.value.to_s << "</t>"
+        end
+        str
+      end
+
+      # serializes cells that are type iso_8601
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def iso_8601_type_serialization(cell, str='')
+        value_serialization 'd', cell.value, str
+      end
+
+
+      # serializes cells that are type date
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def date_type_serialization(cell, str='')
+        value_serialization false, DateTimeConverter::date_to_serial(cell.value).to_s, str
+      end
+
+      # Serializes cells that are type time
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def time_type_serialization(cell, str='')
+        value_serialization false, DateTimeConverter::time_to_serial(cell.value).to_s, str
+      end
+
+      # Serializes cells that are type boolean
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def boolean_type_serialization(cell, str='')
+        value_serialization 'b', cell.value.to_s, str
+      end
+
+      # Serializes cells that are type float
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def float_type_serialization(cell, str='')
+        numeric_type_serialization cell, str
+      end
+
+      # Serializes cells that are type integer
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def integer_type_serialization(cell, str = '')
+        numeric_type_serialization cell, str
+      end
+
+
+      # Serializes cells that are type formula
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def formula_serialization(cell, str='')
+        str << 't="str">' << '<f>' << cell.value.to_s.sub('=', '') << '</f>'
+        str << '<v>' << cell.formula_value.to_s << '</v>' unless cell.formula_value.nil?
+      end
+
+      # Serializes cells that are type inline_string
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def inline_string_serialization(cell, str = '')
+        str << 't="inlineStr">' << '<is>'
+        run_xml_string cell, str
+        str << '</is>'
+      end
+
+      # Serializes cells that are type string
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def string_type_serialization(cell, str='')
+        if cell.is_formula?
+          formula_serialization cell, str
+        elsif !cell.ssti.nil?
+          value_serialization 's', cell.ssti.to_s, str
+        else
+          inline_string_serialization cell, str
+        end
+      end
+
+      private
+
+      def numeric_type_serialization(cell, str = '')
+        value_serialization 'n', cell.value.to_s, str
+      end
+
+      def value_serialization(serialization_type, serialization_value, str = '')
+        str << 't="' << serialization_type << '"' if serialization_type
+        str << '><v>' << serialization_value << '</v>'
+      end
+
+
+    end
+  end
+end

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

@@ -8,35 +8,36 @@ module Axlsx
   #
   class Cfvo
 
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+    # Creates a new Cfvo object
+    # @option options [Symbol] type The type of conditional formatting value object
+    # @option options [Boolean]  gte threshold value usage indicator
+    # @option options [String] val The value of the conditional formatting object
+    def initialize(options={})
+      @gte = true
+      parse_options options
+    end
+
+    serializable_attributes :type, :gte, :val
+
     # Type (ST_CfvoType)
     # The type of this conditional formatting value object. options are num, percent, max, min, formula and percentile
     # @return [Symbol]
     attr_reader :type
 
-
     # Type (xsd:boolean)
     # For icon sets, determines whether this threshold value uses the greater than or equal to operator. 0 indicates 'greater than' is used instead of 'greater than or equal to'.
     # The default value is true
     # @return [Boolean]
     attr_reader :gte
 
-
     # Type (ST_Xstring)
     # The value of the conditional formatting object
     # This library will accept any value so long as it supports to_s
     attr_reader :val
 
-    # Creates a new Cfvo object
-    # @option options [Symbol] type The type of conditional formatting value object
-    # @option options [Boolean]  gte threshold value usage indicator
-    # @option options [String] val The value of the conditional formatting object
-    def initialize(options={})
-      @gte = true
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end
-
     # @see type
     def type=(v); Axlsx::validate_conditional_formatting_value_object_type(v); @type = v end
 
@@ -54,9 +55,8 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<cfvo '
-      str << instance_values.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ')
+      serialized_attributes str
       str << ' />'
     end
-
   end
 end

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

@@ -0,0 +1,15 @@
+module Axlsx
+
+  #A collection of Cfvo objects that initializes with the required
+  #first two items
+  class Cfvos < SimpleTypedList
+
+    def initialize
+      super(Cfvo)
+    end
+
+    def to_xml_string(str='')
+      @list.each { |cfvo| cfvo.to_xml_string(str) }
+    end
+  end
+end

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

@@ -4,6 +4,27 @@ module Axlsx
   # The Col class defines column attributes for columns in sheets.
   class Col
 
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+    # Create a new Col objects
+    # @param min First column affected by this 'column info' record.
+    # @param max Last column affected by this 'column info' record.
+    # @option options [Boolean] collapsed see Col#collapsed
+    # @option options [Boolean] hidden see Col#hidden
+    # @option options [Boolean] outlineLevel see Col#outlineLevel
+    # @option options [Boolean] phonetic see Col#phonetic
+    # @option options [Integer] style see Col#style
+    # @option options [Numeric] width see Col#width
+    def initialize(min, max, options={})
+      Axlsx.validate_unsigned_int(max)
+      Axlsx.validate_unsigned_int(min)
+      @min = min
+      @max = max
+      parse_options options
+    end
+
+    serializable_attributes :collapsed, :hidden, :outline_level, :phonetic, :style, :width, :min, :max, :best_fit, :custom_width
+
     # First column affected by this 'column info' record.
     # @return [Integer]
     attr_reader :min
@@ -17,7 +38,8 @@ module Axlsx
     # 'Best fit' means that when numbers are typed into a cell contained in a 'best fit' column, the column width should
     #  automatically resize to display the number. [Note: In best fit cases, column width must not be made smaller, only larger. end note]
     # @return [Boolean]
-    attr_reader :bestFit
+    attr_reader :best_fit
+    alias :bestFit :best_fit
 
     # Flag indicating if the outlining of the affected column(s) is in the collapsed state.
     # @return [Boolean]
@@ -29,7 +51,8 @@ module Axlsx
 
     # Outline level of affected column(s). Range is 0 to 7.
     # @return [Integer]
-    attr_reader :outlineLevel
+    attr_reader :outline_level
+    alias :outlineLevel :outline_level
 
     # Flag indicating if the phonetic information should be displayed by default for the affected column(s) of the worksheet.
     # @return [Boolean]
@@ -44,7 +67,8 @@ module Axlsx
     attr_reader :width
 
     # @return [Boolean]
-    attr_reader :customWidth
+    attr_reader :custom_width
+    alias :customWidth :custom_width
 
     # @see Col#collapsed
     def collapsed=(v)
@@ -59,11 +83,12 @@ module Axlsx
     end
 
     # @see Col#outline
-    def outlineLevel=(v)
+    def outline_level=(v)
       Axlsx.validate_unsigned_numeric(v)
       raise ArgumentError, 'outlineLevel must be between 0 and 7' unless 0 <= v && v <= 7
-      @outlineLevel = v
+      @outline_level = v
     end
+    alias :outlineLevel= :outline_level=
 
     # @see Col#phonetic
     def phonetic=(v)
@@ -79,30 +104,16 @@ module Axlsx
 
    # @see Col#width
     def width=(v)
-      Axlsx.validate_unsigned_numeric(v) unless v == nil
-      @customWidth = @bestFit = v != nil
+      # Removing this validation make a 10% difference in performance
+      # as it is called EVERY TIME A CELL IS ADDED - the proper solution
+      # is to only set this if a calculated value is greated than the
+      # current @width value.
+      # TODO!!!
+      #Axlsx.validate_unsigned_numeric(v) unless v == nil
+      @custom_width = @best_fit = v != nil
       @width = v
     end
 
-    # Create a new Col objects
-    # @param min First column affected by this 'column info' record.
-    # @param max Last column affected by this 'column info' record.
-    # @option options [Boolean] collapsed see Col#collapsed
-    # @option options [Boolean] hidden see Col#hidden
-    # @option options [Boolean] outlineLevel see Col#outlineLevel
-    # @option options [Boolean] phonetic see Col#phonetic
-    # @option options [Integer] style see Col#style
-    # @option options [Numeric] width see Col#width
-    def initialize(min, max, options={})
-      Axlsx.validate_unsigned_int(max)
-      Axlsx.validate_unsigned_int(min)
-      @min = min
-      @max = max
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end
-    
     # updates the width for this col based on the cells autowidth and 
     # an optionally specified fixed width
     # @param [Cell] cell The cell to use in updating this col's width
@@ -114,7 +125,9 @@ module Axlsx
        if fixed_width.is_a? Numeric
          self.width = fixed_width
        elsif use_autowidth
-        self.width = [width || 0, cell.autowidth || 0].max
+         cell_width = cell.autowidth
+         self.width = cell_width unless (width || 0) > (cell_width || 0)
+         #self.width = [width || 0, cell.autowidth || 0].max
        end 
     end 
 
@@ -122,8 +135,9 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      attrs = self.instance_values.reject{ |key, value| value == nil }
-      str << '<col ' << attrs.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ') << '/>'
+      str << '<col '
+      serialized_attributes str
+      str << '/>'
     end
 
   end

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

@@ -0,0 +1,35 @@
+module Axlsx
+
+  # A collection of Brake objects.
+  # Please do not use this class directly. Instead use 
+  # Worksheet#add_break
+  class ColBreaks < SimpleTypedList
+
+    # Instantiates a new list restricted to Break types
+    def initialize
+      super Break
+    end
+
+    # A column break specific helper for adding a break.
+    # @param [Hash] options A list of options to pass into the Break object
+    # The max and man options are fixed, however any other valid option for 
+    # Break will be passed to the created break object.
+    # @see Break
+    def add_break(options)
+      @list << Break.new(options.merge(:max => 1048575, :man => true))
+      last
+    end
+
+    # Serialize the collection to xml
+    # @param [String] str The string to append this lists xml to.
+    # <colBreaks count="1" manualBreakCount="1">
+    # <brk id="3" max="1048575" man="1"/>
+    # </colBreaks>
+    def to_xml_string(str='')
+      return if empty?
+      str << '<colBreaks count="' << @list.size.to_s << '" manualBreakCount="' << @list.size.to_s << '">'
+      each { |brk| brk.to_xml_string(str) }
+      str << '</colBreaks>'
+    end
+  end
+end

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

@@ -7,34 +7,70 @@ module Axlsx
   # @see ConditionalFormattingRule#initialize
   class ColorScale
 
+    class << self
+
+      # These are the default conditional formatting value objects
+      # that define a two tone color gradient.
+      def default_cfvos
+        [{:type => :min, :val => 0, :color => 'FFFF7128'},
+         {:type => :max, :val => 0, :color => 'FFFFEF9C'}]
+      end
+
+      # A builder for two tone color gradient
+      # @example
+      #   # this creates a two tone color scale
+      #   color_scale = Axlsx::ColorScale.two_tone
+      # @see examples/example.rb conditional formatting examples.
+      def two_tone
+        self.new
+      end
+
+      # A builder for three tone color gradient
+      # @example
+      #   #this creates a three tone color scale
+      #   color_scale = Axlsx::ColorScale.three_tone 
+      # @see examples/example.rb conditional formatting examples.
+      def three_tone
+        self.new({:type => :min, :val => 0, :color => 'FFF8696B'},
+                 {:type => :percent, :val => '50', :color => 'FFFFEB84'},
+                 {:type => :max, :val => 0, :color => 'FF63BE7B'})
+      end
+    end
     # A simple typed list of cfvos
     # @return [SimpleTypedList]
     # @see Cfvo
-    attr_reader :value_objects
+    def value_objects
+      @value_objects ||= Cfvos.new
+    end
 
     # A simple types list of colors
     # @return [SimpleTypedList]
     # @see Color
-    attr_reader :colors
+    def colors
+      @colors ||= SimpleTypedList.new Color
+    end
 
     # creates a new ColorScale object.
-    # This method will yield it self so you can alter the properites of the defauls conditional formating value object (cfvo and colors
-    # Two value objects and two colors are created on initialization and cannot be deleted.
     # @see Cfvo
     # @see Color
-    def initialize
-      initialize_value_objects
-      initialize_colors
+    # @example
+    #     color_scale = Axlsx::ColorScale.new({:type => :num, :val => 0.55, :color => 'fff7696c'})
+    def initialize(*cfvos)
+      initialize_default_cfvos(cfvos)
       yield self if block_given?
     end
 
     # adds a new cfvo / color pair to the color scale and returns a hash containing
     # a reference to the newly created cfvo and color objects so you can alter the default properties.
     # @return [Hash] a hash with :cfvo and :color keys referencing the newly added objects.
+    # @param [Hash] options options for the new cfvo and color objects
+    # @option [Symbol] type The type of cfvo you to add
+    # @option [Any] val The value of the cfvo to add
+    # @option [String] The rgb color for the cfvo
     def add(options={})
-      @value_objects << Cfvo.new(:type => options[:type] || :min, :val => options[:val] || 0)
-      @colors << Color.new(:rgb => options[:color] || "FF000000")
-      {:cfvo => @value_objects.last, :color => @colors.last}
+      value_objects << Cfvo.new(:type => options[:type] || :min, :val => options[:val] || 0)
+      colors << Color.new(:rgb => options[:color] || "FF000000")
+      {:cfvo => value_objects.last, :color => colors.last}
     end
 
 
@@ -42,8 +78,8 @@ module Axlsx
     # @param [Integer] index The index of the cfvo and color object to delete
     # @note you cannot remove the first two cfvo and color pairs
     def delete_at(index=2)
-      @value_objects.delete_at index
-      @colors.delete_at index
+      value_objects.delete_at index
+      colors.delete_at index
     end
 
     # Serialize this color_scale object data to an xml string
@@ -51,26 +87,24 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<colorScale>'
-      @value_objects.each { |cfvo| cfvo.to_xml_string(str) }
-      @colors.each { |color| color.to_xml_string(str) }
+      value_objects.to_xml_string(str)
+      colors.each { |color| color.to_xml_string(str) }
       str << '</colorScale>'
     end
 
     private
-
-    # creates the initial cfvo objects
-    def initialize_value_objects
-      @value_objects = SimpleTypedList.new Cfvo
-      @value_objects.concat [Cfvo.new(:type => :min, :val => 0), Cfvo.new(:type => :max, :val => 0)]
-      @value_objects.lock
+    # There has got to be cleaner way of merging these arrays.
+    def initialize_default_cfvos(user_cfvos)
+      defaults = self.class.default_cfvos
+      user_cfvos.each_with_index do |cfvo, index|
+        if index < defaults.size
+          cfvo = defaults[index].merge(cfvo)
+        end
+        add cfvo
+      end
+      while colors.size < defaults.size
+        add defaults[colors.size - 1]
+      end
     end
-
-    # creates the initial color objects
-    def initialize_colors
-      @colors = SimpleTypedList.new Color
-      @colors.concat [Color.new(:rgb => "FFFF0000"), Color.new(:rgb => "FF0000FF")]
-      @colors.lock
-    end
-
   end
 end

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

@@ -3,22 +3,34 @@ module Axlsx
   # A comment is the text data for a comment
   class Comment
 
-    # The text to render
-    # @return [String]
-    attr_reader :text
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+
+    # Creates a new comment object
+    # @param [Comments] comments The comment collection this comment belongs to
+    # @param [Hash] options
+    # @option [String] author the author of the comment
+    # @option [String] text The text for the comment
+    # @option [String] ref The refence (e.g. 'A3' where this comment will be anchored.
+    # @option [Boolean] visible This controls the visiblity of the associated vml_shape.
+    def initialize(comments, options={})
+      raise ArgumentError, "A comment needs a parent comments object" unless comments.is_a?(Comments)
+      @visible = true
+      @comments = comments
+      parse_options options
+      yield self if block_given?
+    end
 
-    # The author of this comment
-    # @see Comments
-    # @return [String]
-    attr_reader :author
+    string_attr_accessor :text, :author
+    boolean_attr_accessor :visible
 
-    # The owning Comments object
+      # The owning Comments object
     # @return [Comments]
     attr_reader :comments
 
 
     # The string based cell position reference (e.g. 'A1') that determines the positioning of this comment
-    # @return [String]
+    # @return [String|Cell]
     attr_reader :ref
 
     # TODO
@@ -26,22 +38,12 @@ module Axlsx
     # rPh (Phonetic Text Run)
     # phoneticPr (Phonetic Properties)
 
-    def initialize(comments, options={})
-      raise ArgumentError, "A comment needs a parent comments object" unless comments.is_a?(Comments)
-      @comments = comments
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      yield self if block_given?
-    end
-
     # The vml shape that will render this comment
     # @return [VmlShape]
     def vml_shape
       @vml_shape ||= initialize_vml_shape
     end
 
-    #
     # The index of this author in a unique sorted list of all authors in
     # the comment.
     # @return [Integer]
@@ -56,30 +58,20 @@ module Axlsx
       @ref = v.r if v.is_a?(Cell)
     end
 
-    # @see text
-    def text=(v)
-      Axlsx::validate_string(v)
-      @text = v
-    end
-
-    # @see author
-    def author=(v)
-      @author = v
-    end
-
     # serialize the object
     # @param [String] str
     # @return [String]
     def to_xml_string(str = "")
       author = @comments.authors[author_index]
       str << '<comment ref="' << ref << '" authorId="' << author_index.to_s << '">'
-      str << '<text><r>'
-      str << '<rPr> <b/><color indexed="81"/></rPr>'
-      str << '<t>' << author.to_s << ':
-</t></r>'
+      str << '<text>'
+      unless author.to_s == ""
+        str << '<r><rPr><b/><color indexed="81"/></rPr>'
+        str << "<t>" << ::CGI.escapeHTML(author.to_s) << ":\n</t></r>"
+      end
       str << '<r>'
       str << '<rPr><color indexed="81"/></rPr>'
-      str << '<t>' << text << '</t></r></text>'
+      str << '<t>' << ::CGI.escapeHTML(text) << '</t></r></text>'
       str << '</comment>'
     end
 
@@ -89,13 +81,12 @@ module Axlsx
     # by default, all columns are 5 columns wide and 5 rows high
     def initialize_vml_shape
       pos = Axlsx::name_to_indices(ref)
-      @vml_shape = VmlShape.new(:row => pos[1], :column => pos[0]) do |vml|
+      @vml_shape = VmlShape.new(:row => pos[1], :column => pos[0], :visible => @visible) do |vml|
         vml.left_column = vml.column
         vml.right_column = vml.column + 2 
         vml.top_row = vml.row
          vml.bottom_row = vml.row + 4
       end
     end
-
   end
 end

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

@@ -56,9 +56,9 @@ module Axlsx
     # The relationships required by this object
     # @return [Array]
     def relationships
-      [Relationship.new(VML_DRAWING_R, "../#{vml_drawing.pn}"),
-       Relationship.new(COMMENT_R, "../#{pn}"),
-       Relationship.new(COMMENT_R_NULL, "NULL")]
+      [Relationship.new(self, VML_DRAWING_R, "../#{vml_drawing.pn}"),
+       Relationship.new(self, COMMENT_R, "../#{pn}"),
+       Relationship.new(self, COMMENT_R_NULL, "NULL")]
     end
 
     # serialize the object