ooxml_parser 0.1.2 → 0.2.0

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

@@ -1,22 +1,28 @@
 module OoxmlParser
+  # Class for parsing `pattFill` tag
   class PresentationPattern < OOXMLDocumentObject
     attr_accessor :preset, :foreground_color, :background_color
 
-    def initialize(preset = nil)
-      @preset = preset
-    end
+    # Parse PresentationPattern object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [PresentationPattern] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'prst'
+          @preset = value.value.to_sym
+        end
+      end
 
-    def self.parse(pattern_node)
-      pattern = PresentationPattern.new(pattern_node.attribute('prst').value.to_sym)
-      pattern_node.xpath('*').each do |color_node|
+      node.xpath('*').each do |color_node|
         case color_node.name
         when 'fgClr'
-          pattern.foreground_color = Color.parse_color(color_node.xpath('*').first)
+          @foreground_color = Color.parse_color(color_node.xpath('*').first)
         when 'bgClr'
-          pattern.background_color = Color.parse_color(color_node.xpath('*').first)
+          @background_color = Color.parse_color(color_node.xpath('*').first)
         end
       end
-      pattern
+      self
     end
   end
 end

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

@@ -5,29 +5,32 @@ 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
+    # Parse PresentationFill object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [PresentationFill] result of parsing
+    def parse(node)
+      return nil if node.xpath('*').empty?
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'gradFill'
-          fill.type = :gradient
-          fill.color = GradientColor.parse(fill_node)
+          @type = :gradient
+          @color = GradientColor.new(parent: self).parse(node_child)
         when 'solidFill'
-          fill.type = :solid
-          fill.color = Color.parse_color(fill_node.xpath('*').first)
+          @type = :solid
+          @color = Color.parse_color(node_child.xpath('*').first)
         when 'blipFill'
-          fill.type = :image
-          fill.image = ImageFill.parse(fill_node)
+          @type = :image
+          @image = ImageFill.new(parent: self).parse(node_child)
         when 'pattFill'
-          fill.type = :pattern
-          fill.pattern = PresentationPattern.parse(fill_node)
+          @type = :pattern
+          @pattern = PresentationPattern.new(parent: self).parse(node_child)
         when 'noFill'
-          fill.type = :noneColor
-          fill.color = :none
+          @type = :noneColor
+          @color = :none
         end
       end
-      fill
+      return nil if @type.nil?
+      self
     end
   end
 end

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

@@ -1,21 +1,25 @@
 module OoxmlParser
+  # Class for parsing `tile` tag
   class Tile < OOXMLDocumentObject
     attr_accessor :offset, :ratio, :flip, :align
 
-    def initialize(offset = nil, ratio = nil)
+    def initialize(offset = nil, ratio = nil, parent: nil)
       @offset = offset
       @ratio = ratio
+      @parent = parent
     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|
+    # Parse Tile object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Tile] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'algn'
-          tile.align = Alignment.parse(value)
+          @align = value_to_symbol(value)
         end
       end
-      tile
+      self
     end
   end
 end

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

@@ -22,80 +22,20 @@ module OoxmlParser
     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
+      @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

@@ -1,11 +1,18 @@
 module OoxmlParser
+  # Class for parsing `hlinkClick`, `hyperlink` tags
   class Hyperlink < OOXMLDocumentObject
     attr_accessor :url, :tooltip, :coordinates, :id, :highlight_click, :action
+    attr_accessor :action_link
+    attr_accessor :id
 
-    def initialize(link = nil, tooltip = nil, coordinates = nil)
+    def initialize(link = nil,
+                   tooltip = nil,
+                   coordinates = nil,
+                   parent: nil)
       @url = link
       @tooltip = tooltip
       @coordinates = coordinates
+      @parent = parent
     end
 
     alias link url
@@ -13,46 +20,46 @@ module OoxmlParser
     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|
+    # Parse Hyperlink object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Hyperlink] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'location'
-          hyperlink.url = Coordinates.parse_coordinates_from_string(value.value)
+          @url = Coordinates.parse_coordinates_from_string(value.value)
         when 'id'
-          hyperlink.url = OOXMLDocumentObject.get_link_from_rels(on_click_hyperlink_node.attribute('id').value)
+          @id = value.value
+          @url = OOXMLDocumentObject.get_link_from_rels(@id)
         when 'tooltip'
-          hyperlink.tooltip = value.value
+          @tooltip = value.value
         when 'ref'
