ooxml_parser 0.1.1

data/lib/ooxml_parser/common_parser/common_data/color.rb

@@ -0,0 +1,473 @@
+require_relative 'colors/color_alpha_channel'
+require_relative 'colors/hsl_color'
+require_relative 'colors/scheme_color'
+require_relative 'colors/color_properties'
+require_relative 'colors/theme_colors'
+# @author Pavel.Lobashov
+# Class for Color in RGB
+module OoxmlParser
+  class Color
+    # @return [Array] Deprecated Indexed colors
+    # List of color duplicated from `OpenXML Sdk IndexedColors` class
+    # See https://msdn.microsoft.com/en-us/library/documentformat.openxml.spreadsheet.indexedcolors.aspx
+    COLOR_INDEXED =
+      %w(
+        000000
+        FFFFFF
+        FF0000
+        00FF00
+        0000FF
+        FFFF00
+        FF00FF
+        00FFFF
+        000000
+        FFFFFF
+        FF0000
+        00FF00
+        0000FF
+        FFFF00
+        FF00FF
+        00FFFF
+        800000
+        008000
+        000080
+        808000
+        800080
+        008080
+        C0C0C0
+        808080
+        9999FF
+        993366
+        FFFFCC
+        CCFFFF
+        660066
+        FF8080
+        0066CC
+        CCCCFF
+        000080
+        FF00FF
+        FFFF00
+        00FFFF
+        800080
+        800000
+        008080
+        0000FF
+        00CCFF
+        CCFFFF
+        CCFFCC
+        FFFF99
+        99CCFF
+        FF99CC
+        CC99FF
+        FFCC99
+        3366FF
+        33CCCC
+        99CC00
+        FFCC00
+        FF9900
+        FF6600
+        666699
+        969696
+        003366
+        339966
+        003300
+        333300
+        993300
+        993366
+        333399
+        333333
+        n/a
+        n/a
+      ).freeze
+
+    # @return [Integer] Value of Red Part
+    attr_accessor :red
+    # @return [Integer] Value of Green Part
+    attr_accessor :green
+    # @return [Integer] Value of Blue Part
+    attr_accessor :blue
+    # @return [String] Value of Color Style
+    attr_accessor :style
+    alias set_style style=
+
+    # @return [Integer] Value of alpha-channel
+    attr_accessor :alpha_channel
+    alias set_alpha_channel alpha_channel=
+
+    attr_accessor :position
+    attr_accessor :properties
+
+    # Value of color if non selected
+    VALUE_FOR_NONE_COLOR = nil
+
+    def initialize(new_red = VALUE_FOR_NONE_COLOR, new_green = VALUE_FOR_NONE_COLOR, new_blue = VALUE_FOR_NONE_COLOR)
+      @red = new_red
+      @green = new_green
+      @blue = new_blue
+    end
+
+    def to_s
+      if @red == VALUE_FOR_NONE_COLOR && @green == VALUE_FOR_NONE_COLOR && @blue == VALUE_FOR_NONE_COLOR
+        'none'
+      else
+        "RGB (#{@red}, #{@green}, #{@blue})"
+      end
+    end
+
+    def to_hex
+      (@red.to_s(16).rjust(2, '0') + @green.to_s(16).rjust(2, '0') + @blue.to_s(16).rjust(2, '0')).upcase
+    end
+
+    alias to_int16 to_hex
+
+    def none?
+      (@red == VALUE_FOR_NONE_COLOR) && (@green == VALUE_FOR_NONE_COLOR) && (@blue == VALUE_FOR_NONE_COLOR)
+    end
+
+    def white?
+      (@red == 255) && (@green == 255) && (@blue == 255)
+    end
+
+    def copy
+      Color.new(@red, @green, @blue)
+    end
+
+    def ==(other)
+      if other.is_a?(Color)
+        if nil?
+          false
+        elsif (@red == other.red) && (@green == other.green) && (@blue == other.blue)
+          true
+        elsif (none? && other.white?) || (white? && other.none?)
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+
+    # To compare color, which look alike
+    # @param [String or Color] color_to_check color to compare
+    # @param [Integer] delta max delta for each of specters
+    def looks_like?(color_to_check = nil, delta = 8)
+      color_to_check = color_to_check.converted_color if color_to_check.is_a?(SchemeColor)
+      color_to_check = color_to_check.color if color_to_check.is_a?(ForegroundColor)
+      color_to_check = color_to_check.color.converted_color if color_to_check.is_a?(PresentationFill)
+      color_to_check = Color.parse(color_to_check) if color_to_check.is_a?(String)
+      color_to_check = Color.parse(color_to_check.to_s) if color_to_check.is_a?(Symbol)
+      color_to_check = Color.parse(color_to_check.value) if color_to_check.is_a?(DocxColor)
+      return false if none? && !color_to_check.none?
+      return false if !none? && color_to_check.none?
+      return true if self == color_to_check
+      red = color_to_check.red
+      green = color_to_check.green
+      blue = color_to_check.blue
+      ((self.red - red).abs < delta && (self.green - green).abs < delta && (self.blue - blue).abs < delta) ? true : false
+    end
+
+    def calculate_with_tint!(tint)
+      @red += (tint.to_f * (255 - @red)).to_i
+      @green += (tint.to_f * (255 - @green)).to_i
+      @blue += (tint.to_f * (255 - @blue)).to_i
+    end
+
+    def calculate_with_shade!(shade)
+      @red = (@red * shade.to_f).to_i
+      @green = (@green * shade.to_f).to_i
+      @blue = (@blue * shade.to_f).to_i
+    end
+
+    def shade(shade_value)
+      red = Color.scrgb_to_srgb(Color.shade_for_component(Color.srgb_to_scrgb(@red), shade_value))
+      green = Color.scrgb_to_srgb(Color.shade_for_component(Color.srgb_to_scrgb(@green), shade_value))
+      blue = Color.scrgb_to_srgb(Color.shade_for_component(Color.srgb_to_scrgb(@blue), shade_value))
+      Color.new(red, green, blue)
+    end
+
+    def tint(shade_value)
+      red = Color.scrgb_to_srgb(Color.tint_for_component(Color.srgb_to_scrgb(@red), shade_value))
+      green = Color.scrgb_to_srgb(Color.tint_for_component(Color.srgb_to_scrgb(@green), shade_value))
+      blue = Color.scrgb_to_srgb(Color.tint_for_component(Color.srgb_to_scrgb(@blue), shade_value))
+      Color.new(red, green, blue)
+    end
+
+    # code from js to ruby
+    # https://github.com/ONLYOFFICE/ONLYOFFICE-OnlineEditors/blob/master/OfficeWeb/sdk/Excel/model/DrawingObjects/Format/Format.js
+    def to_hsl
+      max_hls = 255.0
+      cd13 = 1.0 / 3.0
+      cd23 = 2.0 / 3.0
+      hls_color = HSLColor.new
+      min = [@red, @green, @blue].min.to_f
+      max = [@red, @green, @blue].max.to_f
+      delta = (max - min).to_f
+      dmax = (max + min) / 255.0
+      ddelta = delta / 255.0
+      hls_color.l = dmax / 2.0
+
+      if delta != 0
+        hls_color.s = if hls_color.l < 0.5
+                        ddelta / dmax
+                      else
+                        ddelta / (2.0 - dmax)
+                      end
+        ddelta *= 1_530.0
+        d_r = (max - @red) / ddelta
+        d_g = (max - @green) / ddelta
+        d_b = (max - @blue) / ddelta
+
+        if @red == max
+          hls_color.h = d_b - d_r
+        elsif @green == max
+          hls_color.h = cd13 + d_r - d_b
+        elsif @blue == max
+          hls_color.h = cd23 + d_g - d_r
+        end
+
+        hls_color.h += 1 if hls_color.h < 0
+        hls_color.h -= 1 if hls_color.h < 1
+      end
+      hls_color.h = ((hls_color.h * max_hls).round >> 0) & 0xFF
+      hls_color.h = 0 if hls_color.h < 0
+      hls_color.h = 255 if hls_color.h > 255
+
+      hls_color.l = ((hls_color.l * max_hls).round >> 0) & 0xFF
+      hls_color.l = 0 if hls_color.l < 0
+      hls_color.l = 255 if hls_color.l > 255
+
+      hls_color.s = ((hls_color.s * max_hls).round >> 0) & 0xFF
+      hls_color.s = 0 if hls_color.s < 0
+      hls_color.s = 255 if hls_color.s > 255
+
+      hls_color
+    end
+
+    # redefine code from our to_hsl realisation to standartised way for services like http://serennu.com/colour/hsltorgb.php
+    def to_hsl_standardised
+      hsl = to_hsl
+      hsl.h = hsl.h * 360 / 256
+      hsl.l = (hsl.l * 100.0 / 255.0).round
+      hsl.s = (hsl.s * 100.0 / 255.0).round
+      hsl
+    end
+
+    class << self
+      def generate_random_color
+        Color.new(rand(256), rand(256), rand(256))
+      end
+
+      alias random generate_random_color
+
+      def from_int16(color)
+        return nil unless color
+        return Color.new(nil, nil, nil) if color == 'auto' || color == 'null'
+
+        char_array = color.split(//)
+        alpha_channel, red, green, blue = nil
+        if char_array.length == 6
+          red = (char_array[0] + char_array[1]).hex
+          green = (char_array[2] + char_array[3]).hex
+          blue = (char_array[4] + char_array[5]).hex
+        elsif char_array.length == 8
+          alpha_channel = (char_array[0] + char_array[1]).hex
+          red = (char_array[2] + char_array[3]).hex
+          green = (char_array[4] + char_array[5]).hex
+          blue = (char_array[6] + char_array[7]).hex
+        end
+        font_color = Color.new(red, green, blue)
+        font_color.set_alpha_channel(alpha_channel) if alpha_channel
+        font_color
+      end
+
+      def parse_color_hash(hash)
+        Color.new(hash['red'], hash['green'], hash['blue'])
+      end
+
+      # Read array of color from the AllTestData's constant
+      # @param [Array] const_array_name - array of the string
+      # @return [Array, Color] array of color
+      def array_from_const(const_array_name)
+        const_array_name.map { |current_color| Color.parse_string(current_color) }
+      end
+
+      def get_rgb_by_color_index(index)
+        color_by_index = COLOR_INDEXED[index]
+        color_by_index == 'n/a' ? Color.new : Color.from_int16(color_by_index)
+      end
+
+      def parse_string(str)
+        return str if str.is_a?(Color)
+        return Color.new(VALUE_FOR_NONE_COLOR, VALUE_FOR_NONE_COLOR, VALUE_FOR_NONE_COLOR) if str == 'none' || str == '' || str == 'transparent' || str.nil?
+        split = if str.include?('RGB (') || str.include?('rgb(')
+                  str.gsub(/[(RGBrgb\(\) )]/, '').split(',')
+                elsif str.include?('RGB ') || str.include?('rgb')
+                  str.gsub(/RGB |rgb/, '').split(', ')
+                else
+                  raise "Incorrect data for color to parse: '#{str}'"
+                end
+
+        Color.new(split[0].to_i, split[1].to_i, split[2].to_i)
+      end
+
+      alias parse parse_string
+
+      def parse_int16_string(color)
+        return nil if color.nil?
+
+        char_array = color.split(//)
+        red = (char_array[0] + char_array[1]).hex
+        green = (char_array[2] + char_array[3]).hex
+        blue = (char_array[4] + char_array[5]).hex
+        Color.new(red, green, blue)
+      end
+
+      def srgb_to_scrgb(color)
+        lineal_value = color.to_f / 255.0
+        result_color = if lineal_value < 0
+                         0
+                       elsif lineal_value <= 0.04045
+                         lineal_value / 12.92
+                       elsif lineal_value <= 1
+                         ((lineal_value + 0.055) / 1.055)**2.4
+                       else
+                         1
+                       end
+        result_color
+      end
+
+      def scrgb_to_srgb(color)
+        result_color = if color < 0
+                         0
+                       elsif color <= 0.0031308
+                         color * 12.92
+                       elsif color < 1
+                         1.055 * (color**(1.0 / 2.4)) - 0.055
+                       else
+                         1
+                       end
+        (result_color * 255.0).to_i
+      end
+
+      def shade_for_component(color_component, shade_value)
+        if color_component * shade_value < 0
+          0
+        elsif color_component * shade_value > 1
+          1
+        else
+          color_component * shade_value
+        end
+      end
+
+      def tint_for_component(color_component, tint)
+        if tint > 0
+          color_component * (1 - tint) + tint
+        else
+          color_component * (1 + tint)
+        end
+      end
+
+      def to_color(something)
+        case something
+        when SchemeColor
+          something.converted_color
+        when ForegroundColor, DocxColorScheme
+          something.color
+        when PresentationFill
+          if something.color.respond_to? :converted_color
+            something.color.converted_color
+          else
+            something.color
+          end
+        when String
+          Color.parse(something)
+        when Symbol
+          Color.parse(something.to_s)
+        when DocxColor
+          Color.parse(something.value)
+        else
+          something
+        end
+      end
+
+      def parse_color_tag(color_tag)
+        unless color_tag.nil?
+          if color_tag.attribute('indexed').nil? && !color_tag.attribute('rgb').nil?
+            if color_tag.attribute('rgb').value.is_a?(String)
+              return Color.from_int16(color_tag.attribute('rgb').value.to_s)
+            end
+            return Color.from_int16(color_tag.attribute('rgb').value.value.to_s)
+          elsif color_tag.attribute('rgb').nil? && !color_tag.attribute('indexed').nil?
+            if color_tag.attribute('indexed').value.is_a?(String)
+              return Color.get_rgb_by_color_index(color_tag.attribute('indexed').value.to_i)
+            end
+            return Color.get_rgb_by_color_index(color_tag.attribute('indexed').value.value.to_i)
+          elsif !color_tag.attribute('theme').nil?
+            return ThemeColors.parse_color_theme(color_tag)
+          end
+        end
+        nil
+      end
+
+      def parse_scheme_color(scheme_color_node)
+        color = ThemeColors.list[scheme_color_node.attribute('val').value.to_sym]
+        hls = HSLColor.rgb_to_hsl(color)
+        scheme_color_node.xpath('*').each do |scheme_color_node_child|
+          case scheme_color_node_child.name
+          when 'lumMod'
+            hls.l = hls.l * (scheme_color_node_child.attribute('val').value.to_f / 100_000.0)
+          when 'lumOff'
+            hls.l = hls.l + (scheme_color_node_child.attribute('val').value.to_f / 100_000.0)
+          end
+        end
+        color = hls.to_rgb
+        color.alpha_channel = ColorAlphaChannel.parse(scheme_color_node)
+        color
+      end
+
+      def parse_color_model(color_model_parent_node)
+        color = nil
+        tint = nil
+        color_model_parent_node.xpath('*').each do |color_model_node|
+          color_model_node.xpath('*').each do |color_mode_node_child|
+            case color_mode_node_child.name
+            when 'tint'
+              tint = color_mode_node_child.attribute('val').value.to_f / 100_000.0
+            end
+          end
+          case color_model_node.name
+          when 'scrgbClr'
+            color = Color.new(color_model_node.attribute('r').value.to_i, color_model_node.attribute('g').value.to_i, color_model_node.attribute('b').value.to_i)
+            color.alpha_channel = ColorAlphaChannel.parse(color_model_node)
+          when 'srgbClr'
+            color = Color.from_int16(color_model_node.attribute('val').value)
+            color.alpha_channel = ColorAlphaChannel.parse(color_model_node)
+          when 'schemeClr'
+            color = parse_scheme_color(color_model_node)
+          end
+        end
+        return nil unless color
+        color.calculate_with_tint!(1.0 - tint) if tint
+        color
+      end
+
+      def parse_color(color_node)
+        case color_node.name
+        when 'srgbClr'
+          color = Color.from_int16(color_node.attribute('val').value)
+          color.properties = ColorProperties.parse(color_node)
+          color
+        when 'schemeClr'
+          color = SchemeColor.new
+          color.value = ThemeColors.list[color_node.attribute('val').value.to_sym]
+          color.properties = ColorProperties.parse(color_node)
+          color.converted_color = HSLColor.calculate_with_luminance color.value,
+                                                                    color.properties.luminance_modulation,
+                                                                    color.properties.luminance_offset
+          color
+        end
+      end
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/colors/color_alpha_channel.rb

@@ -0,0 +1,14 @@
+# Class for working with AlphaChannel
+module OoxmlParser
+  class ColorAlphaChannel
+    # Parse AlphaChannel value
+    # @param node [Nokogiri::XML::Element] node to parse
+    # @return [Fixnum] value of AlphaChannel
+    def self.parse(node)
+      alpha_channel_node = node.xpath('a:alpha', 'xmlns:a' => 'http://schemas.openxmlformats.org/drawingml/2006/main').first
+      alpha_channel_node = node.xpath('w14:alpha', 'xmlns:w14' => 'http://schemas.microsoft.com/office/word/2010/wordml').first if alpha_channel_node.nil?
+      return 100.0 if alpha_channel_node.nil?
+      (alpha_channel_node.attribute('val').value.to_f / 1_000.0).round(0)
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/colors/color_properties.rb

@@ -0,0 +1,21 @@
+# Class for color transformations
+module OoxmlParser
+  class ColorProperties
+    attr_accessor :alpha, :luminance_modulation, :luminance_offset
+
+    def self.parse(color_properties_node)
+      properties = ColorProperties.new
+      color_properties_node.xpath('*').each do |color_properties_node_child|
+        case color_properties_node_child.name
+        when 'alpha'
+          properties.alpha = (color_properties_node_child.attribute('val').value.to_f / 1_000.0).round
+        when 'lumMod'
+          properties.luminance_modulation = color_properties_node_child.attribute('val').value.to_f / 100_000.0
+        when 'lumOff'
+          properties.luminance_offset = color_properties_node_child.attribute('val').value.to_f / 100_000.0
+        end
+      end
+      properties
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/colors/hsl_color.rb

@@ -0,0 +1,150 @@
+# HSL is one of the most common cylindrical-coordinate representations of points in an RGB color model.
+# HSL stands for hue, saturation, and lightness, and is often also called HLS.
+module OoxmlParser
+  class HSLColor
+    attr_accessor :a, :h, :s, :l
+
+    # Hue - The "attribute of a visual sensation according to which an area appears to be similar to one of
+    # the perceived colors: red, yellow, green, and blue, or to a combination of two of them".
+    # Saturation - The "colorfulness of a stimulus relative to its own brightness".
+    # Lightness - The "brightness relative to the brightness of a similarly illuminated white".
+    def initialize(hue = 0, saturation = 0, lightness = 0, a = nil)
+      @a = a
+      @h = hue
+      @s = saturation
+      @l = lightness
+    end
+
+    def self.rgb_to_hsl(rgb_color)
+      hls_color = HSLColor.new
+      red = rgb_color.red.to_f # / 255.0
+      green = rgb_color.green.to_f # / 255.0
+      blue = rgb_color.blue.to_f # / 255.0
+
+      min = [red, green, blue].min.to_f
+      max = [red, green, blue].max.to_f
+
+      delta = (max - min).to_f
+      hls_color.l = (min + max) / 255.0 / 2.0
+      hls_color.a = rgb_color.alpha_channel.to_f / 255.0
+
+      unless max == min
+        hls_color.s = delta / (255.0 - (255.0 - max - min).abs)
+
+        hls_color.h = case
+                      when max == red && green >= blue
+                        60.0 * (green - blue) / delta
+                      when max == red && green < blue
+                        60.0 * (green - blue) / delta + 360.0
+                      when max == green
+                        60.0 * (blue - red) / delta + 120.0
+                      else
+                        60.0 * (red - green) / delta + 240.0
+                      end
+      end
+
+      hls_color
+    end
+
+    # Chroma - The "colorfulness relative to the brightness of a similarly illuminated white".
+    def to_rgb
+      chroma = (1 - (2 * @l - 1).abs) * @s
+      x = chroma * (1 - ((@h / 60.0) % 2.0 - 1).abs)
+      m = @l - chroma / 2.0
+
+      rgb = case
+            when @h == 0
+              Color.new(0, 0, 0)
+            when @h > 0 && @h < 60
+              Color.new(chroma, x, 0)
+            when @h > 60 && @h < 120
+              Color.new(x, chroma, 0)
+            when @h > 120 && @h < 180
+              Color.new(0, chroma, x)
+            when @h > 180 && @h < 240
+              Color.new(0, x, chroma)
+            when @h > 240 && @h < 300
+              Color.new(x, 0, chroma)
+            else
+              Color.new(chroma, 0, x)
+            end
+      Color.new(((rgb.red + m) * 255.0).round, ((rgb.green + m) * 255.0).round, ((rgb.blue + m) * 255.0).round)
+    end
+
+    def set_color(t1, t2, t3)
+      t3 += 1.0 if t3 < 0
+      t3 -= 1.0 if t3 > 1
+      case
+      when 6.0 * t3 < 1 then
+        t2 + (t1 - t2) * 6.0 * t3
+      when 2.0 * t3 < 1 then
+        t1
+      when 3.0 * t3 < 2 then
+        t2 + (t1 - t2) * ((2.0 / 3.0) - t3) * 6.0
+      else
+        t2
+      end
+    end
+
+    def calculate_lum_value(tint, lum)
+      if tint.nil?
+        lum
+      else
+        tint < 0 ? lum * (1.0 + tint) : lum * (1.0 - tint) + (255 - 255 * (1.0 - tint))
+      end
+    end
+
+    def self.calculate_with_luminance(color, lum_mod, lum_off = nil)
+      hls_color = color.is_a?(HSLColor) ? color : HSLColor.rgb_to_hsl(color)
+      # for hsl color which have h == 0 need another values of lumOff lumMod - 0.04(+-0.005)
+      if lum_mod
+        if hls_color.h == 0
+          hls_color.l *= case lum_mod
+                         when 0.2
+                           0.169
+                         when 0.4
+                           0.369
+                         when 0.6
+                           0.55
+                         when 0.75
+                           0.705
+                         when 0.5
+                           0.469
+                         else
+                           lum_mod
+                         end
+        else
+          hls_color.l *= lum_mod
+        end
+      end
+      current_rgb = hls_color.to_rgb
+      return current_rgb if current_rgb == Color.new
+
+      unless lum_off.nil?
+        hls_color = HSLColor.rgb_to_hsl(current_rgb)
+        # for hsl color which have h == 0 need another values of lumOff - 0.04(+-0.01)
+        if hls_color.h == 0
+          hls_color.l += case lum_off
+                         when 0.8
+                           0.76
+                         when 0.6
+                           0.55
+                         when 0.4
+                           0.36
+                         else
+                           lum_off
+                         end
+        else
+          hls_color.l += lum_off
+        end
+        current_rgb = hls_color.to_rgb
+      end
+      current_rgb
+    end
+
+    def calculate_rgb_with_tint(tint)
+      self.l = calculate_lum_value(tint, @l * 255.0) / 255.0
+      to_rgb
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/colors/image/fill_rectangle.rb

@@ -0,0 +1,22 @@
+module OoxmlParser
+  class FillRectangle
+    attr_accessor :left, :top, :right, :bottom
+
+    def self.parse(fill_rectangle_node)
+      fill_rectangle = FillRectangle.new
+      fill_rectangle_node.attributes.each do |key, value|
+        case key
+        when 'b'
+          fill_rectangle.bottom = value.value.to_i
+        when 't'
+          fill_rectangle.top = value.value.to_i
+        when 'l'
+          fill_rectangle.left = value.value.to_i
+        when 'r'
+          fill_rectangle.right = value.value.to_i
+        end
+      end
+      fill_rectangle
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/colors/image/stretching.rb

@@ -0,0 +1,11 @@
+module OoxmlParser
+  class Stretching
+    attr_accessor :fill_rectangle
+
+    def self.parse(stretch_node)
+      stretching = Stretching.new
+      stretching.fill_rectangle = FillRectangle.parse(stretch_node.xpath('a:fillRect').first) if stretch_node.xpath('a:fillRect').first
+      stretching
+    end
+  end
+end