ooxml_parser 0.1.1

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

@@ -0,0 +1,32 @@
+require_relative 'tile'
+require_relative 'image_properties'
+require_relative 'image/stretching'
+module OoxmlParser
+  class ImageFill < OOXMLDocumentObject
+    attr_accessor :path, :stretch, :tile, :properties
+
+    alias path_to_media_file path
+
+    def initialize(path = '')
+      @path = path
+    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
+        when 'blip'
+          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?
+        when 'tile'
+          image.tile = Tile.parse(blip_fill_node_child)
+        end
+      end
+      image
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module OoxmlParser
+  class ImageProperties
+    attr_accessor :alpha_modulate_fixed_effect
+
+    def self.parse(blip_properties_node)
+      properties = ImageProperties.new
+      blip_properties_node.xpath('*').each do |property_node|
+        case property_node.name
+        when 'alphaModFix'
+          properties.alpha_modulate_fixed_effect = (property_node.attribute('amt').value.to_f / 1_000.0).round(1)
+        end
+      end
+      properties
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module OoxmlParser
+  class GradientStop < OOXMLDocumentObject
+    attr_accessor :position, :color
+
+    def initialize(position)
+      @position = position
+    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
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module OoxmlParser
+  class LinearGradient
+    attr_accessor :angle, :scaled
+
+    def initialize(angle = nil, scaled = nil)
+      @angle = angle
+      @scaled = scaled
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative 'gradient_color/gradient_stop'
+require_relative 'gradient_color/linear_gradient'
+module OoxmlParser
+  class GradientColor
+    attr_accessor :gradient_stops, :path
+
+    def initialize(colors = [])
+      @gradient_stops = colors
+    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
+        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)
+          end
+        when 'path'
+          gradient_color.path = gradient_fill_node_child.attribute('path').value.to_sym
+        when 'lin'
+          gradient_color.path = LinearGradient.new(gradient_fill_node_child.attribute('ang').value.to_f / 100_000.0,
+                                                   gradient_fill_node_child.attribute('scaled').value.to_i)
+        end
+      end
+      gradient_color
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module OoxmlParser
+  class PresentationPattern < OOXMLDocumentObject
+    attr_accessor :preset, :foreground_color, :background_color
+
+    def initialize(preset = nil)
+      @preset = preset
+    end
+
+    def self.parse(pattern_node)
+      pattern = PresentationPattern.new(pattern_node.attribute('prst').value.to_sym)
+      pattern_node.xpath('*').each do |color_node|
+        case color_node.name
+        when 'fgClr'
+          pattern.foreground_color = Color.parse_color(color_node.xpath('*').first)
+        when 'bgClr'
+          pattern.background_color = Color.parse_color(color_node.xpath('*').first)
+        end
+      end
+      pattern
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative 'image_fill'
+require_relative 'presentation_fill/gradient_color'
+require_relative 'presentation_fill/presentation_pattern'
+module OoxmlParser
+  class PresentationFill < OOXMLDocumentObject
+    attr_accessor :type, :image, :color, :pattern
+
+    def self.parse(parent_fill_node)
+      fill = PresentationFill.new
+      return nil if parent_fill_node.xpath('*').empty?
+      parent_fill_node.xpath('*').each do |fill_node|
+        case fill_node.name
+        when 'gradFill'
+          fill.type = :gradient
+          fill.color = GradientColor.parse(fill_node)
+        when 'solidFill'
+          fill.type = :solid
+          fill.color = Color.parse_color(fill_node.xpath('*').first)
+        when 'blipFill'
+          fill.type = :image
+          fill.image = ImageFill.parse(fill_node)
+        when 'pattFill'
+          fill.type = :pattern
+          fill.pattern = PresentationPattern.parse(fill_node)
+        when 'noFill'
+          fill.type = :noneColor
+          fill.color = :none
+        end
+      end
+      fill
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module OoxmlParser
+  class SchemeColor
+    attr_accessor :value, :properties, :converted_color
+
+    def initialize(value = nil, converted_color = 0)
+      @value = value
+      @converted_color = converted_color
+    end
+
+    def to_s
+      @converted_color.to_s
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# Class for hold ThemeColors list
+module OoxmlParser
+  class ThemeColors
+    class << self
+      # @return [Hash] list of colors
+      attr_accessor :list
+
+      def parse_color_theme(color_theme_node)
+        themes_array = ThemeColors.list.to_a
+        # TODO: if no swap performed - incorrect color parsing. But don't know why it needed
+        themes_array[0], themes_array[1] = themes_array[1], themes_array[0]
+        themes_array[2], themes_array[3] = themes_array[3], themes_array[2]
+        hls = HSLColor.rgb_to_hsl(themes_array[color_theme_node.attribute('theme').value.to_i][1])
+        tint = 0
+        unless color_theme_node.attribute('tint').nil?
+          tint = color_theme_node.attribute('tint').value.to_f
+        end
+        hls.calculate_rgb_with_tint(tint)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module OoxmlParser
+  class Tile < OOXMLDocumentObject
+    attr_accessor :offset, :ratio, :flip, :align
+
+    def initialize(offset = nil, ratio = nil)
+      @offset = offset
+      @ratio = ratio
+    end
+
+    def self.parse(tile_node)
+      tile = Tile.new(OOXMLShift.parse(tile_node, 'tx', 'ty'), OOXMLShift.parse(tile_node, 'sx', 'sy'))
+      tile_node.attributes.each do |key, value|
+        case key
+        when 'algn'
+          tile.align = Alignment.parse(value)
+        end
+      end
+      tile
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module OoxmlParser
+  class Coordinates
+    attr_accessor :row, :column, :list
+
+    def initialize(row = nil, column = nil, list = nil)
+      @row = row.nil? ? row : row.to_i
+      @column = column
+      @list = list
+    end
+
+    class << self
+      # @param [String] string to parse
+      # @return [Coordinates]
+      def parse_coordinates_from_string(string)
+        coordinates = Coordinates.new
+        begin
+          coordinates.list = string.match(/'\w+'/)[0].delete("''")
+        rescue StandardError
+          'Raise Exception'
+        end
+        string = string.split('!').last
+        if coordinates?(string)
+          coordinates.row = string.scan(/[0-9]/).join('').to_i
+          coordinates.column = string.scan(/[A-Z]/).join('')
+        end
+        coordinates
+      end
+
+      def parser_coordinates_range(arguments_string)
+        sheet_name = 'Sheet1'
+
+        if arguments_string.include?('!')
+          sheet_name, arguments_string = arguments_string.split('!')
+        end
+
+        range = arguments_string.split(':')
+
+        difference = []
+        symbols_from = range.first.scan(/[a-zA-z]/).join
+        symbols_to = range.last.scan(/[a-zA-z]/).join
+        digits_from = range.first.scan(/[0-9]/).join
+        digits_to = range.last.scan(/[0-9]/).join
+
+        difference[0] = [symbols_from, symbols_to] unless symbols_from == symbols_to
+        difference[1] = [digits_from, digits_to] unless digits_from == digits_to
+        arguments_array = []
+        case difference.length
+        when 0
+          arguments_array << Coordinates.new(digits_from, symbols_from)
+        when 1
+          (difference.first.first..difference.first.last).each do |symbol|
+            arguments_array << Coordinates.new(digits_from, symbol, sheet_name)
+          end
+        when 2
+          case difference.first
+          when nil
+            (difference.last.first..difference.last.last).each do |digit|
+              arguments_array << Coordinates.new(digit, symbols_from, sheet_name)
+            end
+          else
+            (difference.first.first..difference.first.last).each do |symbol|
+              (difference.last.first..difference.last.last).each do |digit|
+                arguments_array << Coordinates.new(digit, symbol, sheet_name)
+              end
+            end
+          end
+        else
+          raise 'Wrong arguments format'
+        end
+        arguments_array
+      end
+
+      # This method check is argument contains coordinate
+      # @param [String] string
+      def coordinates?(string)
+        !/^([A-Z]+)(\d+)$/.match(string).nil?
+      end
+
+      # @param [String or Fixnum] number to convert
+      # @return [String] column's name
+      # This method takes string like '12' or '45' etc.
+      # and converts into spreadsheet column's name
+      #    StringHelper.get_column_name('12')  #=> "L"
+      #    StringHelper.get_column_name('45')  #=> "AS"
+      #    StringHelper.get_column_name('287')  #=> "KA"
+      def get_column_name(number)
+        (number.to_i > 0 ? ('A'..'Z').to_a[(number.to_i - 1) % 26] + get_column_name((number.to_i - 1) / 26).reverse : '').reverse
+      end
+    end
+
+    # get_column_number -> integer
+    # @return [Integer] number of column
+    # This method takes @column string
+    # and converts into integer
+    def get_column_number
+      @column.reverse.each_char.reduce(0) do |result, char|
+        result + (char.downcase.ord - 96) * (26**@column.reverse.index(char))
+      end
+    end
+
+    # Compares rows of two cells
+    # @param [Coordinates] other_cell other cell coordinates
+    # @return [true, false] true, if row greater, than other row
+    def row_greater_that_other?(other_cell)
+      @row > other_cell.row
+    end
+
+    # Compares columns of two cells
+    # @param [Coordinates] other_cell other cell coordinates
+    # @return [true, false] true, if column greater, than other row
+    def column_greater_that_other?(other_cell)
+      get_column_number > other_cell.get_column_number
+    end
+
+    def to_s
+      "#{@column}#{@row} #{@list ? "list: #{@list}" : ''}"
+    end
+
+    def nil?
+      @column.nil? && @list.nil? && @row.nil?
+    end
+
+    def ==(other)
+      other.is_a?(Coordinates) ? (@row == other.row && @column == other.column) : false
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require_relative 'underline'
+# @author Pavel.Lobashov
+# Class for working with font styles (bold,italic,underlined,strike)
+# noinspection RubyClassMethodNamingConvention
+module OoxmlParser
+  class FontStyle
+    # @return [false,true] is bold?
+    attr_accessor :bold
+    # @return [false,true] is bold?
+    attr_accessor :italic
+    # @return [Underline] underline type
+    attr_accessor :underlined
+    # @return [Strike] strike type
+    attr_accessor :strike
+
+    # Default constructor
+    # @param [true, false] bold is bold?
+    # @param [true, false] italic is italic?
+    # @param [true, false, String] underlined if not false or nil - default Underline, else none
+    # @param [Symbol] strike string with strike type
+    # @return [FontStyle] new font style
+    def initialize(bold = false, italic = false, underlined = Underline.new(:none), strike = :none)
+      @bold = bold
+      @italic = italic
+      @underlined = (underlined == false || underlined.nil?) ? Underline.new(:none) : underlined
+      @strike = strike
+    end
+
+    class << self
+      # Generate all possible combination of styles without parameter stoke (8)
+      # @return [Array] with all FontStyle
+      def generate_all_styles_without_stroke
+        styles_array = []
+        styles_array << FontStyle.new(true, true, Underline.new(:single), :none)
+        styles_array << FontStyle.new(true, true, nil, :none)
+        styles_array << FontStyle.new(true, false, Underline.new(:single), :none)
+        styles_array << FontStyle.new(true, false, nil, :none)
+
+        styles_array << FontStyle.new(false, true, Underline.new(:single), :none)
+        styles_array << FontStyle.new(false, true, nil, :none)
+        styles_array << FontStyle.new(false, false, Underline.new(:single), :none)
+        styles_array << FontStyle.new(false, false, nil, :none)
+      end
+
+      # Generate all possible combination of styles (16)
+      # @return [Array] with all FontStyle
+      def generate_all_styles
+        styles_array = []
+        styles_array << generate_all_styles_without_stroke
+
+        styles_array << FontStyle.new(true, true, Underline.new(:single), :single)
+        styles_array << FontStyle.new(true, true, nil, :single)
+        styles_array << FontStyle.new(true, false, Underline.new(:single), :single)
+        styles_array << FontStyle.new(false, true, Underline.new(:single), :single)
+
+        styles_array << FontStyle.new(true, false, nil, :single)
+        styles_array << FontStyle.new(false, false, Underline.new(:single), :single)
+        styles_array << FontStyle.new(false, true, nil, :single)
+        styles_array << FontStyle.new(false, false, nil, :single)
+        styles_array.flatten
+      end
+    end
+
+    # Default == operator
+    # @return [true, false] true if two same, false if different
+    def ==(other)
+      (@bold == other.bold) && (@italic == other.italic) && (@underlined == other.underlined) && (@strike == other.strike)
+    end
+
+    # Default + operator
+    # @return [FontStyle] the result of overlapping of two styles
+    def +(other)
+      result = FontStyle.new
+      result.bold = (other.bold == @bold) ? @bold : other.bold
+      result.italic = (other.italic == @italic) ? @italic : other.italic
+      result.underlined = (other.underlined == @underlined) ? @underlined : other.underlined
+      result.strike = (other.strike == @strike) ? @strike : other.strike
+      result
+    end
+
+    # Default to_s operator
+    # @return [String] with text representation
+    def to_s
+      "Bold: #{@bold}, Italic: #{@italic}, Underlined: #{@underlined}, Strike: #{@strike}"
+    end
+
+    def copy
+      return dup if underlined.nil?
+      other = FontStyle.new
+      instance_variables.each do |variable|
+        case variable
+        when @underlined
+          other.instance_variable_set(variable, underlined.copy)
+        else
+          other.instance_variable_set(variable, instance_variable_get(variable))
+        end
+      end
+      other
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module OoxmlParser
+  class Hyperlink < OOXMLDocumentObject
+    attr_accessor :url, :tooltip, :coordinates, :id, :highlight_click, :action
+
+    def initialize(link = nil, tooltip = nil, coordinates = nil)
+      @url = link
+      @tooltip = tooltip
+      @coordinates = coordinates
+    end
+
+    alias link url
+    alias link_to url
+    alias link= url=
+    alias link_to= url=
+
+    def self.parse(on_click_hyperlink_node)
+      hyperlink = Hyperlink.new
+      on_click_hyperlink_node.attributes.each do |key, value|
+        case key
+        when 'location'
+          hyperlink.url = Coordinates.parse_coordinates_from_string(value.value)
+        when 'id'
+          hyperlink.url = OOXMLDocumentObject.get_link_from_rels(on_click_hyperlink_node.attribute('id').value)
+        when 'tooltip'
+          hyperlink.tooltip = value.value
+        when 'ref'
+          hyperlink.coordinates = Coordinates.parse_coordinates_from_string(value.value)
+        end
+      end
+      action = on_click_hyperlink_node.attribute('action').value unless on_click_hyperlink_node.attribute('action').nil?
+      case action
+      when 'ppaction://hlinkshowjump?jump=previousslide'
+        hyperlink.action = :previous_slide
+      when 'ppaction://hlinkshowjump?jump=nextslide'
+        hyperlink.action = :next_slide
+      when 'ppaction://hlinkshowjump?jump=firstslide'
+        hyperlink.action = :first_slide
+      when 'ppaction://hlinkshowjump?jump=lastslide'
+        hyperlink.action = :last_slide
+      when 'ppaction://hlinksldjump'
+        hyperlink.action = :slide
+        hyperlink.link_to = OOXMLDocumentObject.get_link_from_rels(on_click_hyperlink_node.attribute('id').value).scan(/\d+/).join('').to_i
+      else
+        unless on_click_hyperlink_node.attribute('id').nil?
+          hyperlink.action = :external_link
+          hyperlink.link_to = OOXMLDocumentObject.get_link_from_rels(on_click_hyperlink_node.attribute('id').value)
+        end
+      end
+      hyperlink.highlight_click = StringHelper.to_bool(on_click_hyperlink_node.attribute('highlightClick').value) unless on_click_hyperlink_node.attribute('highlightClick').nil?
+      hyperlink
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'securerandom'
+require 'nokogiri'
+require 'xmlsimple'
+require 'zip'
+
+module OoxmlParser
+  class OOXMLDocumentObject
+    DEFAULT_DIRECTORY_FOR_MEDIA = '/tmp'.freeze
+
+    class << self
+      attr_accessor :namespace_prefix
+      attr_accessor :root_subfolder
+      attr_accessor :theme
+      attr_accessor :xmls_stack
+      attr_accessor :path_to_folder
+
+      def copy_file_and_rename_to_zip(path)
+        file_name = File.basename(path)
+        tmp_folder = "/tmp/office_open_xml_parser_#{SecureRandom.uuid}"
+        file_path = "#{tmp_folder}/#{file_name}"
+        FileUtils.rm_rf(tmp_folder) if File.directory?(tmp_folder)
+        FileUtils.mkdir_p(tmp_folder)
+        path = "#{Dir.pwd}/#{path}" unless path[0] == '/'
+        raise "Cannot find file by path #{path}" unless File.exist?(path)
+        FileUtils.cp path, tmp_folder
+        file_path
+      end
+
+      def unzip_file(path_to_file, destination)
+        Zip.warn_invalid_date = false
+        Zip::File.open(path_to_file) do |zip_file|
+          raise LoadError, "There is no files in zip #{path_to_file}" if zip_file.entries.empty?
+          zip_file.each do |file|
+            file_path = File.join(destination, file.name)
+            FileUtils.mkdir_p(File.dirname(file_path))
+            zip_file.extract(file, file_path) unless File.exist?(file_path)
+          end
+        end
+      end
+
+      def dir
+        OOXMLDocumentObject.path_to_folder + File.dirname(OOXMLDocumentObject.xmls_stack.last) + '/'
+      end
+
+      def current_xml
+        OOXMLDocumentObject.path_to_folder + OOXMLDocumentObject.xmls_stack.last
+      end
+
+      def add_to_xmls_stack(path)
+        OOXMLDocumentObject.xmls_stack << if path.include?('..')
+                                            "#{File.dirname(OOXMLDocumentObject.xmls_stack.last)}/#{path}"
+                                          else
+                                            path
+                                          end
+      end
+
+      def get_link_from_rels(id)
+        rels_path = dir + "_rels/#{File.basename(OOXMLDocumentObject.xmls_stack.last)}.rels"
+        raise LoadError, "Cannot find .rels file by path: #{rels_path}" unless File.exist?(rels_path)
+        relationships = XmlSimple.xml_in(File.open(rels_path))
+        relationships['Relationship'].each { |relationship| return relationship['Target'] if id == relationship['Id'] }
+      end
+
+      def media_folder
+        path = "#{DEFAULT_DIRECTORY_FOR_MEDIA}/media_from_#{@file_name}"
+        FileUtils.mkdir(path) unless File.exist?(path)
+        path + '/'
+      end
+
+      def option_enabled?(node, attribute_name = 'val')
+        return true if node.to_s == '1'
+        return false if node.to_s == '0'
+        return false if node.attribute(attribute_name).nil?
+        status = node.attribute(attribute_name).value
+        status == 'true' || status == 'on' || status == '1'
+      end
+
+      def copy_media_file(path_to_file)
+        folder_to_save_media = '/tmp/media_from_' + File.basename(OOXMLDocumentObject.path_to_folder)
+        path_to_copied_file = folder_to_save_media + '/' + File.basename(path_to_file)
+        FileUtils.mkdir(folder_to_save_media) unless File.exist?(folder_to_save_media)
+        FileUtils.copy_file(OOXMLDocumentObject.path_to_folder + path_to_file, path_to_copied_file)
+        path_to_copied_file
+      end
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragraph_properties.rb