-          hyperlink.coordinates = Coordinates.parse_coordinates_from_string(value.value)
+          @coordinates = Coordinates.parse_coordinates_from_string(value.value)
+        when 'action'
+          @action_link = value.value
+        when 'highlightClick'
+          @highlight_click = attribute_enabled?(value)
         end
       end
-      action = on_click_hyperlink_node.attribute('action').value unless on_click_hyperlink_node.attribute('action').nil?
-      case action
+      case @action_link
       when 'ppaction://hlinkshowjump?jump=previousslide'
-        hyperlink.action = :previous_slide
+        @action = :previous_slide
       when 'ppaction://hlinkshowjump?jump=nextslide'
-        hyperlink.action = :next_slide
+        @action = :next_slide
       when 'ppaction://hlinkshowjump?jump=firstslide'
-        hyperlink.action = :first_slide
+        @action = :first_slide
       when 'ppaction://hlinkshowjump?jump=lastslide'
-        hyperlink.action = :last_slide
+        @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
+        @action = :slide
+        @url = OOXMLDocumentObject.get_link_from_rels(@id).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)
+        unless @id.nil?
+          @action = :external_link
+          @url = OOXMLDocumentObject.get_link_from_rels(@id)
         end
       end
-      return hyperlink unless on_click_hyperlink_node.attribute('highlightClick')
-      hyperlink.highlight_click = if on_click_hyperlink_node.attribute('highlightClick').value == '1'
-                                    true
-                                  else
-                                    false
-                                  end
-      hyperlink
+      self
     end
   end
 end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+# Module for helper methods for OOXMLDocumentObject
+module OoxmlDocumentObjectHelper
+  private
+
+  VALUE_TO_SYMBOL_HASH = { l: :left,
+                           ctr: :center,
+                           r: :right,
+                           just: :justify,
+                           b: :bottom,
+                           t: :top,
+                           tr: :top_right,
+                           tl: :top_left,
+                           br: :bottom_right,
+                           bl: :bottom_left,
+                           dist: :distributed,
+                           tb: :horizontal,
+                           rl: :rotate_on_90,
+                           lr: :rotate_on_270,
+                           inset: :in,
+                           lu: :left_up,
+                           ru: :right_up,
+                           ld: :left_down,
+                           rd: :right_down,
+                           d: :down,
+                           u: :up,
+                           lg: :large,
+                           med: :medium,
+                           sm: :small,
+                           beneathText: :beneath_text,
+                           pageBottom: :page_bottom,
+                           sectEnd: :section_end,
+                           docEnd: :document_end,
+                           eachSect: :each_section,
+                           eachPage: :each_page,
+                           sngStrike: :single,
+                           dblStrike: :double,
+                           noStrike: :none,
+                           lgDash: :large_dash,
+                           dashDot: :dash_dot,
+                           dashDotDot: :dash_dot_dot,
+                           mediumDashed: :medium_dashed,
+                           mediumDashDot: :medium_dash_dot,
+                           mediumDashDotDot: :medium_dash_dot_dot,
+                           lgDashDot: :large_dash_dot,
+                           lgDashDotDot: :large_dash_dot_dot,
+                           sysDash: :system_dash,
+                           sysDot: :system_dot,
+                           sysDashDot: :system_dash_dot,
+                           sysDashDotDot: :system_dash_dot_dot,
+                           rightMargin: :right_margin,
+                           leftMargin: :left_margin,
+                           bottomMargin: :bottom_margin,
+                           topMargin: :top_margin,
+                           undOvr: :under_over,
+                           subSup: :subscript_superscript,
+                           lrTb: :left_to_right_top_to_bottom,
+                           tbRl: :top_to_bottom_right_to_left,
+                           btLr: :bottom_to_top_left_to_right,
+                           singlelevel: :single_level,
+                           multilevel: :multi_level,
+                           hybridMultilevel: :hybrid_multi_level,
+                           rnd: :round,
+                           sq: :square }.freeze
+
+  # Convert value to human readable symbol
+  # @param [String] value to convert
+  # @return [Symbol]
+  def value_to_symbol(value)
+    symbol = VALUE_TO_SYMBOL_HASH[value.value.to_sym]
+    return value.value.to_sym if symbol.nil?
+    symbol
+  end
+
+  def option_enabled?(node, attribute_name = 'val')
+    return true if node.attributes.empty?
+    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 == 'false' || status == 'off' || status == '0')
+  end
+
+  def attribute_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 root_object
+    tree_object = self
+    tree_object = tree_object.parent until tree_object.parent.nil?
+    tree_object
+  end
+end

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

