dg-axlsx 2.1.0

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

@@ -0,0 +1,24 @@
+module Axlsx
+
+  # A simple, self serializing class for storing pivot tables
+  class PivotTables < SimpleTypedList
+
+    # creates a new Tables object
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      super PivotTable
+      @worksheet = worksheet
+    end
+
+    # The worksheet that owns this collection of pivot tables
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # returns the relationships required by this collection
+    def relationships
+      return [] if empty?
+      map{ |pivot_table| Relationship.new(pivot_table, PIVOT_TABLE_R, "../#{pivot_table.pn}") }
+    end
+  end
+
+end

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

@@ -0,0 +1,39 @@
+module Axlsx
+  # Options for printing a worksheet. All options are boolean and false by default.
+  #
+  # @note The recommended way to manage print options is via Worksheet#print_options
+  # @see Worksheet#print_options
+  # @see Worksheet#initialize
+  class PrintOptions
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+    include Axlsx::Accessors
+    # Creates a new PrintOptions object
+    # @option options [Boolean] grid_lines Whether grid lines should be printed
+    # @option options [Boolean] headings Whether row and column headings should be printed
+    # @option options [Boolean] horizontal_centered Whether the content should be centered horizontally
+    # @option options [Boolean] vertical_centered  Whether the content should be centered vertically
+    def initialize(options = {})
+      @grid_lines = @headings = @horizontal_centered = @vertical_centered = false
+      set(options)
+    end
+
+    serializable_attributes :grid_lines, :headings, :horizontal_centered, :vertical_centered
+    boolean_attr_accessor :grid_lines, :headings, :horizontal_centered, :vertical_centered
+
+    # Set some or all options at once.
+    # @param [Hash] options The options to set (possible keys are :grid_lines, :headings, :horizontal_centered, and :vertical_centered).
+    def set(options)
+      parse_options options
+    end
+
+    # Serializes the page options element.
+    # @note As all attributes default to "false" according to the xml schema definition, the generated xml includes only those attributes that are set to true.
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      serialized_tag 'printOptions', str
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Axlsx
+  # The Protected Range class represents a set of cells in the worksheet
+  # @note the recommended way to manage protected ranges with via Worksheet#protect_range
+  # @see Worksheet#protect_range
+  class ProtectedRange
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+   # Initializes a new protected range object
+    # @option [String] sqref The cell range reference to protect. This can be an absolute or a relateve range however, it only applies to the current sheet.
+    # @option [String] name An optional name for the protected name.
+    def initialize(options={})
+      parse_options options
+      yield self if block_given?
+    end
+
+    serializable_attributes :sqref, :name
+    # The reference for the protected range
+    # @return [String]
+    attr_reader :sqref
+
+    # The name of the protected range
+    # @return [String]
+    attr_reader :name
+
+    # @see sqref
+    def sqref=(v)
+      Axlsx.validate_string(v)
+      @sqref = v
+    end
+
+    # @see name
+    def name=(v)
+      Axlsx.validate_string(v)
+      @name = v
+    end
+
+    # serializes the proteted range
+    # @param [String] str if this string object is provided we append
+    # our output to that object. Use this - it helps limit the number of
+    # objects created during serialization
+    def to_xml_string(str="")
+      serialized_tag 'protectedRange', str
+    end 
+  end
+end

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

@@ -0,0 +1,34 @@
+module Axlsx
+
+  # A self serializing collection of ranges that should be protected in
+  # the worksheet
+  class ProtectedRanges < SimpleTypedList
+
+    attr_reader :worksheet
+
+    def initialize(worksheet)
+      raise ArgumentError, 'You must provide a worksheet' unless worksheet.is_a?(Worksheet)
+      super ProtectedRange
+      @worksheet = worksheet
+    end
+
+    # Adds a protected range
+    # @param [Array|String] cells A string range reference or array of cells that will be protected
+    def add_range(cells)
+     sqref = if cells.is_a?(String)
+               cells
+             elsif cells.is_a?(SimpleTypedList) || cells.is_a?(Array)
+               Axlsx::cell_range(cells, false)
+             end
+     self << ProtectedRange.new(:sqref => sqref, :name => "Range#{size}")
+     last
+    end
+
+    def to_xml_string(str = '')
+      return if empty?
+      str << '<protectedRanges>'
+      each { |range| range.to_xml_string(str) }
+      str << '</protectedRanges>' 
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Axlsx
+  class RichText < SimpleTypedList
+    def initialize(text = nil, options={})
+      super(RichTextRun)
+      add_run(text, options) unless text.nil?
+      yield self if block_given?
+    end
+
+    attr_reader :cell
+    
+    def cell=(cell)
+      @cell = cell
+      each { |run| run.cell = cell }
+    end
+    
+    def autowidth
+      widtharray = [0] # Are arrays the best way of solving this problem?
+      each { |run| run.autowidth(widtharray) }
+      widtharray.max
+    end
+
+    def add_run(text, options={})
+      self << RichTextRun.new(text, options)
+    end
+    
+    def runs
+      self
+    end
+
+    def to_xml_string(str='')
+      each{ |run| run.to_xml_string(str) }
+      str
+    end
+  end
+end

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

