rubyXL 1.2.10 → 3.4.33

data/lib/rubyXL/convenience_methods/cell.rb

@@ -0,0 +1,276 @@
+module RubyXL
+  module CellConvenienceMethods
+    def change_contents(data, formula_expression = nil)
+      validate_worksheet
+
+      if formula_expression then
+        self.datatype = nil
+        self.formula = RubyXL::Formula.new(:expression => formula_expression)
+      else
+        self.datatype = case data
+                        when Date, Time, Numeric then nil
+                        else RubyXL::DataType::RAW_STRING
+                        end
+      end
+
+      data = workbook.date_to_num(data) if data.is_a?(Date) || data.is_a?(Time)
+
+      self.raw_value = data
+    end
+
+    def remove_formula
+      self.formula = nil
+
+      calculation_chain = workbook && workbook.calculation_chain
+      calculation_cells = calculation_chain && calculation_chain.cells
+      calculation_cells && calculation_cells.reject! { |c|
+        c.ref.col_range.c == self.column && c.ref.row_range.begin == self.row
+      }
+    end
+
+    def get_border(direction)
+      validate_worksheet
+      get_cell_border.get_edge_style(direction)
+    end
+
+    def get_border_color(direction)
+      validate_worksheet
+      get_cell_border.get_edge_color(direction)
+    end
+
+    def change_horizontal_alignment(alignment = 'center')
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.horizontal = alignment }
+    end
+
+    def change_vertical_alignment(alignment = 'center')
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.vertical = alignment }
+    end
+
+    def change_text_wrap(wrap = false)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.wrap_text = wrap }
+    end
+
+    def change_shrink_to_fit(shrink_to_fit = false)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.shrink_to_fit = shrink_to_fit }
+    end
+
+    def change_text_rotation(rot)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.text_rotation = rot }
+    end
+
+    def change_text_indent(indent)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.indent = indent }
+    end
+
+    def change_border(direction, weight)
+      validate_worksheet
+      self.style_index = workbook.modify_border(self.style_index, direction, weight)
+    end
+
+    def change_border_color(direction, color)
+      validate_worksheet
+      Color.validate_color(color)
+      self.style_index = workbook.modify_border_color(self.style_index, direction, color)
+    end
+
+    def is_italicized
+      validate_worksheet
+      get_cell_font.is_italic
+    end
+
+    def is_bolded
+      validate_worksheet
+      get_cell_font.is_bold
+    end
+
+    def is_underlined
+      validate_worksheet
+      get_cell_font.is_underlined
+    end
+
+    def is_struckthrough
+      validate_worksheet
+      get_cell_font.is_strikethrough
+    end
+
+    def font_name
+      validate_worksheet
+      get_cell_font.get_name
+    end
+
+    def font_size
+      validate_worksheet
+      get_cell_font.get_size
+    end
+
+    def font_color
+      validate_worksheet
+      get_cell_font.get_rgb_color || '000000'
+    end
+
+    def fill_color
+      validate_worksheet
+      workbook.get_fill_color(get_cell_xf)
+    end
+
+    def horizontal_alignment
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.horizontal
+    end
+
+    def vertical_alignment
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.vertical
+    end
+
+    def text_wrap
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.wrap_text
+    end
+
+    def text_rotation
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.text_rotation
+    end
+
+    def text_indent
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.indent
+    end
+
+    def set_number_format(format_code)
+      new_xf = get_cell_xf.dup
+      new_xf.num_fmt_id = workbook.stylesheet.register_number_format(format_code)
+      new_xf.apply_number_format = true
+      self.style_index = workbook.register_new_xf(new_xf)
+    end
+
+    # Changes fill color of cell
+    def change_fill(rgb = 'ffffff')
+      validate_worksheet
+      Color.validate_color(rgb)
+      self.style_index = workbook.modify_fill(self.style_index, rgb)
+    end
+
+    # Changes font name of cell
+    def change_font_name(new_font_name = 'Verdana')
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_name(new_font_name)
+      update_font_references(font)
+    end
+
+    # Changes font size of cell
+    def change_font_size(font_size = 10)
+      validate_worksheet
+      raise 'Argument must be a number' unless font_size.is_a?(Integer) || font_size.is_a?(Float)
+
+      font = get_cell_font.dup
+      font.set_size(font_size)
+      update_font_references(font)
+    end
+
+    # Changes font color of cell
+    def change_font_color(font_color = '000000')
+      validate_worksheet
+      Color.validate_color(font_color)
+
+      font = get_cell_font.dup
+      font.set_rgb_color(font_color)
+      update_font_references(font)
+    end
+
+    # Changes font italics settings of cell
+    def change_font_italics(italicized = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_italic(italicized)
+      update_font_references(font)
+    end
+
+    # Changes font bold settings of cell
+    def change_font_bold(bolded = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_bold(bolded)
+      update_font_references(font)
+    end
+
+    # Changes font underline settings of cell
+    def change_font_underline(underlined = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_underline(underlined)
+      update_font_references(font)
+    end
+
+    def change_font_strikethrough(struckthrough = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_strikethrough(struckthrough)
+      update_font_references(font)
+    end
+
+    # Helper method to update the font array and xf array
+    def update_font_references(modified_font)
+      xf = workbook.register_new_font(modified_font, get_cell_xf)
+      self.style_index = workbook.register_new_xf(xf)
+    end
+    private :update_font_references
+
+    # Performs correct modification based on what type of change_type is specified
+    def font_switch(change_type, arg)
+      case change_type
+      when Worksheet::NAME          then change_font_name(arg)
+      when Worksheet::SIZE          then change_font_size(arg)
+      when Worksheet::COLOR         then change_font_color(arg)
+      when Worksheet::ITALICS       then change_font_italics(arg)
+      when Worksheet::BOLD          then change_font_bold(arg)
+      when Worksheet::UNDERLINE     then change_font_underline(arg)
+      when Worksheet::STRIKETHROUGH then change_font_strikethrough(arg)
+      else raise 'Invalid change_type'
+      end
+    end
+
+    def add_hyperlink(url, tooltip = nil)
+      worksheet.relationship_container ||= RubyXL::OOXMLRelationshipsFile.new
+      relationships = worksheet.relationship_container.relationships
+      r_id = "rId#{relationships.size + 1}"
+      relationships << RubyXL::Relationship.new(:id => r_id, :target => url, :target_mode => 'External',
+                                                :type => RubyXL::HyperlinkRelFile::REL_TYPE)
+
+      hyperlink = RubyXL::Hyperlink.new(:ref => self.r, :r_id => r_id)
+      hyperlink.tooltip = tooltip if tooltip
+      worksheet.hyperlinks ||= RubyXL::Hyperlinks.new
+      worksheet.hyperlinks << hyperlink
+    end
+
+#     def add_shared_string(str)
+#       self.datatype = RubyXL::DataType::SHARED_STRING
+#       self.raw_value = @workbook.shared_strings_container.add(str)
+#     end
+  end
+
+  RubyXL::Cell.send(:include, RubyXL::CellConvenienceMethods) # ruby 2.1 compat
+end

data/lib/rubyXL/convenience_methods/color.rb

@@ -0,0 +1,156 @@
+module RubyXL
+  module ColorConvenienceMethods
+    def get_rgb(workbook)
+      if rgb then
+        return rgb
+      elsif theme then
+        theme_color = workbook.theme.get_theme_color(theme)
+        rgb_color = theme_color && theme_color.a_srgb_clr
+        color_value = rgb_color && rgb_color.val
+        return nil if color_value.nil?
+
+        RubyXL::RgbColor.parse(color_value).to_hls.apply_tint(tint).to_rgb.to_s
+      end
+    end
+  end
+
+  module ColorConvenienceClasses
+    # https://ciintelligence.blogspot.com/2012/02/converting-excel-theme-color-and-tint.html
+    class RgbColor
+      attr_accessor :r, :g, :b, :a
+
+      def to_hls
+        hls_color = HlsColor.new
+
+        # Note that we are overriding accessors with local vars here:
+        r = self.r / 255.0
+        g = self.g / 255.0
+        b = self.b / 255.0
+
+        hls_color.a = (self.a || 0) / 255.0
+
+        min = [r, g, b].min
+        max = [r, g, b].max
+        delta = max - min
+
+        if (max == min) then
+          hls_color.h = hls_color.s = 0
+          hls_color.l = max
+          return hls_color
+        end
+
+        hls_color.l = (min + max) / 2
+
+        if (hls_color.l < 0.5) then
+          hls_color.s = delta / (max + min);
+        else
+          hls_color.s = delta / (2.0 - max - min);
+        end
+
+        hls_color.h = (g - b) / delta       if (r == max)
+        hls_color.h = 2.0 + ((b - r) / delta) if (g == max)
+        hls_color.h = 4.0 + ((r - g) / delta) if (b == max)
+
+        hls_color.h *= 60;
+        hls_color.h += 360 if hls_color.h < 0
+
+        hls_color
+      end
+
+      def self.parse(str)
+        r, g, b, a = str.unpack('A2A2A2A2')
+
+        rgb_color = RgbColor.new
+        rgb_color.r = r && r.to_i(16)
+        rgb_color.g = g && g.to_i(16)
+        rgb_color.b = b && b.to_i(16)
+        rgb_color.a = a && a.to_i(16)
+
+        rgb_color
+      end
+
+      def to_s
+        if a && a != 0 then
+          format('%02x%02x%02x%02x', r, g, b, a)
+        else
+          format('%02x%02x%02x', r, g, b)
+        end
+      end
+    end
+
+    class HlsColor
+      attr_accessor :h, :l, :s, :a
+
+      def to_rgb
+        rgb_color = RgbColor.new
+
+        r = g = b = l
+
+        if s != 0 then
+          t1 = nil
+
+          if l < 0.5 then
+            t1 = l * (1.0 + s)
+          else
+            t1 = l + s - (l * s)
+          end
+
+          t2 = (2.0 * l) - t1;
+          h = self.h / 360.0
+
+          t_r = h + (1.0 / 3.0)
+          r = set_color(t1, t2, t_r)
+
+          t_g = h;
+          g = set_color(t1, t2, t_g)
+
+          t_b = h - (1.0 / 3.0);
+          b = set_color(t1, t2, t_b)
+        end
+
+        rgb_color.r = (r * 255).round(0).to_i
+        rgb_color.g = (g * 255).round(0).to_i
+        rgb_color.b = (b * 255).round(0).to_i
+
+        rgb_color.a = (a * 255).round(0).to_i
+
+        rgb_color
+      end
+
+      def set_color(t1, t2, t3)
+        color = 0
+
+        t3 += 1.0 if (t3 < 0)
+        t3 -= 1.0 if (t3 > 1)
+
+        if (6.0 * t3 < 1) then
+          color = t2 + ((t1 - t2) * 6.0 * t3);
+        elsif (2.0 * t3 < 1) then
+          color = t1;
+        elsif (3.0 * t3 < 2) then
+          color = t2 + ((t1 - t2) * ((2.0 / 3.0) - t3) * 6.0);
+        else
+          color = t2;
+        end
+
+        color
+      end
+      private :set_color
+
+      def apply_tint(tint)
+        return self if tint.nil? || tint == 0
+
+        if tint < 0 then
+          self.l = l * (1.0 + tint);
+        else
+          self.l = (l * (1.0 - tint)) + tint;
+        end
+
+        self
+      end
+    end
+  end
+
+  RubyXL::Color.send(:include, RubyXL::ColorConvenienceMethods) # ruby 2.1 compat
+  include(RubyXL::ColorConvenienceClasses)
+end

data/lib/rubyXL/convenience_methods/font.rb

@@ -0,0 +1,63 @@
+module RubyXL
+  module FontConvenienceMethods
+    # Funny enough, but presence of <i> without value (equivalent to `val == nul`) means "italic = true"!
+    # Same is true for bold, strikethrough, etc
+    def is_italic
+      i && (i.val != false)
+    end
+
+    def is_bold
+      b && (b.val != false)
+    end
+
+    def is_underlined
+      u && (u.val != false)
+    end
+
+    def is_strikethrough
+      strike && (strike.val != false)
+    end
+
+    def get_name
+      name && name.val
+    end
+
+    def get_size
+      sz && sz.val
+    end
+
+    def get_rgb_color
+      color && color.rgb
+    end
+
+    def set_italic(val)
+      self.i = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_bold(val)
+      self.b = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_underline(val)
+      self.u = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_strikethrough(val)
+      self.strike = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_name(val)
+      self.name = RubyXL::StringValue.new(:val => val)
+    end
+
+    def set_size(val)
+      self.sz = RubyXL::FloatValue.new(:val => val)
+    end
+
+    def set_rgb_color(font_color)
+      self.color = RubyXL::Color.new(:rgb => font_color.to_s)
+    end
+  end
+
+  RubyXL::Font.send(:include, RubyXL::FontConvenienceMethods) # ruby 2.1 compat
+end

data/lib/rubyXL/convenience_methods/workbook.rb

@@ -0,0 +1,137 @@
+module RubyXL
+  module WorkbookConvenienceMethods
+    def each
+      worksheets.each{ |i| yield i }
+    end
+
+    def cell_xfs # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.cell_xfs
+    end
+
+    def fonts # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.fonts
+    end
+
+    def fills # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.fills
+    end
+
+    def borders # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.borders
+    end
+
+    def get_fill_color(xf)
+      fills[xf.fill_id]&.pattern_fill&.fg_color&.get_rgb(self)&.to_s || 'ffffff'
+    end
+
+    def register_new_fill(new_fill, old_xf)
+      new_xf = old_xf.dup
+      new_xf.apply_fill = true
+      new_xf.fill_id = fills.find_index { |x| x == new_fill } # Reuse existing fill, if it exists
+      new_xf.fill_id ||= fills.size # If this fill has never existed before, add it to collection.
+      fills[new_xf.fill_id] = new_fill
+      new_xf
+    end
+
+    def register_new_font(new_font, old_xf)
+      new_xf = old_xf.dup
+      new_xf.font_id = fonts.find_index { |x| x == new_font } # Reuse existing font, if it exists
+      new_xf.font_id ||= fonts.size # If this font has never existed before, add it to collection.
+      fonts[new_xf.font_id] = new_font
+      new_xf.apply_font = true
+      new_xf
+    end
+
+    def register_new_xf(new_xf)
+      new_xf_id = cell_xfs.find_index { |xf| xf == new_xf } # Reuse existing XF, if it exists
+      new_xf_id ||= cell_xfs.size # If this XF has never existed before, add it to collection.
+      cell_xfs[new_xf_id] = new_xf
+      new_xf_id
+    end
+
+    def modify_alignment(style_index, &block)
+      old_xf = cell_xfs[style_index || 0]
+      new_xf = old_xf.dup
+      if old_xf.alignment then
+        new_xf.alignment = old_xf.alignment.dup
+      else
+        new_xf.alignment = RubyXL::Alignment.new
+      end
+
+      yield(new_xf.alignment)
+      new_xf.apply_alignment = true
+
+      register_new_xf(new_xf)
+    end
+
+    def modify_fill(style_index, rgb)
+      xf = cell_xfs[style_index || 0].dup
+      new_fill = RubyXL::Fill.new(:pattern_fill =>
+                                                   RubyXL::PatternFill.new(:pattern_type => 'solid',
+                                                                           :fg_color     => RubyXL::Color.new(:rgb => rgb)))
+      register_new_xf(register_new_fill(new_fill, xf))
+    end
+
+    def modify_border(style_index, direction, weight)
+      xf = cell_xfs[style_index || 0].dup
+      new_border = borders[xf.border_id || 0].dup
+
+      edge = new_border.send(direction)
+      new_border.send("#{direction}=", edge.dup) if edge
+
+      new_border.set_edge_style(direction, weight)
+
+      xf.border_id = borders.find_index { |x| x == new_border } # Reuse existing border, if it exists
+      xf.border_id ||= borders.size # If this border has never existed before, add it to collection.
+      borders[xf.border_id] = new_border
+      xf.apply_border = true
+
+      register_new_xf(xf)
+    end
+
+    def modify_border_color(style_index, direction, color)
+      xf = cell_xfs[style_index || 0].dup
+      new_border = borders[xf.border_id || 0].dup
+      new_border.set_edge_color(direction, color)
+
+      xf.border_id = borders.find_index { |x| x == new_border } # Reuse existing border, if it exists
+      xf.border_id ||= borders.size # If this border has never existed before, add it to collection.
+      borders[xf.border_id] = new_border
+      xf.apply_border = true
+
+      register_new_xf(xf)
+    end
+
+    # Calculate password hash from string for use in 'password' fields.
+    # https://www.openoffice.org/sc/excelfileformat.pdf
+    def password_hash(pwd)
+      hsh = 0
+      pwd.reverse.each_char { |c|
+        hsh = hsh ^ c.ord
+        hsh = hsh << 1
+        hsh -= 0x7fff if hsh > 0x7fff
+      }
+
+      (hsh ^ pwd.length ^ 0xCE4B).to_s(16)
+    end
+
+    def define_new_name(name, reference)
+      self.defined_names ||= RubyXL::DefinedNames.new
+      self.defined_names << RubyXL::DefinedName.new({:name => name, :reference => reference})
+    end
+
+    def get_defined_name(name)
+      self.defined_names && self.defined_names.find { |n| n.name == name }
+    end
+
+    def title
+      self.root.core_properties.dc_title && self.root.core_properties.dc_title.value
+    end
+
+    def title=(v)
+      self.root.core_properties.dc_title = v && RubyXL::StringNode.new(:value => v)
+    end
+  end
+
+  RubyXL::Workbook.send(:include, RubyXL::WorkbookConvenienceMethods) # ruby 2.1 compat
+end