ooxml_parser 0.1.2 → 0.2.0

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_formula/nary/nary_properties/nary_limit_location.rb

@@ -0,0 +1,20 @@
+module OoxmlParser
+  # Class for parsing `m:limLoc` object
+  class NaryLimitLocation < OOXMLDocumentObject
+    # @return [String] value of limit location
+    attr_accessor :value
+
+    # Parse NaryLimitLocation
+    # @param [Nokogiri::XML:Node] node with NaryLimitLocation
+    # @return [NaryLimitLocation] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value_to_symbol(value)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_formula/nary/nary_properties.rb

@@ -0,0 +1,26 @@
+require_relative 'nary_properties/nary_grow'
+require_relative 'nary_properties/nary_limit_location'
+module OoxmlParser
+  # Class for parsing `m:naryPr` object
+  class NaryProperties < OOXMLDocumentObject
+    # @return [NaryGrow] grow value
+    attr_accessor :grow
+    # @return [NaryLimitLocation] nary limit location
+    attr_accessor :limit_location
+
+    # Parse NaryProperties
+    # @param [Nokogiri::XML:Node] node with NaryProperties
+    # @return [NaryProperties] result of parsing
+    def parse(node)
+      node.xpath('*').each do |nary_pr_child|
+        case nary_pr_child.name
+        when 'grow'
+          @grow = NaryGrow.new(parent: self).parse(nary_pr_child)
+        when 'limLoc'
+          @limit_location = NaryLimitLocation.new(parent: self).parse(nary_pr_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_formula/nary.rb

@@ -0,0 +1,31 @@
+require_relative 'nary/nary_properties'
+module OoxmlParser
+  # Class for parsing `m:nary` object
+  class Nary < OOXMLDocumentObject
+    # @return [DocxFormula] top value
+    attr_accessor :top_value
+
+    # @return [DocxFormula] bottom_value
+    attr_accessor :bottom_value
+
+    # @return [NaryProperties] properties of nary
+    attr_accessor :properties
+
+    # Parse Nary
+    # @param [Nokogiri::XML:Node] node with Nary
+    # @return [Nary] result of parsing
+    def parse(node)
+      node.xpath('*').each do |nary_child_node|
+        case nary_child_node.name
+        when 'sub'
+          @bottom_value = DocxFormula.new(parent: self).parse(nary_child_node)
+        when 'sup'
+          @top_value = DocxFormula.new(parent: self).parse(nary_child_node)
+        when 'naryPr'
+          @properties = NaryProperties.new(parent: self).parse(nary_child_node)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_formula/pre_sub_superscript.rb

@@ -0,0 +1,27 @@
+module OoxmlParser
+  # Class for parsing `m:sPre` object
+  class PreSubSuperscript < OOXMLDocumentObject
+    # @return [DocxFormula] top value
+    attr_accessor :top_value
+
+    # @return [DocxFormula] bottom_value
+    attr_accessor :bottom_value
+
+    # @return [DocxFormula] base
+    attr_accessor :base
+
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'sub'
+          @bottom_value = DocxFormula.new(parent: self).parse(node_child)
+        when 'sup'
+          @top_value = DocxFormula.new(parent: self).parse(node_child)
+        when 'e'
+          @base = DocxFormula.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_formula/radical.rb

@@ -1,11 +1,25 @@
-# Radical Data
 module OoxmlParser
-  class Radical
+  # Class for `rad` data
+  class Radical < OOXMLDocumentObject
     attr_accessor :degree, :value
 
-    def initialize(degree = 2, value = nil)
-      @degree = degree
-      @value = value
+    def initialize(parent: nil)
+      @degree = 2
+      @parent = parent
+    end
+
+    # Parse Function object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Function] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'deg'
+          @degree = DocxFormula.new(parent: self).parse(node_child)
+        end
+      end
+      @value = DocxFormula.new(parent: self).parse(node)
+      self
     end
   end
 end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_formula.rb

@@ -1,5 +1,5 @@
-# Class for containg DocxFormulas
 require_relative 'docx_formula/accent'
+require_relative 'docx_formula/argument_properties'
 require_relative 'docx_formula/bar'
 require_relative 'docx_formula/box'
 require_relative 'docx_formula/delimeter'
@@ -7,197 +7,66 @@ require_relative 'docx_formula/fraction'
 require_relative 'docx_formula/function'
 require_relative 'docx_formula/group_char'
 require_relative 'docx_formula/limit'
+require_relative 'docx_formula/math_run'
 require_relative 'docx_formula/matrix'
-require_relative 'docx_formula/operator'
+require_relative 'docx_formula/nary'
 require_relative 'docx_formula/index'
+require_relative 'docx_formula/pre_sub_superscript'
 require_relative 'docx_formula/radical'
 module OoxmlParser
-  class DocxFormula
-    attr_accessor :elements
+  # Class for formula data
+  class DocxFormula < OOXMLDocumentObject
+    attr_accessor :formula_run
+    # @return [ArgumentProperties] properties of arguments
+    attr_accessor :argument_properties
 
-    def initialize(elements = [])
-      @elements = elements
+    def initialize(parent: nil)
+      @formula_run = []
+      @parent = parent
     end
 
-    def self.parse(element)
-      formula = DocxFormula.new
-      element.xpath('*').each do |sub_element|
-        if sub_element.name == 'r'
-          formula.elements << parse_math_character(sub_element)
-        elsif sub_element.name == 'box'
-          box = Box.new
-          box.element = parse_math_character(sub_element)
-          formula.elements << box
-        elsif sub_element.name == 'borderBox'
-          box = Box.new
-          box.borders = true
-          box.element = parse_math_character(sub_element)
-          formula.elements << box
-        elsif sub_element.name == 'func'
-          function = Function.new
-          sub_element.xpath('m:fName').each do |f_name|
-            function.name = DocxFormula.parse(f_name)
-          end
-          function.argument = DocxFormula.parse(sub_element)
-          formula.elements << function
-        elsif sub_element.name == 'rad'
-          radical = Radical.new
-          radical.value = DocxFormula.parse(sub_element)
-          sub_element.xpath('m:deg').each do |deg|
-            radical.degree = DocxFormula.parse(deg)
-            radical.degree = 2 if radical.degree.nil?
-          end
-          formula.elements << radical
-        elsif sub_element.name == 'e'
-          formula.elements << DocxFormula.parse(sub_element)
-        elsif sub_element.name == 'eqArr'
-          sub_element.xpath('m:e').each do |e|
-            formula.elements << DocxFormula.parse(e)
-          end
-        elsif sub_element.name == 'd'
-          delimeter = Delimiter.new
-          sub_element.xpath('m:dPr').each do |d_pr|
-            d_pr.xpath('m:begChr').each do |beg_chr|
-              delimeter.begin_character = beg_chr.attribute('val').value
-            end
-            d_pr.xpath('m:endChr').each do |end_chr|
-              delimeter.end_character = end_chr.attribute('val').value
-            end
-          end
-          delimeter.value = DocxFormula.parse(sub_element)
-          formula.elements << delimeter
-        elsif sub_element.name == 'nary'
-          operator = Operator.new
-          sub_element.xpath('m:naryPr').each do |nary_pr|
-            nary_pr.xpath('m:chr').each do |chr|
-              operator.operator = chr.attribute('val').value
-            end
-          end
-          sub_element.xpath('m:sub').each do |sub|
-            operator.bottom_value = DocxFormula.parse(sub)
-          end
-          sub_element.xpath('m:sup').each do |sup|
-            operator.top_value = DocxFormula.parse(sup)
-          end
-          operator.value = DocxFormula.parse(sub_element)
-          formula.elements << operator
-        elsif sub_element.name == 'sSubSup'
-          index = Index.new
-          index.value = DocxFormula.parse(sub_element)
-          sub_element.xpath('m:sup').each do |sup|
-            index.top_index = DocxFormula.parse(sup)
-          end
-          sub_element.xpath('m:sub').each do |sub|
-            index.top_index = DocxFormula.parse(sub)
-          end
-          formula.elements << index
-        elsif sub_element.name == 'sSup'
-          index = Index.new
-          index.value = DocxFormula.parse(sub_element)
-          sub_element.xpath('m:sup').each do |sup|
-            index.top_index = DocxFormula.parse(sup)
-          end
-          formula.elements << index
-        elsif sub_element.name == 'sSub'
-          index = Index.new
-          index.value = DocxFormula.parse(sub_element)
-          sub_element.xpath('m:sub').each do |sub|
-            index.top_index = DocxFormula.parse(sub)
-          end
-          formula.elements << index
-        elsif sub_element.name == 'f'
-          fraction = Fraction.new
-          sub_element.xpath('m:num').each do |num|
-            fraction.numerator = DocxFormula.parse(num)
-          end
-          sub_element.xpath('m:den').each do |den|
-            fraction.denominator = DocxFormula.parse(den)
-            formula.elements << fraction
-          end
-        elsif sub_element.name == 'm'
-          matrix = Matrix.new
-          columns_count = 1
-          j = 0
-          sub_element.xpath('m:mPr').each do |m_pr|
-            m_pr.xpath('m:mcs').each do |mcs|
-              mcs.xpath('m:mc').each do |mc|
-                mc.xpath('m:mcPr').each do |mc_pr|
-                  mc_pr.xpath('m:count').each do |count|
-                    columns_count = count.attribute('val').value
-                  end
-                end
-              end
-            end
-          end
-          sub_element.xpath('m:mr').each do |mr|
-            i = 0
-            matrix.rows << MatrixRow.new(columns_count.to_i)
-            mr.xpath('m:e').each do |e|
-              matrix.rows[j].columns[i] = DocxFormula.parse(e)
-              i += 1
-            end
-            j += 1
-          end
-          formula.elements << matrix
-        elsif sub_element.name == 'bar'
-          bar = Bar.new
-          sub_element.xpath('m:barPr').each do |bar_pr|
-            bar_pr.xpath('m:pos').each do |pos|
-              bar.position = pos.attribute('val').value
-            end
-          end
-          bar.element = DocxFormula.parse(sub_element)
-          formula.elements << bar
-        elsif sub_element.name == 'acc'
-          accent = Accent.new
-          sub_element.xpath('m:accPr').each do |acc_pr|
-            acc_pr.xpath('m:chr').each do |chr|
-              accent.symbol = chr.attribute('val').value
-            end
-          end
-          accent.element = DocxFormula.parse(sub_element)
-          formula.elements << accent
-        elsif sub_element.name == 'groupChr'
-          group_char = GroupChar.new
-          sub_element.xpath('m:groupChrPr').each do |group_chr_pr|
-            group_chr_pr.xpath('m:chr').each do |chr|
-              group_char.symbol = chr.attribute('val').value
-            end
-            group_chr_pr.xpath('m:pos').each do |pos|
-              group_char.position = pos.attribute('val').value
-            end
-            group_chr_pr.xpath('vertJc').each do |vert_jc|
-              group_char.vertical_align = vert_jc.attribute('val').value
-            end
-          end
-          group_char.element = DocxFormula.parse(sub_element)
-          formula.elements << group_char
-        elsif sub_element.name == 'limUpp'
-          limit = Limit.new
-          limit.type = 'Upper'
-          limit.element = DocxFormula.parse(sub_element)
-          sub_element.xpath('m:lim').each do |lim|
-            limit.limit = DocxFormula.parse(lim)
-          end
-          formula.elements << limit
-        elsif sub_element.name == 'limLow'
-          limit = Limit.new
-          limit.type = 'Lower'
-          limit.element = DocxFormula.parse(sub_element)
-          sub_element.xpath('m:lim').each do |lim|
-            limit.limit = DocxFormula.parse(lim)
-          end
-          formula.elements << limit
+    # Parse DocxFormula object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [DocxFormula] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'r'
+          @formula_run << MathRun.new(parent: self).parse(node_child)
+        when 'box', 'borderBox'
+          @formula_run << Box.new(parent: self).parse(node_child)
+        when 'func'
+          @formula_run << Function.new(parent: self).parse(node_child)
+        when 'rad'
+          @formula_run << Radical.new(parent: self).parse(node_child)
+        when 'e', 'eqArr'
+          @formula_run << DocxFormula.new(parent: self).parse(node_child)
+        when 'nary'
+          @formula_run << Nary.new(parent: self).parse(node_child)
+        when 'd'
+          @formula_run << Delimiter.new(parent: self).parse(node_child)
+        when 'sSubSup', 'sSup', 'sSub'
+          @formula_run << Index.new(parent: self).parse(node_child)
+        when 'f'
+          @formula_run << Fraction.new(parent: self).parse(node_child)
+        when 'm'
+          @formula_run << Matrix.new(parent: self).parse(node_child)
+        when 'bar'
+          @formula_run << Bar.new(parent: self).parse(node_child)
+        when 'acc'
+          @formula_run << Accent.new(parent: self).parse(node_child)
+        when 'groupChr'
+          @formula_run << GroupChar.new(parent: self).parse(node_child)
+        when 'argPr'
+          @argument_properties = ArgumentProperties.new(parent: self).parse(node_child)
+        when 'sPre'
+          @formula_run << PreSubSuperscript.new(parent: self).parse(node_child)
+        when 'limUpp', 'limLow'
+          @formula_run << Limit.new(parent: self).parse(node_child)
         end
       end
-      return nil if formula.elements.empty?
-      formula
-    end
-
-    def self.parse_math_character(element)
-      element.xpath('m:t').each do |t|
-        return t.text
-      end
+      return nil if @formula_run.empty?
+      self
     end
   end
 end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_paragraph_run/docx_paragraph_run_helpers.rb

@@ -0,0 +1,89 @@
+module OoxmlParser
+  module DocxParagraphRunHelpers
+    def parse_properties(node, _default_character = DocumentStructure.default_run_style)
+      self.font_style = FontStyle.new
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'rFonts'
+          node_child.attributes.each do |font_attribute, value|
+            case font_attribute
+            when 'asciiTheme'
+              self.font = DocxParagraphRun.parse_font_by_theme(node_child.attribute('asciiTheme').value)
+            when 'ascii'
+              self.font = value.value
+              break
+            end
+          end
+        when 'sz'
+          self.size = node_child.attribute('val').value.to_i / 2.0
+        when 'highlight'
+          self.highlight = node_child.attribute('val').value
+        when 'vertAlign'
+          self.vertical_align = node_child.attribute('val').value.to_sym
+        when 'effect'
+          self.effect = node_child.attribute('val').value
+        when 'position'
+          self.position = (node_child.attribute('val').value.to_f / (28.0 + 1.0 / 3.0) / 2.0).round(1)
+        when 'em'
+          self.em = node_child.attribute('val').value
+        when 'spacing'
+          self.spacing = (node_child.attribute('val').value.to_f / 566.9).round(1)
+        when 'textFill'
+          self.text_fill = TextFill.new(parent: self).parse(node_child)
+        when 'textOutline'
+          self.text_outline = TextOutline.new(parent: self).parse(node_child)
+        when 'bCs', 'b'
+          font_style.bold = option_enabled?(node_child)
+        when 'iCs', 'i'
+          font_style.italic = option_enabled?(node_child)
+        when 'caps'
+          self.caps = :caps
+        when 'smallCaps'
+          self.caps = :small_caps if option_enabled?(node_child)
+        when 'color'
+          node_child.attributes.each do |key, value|
+            case key
+            when 'val'
+              self.font_color = Color.new(parent: self).parse_hex_string(value.value)
+            when 'themeColor'
+              unless ThemeColors.list[value.value.to_sym].nil?
+                break if value.value == 'text2' || value.value == 'background2' || value.value.include?('accent') # Don't know why. Just works
+                self.font_color = ThemeColors.list[value.value.to_sym].dup
+              end
+            when 'themeShade'
+              font_color.calculate_with_shade!(value.value.hex.to_f / 255.0)
+            when 'themeTint'
+              font_color.calculate_with_tint!(1.0 - (value.value.hex.to_f / 255.0))
+            end
+          end
+        when 'shd'
+          self.background_color = node_child.attribute('fill').value
+          unless node_child.attribute('fill').value == 'auto' || node_child.attribute('fill').value == '' || node_child.attribute('fill').value == 'null'
+            self.background_color = Color.new(parent: self).parse_hex_string(node_child.attribute('fill').value)
+          end
+        when 'uCs'
+          font_style.underlined = Underline.new
+          if option_enabled?(node_child)
+            font_style.underlined.style = node_child.attribute('val').value
+            unless node_child.attribute('color').nil?
+              font_style.underlined.color = Color.new(parent: font_style.underlined).parse_hex_string(node_child.attribute('color').value)
+            end
+          end
+        when 'u'
+          font_style.underlined = Underline.new
+          if option_enabled?(node_child)
+            font_style.underlined.style = node_child.attribute('val').value
+            unless node_child.attribute('color').nil?
+              font_style.underlined.color = Color.new(parent: font_style.underlined).parse_hex_string(node_child.attribute('color').value)
+            end
+          end
+        when 'strike'
+          font_style.strike = :single if option_enabled?(node_child)
+        when 'dstrike'
+          font_style.strike = :double if option_enabled?(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_paragraph_run/object/ole_object.rb

@@ -0,0 +1,23 @@
+module OoxmlParser
+  # Class for parsing `o:OLEObject` tags
+  class OleObject < OOXMLDocumentObject
+    # @return [String] id of ole_object
+    attr_accessor :id
+    # @return [FileReference] data referenced in object
+    attr_accessor :file_reference
+
+    # Parse OleObject object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [OleObject] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'id'
+          @id = value.value
+        end
+      end
+      @file_reference = FileReference.new(parent: self).parse(node)
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_paragraph_run/object.rb

@@ -0,0 +1,21 @@
+require_relative 'object/ole_object'
+module OoxmlParser
+  # Class for parsing `w:object`
+  class RunObject < OOXMLDocumentObject
+    # @return [OleObject] ole object of object
+    attr_accessor :ole_object
+
+    # Parse RunObject object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [RunObject] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'OLEObject'
+          @ole_object = OleObject.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_paragraph_run/shape.rb

@@ -1,39 +1,46 @@
 require_relative 'shape/shape_properties'
 module OoxmlParser
+  # Class for parsing `shape`, `rect`, `oval` tags
   class Shape < OOXMLDocumentObject
     attr_accessor :type, :properties, :elements
 
-    def initialize(type = nil, properties = ShapeProperties.new, elements = [])
+    def initialize(type = nil,
+                   properties = ShapeProperties.new,
+                   elements = [],
+                   parent: nil)
       @type = type
       @properties = properties
       @elements = elements
+      @parent = parent
     end
 
-    def self.parse(shape_node, type)
-      shape = Shape.new
-      shape.type = type
-      shape_node.attribute('style').value.to_s.split(';').each do |property|
+    # Parse Shape object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Shape] result of parsing
+    def parse(node, type)
+      @type = type
+      node.attribute('style').value.to_s.split(';').each do |property|
         if property.include?('margin-top')
-          shape.properties.margins.top = property.split(':').last
+          @properties.margins.top = property.split(':').last
         elsif property.include?('margin-left')
-          shape.properties.margins.left = property.split(':').last
+          @properties.margins.left = property.split(':').last
         elsif property.include?('margin-right')
-          shape.properties.margins.right = property.split(':').last
+          @properties.margins.right = property.split(':').last
         elsif property.include?('width')
-          shape.properties.size.width = property.split(':').last
+          @properties.size.width = property.split(':').last
         elsif property.include?('height')
-          shape.properties.size.height = property.split(':').last
+          @properties.size.height = property.split(':').last
         elsif property.include?('z-index')
-          shape.properties.z_index = property.split(':').last
+          @properties.z_index = property.split(':').last
         elsif property.include?('position')
-          shape.properties.position = property.split(':').last
+          @properties.position = property.split(':').last
         end
       end
-      shape.properties.fill_color = Color.from_int16(shape_node.attribute('fillcolor').value.to_s.sub('#', '').split(' ').first) unless shape_node.attribute('fillcolor').nil?
-      shape.properties.stroke.weight = shape_node.attribute('strokeweight').value unless shape_node.attribute('strokeweight').nil?
-      shape.properties.stroke.color = Color.from_int16(shape_node.attribute('strokecolor').value.to_s.sub('#', '').split(' ').first) unless shape_node.attribute('strokecolor').nil?
-      shape.elements = TextBox.parse_list(shape_node.xpath('v:textbox').first) unless shape_node.xpath('v:textbox').first.nil?
-      shape
+      @properties.fill_color = Color.new(parent: self).parse_hex_string(node.attribute('fillcolor').value.to_s.sub('#', '').split(' ').first) unless node.attribute('fillcolor').nil?
+      @properties.stroke.weight = node.attribute('strokeweight').value unless node.attribute('strokeweight').nil?
+      @properties.stroke.color = Color.new(parent: self).parse_hex_string(node.attribute('strokecolor').value.to_s.sub('#', '').split(' ').first) unless node.attribute('strokecolor').nil?
+      @elements = TextBox.parse_list(node.xpath('v:textbox').first, parent: self) unless node.xpath('v:textbox').first.nil?
+      self
     end
   end
 end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_paragraph_run/text_fill.rb

@@ -1,13 +1,14 @@
-# Class for parsing text outline and its properties
 module OoxmlParser
+  # Data about `textFill` object
   class TextFill < OOXMLDocumentObject
     attr_accessor :color_scheme
 
-    def self.parse(node)
-      text_fill = TextFill.new
-
-      text_fill.color_scheme = DocxColorScheme.parse(node)
-      text_fill
+    # Parse TextFill object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TextFill] result of parsing
+    def parse(node)
+      @color_scheme = DocxColorScheme.new(parent: self).parse(node)
+      self
     end
   end
 end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/docx_paragraph_run/text_outline.rb

@@ -1,22 +1,27 @@
 # Class for parsing text outline and its properties
 module OoxmlParser
+  # Class for parsing `w:textOutline`
   class TextOutline < OOXMLDocumentObject
     attr_accessor :width, :color_scheme
 
-    def initialize
-      @width = 0
+    def initialize(parent: nil)
+      @width = OoxmlSize.new(0)
       @color_scheme = :none
+      @parent = parent
     end
 
-    def self.parse(node)
-      text_outline = TextOutline.new
-
-      unless node.attribute('w').nil?
-        text_outline.width = (node.attribute('w').value.to_f / 12_699).round(2)
+    # Parse TextOutline object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TextOutline] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'w'
+          @width = OoxmlSize.new(value.value.to_f, :emu)
+        end
       end
-
-      text_outline.color_scheme = DocxColorScheme.parse(node)
-      text_outline
+      @color_scheme = DocxColorScheme.new(parent: self).parse(node)
+      self
     end
   end
 end