l_axlsx 2.0.1

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

@@ -0,0 +1,154 @@
+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
+        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?
+          valid = RichTextRun::INLINE_STYLES - [:value, :type]
+          data = Hash[cell.instance_values.map{ |k, v| [k.to_sym, v] }] 
+          data = data.select { |key, value| valid.include?(key) && !value.nil? }
+          RichText.new(cell.value.to_s, data).to_xml_string(str)
+        elsif cell.contains_rich_text?
+          cell.value.to_xml_string(str)
+        else
+          str << ('<t>' << cell.clean_value << '</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(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(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(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(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(cell, str='')
+        numeric 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(cell, str = '')
+        numeric 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.clean_value.to_s.sub('=', '') << '</f>')
+        str << ('<v>' << cell.formula_value.to_s << '</v>') unless cell.formula_value.nil?
+      end
+
+      # Serializes cells that are type array 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 array_formula_serialization(cell, str='')
+        str << ('t="str">' << '<f t="array" ref="' << cell.r << '">' << cell.clean_value.to_s.sub('{=', '').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(cell, str='')
+        if cell.is_array_formula?
+          array_formula_serialization cell, str
+        elsif cell.is_formula?
+          formula_serialization cell, str
+        elsif !cell.ssti.nil?
+          value_serialization 's', cell.ssti, str
+        else
+          inline_string_serialization cell, str
+        end
+      end
+      
+      # Serializes cells that are of the type richtext
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def richtext(cell, str)
+        if cell.ssti.nil?
+          inline_string_serialization cell, str
+        else
+          value_serialization 's', cell.ssti, str
+        end
+      end
+
+      private
+
+      def numeric(cell, str = '')
+        value_serialization 'n', cell.value, str
+      end
+
+      def value_serialization(serialization_type, serialization_value, str = '')
+        str << ('t="' << serialization_type.to_s << '"') if serialization_type
+        str << ('><v>' << serialization_value.to_s << '</v>')
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Axlsx
+  # Conditional Format Value Object
+  # Describes the values of the interpolation points in a gradient scale. This object is used by ColorScale, DataBar and IconSet classes
+  #
+  # @note The recommended way to manage these rules is via Worksheet#add_conditional_formatting
+  # @see Worksheet#add_conditional_formatting
+  # @see ConditionalFormattingRule#initialize
+  #
+  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
+
+    # @see type
+    def type=(v); Axlsx::validate_conditional_formatting_value_object_type(v); @type = v end
+
+    # @see gte
+    def gte=(v); Axlsx::validate_boolean(v); @gte = v end
+
+    # @see val
+    def val=(v)
+      raise ArgumentError, "#{v.inspect} must respond to to_s" unless v.respond_to?(:to_s)
+      @val = v.to_s
+    end
+
+    # serialize the Csvo object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      serialized_tag('cfvo', 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='')
+      each { |cfvo| cfvo.to_xml_string(str) }
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+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
+
+    # Last column affected by this 'column info' record.
+    # @return [Integer]
+    attr_reader :max
+
+    # Flag indicating if the specified column(s) is set to 'best fit'. 'Best fit' is set to true under these conditions:
+    # The column width has never been manually set by the user, AND The column width is not the default width
+    # '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 :best_fit
+    alias :bestFit :best_fit
+
+    # Flag indicating if the outlining of the affected column(s) is in the collapsed state.
+    # @return [Boolean]
+    attr_reader :collapsed
+
+    # Flag indicating if the affected column(s) are hidden on this worksheet.
+    # @return [Boolean]
+    attr_reader :hidden
+
+    # Outline level of affected column(s). Range is 0 to 7.
+    # @return [Integer]
+    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]
+    attr_reader :phonetic
+
+    # Default style for the affected column(s). Affects cells not yet allocated in the column(s). In other words, this style applies to new columns.
+    # @return [Integer]
+    attr_reader :style
+
+    # The width of the column
+    # @return [Numeric]
+    attr_reader :width
+
+    # @return [Boolean]
+    attr_reader :custom_width
+    alias :customWidth :custom_width
+
+    # @see Col#collapsed
+    def collapsed=(v)
+      Axlsx.validate_boolean(v)
+      @collapsed = v
+    end
+
+    # @see Col#hidden
+    def hidden=(v)
+      Axlsx.validate_boolean(v)
+      @hidden = v
+    end
+
+    # @see Col#outline
+    def outline_level=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      raise ArgumentError, 'outlineLevel must be between 0 and 7' unless 0 <= v && v <= 7
+      @outline_level = v
+    end
+    alias :outlineLevel= :outline_level=
+
+    # @see Col#phonetic
+    def phonetic=(v)
+      Axlsx.validate_boolean(v)
+      @phonetic = v
+    end
+
+    # @see Col#style
+    def style=(v)
+      Axlsx.validate_unsigned_int(v)
+      @style = v
+    end
+
+   # @see Col#width
+    def width=(v)
+      # 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
+
+    # 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
+    # @param [Integer] fixed_width If this is specified the width is set
+    # to this value and the cell's attributes are ignored.
+    # @param [Boolean] use_autowidth If this is false, the cell's
+    # autowidth value will be ignored.
+    def update_width(cell, fixed_width=nil, use_autowidth=true)
+      if fixed_width.is_a? Numeric
+       self.width = fixed_width
+      elsif use_autowidth
+       cell_width = cell.autowidth
+       self.width = cell_width unless (width || 0) > (cell_width || 0)
+      end 
+    end 
+
+    # Serialize this columns data to an xml string
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      serialized_tag('col', str)
+    end
+
+  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)
+      self << 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="' << size.to_s << '" manualBreakCount="' << size.to_s << '">')
+      each { |brk| brk.to_xml_string(str) }
+      str << '</colBreaks>'
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module Axlsx
+  # Conditional Format Rule color scale object
+  # Describes a gradated color scale in this conditional formatting rule.
+
+  # @note The recommended way to manage these rules is via Worksheet#add_conditional_formatting
+  # @see Worksheet#add_conditional_formatting
+  # @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
+    def value_objects
+      @value_objects ||= Cfvos.new
+    end
+
+    # A simple types list of colors
+    # @return [SimpleTypedList]
+    # @see Color
+    def colors
+      @colors ||= SimpleTypedList.new Color
+    end
+
+    # creates a new ColorScale object.
+    # @see Cfvo
+    # @see Color
+    # @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}
+    end
+
+
+    # removes the cfvo and color pair at the index specified.
+    # @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
+    end
+
+    # Serialize this color_scale object data to an xml string
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<colorScale>'
+      value_objects.to_xml_string(str)
+      colors.each { |color| color.to_xml_string(str) }
+      str << '</colorScale>'
+    end
+
+    private
+    # 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
+  end
+end