ooxml_parser 0.1.2 → 0.2.0

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

@@ -1,3 +1,4 @@
+require_relative 'color/color_helper'
 require_relative 'colors/color_alpha_channel'
 require_relative 'colors/hsl_color'
 require_relative 'colors/scheme_color'
@@ -6,7 +7,8 @@ require_relative 'colors/theme_colors'
 # @author Pavel.Lobashov
 # Class for Color in RGB
 module OoxmlParser
-  class Color
+  class Color < OOXMLDocumentObject
+    include ColorHelper
     # @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
@@ -89,6 +91,8 @@ module OoxmlParser
     # @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
@@ -100,10 +104,14 @@ module OoxmlParser
     # 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)
+    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
+      @parent = parent
     end
 
     def to_s
@@ -114,6 +122,10 @@ module OoxmlParser
       end
     end
 
+    def inspect
+      to_s
+    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
@@ -153,18 +165,19 @@ module OoxmlParser
     # @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.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 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
+      (self.red - red).abs < delta && (self.green - green).abs < delta && (self.blue - blue).abs < delta ? true : false
     end
 
     def calculate_with_tint!(tint)
@@ -179,80 +192,6 @@ module OoxmlParser
       @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))
@@ -260,31 +199,6 @@ module OoxmlParser
 
       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
@@ -294,7 +208,8 @@ module OoxmlParser
 
       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)
+        return :unknown if color_by_index.nil?
+        color_by_index == 'n/a' ? Color.new : Color.new.parse_hex_string(color_by_index)
       end
 
       def parse_string(str)
@@ -313,67 +228,14 @@ module OoxmlParser
 
       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
+        when DocxColorScheme
           something.color
+        when Fill
+          something.to_color
         when PresentationFill
           if something.color.respond_to? :converted_color
             something.color.converted_color
@@ -391,28 +253,26 @@ module OoxmlParser
         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)
+      def parse_color_tag(node)
+        return if node.nil?
+        node.attributes.each do |key, value|
+          case key
+          when 'val'
+            return Color.new.parse_hex_string(value.value.to_s)
+          when 'theme'
+            return ThemeColors.parse_color_theme(node)
+          when 'rgb'
+            return Color.new.parse_hex_string(value.value.to_s)
+          when 'indexed'
+            return Color.get_rgb_by_color_index(value.value.to_i)
           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_name = nil
         scheme_color_node.xpath('*').each do |scheme_color_node_child|
           case scheme_color_node_child.name
           when 'lumMod'
@@ -421,8 +281,15 @@ module OoxmlParser
             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
         color.alpha_channel = ColorAlphaChannel.parse(scheme_color_node)
+        color.scheme = scheme_name
         color
       end
 
@@ -441,7 +308,7 @@ module OoxmlParser
             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 = Color.new.parse_hex_string(color_model_node.attribute('val').value)
             color.alpha_channel = ColorAlphaChannel.parse(color_model_node)
           when 'schemeClr'
             color = parse_scheme_color(color_model_node)
@@ -455,16 +322,15 @@ module OoxmlParser
       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 = Color.new.parse_hex_string(color_node.attribute('val').value)
+          color.properties = ColorProperties.new(parent: color).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.properties = ColorProperties.new(parent: color).parse(color_node)
+          color.converted_color = parse_scheme_color(color_node)
+          color.value.calculate_with_tint!(1.0 - color.properties.tint) if color.properties.tint
           color
         end
       end

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

@@ -1,21 +1,26 @@
-# Class for color transformations
 module OoxmlParser
-  class ColorProperties
+  # Class for color transformations
+  class ColorProperties < OOXMLDocumentObject
     attr_accessor :alpha, :luminance_modulation, :luminance_offset
+    attr_accessor :tint
 
