axlsx 1.1.4 → 1.3.1

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

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+module Axlsx
+  # Pane options for a worksheet.
+  #
+  # @note The recommended way to manage the pane options is via SheetView#pane
+  # @see SheetView#pane
+  class Pane
+    
+    # Active Pane
+    # The pane that is active.
+    # Options are 
+    #  * bottom_left:  Bottom left pane, when both vertical and horizontal
+    #                  splits are applied. This value is also used when only
+    #                  a horizontal split has been applied, dividing the pane 
+    #                  into upper and lower regions. In that case, this value 
+    #                  specifies the bottom pane.
+    #  * bottom_right: Bottom right pane, when both vertical and horizontal
+    #                  splits are applied.
+    #  * top_left:     Top left pane, when both vertical and horizontal splits
+    #                  are applied. This value is also used when only a horizontal 
+    #                  split has been applied, dividing the pane into upper and lower
+    #                  regions. In that case, this value specifies the top pane.
+    #                  This value is also used when only a vertical split has
+    #                  been applied, dividing the pane into right and left
+    #                  regions. In that case, this value specifies the left pane
+    #  * top_right:    Top right pane, when both vertical and horizontal
+    #                  splits are applied. This value is also used when only
+    #                  a vertical split has been applied, dividing the pane 
+    #                  into right and left regions. In that case, this value 
+    #                  specifies the right pane.
+    # @see type
+    # @return [Symbol]
+    # default nil
+    attr_reader :active_pane
+    
+    
+    # Split State
+    # Indicates whether the pane has horizontal / vertical 
+    # splits, and whether those splits are frozen.
+    # Options are 
+    #  * frozen:       Panes are frozen, but were not split being frozen. In
+    #                  this state, when the panes are unfrozen again, a single
+    #                  pane results, with no split. In this state, the split 
+    #                  bars are not adjustable.
+    #  * frozen_split: Panes are frozen and were split before being frozen. In
+    #                  this state, when the panes are unfrozen again, the split
+    #                  remains, but is adjustable.
+    #  * split:        Panes are split, but not frozen. In this state, the split
+    #                  bars are adjustable by the user.
+    # @see type
+    # @return [Symbol]
+    # default nil
+    attr_reader :state
+    
+    
+    # Top Left Visible Cell
+    # Location of the top left visible cell in the bottom 
+    # right pane (when in Left-To-Right mode).
+    # @see type
+    # @return [String]
+    # default nil
+    attr_reader :top_left_cell
+    
+    
+    # Horizontal Split Position
+    # Horizontal position of the split, in 1/20th of a point; 0 (zero)
+    # if none. If the pane is frozen, this value indicates the number 
+    # of columns visible in the top pane.
+    # @see type
+    # @return [Integer]
+    # default 0
+    attr_reader :x_split
+    
+    
+    # Vertical Split Position
+    # Vertical position of the split, in 1/20th of a point; 0 (zero) 
+    # if none. If the pane is frozen, this value indicates the number
+    # of rows visible in the left pane.
+    # @see type
+    # @return [Integer]
+    # default 0
+    attr_reader :y_split
+    
+    
+    # Creates a new {Pane} object
+    # @option options [Symbol] active_pane Active Pane
+    # @option options [Symbol] state Split State
+    # @option options [Cell, String] top_left_cell Top Left Visible Cell
+    # @option options [Integer] x_split Horizontal Split Position
+    # @option options [Integer] y_split Vertical Split Position
+    def initialize(options={})
+      #defaults
+      @active_pane = @state = @top_left_cell = nil
+      @x_split = @y_split = 0
+      
+      # write options to instance variables
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+    
+    
+    # @see active_pane
+    def active_pane=(v); Axlsx::validate_pane_type(v); @active_pane = v end
+    
+    
+    # @see state
+    def state=(v); Axlsx::validate_split_state_type(v); @state = v end
+    
+    
+    # @see top_left_cell
+    def top_left_cell=(v)
+      cell = (v.class == Axlsx::Cell ? v.r_abs : v)
+      Axlsx::validate_string(cell)  
+      @top_left_cell = cell 
+    end
+    
+    
+    # @see x_split
+    def x_split=(v); Axlsx::validate_unsigned_int(v); @x_split = v end
+    
+    
+    # @see y_split
+    def y_split=(v); Axlsx::validate_unsigned_int(v); @y_split = v end
+    
+    
+    # Serializes the data validation
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      if @state == :frozen && @top_left_cell.nil?
+        row = @y_split || 0
+        column = @x_split || 0
+        
+        @top_left_cell = "#{('A'..'ZZ').to_a[column]}#{row+1}"
+      end
+      
+      str << '<pane '
+      str << instance_values.map { |key, value| '' << key.gsub(/_(.)/){ $1.upcase } << 
+        %{="#{[:active_pane, :state].include?(key.to_sym) ? value.to_s.gsub(/_(.)/){ $1.upcase } : value}"} unless value.nil? }.join(' ')
+      str << '/>'
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+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
+
+    # Whether grid lines should be printed.
+    # @return [Boolean]
+    attr_reader :grid_lines
+
+    # Whether row and column headings should be printed.
+    # @return [Boolean]
+    attr_reader :headings
+
+    # Whether the content should be centered horizontally on the page.
+    # @return [Boolean]
+    attr_reader :horizontal_centered
+
+    # Whether the content should be centered vertically on the page.
+    # @return [Boolean]
+    attr_reader :vertical_centered
+
+    # 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
+
+    # 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)
+      options.each do |k, v|
+        send("#{k}=", v) if respond_to? "#{k}="
+      end
+    end
+
+    # @see grid_lines
+    def grid_lines=(v); Axlsx::validate_boolean(v); @grid_lines = v; end
+    # @see headings
+    def headings=(v); Axlsx::validate_boolean(v); @headings = v; end
+    # @see horizontal_centered
+    def horizontal_centered=(v); Axlsx::validate_boolean(v); @horizontal_centered = v; end
+    # @see vertical_centered
+    def vertical_centered=(v); Axlsx::validate_boolean(v); @vertical_centered = v; 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 = '')
+      str << '<printOptions '
+      # 
+      str << instance_values.select{ |k,v| v == true }.map{ |k,v| k.gsub(/_(.)/){ $1.upcase } << %{="#{v}"} }.join(' ')
+      str << '/>'
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+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
+
+    # The reference for the protected range
+    # @return [String]
+    attr_reader :sqref
+
+    # The name of the protected range
+    # @return [String]
+    attr_reader :name
+
+    # 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={})
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      yield self if block_given?
+    end
+    
+    # @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="")
+      attrs = self.instance_values.reject{ |key, value| value == nil }
+      str << '<protectedRange ' << attrs.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ') << '/>'
+    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
+     @list << 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/row.rb

