axlsx 1.2.3 → 1.3.1

data/lib/axlsx/workbook/worksheet/auto_filter/filters.rb

@@ -0,0 +1,253 @@
+module Axlsx
+
+  # When multiple values are chosen to filter by, or when a group of date values are chosen to filter by, 
+  # this object groups those criteria together.
+  class Filters
+
+    # Allowed calendar types
+    CALENDAR_TYPES = %w(gregorian gregorianUs gregorianMeFrench gregorianArabic hijri hebrew taiwan japan thai korea saka gregorianXlitEnglish gregorianXlitFrench none)
+
+    # Creates a new Filters object
+    # @param [Hash] options Options used to set this objects attributes and
+    #                       create filter and/or date group items
+    # @option [Boolean] blank @see blank
+    # @option [String] calendar_type @see calendar_type
+    # @option [Array] filter_items An array of values that will be used to create filter objects.
+    # @option [Array] date_group_items An array of hases defining date group item filters to apply.
+    # @note The recommended way to interact with filter objects is via AutoFilter#add_column
+    # @example
+    #   ws.auto_filter.add_column(0, :filters, :blank => true, :calendar_type => 'japan', :filter_items => [100, 'a'])
+    def initialize(options={})
+      options.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to? "#{key}="
+      end
+    end
+
+    # Flag indicating whether to filter by blank.
+    # @return [Boolean]
+    attr_reader :blank
+
+    # Calendar type for date grouped items. 
+    # Used to interpret the values in dateGroupItem.
+    # This is the calendar type used to evaluate all dates in the filter column,
+    # even when those dates are not using the same calendar system / date formatting.
+    attr_reader :calendar_type
+
+    # Tells us if the row of the cell provided should be filterd as it
+    # does not meet any of the specified filter_items or
+    # date_group_items restrictions.
+    # @param [Cell] cell The cell to test against items
+    # TODO implement this for date filters as well!
+    def apply(cell)
+      return false unless cell
+      filter_items.each do |filter|
+        return false if cell.value == filter.val
+      end
+      true
+    end
+      
+    # The filter values in this filters object
+    def filter_items
+      @filter_items ||= []
+    end
+
+    # the date group values in this filters object
+    def date_group_items
+      @date_group_items ||= []
+    end
+
+    # @see calendar_type
+    # @param [String] calendar The calendar type to use. This must be one of the types defined in CALENDAR_TYPES
+    # @return [String]
+    def calendar_type=(calendar)
+      RestrictionValidator.validate 'Filters.calendar_type', CALENDAR_TYPES, calendar
+      @calendar_type = calendar
+    end
+
+    # Set the value for blank
+    # @see blank
+    def blank=(use_blank)
+      Axlsx.validate_boolean use_blank
+      @blank = use_blank
+    end
+
+    # Serialize the object to xml
+    def to_xml_string(str = '')
+      str << "<filters #{serialized_attributes}>"
+      filter_items.each {  |filter| filter.to_xml_string(str) }
+      date_group_items.each { |date_group_item| date_group_item.to_xml_string(str) }
+      str << '</filters>'
+    end
+
+    # not entirely happy with this. 
+    # filter_items should be a simple typed list that overrides << etc
+    # to create Filter objects from the inserted values. However this
+    # is most likely so rarely used...(really? do you know that?)
+    def filter_items=(values)
+      values.each do |value|
+        filter_items << Filter.new(value)
+      end
+    end
+
+    # Date group items are date group filter items where you specify the
+    # date_group and a value for that option as part of the auto_filter
+    # @note This can be specified, but will not be applied to the date
+    # values in your workbook at this time.
+    def date_group_items=(options)
+      options.each do |date_group|
+        raise ArgumentError, "date_group_items should be an array of hashes specifying the options for each date_group_item" unless date_group.is_a?(Hash)
+        date_group_items << DateGroupItem.new(date_group)
+      end
+    end
+
+    private
+
+    def serialized_attributes(str='')
+      instance_values.each do |key, value|
+        if %(blank claendar_type).include? key.to_s
+        str << "#{Axlsx.camel(key, false)}='#{value}' "
+        end
+      end
+      str
+    end
+
+    # This class expresses a filter criteria value.
+    class Filter
+
+      # Creates a new filter value object
+      # @param [Any] value   The value of the filter. This is not restricted, but
+      #                       will be serialized via to_s so if you are passing an object
+      #                       be careful.
+      def initialize(value)
+        @val = value
+      end
+
+
+      #Filter value used in the criteria.
+      attr_accessor :val
+
+      # Serializes the filter value object
+      # @param [String] str The string to concact the serialization information to.
+      def to_xml_string(str = '')
+        str << "<filter val='#{@val.to_s}' />"
+      end
+    end
+
+
+    # This collection is used to express a group of dates or times which are
+    # used in an AutoFilter criteria. Values are always written in the calendar
+    # type of the first date encountered in the filter range, so that all
+    # subsequent dates, even when formatted or represented by other calendar
+    # types, can be correctly compared for the purposes of filtering.
+    class DateGroupItem
+
+      # Allowed date time groupings
+      DATE_TIME_GROUPING = %w(year month day hour minute second)
+
+      # Creates a new DateGroupItem
+      # @param [Hash] options A hash of options to use when
+      # instanciating the object
+      # @option [String] date_time_grouping the part of the date this
+      # filter should apply for grouping
+      # @option [Integer|String] year @see year
+      # @option [Integer] month @see month
+      # @option [Integer] day @see day
+      # @option [Integer] hour @see hour
+      # @option [Integer] minute @see minute
+      # @option [Integer] second @see second
+      def initialize(options={})
+        raise ArgumentError,  "You must specify a year for date time grouping" unless options[:year]
+        raise ArgumentError, "You must specify a date_time_grouping when creating a DateGroupItem for auto filter" unless options[:date_time_grouping]
+        options.each do |key, value|
+          self.send("#{key}=", value) if self.respond_to?("#{key}=")
+        end
+      end
+
+      # Grouping level
+      # This must be one of year, month, day, hour, minute or second.
+      # @return [String]
+      attr_reader :date_time_grouping
+
+      # Year (4 digits)
+      # @return [Integer|String]
+      attr_reader :year
+
+      # Month (1..12)
+      # @return [Integer]
+      attr_reader :month
+
+      # Day (1-31)
+      # @return [Integer]
+      attr_reader :day
+
+      # Hour (0..23)
+      # @return [Integer]
+      attr_reader :hour
+
+      # Minute (0..59(
+      # @return [Integer]
+      attr_reader :minute
+
+      # Second (0..59)
+      # @return [Integer]
+      attr_reader :second
+
+      # The year value for the date group item
+      # This must be a four digit value
+      def year=(value)
+        RegexValidator.validate "DateGroupItem.year", /\d{4}/, value
+        @year = value
+      end
+
+      # The month value for the date group item
+      # This must be between 1 and 12
+      def month=(value)
+        RangeValidator.validate "DateGroupItem.month", 0, 12, value
+        @month = value
+      end
+
+      # The day value for the date group item
+      # This must be between 1 and 31 
+      # @note no attempt is made to ensure the date value is valid for any given month
+      def day=(value)
+        RangeValidator.validate "DateGroupItem.day", 0, 31, value
+        @day = value
+      end
+
+      # The hour value for the date group item
+      # # this must be between 0 and 23
+      def hour=(value)
+        RangeValidator.validate "DateGroupItem.hour", 0, 23, value
+        @hour = value
+      end
+
+      # The minute value for the date group item
+      # This must be between 0 and 59
+      def minute=(value)
+         RangeValidator.validate "DateGroupItem.minute", 0, 59, value
+         @minute = value
+      end
+
+      # The second value for the date group item
+      # This must be between 0 and 59
+      def second=(value)
+        RangeValidator.validate "DateGroupItem.second", 0, 59, value
+        @second = value
+      end
+
+      # The date time grouping for this filter.
+      def date_time_grouping=(grouping)
+        RestrictionValidator.validate 'DateGroupItem.date_time_grouping', DATE_TIME_GROUPING, grouping.to_s
+        @date_time_grouping = grouping.to_s
+      end
+
+      # Serialize the object to xml
+      # @param [String] str The string object this serialization will be concatenated to.
+      def to_xml_string(str = '')
+        str << '<dateGroupItem '
+        instance_values.each { |key, value| str << "#{key}='#{value.to_s}' " }
+        str << '/>'
+      end
+    end
+  end
+end

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