@@ -1,14 +1,22 @@
+require 'filemagic'
 require 'securerandom'
 require 'nokogiri'
-require 'xmlsimple'
 require 'zip'
+require_relative 'ooxml_document_object/ooxml_document_object_helper'
 
 module OoxmlParser
   class OOXMLDocumentObject
-    DEFAULT_DIRECTORY_FOR_MEDIA = '/tmp'.freeze
+    include OoxmlDocumentObjectHelper
+    # @return [OOXMLDocumentObject] object which hold current object
+    attr_accessor :parent
+
+    def initialize(parent: nil)
+      @parent = parent
+    end
 
     def ==(other)
       instance_variables.each do |current_attribute|
+        next if current_attribute == :@parent
         unless instance_variable_get(current_attribute) == other.instance_variable_get(current_attribute)
           return false
         end
@@ -16,8 +24,12 @@ module OoxmlParser
       true
     end
 
+    # @return [True, false] if structure contain any user data
+    def with_data?
+      true
+    end
+
     class << self
-      attr_accessor :namespace_prefix
       attr_accessor :root_subfolder
       attr_accessor :theme
       attr_accessor :xmls_stack
@@ -26,11 +38,11 @@ module OoxmlParser
       # @param path_to_file [String] file
       # @return [True, False] Check if file is protected by password on open
       def encrypted_file?(path_to_file)
-        file_result = `file "#{path_to_file}"`
+        file_result = FileMagic.new(:mime).file(path_to_file)
         # Support of Encrtypted status in `file` util was introduced in file v5.20
         # but LTS version of ubuntu before 16.04 uses older `file` and it return `Composite Document`
         # https://github.com/file/file/blob/master/ChangeLog#L217
-        if file_result.include?('Encrypted') || file_result.include?('Composite Document File V2 Document, No summary info')
+        if file_result.include?('encrypted') || file_result.include?('Composite Document File V2 Document, No summary info')
           warn("File #{path_to_file} is encrypted. Can't parse it")
           return true
         end
@@ -39,11 +51,10 @@ module OoxmlParser
 
       def copy_file_and_rename_to_zip(path)
         file_name = File.basename(path)
-        tmp_folder = "/tmp/office_open_xml_parser_#{SecureRandom.uuid}"
+        tmp_folder = Dir.mktmpdir('ruby-ooxml-parser')
         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
@@ -72,43 +83,18 @@ module OoxmlParser
       def add_to_xmls_stack(path)
         OOXMLDocumentObject.xmls_stack << if path.include?('..')
                                             "#{File.dirname(OOXMLDocumentObject.xmls_stack.last)}/#{path}"
-                                          else
+                                          elsif path.start_with?(OOXMLDocumentObject.root_subfolder)
                                             path
+                                          else
+                                            OOXMLDocumentObject.root_subfolder + 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)
-        full_path_to_file = OOXMLDocumentObject.path_to_folder + path_to_file
-        unless File.exist?(full_path_to_file)
-          warn "Couldn't find #{full_path_to_file} file on filesystem. Possible problem in original document"
-          return nil
-        end
-        FileUtils.mkdir(folder_to_save_media) unless File.exist?(folder_to_save_media)
-        FileUtils.copy_file(full_path_to_file, path_to_copied_file)
-        path_to_copied_file
+        relationships = Relationships.parse_rels(rels_path)
+        relationships.target_by_id(id)
       end
     end
   end

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

@@ -1,48 +1,96 @@
+require_relative 'paragrpah_properties/numbering_properties'
+require_relative 'paragrpah_properties/paragraph_borders'
+require_relative 'paragrpah_properties/paragraph_spacing'
 require_relative 'paragrpah_properties/spacing'
-require_relative 'paragrpah_properties/numbering'
+require_relative 'paragrpah_properties/tab_list'
+require_relative 'paragrpah_properties/tabs'
 module OoxmlParser
   class ParagraphProperties < OOXMLDocumentObject