-    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
+    # Parse ColorProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ColorProperties] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'alpha'
-          properties.alpha = (color_properties_node_child.attribute('val').value.to_f / 1_000.0).round
+          @alpha = (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
+          @luminance_modulation = 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
+          @luminance_offset = node_child.attribute('val').value.to_f / 100_000.0
+        when 'tint'
+          @tint = node_child.attribute('val').value.to_f / 100_000.0
         end
       end
-      properties
+      self
     end
   end
 end

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

@@ -51,7 +51,7 @@ module OoxmlParser
       x = chroma * (1 - ((@h / 60.0) % 2.0 - 1).abs)
       m = @l - chroma / 2.0
 
-      rgb = if @h == 0
+      rgb = if @h.zero?
               Color.new(0, 0, 0)
             elsif @h > 0 && @h < 60
               Color.new(chroma, x, 0)
@@ -69,20 +69,6 @@ module OoxmlParser
       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
-      if 6.0 * t3 < 1
-        t2 + (t1 - t2) * 6.0 * t3
-      elsif 2.0 * t3 < 1
-        t1
-      elsif 3.0 * t3 < 2
-        t2 + (t1 - t2) * ((2.0 / 3.0) - t3) * 6.0
-      else
-        t2
-      end
-    end
-
     def calculate_lum_value(tint, lum)
       if tint.nil?
         lum
@@ -91,54 +77,6 @@ module OoxmlParser
       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

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

@@ -1,33 +1,30 @@
 require_relative 'tile'
-require_relative 'image_properties'
-require_relative 'image/stretching'
 module OoxmlParser
   class ImageFill < OOXMLDocumentObject
-    attr_accessor :path, :stretch, :tile, :properties
+    attr_accessor :stretch, :tile, :properties
+    # @return [FileReference] image structure
+    attr_accessor :file_reference
 
-    alias path_to_media_file path
-
-    def initialize(path = '')
-      @path = path
+    def initialize(parent: nil)
+      @path = ''
+      @parent = parent
     end
 
-    def self.parse(blip_fill_node)
-      image = ImageFill.new
-      blip_fill_node.xpath('*').each do |blip_fill_node_child|
-        case blip_fill_node_child.name
+    # Parse ImageFill object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ImageFill] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'blip'
-          next unless blip_fill_node_child.attribute('embed')
-          path_to_original_image = OOXMLDocumentObject.get_link_from_rels(blip_fill_node_child.attribute('embed').value)
-          FileUtils.copy(dir + path_to_original_image, OOXMLDocumentObject.media_folder + File.basename(path_to_original_image))
-          image.path = OOXMLDocumentObject.media_folder + File.basename(path_to_original_image)
-          image.properties = ImageProperties.parse(blip_fill_node_child)
-        when 'stretch'
-          image.stretch = Stretching.parse(blip_fill_node_child) # !blip_fill_node_child.xpath('a:fillRect').first.nil?
+          @file_reference = FileReference.new(parent: self).parse(node_child)
         when 'tile'
-          image.tile = Tile.parse(blip_fill_node_child)
+          @tile = Tile.new(OOXMLCoordinates.parse(node_child, x_attr: 'tx', y_attr: 'ty'),
+                           OOXMLCoordinates.parse(node_child, x_attr: 'sx', y_attr: 'sy'),
+                           parent: self).parse(node_child)
         end
       end
-      image
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/colors/presentation_fill/gradient_color/gradient_stop/preset_color.rb

@@ -0,0 +1,20 @@
+module OoxmlParser
+  # Class for working with `a:prstClr` tag
+  class PresetColor < OOXMLDocumentObject
+    # @return [String] value of preset color
+    attr_accessor :value
+
+    # Parse PresetColor object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [PresetColor] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/colors/presentation_fill/gradient_color/gradient_stop.rb

@@ -1,15 +1,28 @@
+require_relative 'gradient_stop/preset_color'
 module OoxmlParser
   class GradientStop < OOXMLDocumentObject
     attr_accessor :position, :color
 
-    def initialize(position)
-      @position = position
-    end
+    # Parse GradientStop object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [GradientStop] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'pos'
+          @position = value.value.to_i / 1_000
+        end
+      end
 
-    def self.parse(gs_node)
-      gradient_stop = GradientStop.new(gs_node.attribute('pos').value.to_i / 1_000)
-      gs_node.xpath('*').each { |color_node| gradient_stop.color = Color.parse_color(color_node) }
-      gradient_stop
+      node.xpath('*').each do |node_child|
+        @color = case node_child.name
+                 when 'prstClr'
+                   PresetColor.new(parent: self).parse(node_child)
+                 else
+                   Color.parse_color(node_child)
+                 end
+      end
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/colors/presentation_fill/gradient_color/linear_gradient.rb

@@ -1,20 +1,21 @@
 module OoxmlParser
-  class LinearGradient
+  # Class for parsing `lin` tags
+  class LinearGradient < OOXMLDocumentObject
     attr_accessor :angle, :scaled
 
-    def initialize(angle = nil, scaled = nil)
-      @angle = angle
-      @scaled = scaled
-    end
-
     # Parse LinearGradient object
     # @param node [Nokogiri::XML:Element] node to parse
     # @return [LinearGradient] result of parsing
-    def self.parse(node)
-      gradient = LinearGradient.new
-      gradient.angle = node.attribute('ang').value.to_f / 100_000.0 if node.attribute('ang')
-      gradient.scaled = node.attribute('scaled').value.to_i if node.attribute('scaled')
-      gradient
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'ang'
+          @angle = value.value.to_f / 100_000.0
+        when 'scaled'
+          @scaled = value.value.to_i
+        end
+      end
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/colors/presentation_fill/gradient_color.rb

@@ -1,34 +1,34 @@
 require_relative 'gradient_color/gradient_stop'
 require_relative 'gradient_color/linear_gradient'
 module OoxmlParser
+  # Class for parsing `gradFill` tags
   class GradientColor
     attr_accessor :gradient_stops, :path
+    # @return [LinearGradient] content of Linear Gradient
+    attr_accessor :linear_gradient
 
-    def initialize(colors = [])
-      @gradient_stops = colors
+    def initialize(parent: nil)
+      @gradient_stops = []
+      @parent = parent
     end
 
-    def self.parse(gradient_fill_node)
-      gradient_color = GradientColor.new
-      gradient_fill_node.xpath('*').each do |gradient_fill_node_child|
-        case gradient_fill_node_child.name
+    # Parse GradientColor object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [GradientColor] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'gsLst'
-          begin
-            gradient_fill_node_child.xpath('//a:gs')
-            namespace = 'a'
-          rescue Nokogiri::XML::XPath::SyntaxError
-            namespace = 'w14'
-          end
-          gradient_fill_node_child.xpath("#{namespace}:gs").each do |gradient_stop_node|
-            gradient_color.gradient_stops << GradientStop.parse(gradient_stop_node)
+          node_child.xpath('*').each do |gradient_stop_node|
+            @gradient_stops << GradientStop.new(parent: self).parse(gradient_stop_node)
           end
         when 'path'
-          gradient_color.path = gradient_fill_node_child.attribute('path').value.to_sym
+          @path = node_child.attribute('path').value.to_sym
         when 'lin'
-          gradient_color.path = LinearGradient.parse(gradient_fill_node_child)
+          @linear_gradient = LinearGradient.new(parent: self).parse(node_child)
         end
       end
-      gradient_color
+      self
     end
   end
 end