@@ -330,7 +330,7 @@ module Axlsx
       font_scale = (font_size/10.0).to_f
       ((value.to_s.count(Worksheet.thin_chars) * mdw + 5) / mdw * 256) / 256.0 * font_scale
     end
-   
+
     # returns the absolute or relative string style reference for
     # this cell. 
     # @param [Boolean] absolute -when false a relative reference will be
@@ -338,12 +338,17 @@ module Axlsx
     # @return [String]
     def reference(absolute=true)
       absolute ? r_abs : r
-    end 
-    
+    end
+
     private
 
+    # 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
-        sz || @styles.fonts[@styles.cellXfs[style].fontId].sz || @styles.fonts[0].sz
+        font = @styles.fonts[@styles.cellXfs[style].fontId] || @styles.fonts[0]
+        size_from_styles = (font.b || b) ? font.sz * 1.5 : font.sz
+        sz || size_from_styles
     end
 
     # Utility method for setting inline style attributes

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

@@ -10,7 +10,7 @@ module Axlsx
     # @return [Numeric]
     def self.date_to_serial(date)
       epoch = Axlsx::Workbook::date1904 ? Date.new(1904) : Date.new(1899, 12, 30)
-      (date-epoch).to_f
+      (date - epoch).to_f
     end
 
     # The time_to_serial methond converts a Time object its excel serialized form.

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