-    attr_accessor :align, :numbering, :level, :spacing, :spacing_before, :spacing_after, :indent, :margin_left, :margin_right,
-                  :tabs
+    attr_accessor :align, :numbering, :level, :spacing, :spacing_before, :spacing_after, :indent, :margin_left, :margin_right
+    # @return [Tabs] list of tabs
+    attr_accessor :tabs
+    # @return [RunProperties] properties of run
+    attr_accessor :run_properties
+    # @return [Borders] borders of paragraph
+    attr_accessor :paragraph_borders
+    # @return [True, False] Specifies that the paragraph
+    # (or at least part of it) should be rendered on
+    # the same page as the next paragraph when possible
+    attr_accessor :keep_next
+    # @return [PageProperties] properties of section
+    attr_accessor :section_properties
+    # @return [True, False] This element specifies that any space specified
+    # before or after this paragraph, specified using the spacing element (17.3.1.33),
+    # should not be applied when the preceding and following paragraphs are of
+    # the same paragraph style, affecting the top and bottom spacing respectively
+    attr_accessor :contextual_spacing
+    # @return [Symbol] The alignment or justification to be applied to a paragraph
+    attr_accessor :justification
 
-    def initialize(numbering = Numbering.new)
+    def initialize(numbering = NumberingProperties.new, parent: nil)
       @numbering = numbering
-      @spacing = Spacing.new(0, 0, 1, :multiple)
+      @spacing = Spacing.new(OoxmlSize.new(0),
+                             OoxmlSize.new(0),
+                             OoxmlSize.new(1, :centimeter),
+                             :multiple)
+      @keep_next = false
+      @tabs = []
+      @parent = parent
     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|
+    # Parse ParagraphProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ParagraphProperties] result of parsing
+    def parse(node)
+      @spacing.parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'algn'
-          paragraph_properties.align = Alignment.parse(value)
+          @align = value_to_symbol(value)
         when 'lvl'
-          paragraph_properties.level = value.value.to_i
+          @level = value.value.to_i
         when 'indent'
-          paragraph_properties.indent = (value.value.to_f / 360_000.0).round(2)
+          @indent = OoxmlSize.new(value.value.to_f, :emu)
         when 'marR'
-          paragraph_properties.margin_right = (value.value.to_f / 360_000.0).round(2)
+          @margin_right = OoxmlSize.new(value.value.to_f, :emu)
         when 'marL'
-          paragraph_properties.margin_left = (value.value.to_f / 360_000.0).round(2)
+          @margin_left = OoxmlSize.new(value.value.to_f, :emu)
         end
       end
-      paragraph_props_node.xpath('*').each do |properties_element|
-        case properties_element.name
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'buSzPct'
-          paragraph_properties.numbering.size = properties_element.attribute('val').value
+          @numbering.size = node_child.attribute('val').value
         when 'buFont'
-          paragraph_properties.numbering.font = properties_element.attribute('typeface').value
+          @numbering.font = node_child.attribute('typeface').value
         when 'buChar'
-          paragraph_properties.numbering.symbol = properties_element.attribute('char').value
+          @numbering.symbol = node_child.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 if properties_element.attribute('startAt')
+          @numbering.type = node_child.attribute('type').value.to_sym
+          @numbering.start_at = node_child.attribute('startAt').value if node_child.attribute('startAt')
+        when 'tabs'
+          @tabs = Tabs.new(parent: self).parse(node_child)
         when 'tabLst'
-          paragraph_properties.tabs = ParagraphTab.parse(properties_element)
+          @tabs = TabList.new(parent: self).parse(node_child)
+        when 'ind'
+          @indent = Indents.new(parent: self).parse(node_child)
+        when 'rPr'
+          @run_properties = RunProperties.new(parent: self).parse(node_child)
+        when 'pBdr'
+          @paragraph_borders = ParagraphBorders.new(parent: self).parse(node_child)
+        when 'keepNext'
+          @keep_next = true
+        when 'sectPr'
+          @section_properties = PageProperties.new(parent: self).parse(node_child, @parent, DocxParagraphRun.new)
+        when 'spacing'
+          @spacing = ParagraphSpacing.new(parent: self).parse(node_child)
+        when 'jc'
+          @justification = value_to_symbol(node_child.attribute('val'))
+        when 'contextualSpacing'
+          @contextual_spacing = option_enabled?(node_child)
         end
       end
-      paragraph_properties
+      self
     end
   end
 end

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

@@ -0,0 +1,20 @@
+module OoxmlParser
+  # Class for parsing `w:lang` object
+  class Language < OOXMLDocumentObject
+    # @return [String] value of language
+    attr_accessor :value
+
+    # Parse Language
+    # @param [Nokogiri::XML:Node] node with Language
+    # @return [Language] 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