@@ -5,7 +5,16 @@ module Axlsx
   # @see Worksheet#add_row
   class Row
 
-    SERIALIZABLE_ATTRIBUTES = [:hidden, :outlineLevel, :collapsed, :style]
+    # No support is provided for the following attributes
+    # spans
+    # thickTop
+    # thickBottom
+
+
+    # A list of serilizable attributes.
+    # @note height(ht) and customHeight are manages separately for now. Have a look at Row#height
+    SERIALIZABLE_ATTRIBUTES = [:hidden, :outlineLevel, :collapsed, :s, :customFormat, :ph]
+    
     # The worksheet this row belongs to
     # @return [Worksheet]
     attr_reader :worksheet
@@ -14,38 +23,40 @@ module Axlsx
     # @return [SimpleTypedList]
     attr_reader :cells
 
-    # The height of this row in points, if set explicitly.
+    # Row height measured in point size. There is no margin padding on row height.
     # @return [Float]
     attr_reader :height
 
-    # Flag indicating if the outlining of the affected column(s) is in the collapsed state.
+    # Flag indicating if the outlining of row.
     # @return [Boolean]
     attr_reader :collapsed
 
-    # Flag indicating if the affected column(s) are hidden on this worksheet.
+    # Flag indicating if the the row is hidden.
     # @return [Boolean]
     attr_reader :hidden
 
-    # Outline level of affected column(s). Range is 0 to 7.
+    # Outlining level of the row, when outlining is on
     # @return [Integer]
     attr_reader :outlineLevel
 
-    # 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.
+    # The style applied ot the row. This affects the entire row.
     # @return [Integer]
-    attr_reader :style
-
-    # TODO  18.3.1.73
-    # # collapsed
-    # customFormat
-    # # hidden
-    # # outlineLevel
-    # ph
-    # # s (style)
-    # spans
-    # thickTop
-    # thickBottom
+    attr_reader :s
 
+    # indicates that a style has been applied directly to the row via Row#s
+    # @return [Boolean]
+    attr_reader :customFormat
 
+    # indicates if the row should show phonetic
+    # @return [Boolean]
+    attr_reader :ph
+
+    # NOTE removing this from the api as it is actually incorrect. 
+    # having a method to style a row's cells is fine, but it is not an attribute on the row. 
+    # The proper attribute is ':s'
+    # attr_reader style
+    #
+    
     # 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.
@@ -81,6 +92,12 @@ module Axlsx
       Axlsx.validate_boolean(v)
       @hidden = v
     end
