axlsx 1.1.4 → 1.2.0

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_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,24 @@
+module Axlsx
+
+  # The SheetPr class manages serialization fo a worksheet's sheetPr element.
+  # Only fit_to_page is implemented
+  class SheetPr
+
+    # Creates a new SheetPr object
+    # @param [Worksheet] worksheet The worksheet that owns this SheetPr object
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+
+    attr_reader :worksheet
+
+    # Serialize the object
+    # @param [String] str serialized output will be appended to this object if provided.
+    # @return [String]
+    def to_xml_string(str = '')
+       return unless worksheet.fit_to_page?
+      str << "<sheetPr><pageSetUpPr fitToPage=\"%s\"></pageSetUpPr></sheetPr>" % worksheet.fit_to_page?
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The SheetProtection object manages worksheet protection options per sheet.
+  class SheetProtection
+
+    # If 1 or true then AutoFilters should not be allowed to operate when the sheet is protected.
+    # If 0 or false then AutoFilters should be allowed to operate when the sheet is protected.
+    # @return [Boolean]
+    # default true 
+    attr_reader :auto_filter
+
+    # If 1 or true then deleting columns should not be allowed when the sheet is protected. 
+    # If 0 or false then deleting columns should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :delete_columns
+
+    # If 1 or true then deleting rows should not be allowed when the sheet is protected.
+    # If 0 or false then deleting rows should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :delete_rows
+
+    # If 1 or true then formatting cells should not be allowed when the sheet is protected.
+    # If 0 or false then formatting cells should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :format_cells
+
+    # If 1 or true then formatting columns should not be allowed when the sheet is protected.
+    # If 0 or false then formatting columns should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :format_columns
+
+    # If 1 or true then formatting rows should not be allowed when the sheet is protected. 
+    # If 0 or false then formatting rows should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :format_rows
+
+    # If 1 or true then inserting columns should not be allowed when the sheet is protected. 
+    # If 0 or false then inserting columns should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :insert_columns
+
+    # If 1 or true then inserting hyperlinks should not be allowed when the sheet is protected. 
+    # If 0 or false then inserting hyperlinks should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :insert_hyperlinks
+
+    # If 1 or true then inserting rows should not be allowed when the sheet is protected. 
+    # If 0 or false then inserting rows should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :insert_rows
+
+    # If 1 or true then editing of objects should not be allowed when the sheet is protected. 
+    # If 0 or false then objects are allowed to be edited when the sheet is protected.
+    # @return [Boolean]
+    # default false
+    attr_reader :objects
+
+    # If 1 or true then PivotTables should not be allowed to operate when the sheet is protected.
+    # If 0 or false then PivotTables should be allowed to operate when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :pivot_tables
+
+    # Specifies the salt which was prepended to the user-supplied password before it was hashed using the hashing algorithm
+    # @return [String]
+    attr_reader :salt_value
+
+    # If 1 or true then Scenarios should not be edited when the sheet is protected.
+    # If 0 or false then Scenarios are allowed to be edited when the sheet is protected.
+    # @return [Boolean]
+    # default false
+    attr_reader :scenarios
+
+    # If 1 or true then selection of locked cells should not be allowed when the sheet is protected.
+    # If 0 or false then selection of locked cells should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default false
+    attr_reader :select_locked_cells
+
+    # If 1 or true then selection of unlocked cells should not be allowed when the sheet is protected.
+    # If 0 or false then selection of unlocked cells should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default false
+    attr_reader :select_unlocked_cells
+
+    # If 1 or true then the sheet is protected. 
+    # If 0 or false then the sheet is not protected. 
+    # @return [Boolean]
+    # default true
+    attr_reader :sheet
+
+    # If 1 or true then sorting should not be allowed when the sheet is protected.
+    # If 0 or false then sorting should be allowed when the sheet is protected.
+    # @return [Boolean]
+    # default true
+    attr_reader :sort
+
+    # Password hash
+    # @return [String]
+    # default nil
+    attr_reader :password
+
+    # Creates a new SheetProtection instance
+    # @option options [Boolean] sheet @see SheetProtection#sheet
+    # @option options [Boolean] objects @see SheetProtection#objects
+    # @option options [Boolean] scenarios @see SheetProtection#scenarios
+    # @option options [Boolean] format_cells @see SheetProtection#objects
+    # @option options [Boolean] format_columns @see SheetProtection#format_columns
+    # @option options [Boolean] format_rows @see SheetProtection#format_rows
+    # @option options [Boolean] insert_columns @see SheetProtection#insert_columns
+    # @option options [Boolean] insert_rows @see SheetProtection#insert_rows
+    # @option options [Boolean] insert_hyperlinks @see SheetProtection#insert_hyperlinks
+    # @option options [Boolean] delete_columns @see SheetProtection#delete_columns
+    # @option options [Boolean] delete_rows @see SheetProtection#delete_rows
+    # @option options [Boolean] select_locked_cells @see SheetProtection#select_locked_cells
+    # @option options [Boolean] sort @see SheetProtection#sort
+    # @option options [Boolean] auto_filter @see SheetProtection#auto_filter
+    # @option options [Boolean] pivot_tables @see SheetProtection#pivot_tables
+    # @option options [Boolean] select_unlocked_cells @see SheetProtection#select_unlocked_cells
+    # @option options [String] password. The password required for unlocking. @see SheetProtection#password=
+    # @option options [Boolean] objects @see SheetProtection#objects
+    def initialize(options={})
+      @objects = @scenarios = @select_locked_cells = @select_unlocked_cells = false
+      @sheet = @format_cells = @format_rows = @format_columns = @insert_columns = @insert_rows = @insert_hyperlinks = @delete_columns = @delete_rows = @sort = @auto_filter = @pivot_tables = true
+      @password = nil
+
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+
+
+     # create validating setters for boolean values
+     # @return [Boolean] 
+     [:sheet, :objects, :scenarios, :select_locked_cells, :sort,
+     :select_unlocked_cells, :format_cells, :format_rows, :format_columns,
+     :insert_columns, :insert_rows, :insert_hyperlinks, :delete_columns,
+     :delete_rows, :auto_filter, :pivot_tables].each do |f_name|
+       define_method "#{f_name.to_s}=".to_sym do |v|
+         Axlsx::validate_boolean(v)
+         instance_variable_set "@#{f_name.to_s}".to_sym, v
+       end
+     end
+
+     # This block is intended to implement the salt_value, hash_value and spin count as per the ECMA-376 standard. 
+     # However, it does not seem to actually work in EXCEL - instead they are using their old retro algorithm shown below 
+     # defined in the transitional portion of the speck. I am leaving this code in in the hope that someday Ill be able to 
+     # figure out why it does not work, and if Excel even supports it.
+#     def propper_password=(v)
+#       @algorithm_name = v == nil ? nil : 'SHA-1'
+#       @salt_value = @spin_count = @hash_value = v if v == nil
+#       return if v == nil
+#       require 'digest/sha1'
+#       @spin_count = 10000
+#       @salt_value = Digest::SHA1.hexdigest(rand(36**8).to_s(36))
+#       @spin_count.times do |count|
+#         @hash_value = Digest::SHA1.hexdigest((@hash_value ||= (@salt_value + v.to_s)) + Array(count).pack('V'))
+#       end
+#     end
+
+
+
+     # encodes password for protection locking
+     def password=(v)
+       return if v == nil
+        @password = create_password_hash(v)
+     end
+
+     # Serialize the object
+     # @param [String] str
+     # @return [String]
+     def to_xml_string(str = '')
+       str << '<sheetProtection '
+       str << instance_values.map{ |k,v| k.gsub(/_(.)/){ $1.upcase } << %{="#{v.to_s}"} }.join(' ')
+       str << '/>'
+     end
+
+  private
+    # Creates a password hash for a given password
+    # @return [String]
+    def create_password_hash(password)
+      encoded_password = encode_password(password)
+
+      password_as_hex = [encoded_password].pack("v")
+      password_as_string = password_as_hex.unpack("H*").first.upcase
+
+      password_as_string[2..3] + password_as_string[0..1]
+    end
+
+
+    # Encodes a given password
+    # Based on the algorithm provided by Daniel Rentz of OpenOffice.
+    # http://www.openoffice.org/sc/excelfileformat.pdf, Revision 1.42, page 115 (21.05.2012)
+    # @return [String]
+    def encode_password(password)
+      i = 0
+      chars = password.split(//)
+      count = chars.size
+
+      chars.collect! do |char|
+        i += 1
+        char     = char.unpack('c')[0] << i #ord << i
+        low_15   = char & 0x7fff
+        high_15  = char & 0x7fff << 15
+        high_15  = high_15 >> 15
+        char     = low_15 | high_15
+      end
+
+      encoded_password  = 0x0000
+      chars.each { |c| encoded_password ^= c }
+      encoded_password ^= count
+      encoded_password ^= 0xCE4B
+    end
+  end
+end