ooxml_parser 0.14.1-mingw32

data/lib/ooxml_parser/common_parser/common_data/alternate_content/picture/group/old_docx_group_properties.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Fallback DOCX group properties
+  class OldDocxGroupProperties
+    attr_accessor :wrap
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/picture/old_docx_picture.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'shape/old_docx_shape'
+require_relative 'shape/old_docx_shape_fill'
+require_relative 'group/old_docx_group'
+module OoxmlParser
+  # Fallback DOCX Picture
+  class OldDocxPicture < OOXMLDocumentObject
+    attr_accessor :data, :type
+
+    # Parse OldDocxPicture object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [OldDocxPicture] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'shape'
+          @type = :shape
+          @data = OldDocxShape.new(parent: self).parse(node_child)
+        when 'group'
+          @type = :group
+          @data = OldDocxGroup.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/picture/shape/old_docx_shape.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'old_docx_shape_properties'
+module OoxmlParser
+  # Fallback DOCX shape data
+  class OldDocxShape < OOXMLDocumentObject
+    attr_accessor :properties, :text_box, :fill
+    # @return [FileReference] image structure
+    attr_accessor :file_reference
+
+    # Parse OldDocxShape object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [OldDocxShape] result of parsing
+    def parse(node)
+      @properties = OldDocxShapeProperties.new(parent: self).parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'textbox'
+          @text_box = TextBox.parse_list(node_child, parent: self)
+        when 'imagedata'
+          @file_reference = FileReference.new(parent: self).parse(node_child)
+        when 'fill'
+          @fill = OldDocxShapeFill.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/picture/shape/old_docx_shape_fill.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Fallback DOCX shape fill properties
+  class OldDocxShapeFill < OOXMLDocumentObject
+    attr_accessor :stretching_type, :opacity, :title
+    # @return [FileReference] image structure
+    attr_accessor :file_reference
+
+    # Parse OldDocxShapeFill object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [OldDocxShapeFill] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'id'
+          @file_reference = FileReference.new(parent: self).parse(node)
+        when 'type'
+          @stretching_type = case value.value
+                             when 'frame'
+                               :stretch
+                             else
+                               value.value.to_sym
+                             end
+        when 'title'
+          @title = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/picture/shape/old_docx_shape_properties.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Fallback DOCX Shape Properties
+  class OldDocxShapeProperties < OOXMLDocumentObject
+    attr_accessor :fill_color, :stroke_color, :stroke_weight
+
+    # Parse OldDocxShapeProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [OldDocxShapeProperties] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'fillcolor'
+          @fill_color = Color.new(parent: self).parse_hex_string(value.value.delete('#'))
+        when 'strokecolor'
+          @stroke_color = Color.new(parent: self).parse_hex_string(value.value.delete('#'))
+        when 'strokeweight'
+          @stroke_weight = value.value.to_f
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Border Properties Data
+  class BordersProperties < OOXMLDocumentObject
+    attr_accessor :color, :space, :val, :shadow, :frame, :side
+    # @return [OoxmlSize] size of border
+    attr_reader :size
+
+    def initialize(color = :auto, size = 0, val = :none, space = 0, parent: nil)
+      @color = color
+      @size = size
+      @val = val
+      @space = space
+      super(parent: parent)
+    end
+
+    # @return [OoxmlSize] alias for sz
+    def sz
+      size
+    end
+
+    extend Gem::Deprecate
+    deprecate :sz, 'size', 2020, 1
+
+    def nil?
+      size.zero? && val == :none
+    end
+
+    # @return [String] result of convert of object to string
+    def to_s
+      return '' if nil?
+
+      "borders color: #{@color}, size: #{size}, space: #{@space}, value: #{@val}"
+    end
+
+    # Method to copy object
+    # @return [BordersProperties] copied object
+    def copy
+      BordersProperties.new(@color, size, @val, @space)
+    end
+
+    def visible?
+      return false if nil?
+
+      val != 'none'
+    end
+
+    # Parse BordersProperties
+    # @param [Nokogiri::XML:Element] node with BordersProperties
+    # @return [BordersProperties] value of BordersProperties
+    def parse(node)
+      return nil if node.attribute('val').value == 'nil'
+
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @val = value.value.to_sym
+        when 'sz'
+          @size = OoxmlSize.new(value.value.to_f, :one_eighth_point)
+        when 'space'
+          @space = OoxmlSize.new(value.value.to_f, :point)
+        when 'color'
+          @color = value.value.to_s
+          @color = Color.new(parent: self).parse_hex_string(@color) if @color != 'auto'
+        when 'shadow'
+          @shadow = value.value
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Helper methods for color
+  module ColorHelper
+    # Parse string in hex
+    # @param [String] hex_string with or without alpha-channel
+    def parse_hex_string(hex_string)
+      return self if %w[auto null].include?(hex_string)
+
+      char_array = hex_string.chars
+      case char_array.length
+      when 3
+        @red = char_array[0].hex
+        @green = char_array[1].hex
+        @blue = char_array[2].hex
+      when 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
+      when 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
+      self
+    end
+
+    # Convert color to HSLColor
+    # @return [HSLColor]
+    def to_hsl
+      hls_color = HSLColor.new
+
+      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.alpha_channel = alpha_channel.to_f / 255.0
+
+      unless max == min
+        hls_color.s = delta / (255.0 - (255.0 - max - min).abs)
+
+        hls_color.h = if max == red && green >= blue
+                        60.0 * (green - blue) / delta
+                      elsif max == red && green < blue
+                        60.0 * (green - blue) / delta + 360.0
+                      elsif max == green
+                        60.0 * (blue - red) / delta + 120.0
+                      else
+                        60.0 * (red - green) / delta + 240.0
+                      end
+      end
+
+      hls_color
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/color/color_indexes.list