@@ -0,0 +1,47 @@
+module Axlsx
+
+  # Page setup properties of the worksheet
+  # This class name is not a typo, its spec.
+  class PageSetUpPr
+
+    # creates a new page setup properties object
+    # @param [Hash] options
+    # @option [Boolean] auto_page_breaks Flag indicating whether the sheet displays Automatic Page Breaks.
+    # @option [Boolean] fit_to_page Flag indicating whether the Fit to Page print option is enabled.
+    def initialize(options = {})
+      options.each do |key, value|
+        self.send("#{key}=",value) if self.respond_to?("#{key}=")
+      end
+    end
+
+    attr_reader :auto_page_breaks
+    attr_reader :fit_to_page
+
+    # Flag indicating whether the Fit to Page print option is enabled.
+    # @param [Boolean] value
+    # @return [Boolean]
+    def fit_to_page=(value)
+      Axlsx.validate_boolean value
+      @fit_to_page = value
+    end
+
+    # Flag indicating whether the sheet displays Automatic Page Breaks.
+    # @param [Boolean] value
+    # @return [Boolean]
+    def auto_page_breaks=(value)
+      Axlsx.validate_boolean value
+      @auto_page_breaks = value
+    end
+
+    # serialize to xml
+    def to_xml_string(str='')
+      str << '<pageSetUpPr ' << 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_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_pr.rb

@@ -1,24 +1,107 @@
 module Axlsx
 
   # The SheetPr class manages serialization fo a worksheet's sheetPr element.
-  # Only fit_to_page is implemented
   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)
+    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 = '')
-       return unless worksheet.fit_to_page?
-      str << "<sheetPr><pageSetUpPr fitToPage=\"%s\"></pageSetUpPr></sheetPr>" % worksheet.fit_to_page?
+      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