@@ -0,0 +1,254 @@
+module Axlsx
+  class RichTextRun
+    
+    include Axlsx::OptionsParser
+    
+    attr_reader :value
+    
+    INLINE_STYLES = [:font_name, :charset,
+                     :family, :b, :i, :strike, :outline,
+                     :shadow, :condense, :extend, :u,
+                     :vertAlign, :sz, :color, :scheme].freeze
+    
+    def initialize(value, options={})
+      self.value = value
+      parse_options(options) 
+    end
+    
+    def value=(value)
+      @value = value
+    end
+    
+    attr_accessor :cell
+    
+    # The inline font_name property for the cell
+    # @return [String]
+    attr_reader :font_name
+    # @see font_name
+    def font_name=(v) set_run_style :validate_string, :font_name, v; end
+
+    # The inline charset property for the cell
+    # As far as I can tell, this is pretty much ignored. However, based on the spec it should be one of the following:
+    # 0  ANSI_CHARSET
+    # 1 DEFAULT_CHARSET
+    # 2 SYMBOL_CHARSET
+    # 77 MAC_CHARSET
+    # 128 SHIFTJIS_CHARSET
+    # 129  HANGUL_CHARSET
+    # 130  JOHAB_CHARSET
+    # 134  GB2312_CHARSET
+    # 136  CHINESEBIG5_CHARSET
+    # 161  GREEK_CHARSET
+    # 162  TURKISH_CHARSET
+    # 163  VIETNAMESE_CHARSET
+    # 177  HEBREW_CHARSET
+    # 178  ARABIC_CHARSET
+    # 186  BALTIC_CHARSET
+    # 204  RUSSIAN_CHARSET
+    # 222  THAI_CHARSET
+    # 238  EASTEUROPE_CHARSET
+    # 255  OEM_CHARSET
+    # @return [String]
+    attr_reader :charset
+    # @see charset
+    def charset=(v) set_run_style :validate_unsigned_int, :charset, v; end
+
+    # The inline family property for the cell
+    # @return [Integer]
+    # 1 Roman
+    # 2 Swiss
+    # 3 Modern
+    # 4 Script
+    # 5 Decorative
+    attr_reader :family
+    # @see family
+    def family=(v)
+      set_run_style :validate_family, :family, v.to_i
+    end
+
+    # The inline bold property for the cell
+    # @return [Boolean]
+    attr_reader :b
+    # @see b
+    def b=(v) set_run_style :validate_boolean, :b, v; end
+
+    # The inline italic property for the cell
+    # @return [Boolean]
+    attr_reader :i
+    # @see i
+    def i=(v) set_run_style :validate_boolean, :i, v; end
+
+    # The inline strike property for the cell
+    # @return [Boolean]
+    attr_reader :strike
+    # @see strike
+    def strike=(v) set_run_style :validate_boolean, :strike, v; end
+
+    # The inline outline property for the cell
+    # @return [Boolean]
+    attr_reader :outline
+    # @see outline
+    def outline=(v) set_run_style :validate_boolean, :outline, v; end
+
+    # The inline shadow property for the cell
+    # @return [Boolean]
+    attr_reader :shadow
+    # @see shadow
+    def shadow=(v) set_run_style :validate_boolean, :shadow, v; end
+
+    # The inline condense property for the cell
+    # @return [Boolean]
+    attr_reader :condense
+    # @see condense
+    def condense=(v) set_run_style :validate_boolean, :condense, v; end
+
+    # The inline extend property for the cell
+    # @return [Boolean]
+    attr_reader :extend
+    # @see extend
+    def extend=(v) set_run_style :validate_boolean, :extend, v; end
+
+    # The inline underline property for the cell.
+    # It must be one of :none, :single, :double, :singleAccounting, :doubleAccounting, true
+    # @return [Boolean]
+    # @return [String]
+    # @note true is for backwards compatability and is reassigned to :single
+    attr_reader :u
+    # @see u
+    def u=(v)
+      v = :single if (v == true || v == 1 || v == :true || v == 'true')
+      set_run_style :validate_cell_u, :u, v
+    end
+
+    # The inline color property for the cell
+    # @return [Color]
+    attr_reader :color
+    # @param [String] v The 8 character representation for an rgb color #FFFFFFFF"
+    def color=(v)
+      @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
+    end
+
+    # The inline sz property for the cell
+    # @return [Inteter]
+    attr_reader :sz
+    # @see sz
+    def sz=(v) set_run_style :validate_unsigned_int, :sz, v; end
+
+    # The inline vertical alignment property for the cell
+    # this must be one of [:baseline, :subscript, :superscript]
+    # @return [Symbol]
+    attr_reader :vertAlign
+    # @see vertAlign
+    def vertAlign=(v)
+      RestrictionValidator.validate :cell_vertAlign, [:baseline, :subscript, :superscript], v
+      set_run_style nil, :vertAlign, v
+    end
+
+    # The inline scheme property for the cell
+    # this must be one of [:none, major, minor]
+    # @return [Symbol]
+    attr_reader :scheme
+    # @see scheme
+    def scheme=(v)
+      RestrictionValidator.validate :cell_scheme, [:none, :major, :minor], v
+      set_run_style nil, :scheme, v
+    end
+
+    # The Shared Strings Table index for this cell
+    # @return [Integer]
+    attr_reader :ssti
+    
+    # @return [Integer] The cellXfs item index applied to this cell.
+    # @raise [ArgumentError] Invalid cellXfs id if the value provided is not within cellXfs items range.
+    def style=(v)
+      Axlsx::validate_unsigned_int(v)
+      count = styles.cellXfs.size
+      raise ArgumentError, "Invalid cellXfs id" unless v < count
+      @style = v
+    end
+
+    def autowidth(widtharray)
+      return if value.nil?
+      if styles.cellXfs[style].alignment && styles.cellXfs[style].alignment.wrap_text
+        first = true
+        value.to_s.split(/\r?\n/, -1).each do |line|
+          if first
+            first = false
+          else
+            widtharray << 0
+          end
+          widtharray[-1] += string_width(line, font_size)
+        end
+      else
+        widtharray[-1] += string_width(value.to_s, font_size)
+      end
+      widtharray
+    end
+    
+    # Utility method for setting inline style attributes
+    def set_run_style(validator, attr, value)
+      return unless INLINE_STYLES.include?(attr.to_sym)
+      Axlsx.send(validator, value) unless validator.nil?
+      self.instance_variable_set :"@#{attr.to_s}", value
+    end
+    
+    def to_xml_string(str = '')
+      valid = RichTextRun::INLINE_STYLES
+      data = Hash[self.instance_values.map{ |k, v| [k.to_sym, v] }] 
+      data = data.select { |key, value| valid.include?(key) && !value.nil? }
+      
+      str << '<r><rPr>'
+      data.keys.each do |key|
+        case key
+        when :font_name
+          str << ('<rFont val="' << font_name << '"/>')
+        when :color
+          str << data[key].to_xml_string
+        else
+          str << ('<' << key.to_s << ' val="' << xml_value(data[key]) << '"/>')
+        end
+      end
+      clean_value = Axlsx::trust_input ? @value.to_s : ::CGI.escapeHTML(Axlsx::sanitize(@value.to_s))
+      str << ('</rPr><t>' << clean_value << '</t></r>')
+    end
+    
+    private
+    
+    # Returns the width of a string according to the current style
+    # This is still not perfect...
+    #  - scaling is not linear as font sizes increase
+    def string_width(string, font_size)
+      font_scale = font_size / 10.0
+      string.count(Worksheet::THIN_CHARS) * font_scale
+    end
+    
+    # we scale the font size if bold style is applied to either the style font or
+    # the cell itself. Yes, it is a bit of a hack, but it is much better than using
+    # imagemagick and loading metrics for every character.
+    def font_size
+      return sz if sz
+      font = styles.fonts[styles.cellXfs[style].fontId] || styles.fonts[0]
+      (font.b || (defined?(@b) && @b)) ? (font.sz * 1.5) : font.sz
+    end
+    
+    def style
+      cell.style
+    end
+    
+    def styles
+      cell.row.worksheet.styles 
+    end
+    
+    # Converts the value to the correct XML representation (fixes issues with
+    # Numbers)
+    def xml_value value
+      if value == true
+        1
+      elsif value == false
+        0
+      else
+        value
+      end.to_s
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+module Axlsx
+  # A Row is a single row in a worksheet.
+  # @note The recommended way to manage rows and cells is to use Worksheet#add_row
+  # @see Worksheet#add_row
+  class Row < SimpleTypedList
+    include SerializedAttributes
+    include Accessors
+    
+    # No support is provided for the following attributes
+    # spans
+    # thickTop
+    # thickBottom
+
+   # Creates a new row. New Cell objects are created based on the values, types and style options.
+    # A new cell is created for each item in the values array. style and types options are applied as follows:
+    #   If the types option is defined and is a symbol it is applied to all the cells created.
+    #   If the types option is an array, cell types are applied by index for each cell
+    #   If the types option is not set, the cell will automatically determine its type.
+    #   If the style option is defined and is an Integer, it is applied to all cells created.
+    #   If the style option is an array, style is applied by index for each cell.
+    #   If the style option is not defined, the default style (0) is applied to each cell.
+    # @param [Worksheet] worksheet
+    # @option options [Array] values
+    # @option options [Array, Symbol] types
+    # @option options [Array, Integer] style
+    # @option options [Float] height the row's height (in points)
+    # @see Row#array_to_cells
+    # @see Cell
+    def initialize(worksheet, values=[], options={})
+      self.worksheet = worksheet
+      super(Cell, nil, values.size)
+      self.height = options.delete(:height)
+      worksheet.rows << self
+      array_to_cells(values, options)
+    end
+
+    # A list of serializable attributes.
+    serializable_attributes :hidden, :outline_level, :collapsed, :custom_format, :s, :ph, :custom_height, :ht
+
+    # Boolean row attribute accessors
+    boolean_attr_accessor :hidden, :collapsed, :custom_format, :ph, :custom_height
+
+    # The worksheet this row belongs to
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # Row height measured in point size. There is no margin padding on row height.
+    # @return [Float]
+    def height
+      defined?(@ht) ? @ht : nil
+    end
+
+    # Outlining level of the row, when outlining is on
+    # @return [Integer]
+    attr_reader :outline_level
+    alias :outlineLevel :outline_level
+
+    # The style applied ot the row. This affects the entire row.
+    # @return [Integer]
+    attr_reader :s
+
+    # @see Row#s
+    def s=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @custom_format = true 
+      @s = v
+    end
+
+    # @see Row#outline
+    def outline_level=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @outline_level = v
+    end
+    
+    alias :outlineLevel= :outline_level=
+
+    # The index of this row in the worksheet
+    # @return [Integer]
+    def row_index
+      worksheet.rows.index(self)
+    end
+
+    # Serializes the row
+    # @param [Integer] r_index The row index, 0 based.
+    # @param [String] str The string this rows xml will be appended to.
+    # @return [String]
+    def to_xml_string(r_index, str = '')
+      serialized_tag('row', str, :r => r_index + 1) do
+        tmp = '' # time / memory tradeoff, lots of calls to rubyzip costs more
+                 # time..
+        each_with_index { |cell, c_index| cell.to_xml_string(r_index, c_index, tmp) }
+        str << tmp
+      end
+    end
+
+    # Adds a single cell to the row based on the data provided and updates the worksheet's autofit data.
+    # @return [Cell]
+    def add_cell(value = '', options = {})
+      c = Cell.new(self, value, options)
+      self << c
+      worksheet.send(:update_column_info, self, [])
+      c
+    end
+
+    # sets the style for every cell in this row
+    def style=(style)
+      each_with_index do | cell, index |
+        cell.style = style.is_a?(Array) ? style[index] : style
+      end
+    end
+
+    # @see height
+    def height=(v)
+      unless v.nil?
+        Axlsx::validate_unsigned_numeric(v)
+        @custom_height = true
+        @ht = v
+      end
+    end
+    
+    # return cells
+    def cells
+      self
+    end
+
+    private
+
+    # assigns the owning worksheet for this row
+    def worksheet=(v) DataTypeValidator.validate :row_worksheet, Worksheet, v; @worksheet=v; end
+
+    # Converts values, types, and style options into cells and associates them with this row.
+    # A new cell is created for each item in the values array.
+    # If value option is defined and is a symbol it is applied to all the cells created.
+    # If the value option is an array, cell types are applied by index for each cell
+    # If the style option is defined and is an Integer, it is applied to all cells created.
+    # If the style option is an array, style is applied by index for each cell.
+    # @option options [Array] values
+    # @option options [Array, Symbol] types
+    # @option options [Array, Integer] style
+    def array_to_cells(values, options={})
+      DataTypeValidator.validate :array_to_cells, Array, values
+      types, style, formula_values = options.delete(:types), options.delete(:style), options.delete(:formula_values)
+      values.each_with_index do |value, index|
+        options[:style] = style.is_a?(Array) ? style[index] : style if style
+        options[:type] = types.is_a?(Array) ? types[index] : types if types
+        options[:formula_value] = formula_values[index] if formula_values.is_a?(Array)
+
+        self[index] = Cell.new(self, value, options)
+      end
+    end
+  end
+
+end