@@ -0,0 +1,66 @@
+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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `color` tag
+  class OoxmlColor < OOXMLDocumentObject
+    # @return [Color] value of color
+    attr_reader :value
+    # @return [Symbol] theme color name
+    attr_reader :theme_color
+    # @return [Symbol] theme shade
+    attr_reader :theme_shade
+    # @return [Integer] theme index
+    attr_reader :theme
+    # @return [Float] tint
+    attr_reader :tint
+    # @return [Float] Indexed id
+    attr_reader :indexed
+    # @return [Color] rgb color
+    attr_reader :rgb
+
+    # Convert OoxmlColor to other color type
+    # @return [Object] result of conversion
+    def to_color
+      return Color.get_rgb_by_color_index(indexed) if indexed
+      return ThemeColors.new(parent: self).parse_color_theme(theme, tint) if theme
+      return rgb if rgb
+
+      value
+    end
+
+    # Compare this object to other
+    # @param other [Object] any other object
+    # @return [True, False] result of comparision
+    def ==(other)
+      return to_color == other if other.is_a?(Color)
+      return to_color == other if other.is_a?(Symbol)
+
+      super
+    end
+
+    # Parse OoxmlColor object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [OoxmlColor] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = Color.new.parse_hex_string(value.value.to_s)
+        when 'themeColor'
+          @theme_color = value.value.to_sym
+        when 'themeShade'
+          @theme_shade = Integer("0x#{value.value}")
+        when 'theme'
+          @theme = value.value.to_i
+        when 'tint'
+          @tint = value.value.to_f
+        when 'indexed'
+          @indexed = value.value.to_i
+        when 'rgb'
+          @rgb = Color.new.parse_hex_string(value.value)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative 'color/color_helper'
+require_relative 'color/ooxml_color'
+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
+module OoxmlParser
+  # Class for Color in RGB
+  class Color < OOXMLDocumentObject
+    include ColorHelper
+    # @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 [String] color scheme of color
+    attr_accessor :scheme
+
+    # @return [Integer] Value of alpha-channel
+    attr_accessor :alpha_channel
+
+    alias set_alpha_channel alpha_channel=
+
+    # @return [ColorProperties] properties of color
+    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,
+                   parent: nil)
+      @red = new_red
+      @green = new_green
+      @blue = new_blue
+      super(parent: parent)
+    end
+
+    # @return [String] result of convert of object to string
+    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
+
+    # @return [String] inspect of object for debug means
+    def inspect
+      to_s
+    end
+
+    # @return [String] color in hex value
+    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
+
+    # @return [True, False] is color default
+    def none?
+      (@red == VALUE_FOR_NONE_COLOR) && (@green == VALUE_FOR_NONE_COLOR) && (@blue == VALUE_FOR_NONE_COLOR) ||
+        (style == :nil)
+    end
+
+    # @return [True, False] is color not default
+    def any?
+      !none?
+    end
+
+    # @return [True, False] is color white
+    def white?
+      (@red == 255) && (@green == 255) && (@blue == 255)
+    end
+
+    # Method to copy object
+    # @return [Color] copied object
+    def copy
+      Color.new(@red, @green, @blue)
+    end
+
+    # Compare this object to other
+    # @param other [Object] any other object
+    # @return [True, False] result of comparision
+    def ==(other)
+      if other.is_a?(Color)
+        ((@red == other.red) && (@green == other.green) && (@blue == other.blue)) ||
+          (none? && other.white?) ||
+          (white? && other.none?)
+      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.pattern_fill.foreground_folor if color_to_check.is_a?(Fill)
+      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 true if none? && color_to_check.nil?
+      return true if none? && color_to_check.none?
+      return false if none? && color_to_check.any?
+      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
+    end
+
+    # Apply tint to color
+    # @param tint [Integer] tint to apply
+    # @return [void]
+    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
+
+    # Apply shade to color
+    # @param shade [Integer] shade to apply
+    # @return [void]
+    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
+
+    # Parse color scheme data
+    # @param scheme_color_node [Nokogiri::XML:Element] node to parse
+    # @return [Color] result of parsing
+    def parse_scheme_color(scheme_color_node)
+      color = root_object.theme.color_scheme[scheme_color_node.attribute('val').value.to_sym].color
+      hls = color.to_hsl
+      scheme_name = nil
+      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
+      scheme_color_node.attributes.each do |key, value|
+        case key
+        when 'val'
+          scheme_name = value.to_s
+        end
+      end
+      color = hls.to_rgb
+      @red = color.red
+      @green = color.green
+      @blue = color.blue
+      @alpha_channel = ColorAlphaChannel.parse(scheme_color_node)
+      @scheme = scheme_name
+      self
+    end
+
+    # Parse color model data
+    # @param color_model_parent_node [Nokogiri::XML:Element] node to parse
+    # @return [Color] result of parsing
+    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 'srgbClr'
+          color = Color.new.parse_hex_string(color_model_node.attribute('val').value)
+          color.alpha_channel = ColorAlphaChannel.parse(color_model_node)
+        when 'schemeClr'
+          color = Color.new(parent: self).parse_scheme_color(color_model_node)
+        end
+      end
+      return nil unless color
+
+      color.calculate_with_tint!(1.0 - tint) if tint
+      @red = color.red
+      @green = color.green
+      @blue = color.blue
+      @alpha_channel = color.alpha_channel
+      @scheme = color.scheme
+      self
+    end
+
+    # Parse color data
+    # @param color_node [Nokogiri::XML:Element] node to parse
+    # @return [Color] result of parsing
+    def parse_color(color_node)
+      case color_node.name
+      when 'srgbClr'
+        color = parse_hex_string(color_node.attribute('val').value)
+        color.properties = ColorProperties.new(parent: color).parse(color_node)
+        color
+      when 'schemeClr'
+        color = SchemeColor.new(parent: parent)
+        return ValuedChild.new(:string, parent: parent).parse(color_node) unless root_object.theme
+
+        color.value = root_object.theme.color_scheme[color_node.attribute('val').value.to_sym].color
+        color.properties = ColorProperties.new(parent: color).parse(color_node)
+        color.converted_color = Color.new(parent: self).parse_scheme_color(color_node)
+        color.value.calculate_with_tint!(1.0 - color.properties.tint) if color.properties.tint
+        color
+      end
+    end
+
+    class << self
+      # @return [Color] random color
+      def generate_random_color
+        Color.new(rand(256), rand(256), rand(256))
+      end
+
+      alias random generate_random_color
+
+      # 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
+
+      # @param index [Integer] index to get
+      # @return [Color] color by it's index
+      def get_rgb_by_color_index(index)
+        color_by_index = color_indexes[index]
+        return :unknown if color_by_index.nil?
+
+        color_by_index == 'n/a' ? Color.new : Color.new.parse_hex_string(color_by_index)
+      end
+
+      # @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
+      def color_indexes
+        @color_indexes ||= File.readlines("#{__dir__}/color/color_indexes.list", chomp: true)
+      end
+
+      # Parse color from string
+      # @param str [String] string to parse
+      # @return [Color] result of parsing
+      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
+
+      # Convert other object type to Color
+      # @param something [Object] object to convert
+      # @return [Color] result of conversion
+      def to_color(something)
+        case something
+        when SchemeColor
+          something.converted_color
+        when DocxColorScheme
+          something.color
+        when Fill
+          something.to_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
+    end
+  end
+end