caxlsx 2.0.2

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

@@ -0,0 +1,20 @@
+module Axlsx
+
+  # The cols class manages the col object used to manage column widths. 
+  # This is where the magic happens with autowidth
+  class Cols < SimpleTypedList
+
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      super Col
+      @worksheet = worksheet
+    end
+
+    def to_xml_string(str = '')
+     return if empty?
+     str << '<cols>'
+     each { |item| item.to_xml_string(str) }
+     str << '</cols>' 
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Axlsx
+
+  # A comment is the text data for a comment
+  class Comment
+
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+
+    # Creates a new comment object
+    # @param [Comments] comments The comment collection this comment belongs to
+    # @param [Hash] options
+    # @option [String] author the author of the comment
+    # @option [String] text The text for the comment
+    # @option [String] ref The refence (e.g. 'A3' where this comment will be anchored.
+    # @option [Boolean] visible This controls the visiblity of the associated vml_shape.
+    def initialize(comments, options={})
+      raise ArgumentError, "A comment needs a parent comments object" unless comments.is_a?(Comments)
+      @visible = true
+      @comments = comments
+      parse_options options
+      yield self if block_given?
+    end
+
+    string_attr_accessor :text, :author
+    boolean_attr_accessor :visible
+
+      # The owning Comments object
+    # @return [Comments]
+    attr_reader :comments
+
+
+    # The string based cell position reference (e.g. 'A1') that determines the positioning of this comment
+    # @return [String|Cell]
+    attr_reader :ref
+
+    # TODO
+    # r (Rich Text Run)
+    # rPh (Phonetic Text Run)
+    # phoneticPr (Phonetic Properties)
+
+    # The vml shape that will render this comment
+    # @return [VmlShape]
+    def vml_shape
+      @vml_shape ||= initialize_vml_shape
+    end
+
+    # The index of this author in a unique sorted list of all authors in
+    # the comment.
+    # @return [Integer]
+    def author_index
+      @comments.authors.index(author)
+    end
+
+    # @see ref
+    def ref=(v)
+      Axlsx::DataTypeValidator.validate "Comment.ref", [String, Cell], v
+      @ref = v if v.is_a?(String)
+      @ref = v.r if v.is_a?(Cell)
+    end
+
+    # serialize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = "")
+      author = @comments.authors[author_index]
+      str << '<comment ref="' << ref << '" authorId="' << author_index.to_s << '">'
+      str << '<text>'
+      unless author.to_s == ""
+        str << '<r><rPr><b/><color indexed="81"/></rPr>'
+        str << "<t>" << ::CGI.escapeHTML(author.to_s) << ":\n</t></r>"
+      end
+      str << '<r>'
+      str << '<rPr><color indexed="81"/></rPr>'
+      str << '<t>' << ::CGI.escapeHTML(text) << '</t></r></text>'
+      str << '</comment>'
+    end
+
+    private
+
+    # initialize the vml shape based on this comment's ref/position in the worksheet.
+    # by default, all columns are 5 columns wide and 5 rows high
+    def initialize_vml_shape
+      pos = Axlsx::name_to_indices(ref)
+      @vml_shape = VmlShape.new(:row => pos[1], :column => pos[0], :visible => @visible) do |vml|
+        vml.left_column = vml.column
+        vml.right_column = vml.column + 2 
+        vml.top_row = vml.row
+         vml.bottom_row = vml.row + 4
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+module Axlsx
+
+  # Comments is a collection of Comment objects for a worksheet
+  class Comments < SimpleTypedList
+
+    # the vml_drawing that holds the shapes for comments
+    # @return [VmlDrawing]
+    attr_reader :vml_drawing
+
+    # The worksheet that these comments belong to
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # The index of this collection in the workbook. Effectively the index of the worksheet.
+    # @return [Integer]
+    def index
+      @worksheet.index
+    end
+
+    # The part name for this object
+    # @return [String]
+    def pn
+      "#{COMMENT_PN % (index+1)}"
+    end
+
+    # Creates a new Comments object
+    # @param [Worksheet] worksheet The sheet that these comments belong to.
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      super(Comment)
+      @worksheet = worksheet
+      @vml_drawing = VmlDrawing.new(self)
+    end
+
+    # Adds a new comment to the worksheet that owns these comments.
+    # @note the author, text and ref options are required
+    # @option options [String] author The name of the author for this comment
+    # @option options [String] text The text for this comment
+    # @option options [Stirng|Cell] ref The cell that this comment is attached to.
+    def add_comment(options={})
+      raise ArgumentError, "Comment require an author" unless options[:author]
+      raise ArgumentError, "Comment requires text" unless options[:text]
+      raise ArgumentError, "Comment requires ref" unless options[:ref]
+      @list << Comment.new(self, options)
+      yield @list.last if block_given?
+      @list.last
+    end
+
+    # A sorted list of the unique authors in the contained comments
+    # @return [Array]
+    def authors
+      @list.map { |comment| comment.author.to_s }.uniq.sort
+    end
+
+    # The relationships required by this object
+    # @return [Array]
+    def relationships
+      [Relationship.new(self, VML_DRAWING_R, "../#{vml_drawing.pn}"),
+       Relationship.new(self, COMMENT_R, "../#{pn}"),
+       Relationship.new(self, COMMENT_R_NULL, "NULL")]
+    end
+
+    # serialize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str="")
+      str << '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<comments xmlns="' << XML_NS << '">'
+      str << '<authors>'
+      authors.each do  |author|
+        str << '<author>' << author.to_s << '</author>'
+      end
+      str << '</authors>'
+      str << '<commentList>'
+      @list.each do |comment|
+        comment.to_xml_string str
+      end
+      str << '</commentList></comments>'
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,82 @@
+module Axlsx
+  # Conditional formatting allows styling of ranges based on functions
+  #
+  # @note The recommended way to manage conditional formatting is via Worksheet#add_conditional_formatting
+  # @see Worksheet#add_conditional_formatting
+  # @see ConditionalFormattingRule
+  class ConditionalFormatting
+
+   include Axlsx::OptionsParser
+   
+    # Creates a new {ConditionalFormatting} object
+    # @option options [Array] rules The rules to apply
+    # @option options [String] sqref The range to apply the rules to
+    def initialize(options={})
+      @rules = []
+      parse_options options
+    end
+
+    # Range over which the formatting is applied, in "A1:B2" format
+    # @return [String]
+    attr_reader :sqref
+
+    # Rules to apply the formatting to. Can be either a hash of
+    # options to create a {ConditionalFormattingRule}, an array of hashes
+    # for multiple ConditionalFormattingRules, or an array of already
+    # created ConditionalFormattingRules.
+    # @see ConditionalFormattingRule#initialize
+    # @return [Array]
+    attr_reader :rules
+
+     # Add Conditional Formatting Rules to this object. Rules can either
+    # be already created {ConditionalFormattingRule} elements or
+    # hashes of options for automatic creation.  If rules is a hash
+    # instead of an array, assume only one rule being added.
+    #
+    # @example This would apply formatting "1" to cells > 20, and formatting "2" to cells < 1
+    #        conditional_formatting.add_rules [
+    #            { :type => :cellIs, :operator => :greaterThan, :formula => "20", :dxfId => 1, :priority=> 1 },
+    #            { :type => :cellIs, :operator => :lessThan, :formula => "10", :dxfId => 2, :priority=> 2 } ]
+    #
+    # @param [Array|Hash] rules the rules to apply, can be just one in hash form
+    # @see ConditionalFormattingRule#initialize
+    def add_rules(rules)
+      rules = [rules] if rules.is_a? Hash
+      rules.each do |rule|
+        add_rule rule
+      end
+    end
+
+    # Add a ConditionalFormattingRule. If a hash of options is passed
+    # in create a rule on the fly.
+    # @param [ConditionalFormattingRule|Hash] rule A rule to use, or the options necessary to create one.
+    # @see ConditionalFormattingRule#initialize
+    def add_rule(rule)
+      if rule.is_a? Axlsx::ConditionalFormattingRule
+        @rules << rule
+      elsif rule.is_a? Hash
+        @rules << ConditionalFormattingRule.new(rule)
+      end
+    end
+
+    # @see rules
+    def rules=(v); @rules = v end
+    # @see sqref
+    def sqref=(v); Axlsx::validate_string(v); @sqref = v end
+
+    # Serializes the conditional formatting element
+    # @example Conditional Formatting XML looks like:
+    #    <conditionalFormatting sqref="E3:E9">
+    #        <cfRule type="cellIs" dxfId="0" priority="1" operator="greaterThan">
+    #             <formula>0.5</formula>
+    #        </cfRule>
+    #    </conditionalFormatting>
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<conditionalFormatting sqref="' << sqref << '">'
+      str << rules.collect{ |rule| rule.to_xml_string }.join(' ')
+      str << '</conditionalFormatting>'
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+module Axlsx
+  # Conditional formatting rules specify formulas whose evaluations
+  # format cells
+  #
+  # @note The recommended way to manage these rules is via Worksheet#add_conditional_formatting
+  # @see Worksheet#add_conditional_formatting
+  # @see ConditionalFormattingRule#initialize
+  class ConditionalFormattingRule
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+    # Creates a new Conditional Formatting Rule object
+    # @option options [Symbol] type The type of this formatting rule
+    # @option options [Boolean] aboveAverage This is an aboveAverage rule
+    # @option options [Boolean] bottom This is a bottom N rule.
+    # @option options [Integer] dxfId The formatting id to apply to matches
+    # @option options [Boolean] equalAverage Is the aboveAverage or belowAverage rule inclusive
+    # @option options [Integer] priority The priority of the rule, 1 is highest
+    # @option options [Symbol] operator Which operator to apply
+    # @option options [String] text The value to apply a text operator against
+    # @option options [Boolean] percent If a top/bottom N rule, evaluate as N% rather than N
+    # @option options [Integer] rank If a top/bottom N rule, the value of N
+    # @option options [Integer] stdDev The number of standard deviations above or below the average to match
+    # @option options [Boolean] stopIfTrue Stop evaluating rules after this rule matches
+    # @option options [Symbol]  timePeriod The time period in a date occuring... rule
+    # @option options [String] formula The formula to match against in i.e. an equal rule. Use a [minimum, maximum] array for cellIs between/notBetween conditionals.
+    def initialize(options={})
+      @color_scale = @data_bar = @icon_set = @formula = nil
+      parse_options options
+    end
+
+    serializable_attributes :type, :aboveAverage, :bottom, :dxfId, :equalAverage,
+                            :priority, :operator, :text, :percent, :rank, :stdDev,
+                            :stopIfTrue, :timePeriod
+
+    # Formula
+    # The formula or value to match against (e.g. 5 with an operator of :greaterThan to specify cell_value > 5).
+    # If the operator is :between or :notBetween, use an array to specify [minimum, maximum]
+    # @return [String]
+    attr_reader :formula
+
+    # Type (ST_CfType)
+    # options are expression, cellIs, colorScale, dataBar, iconSet,
+    # top10, uniqueValues, duplicateValues, containsText,
+    # notContainsText, beginsWith, endsWith, containsBlanks,
+    # notContainsBlanks, containsErrors, notContainsErrors,
+    # timePeriod, aboveAverage
+    # @return [Symbol]
+    attr_reader :type
+
+    # Above average rule
+    # Indicates whether the rule is an "above average" rule. True
+    # indicates 'above average'. This attribute is ignored if type is
+    # not equal to aboveAverage.
+    # @return [Boolean]
+    attr_reader :aboveAverage
+
+    # Bottom N rule
+    # @return [Boolean]
+    attr_reader :bottom
+
+    # Differential Formatting Id
+    # @return [Integer]
+    attr_reader :dxfId
+
+    # Equal Average
+    # Flag indicating whether the 'aboveAverage' and 'belowAverage'
+    # criteria is inclusive of the average itself, or exclusive of
+    # that value.
+    # @return [Boolean]
+    attr_reader :equalAverage
+
+    # Operator
+    # The operator in a "cell value is" conditional formatting
+    # rule. This attribute is ignored if type is not equal to cellIs
+    #
+    # Operator must be one of lessThan, lessThanOrEqual, equal,
+    # notEqual, greaterThanOrEqual, greaterThan, between, notBetween,
+    # containsText, notContains, beginsWith, endsWith
+    # @return [Symbol]
+    attr_reader :operator
+
+    # Priority
+    # The priority of this conditional formatting rule. This value is
+    # used to determine which format should be evaluated and
+    # rendered. Lower numeric values are higher priority than higher
+    # numeric values, where '1' is the highest priority.
+    # @return [Integer]
+    attr_reader :priority
+
+    # Text
+    # used in a "text contains" conditional formatting
+    # rule.
+    # @return [String]
+    attr_reader :text
+
+    # percent (Top 10 Percent)
+    # indicates whether a "top/bottom n" rule is a "top/bottom n
+    # percent" rule. This attribute is ignored if type is not equal to
+    # top10.
+    # @return [Boolean]
+    attr_reader :percent
+
+    # rank (Rank)
+    # The value of "n" in a "top/bottom n" conditional formatting
+    # rule. This attribute is ignored if type is not equal to top10.
+    # @return [Integer]
+    attr_reader :rank
+
+    # stdDev (StdDev)
+    # The number of standard deviations to include above or below the
+    # average in the conditional formatting rule. This attribute is
+    # ignored if type is not equal to aboveAverage. If a value is
+    # present for stdDev and the rule type = aboveAverage, then this
+    # rule is automatically an "above or below N standard deviations"
+    # rule.
+    # @return [Integer]
+    attr_reader :stdDev
+
+    # stopIfTrue (Stop If True)
+    # If this flag is '1', no rules with lower priority shall be
+    # applied over this rule, when this rule evaluates to true.
+    # @return [Boolean]
+    attr_reader :stopIfTrue
+
+    # timePeriod (Time Period)
+    # The applicable time period in a "date occurring…" conditional
+    # formatting rule. This attribute is ignored if type is not equal
+    # to timePeriod.
+    # Valid types are today, yesterday, tomorrow, last7Days,
+    # thisMonth, lastMonth, nextMonth, thisWeek, lastWeek, nextWeek
+    attr_reader :timePeriod
+
+
+    # colorScale (Color Scale)
+    # The color scale to apply to this conditional formatting
+    # @return [ColorScale]
+    def color_scale
+      @color_scale ||= ColorScale.new
+    end
+
+    # dataBar (Data Bar)
+    # The data bar to apply to this conditional formatting
+    # @return [DataBar]
+    def data_bar
+      @data_bar ||= DataBar.new
+    end
+
+    # iconSet (Icon Set)
+    # The icon set to apply to this conditional formatting
+    # @return [IconSet]
+    def icon_set
+      @icon_set ||= IconSet.new
+    end
+
+    # @see type
+    def type=(v); Axlsx::validate_conditional_formatting_type(v); @type = v end
+    # @see aboveAverage
+    def aboveAverage=(v); Axlsx::validate_boolean(v); @aboveAverage = v end
+    # @see bottom
+    def bottom=(v); Axlsx::validate_boolean(v); @bottom = v end
+    # @see dxfId
+    def dxfId=(v); Axlsx::validate_unsigned_numeric(v); @dxfId = v end
+    # @see equalAverage
+    def equalAverage=(v); Axlsx::validate_boolean(v); @equalAverage = v end
+    # @see priority
+    def priority=(v); Axlsx::validate_unsigned_numeric(v); @priority = v end
+    # @see operator
+    def operator=(v); Axlsx::validate_conditional_formatting_operator(v); @operator = v end
+    # @see text
+    def text=(v); Axlsx::validate_string(v); @text = v end
+    # @see percent
+    def percent=(v); Axlsx::validate_boolean(v); @percent = v end
+    # @see rank
+    def rank=(v); Axlsx::validate_unsigned_numeric(v); @rank = v end
+    # @see stdDev
+    def stdDev=(v); Axlsx::validate_unsigned_numeric(v); @stdDev = v end
+    # @see stopIfTrue
+    def stopIfTrue=(v); Axlsx::validate_boolean(v); @stopIfTrue = v end
+    # @see timePeriod
+    def timePeriod=(v); Axlsx::validate_time_period_type(v); @timePeriod = v end
+    # @see formula
+    def formula=(v); [*v].each {|x| Axlsx::validate_string(x) }; @formula = [*v].map { |form| ::CGI.escapeHTML(form) } end
+
+    # @see color_scale
+    def color_scale=(v)
+      Axlsx::DataTypeValidator.validate 'conditional_formatting_rule.color_scale', ColorScale, v
+      @color_scale = v
+    end
+
+    # @see data_bar
+    def data_bar=(v)
+      Axlsx::DataTypeValidator.validate 'conditional_formatting_rule.data_bar', DataBar, v
+      @data_bar = v
+    end
+
+    # @see icon_set
+    def icon_set=(v)
+      Axlsx::DataTypeValidator.validate 'conditional_formatting_rule.icon_set', IconSet, v
+      @icon_set = v
+    end
+
+
+    # Serializes the conditional formatting rule
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<cfRule '
+      serialized_attributes str
+      str << '>'
+      str << '<formula>' << [*self.formula].join('</formula><formula>') << '</formula>' if @formula
+      @color_scale.to_xml_string(str) if @color_scale && @type == :colorScale
+      @data_bar.to_xml_string(str) if @data_bar && @type == :dataBar
+      @icon_set.to_xml_string(str) if @icon_set && @type == :iconSet
+      str << '</cfRule>'
+    end
+  end
+end