+   
+    # @see Row#ph
+    def ph=(v) Axlsx.validate_boolean(v); @ph = v end
+
+    # @see Row#s
+    def s=(v) Axlsx.validate_unsigned_numeric(v); @s = v; @customFormat = true end
 
     # @see Row#outline
     def outlineLevel=(v)
@@ -88,7 +105,6 @@ module Axlsx
       @outlineLevel = v
     end
 
-
     # The index of this row in the worksheet
     # @return [Integer]
     def index
@@ -118,7 +134,7 @@ module Axlsx
     # @return [Cell]
     def add_cell(value="", options={})
       c = Cell.new(self, value, options)
-      worksheet.send(:update_column_info, self.cells, [], self.cells.map(&:style))
+      worksheet.send(:update_column_info, self.cells, [])
       c
     end
 

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

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+module Axlsx
+  # Selection options for worksheet panes.
+  #
+  # @note The recommended way to manage the selection pane options is via SheetView#add_selection
+  # @see SheetView#add_selection
+  class Selection
+    
+    # Active Cell Location
+    # Location of the active cell.
+    # @see type
+    # @return [String]
+    # default nil
+    attr_reader :active_cell
+    
+    
+    # Active Cell Index
+    # 0-based index of the range reference (in the array of references listed in sqref)
+    # containing the active cell. Only used when the selection in sqref is not contiguous.
+    # Therefore, this value needs to be aware of the order in which the range references are
+    # written in sqref.
+    # When this value is out of range then activeCell can be used.
+    # @see type
+    # @return [Integer]
+    # default nil
+    attr_reader :active_cell_id
+    
+    
+    # Pane
+    # The pane to which this selection belongs.
+    # Options are 
+    #  * bottom_left:  Bottom left pane, when both vertical and horizontal
+    #                  splits are applied. This value is also used when only
+    #                  a horizontal split has been applied, dividing the pane 
+    #                  into upper and lower regions. In that case, this value 
+    #                  specifies the bottom pane.
+    #  * bottom_right: Bottom right pane, when both vertical and horizontal
+    #                  splits are applied.
+    #  * top_left:     Top left pane, when both vertical and horizontal splits
+    #                  are applied. This value is also used when only a horizontal 
+    #                  split has been applied, dividing the pane into upper and lower
+    #                  regions. In that case, this value specifies the top pane.
+    #                  This value is also used when only a vertical split has
+    #                  been applied, dividing the pane into right and left
+    #                  regions. In that case, this value specifies the left pane
+    #  * top_right:    Top right pane, when both vertical and horizontal
+    #                  splits are applied. This value is also used when only
+    #                  a vertical split has been applied, dividing the pane 
+    #                  into right and left regions. In that case, this value 
+    #                  specifies the right pane.
+    # @see type
+    # @return [Symbol]
+    # default nil
+    attr_reader :pane
+    
+    
+    # Sequence of References
+    # Range of the selection. Can be non-contiguous set of ranges.
+    # @see type
+    # @return [String]
+    # default nil
+    attr_reader :sqref
+    
+    
+    # Creates a new {Selection} object
+    # @option options [Cell, String] active_cell Active Cell Location
+    # @option options [Integer] active_cell_id Active Cell Index
+    # @option options [Symbol] pane Pane
+    # @option options [String] sqref Sequence of References
+    def initialize(options={})
+      #defaults
+      @active_cell = @active_cell_id = @pane = @sqref = nil
+      
+      # write options to instance variables
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+    
+    
+    # @see active_cell
+    def active_cell=(v)
+      cell = (v.class == Axlsx::Cell ? v.r_abs : v)
+      Axlsx::validate_string(cell)  
+      @active_cell = cell 
+    end
+    
+    
+    # @see active_cell_id
+    def active_cell_id=(v); Axlsx::validate_unsigned_int(v); @active_cell_id = v end
+    
+    
+    # @see pane
+    def pane=(v); Axlsx::validate_pane_type(v); @pane = v end
+    
+    
+    # @see sqref
+    def sqref=(v); Axlsx::validate_string(v); @sqref = v end
+    
+    
+    # Serializes the data validation
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<selection '
+      str << instance_values.map { |key, value| '' << key.gsub(/_(.)/){ $1.upcase } << 
+        %{="#{[:pane].include?(key.to_sym) ? value.to_s.gsub(/_(.)/){ $1.upcase } : value}"} unless value.nil? }.join(' ')
+      str << '/>'
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Axlsx
+
+  # the SheetCalcPr object for the worksheet
+  # This object contains calculation properties for the worksheet.
+  class SheetCalcPr
+
+    # creates a new SheetCalcPr
+    # @param [Hash] options Options for this object
+    # @option [Boolean] full_calc_on_load @see full_calc_on_load
+    def initialize(options={})
+      @full_calc_on_load = true
+      options.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to?("#{key}=")
+      end
+    end
+
+    # Indicates whether the application should do a full calculate on
+    # load due to contents on this sheet. After load and successful cal,c
+    # the application shall set this value to false. Set this to true
+    # when the application should calculate the workbook on load.
+    # @return [Boolean]
+    def full_calc_on_load
+      @full_calc_on_load
+    end
+
+    # specify the full_calc_on_load value
+    # @param [Boolean] value
+    # @see full_calc_on_load
+    def full_calc_on_load=(value)
+      Axlsx.validate_boolean(value)
+      @full_calc_on_load = value
+    end
+
+    # Serialize the object
+    # @param [String] str the string to append this objects serialized
+    # content to.
+    # @return [String]
+    def to_xml_string(str='')
+      str << "<sheetCalcPr #{serialized_attributes}/>"
+    end
+
+    private
+
+    def serialized_attributes
+      instance_values.map { |key, value| "#{Axlsx.camel(key, false)}='#{value}'" }.join(' ')
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+module Axlsx
+
+  # This class manages the serialization of rows for worksheets
+  class SheetData
+
+    # Creates a new SheetData object
+    # @param [Worksheet] worksheet The worksheet that owns this sheet data.
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+    
+    attr_reader :worksheet
+
+    # Serialize the sheet data
+    # @param [String] str the string this objects serializaton will be concacted to.
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<sheetData>'
+      worksheet.rows.each_with_index{ |row, index| row.to_xml_string(index, str) }
+      str << '</sheetData>'
+    end
+    
+  end
+end

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