@@ -0,0 +1,48 @@
+require_relative 'paragrpah_properties/spacing'
+require_relative 'paragrpah_properties/numbering'
+module OoxmlParser
+  class ParagraphProperties < OOXMLDocumentObject
+    attr_accessor :align, :numbering, :level, :spacing, :spacing_before, :spacing_after, :indent, :margin_left, :margin_right,
+                  :tabs
+
+    def initialize(numbering = Numbering.new)
+      @numbering = numbering
+      @spacing = Spacing.new(0, 0, 1, :multiple)
+    end
+
+    def self.parse(paragraph_props_node)
+      paragraph_properties = ParagraphProperties.new
+      paragraph_properties.spacing.parse(paragraph_props_node)
+      paragraph_props_node.attributes.each do |key, value|
+        case key
+        when 'algn'
+          paragraph_properties.align = Alignment.parse(value)
+        when 'lvl'
+          paragraph_properties.level = value.value.to_i
+        when 'indent'
+          paragraph_properties.indent = (value.value.to_f / 360_000.0).round(2)
+        when 'marR'
+          paragraph_properties.margin_right = (value.value.to_f / 360_000.0).round(2)
+        when 'marL'
+          paragraph_properties.margin_left = (value.value.to_f / 360_000.0).round(2)
+        end
+      end
+      paragraph_props_node.xpath('*').each do |properties_element|
+        case properties_element.name
+        when 'buSzPct'
+          paragraph_properties.numbering.size = properties_element.attribute('val').value
+        when 'buFont'
+          paragraph_properties.numbering.font = properties_element.attribute('typeface').value
+        when 'buChar'
+          paragraph_properties.numbering.symbol = properties_element.attribute('char').value
+        when 'buAutoNum'
+          paragraph_properties.numbering.type = properties_element.attribute('type').value.to_sym
+          paragraph_properties.numbering.start_at = properties_element.attribute('startAt').value
+        when 'tabLst'
+          paragraph_properties.tabs = ParagraphTab.parse(properties_element)
+        end
+      end
+      paragraph_properties
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragraph_run/run_properties/outline.rb

@@ -0,0 +1,23 @@
+# Class for parsing Run Outline properties
+module OoxmlParser
+  class Outline < OOXMLDocumentObject
+    attr_accessor :width
+    attr_accessor :color_scheme
+
+    def initialize
+      @width = 0
+    end
+
+    def self.parse(node)
+      outline = Outline.new
+      node.attributes.each do |key, value|
+        case key
+        when 'w'
+          outline.width = (value.value.to_f / 12_699.3).round(2)
+        end
+      end
+      outline.color_scheme = DocxColorScheme.parse(node)
+      outline
+    end
+  end
+end