@@ -0,0 +1,107 @@
+module Axlsx
+
+  # The SheetPr class manages serialization fo a worksheet's sheetPr element.
+  class SheetPr
+
+
+    # These attributes are all boolean so I'm doing a bit of a hand
+    # waving magic show to set up the attriubte accessors
+    BOOLEAN_ATTRIBUTES = [:sync_horizontal, 
+                          :sync_vertical, 
+                          :transtion_evaluation, 
+                          :transition_entry,
+                          :published,
+                          :filter_mode,
+                          :enable_format_conditions_calculation]
+
+
+    # Creates a new SheetPr object
+    # @param [Worksheet] worksheet The worksheet that owns this SheetPr object
+    def initialize(worksheet, options={})
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+      options.each do |key, value|
+        attr = "#{key}="  
+        self.send(attr, value) if self.respond_to?(attr)
+      end
+    end
+
+    # Dynamically create accessors for boolean attriubtes
+    BOOLEAN_ATTRIBUTES.each do |attr|    
+      class_eval %{
+      # The #{attr} attribute reader
+      # @return [Boolean]
+      attr_reader :#{attr} 
+
+      # The #{attr} writer
+      # @param [Boolean] value The value to assign to #{attr}
+      # @return [Boolean]
+      def #{attr}=(value)
+        Axlsx::validate_boolean(value)
+        @#{attr} = value
+      end
+      }
+    end
+
+    # Anchor point for worksheet's window.
+    # @return [String]
+    attr_reader :code_name
+
+    # Specifies a stable name of the sheet, which should not change over time,
+    #  and does not change from user input. This name should be used by code 
+    #  to reference a particular sheet.
+    # @return [String]
+    attr_reader :sync_ref
+
+    # The worksheet these properties apply to!
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # @see code_name
+    # @param [String] name
+    def code_name=(name)
+      @code_name = name
+    end
+
+    # @see sync_ref
+    # @param [String] ref A cell reference (e.g. "A1")
+    def sync_ref=(ref)
+      @sync_ref = ref
+    end
+
+    # Serialize the object
+    # @param [String] str serialized output will be appended to this object if provided.
+    # @return [String]
+    def to_xml_string(str = '')
+      update_properties
+      str << "<sheetPr #{serialized_attributes}>"
+      page_setup_pr.to_xml_string(str)
+      str << "</sheetPr>"
+    end
+
+    # The PageSetUpPr for this sheet pr object
+    # @return [PageSetUpPr]
+    def page_setup_pr
+      @page_setup_pr ||= PageSetUpPr.new
+    end
+
+    private
+
+    def serialized_attributes(str = '')
+      instance_values.each do |key, value| 
+        unless %(worksheet page_setup_pr).include? key
+          str << "#{Axlsx.camel(key, false)}='#{value}' " 
+        end
+      end
+      str
+    end
+
+    def update_properties
+      page_setup_pr.fit_to_page = worksheet.fit_to_page?
+      if worksheet.auto_filter.columns.size > 0
+        self.filter_mode = 1
+        self.enable_format_conditions_calculation = 1
+      end
+    end
+  end
+end