ooxml_parser 0.14.1-mingw32

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/page_properties/document_grid.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `docGrid` tags
+  class DocumentGrid < OOXMLDocumentObject
+    attr_accessor :type, :line_pitch, :char_space
+
+    # Parse DocumentGrid
+    # @param [Nokogiri::XML:Element] node with DocumentGrid
+    # @return [DocumentGrid] value of DocumentGrid
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'charSpace'
+          @char_space = value.value
+        when 'linePitch'
+          @line_pitch = value.value.to_i
+        when 'type'
+          @type = value.value
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/page_properties/footnote_properties.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `footnotePr` tags
+  class FootnoteProperties < OOXMLDocumentObject
+    # @return [NumberingFormat] format of numbering
+    attr_accessor :numbering_format
+    # @return [ValuedChild] type of numbering restart
+    attr_accessor :numbering_restart
+    # @return [ValuedChild] value of numbering start
+    attr_accessor :numbering_start
+    # @return [ValuedChild] position of footnote
+    attr_accessor :position
+
+    # Parse FootnoteProperties
+    # @param [Nokogiri::XML:Element] node with FootnoteProperties
+    # @return [FootnoteProperties] value of FootnoteProperties
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'numFmt'
+          @numbering_format = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        when 'numRestart'
+          @numbering_restart = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        when 'numStart'
+          @numbering_start = ValuedChild.new(:integer, parent: self).parse(node_child)
+        when 'pos'
+          @position = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/page_properties/note.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class with data of Note
+  class Note < OOXMLDocumentObject
+    attr_accessor :type, :elements, :assigned_to
+
+    def initialize
+      @elements = []
+      super(parent: nil)
+    end
+
+    # Parse note data
+    # @param params [Hash] data to parse
+    # @return [Note] result of parsing
+    def self.parse(params)
+      note = Note.new
+      note.type = params[:type]
+      note.assigned_to = params[:assigned_to]
+      note.parent = params[:parent]
+      doc = note.parse_xml(note.file_path(params[:target]))
+      if note.type.include?('footer')
+        xpath_note = '//w:ftr'
+      elsif note.type.include?('header')
+        xpath_note = '//w:hdr'
+      end
+      doc.search(xpath_note).each do |ftr|
+        number = 0
+        ftr.xpath('*').each do |sub_element|
+          case sub_element.name
+          when 'p'
+            note.elements << params[:default_paragraph].dup.parse(sub_element, number, params[:default_character], parent: note)
+            number += 1
+          when 'tbl'
+            note.elements << Table.new(parent: note).parse(sub_element, number)
+            number += 1
+          end
+        end
+      end
+      note
+    end
+
+    # @param target [String] name of target
+    # @return [String] path to note xml file
+    def file_path(target)
+      file = "#{OOXMLDocumentObject.path_to_folder}word/#{target}"
+      return file if File.exist?(file)
+
+      "#{OOXMLDocumentObject.path_to_folder}#{target}" unless File.exist?(file)
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/page_properties/page_margins.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `pgMar` tags
+  class PageMargins < OOXMLDocumentObject
+    attr_accessor :top, :bottom, :left, :right, :footer, :gutter, :header
+
+    def initialize(params)
+      @top = params[:top]
+      @bottom = params[:bottom]
+      @left = params[:left]
+      @right = params[:right]
+      @header = params[:header]
+      @footer = params[:footer]
+      @gutter = params[:gutter]
+      @parent = params[:parent]
+      super(parent: nil)
+    end
+
+    # Parse BordersProperties
+    # @param [Nokogiri::XML:Element] node with PageMargins
+    # @return [PageMargins] value of PageMargins
+    def parse(node, unit = :dxa)
+      node.attributes.each do |key, value|
+        case key
+        when 'top'
+          @top = OoxmlSize.new(value.value.to_f, unit)
+        when 'left'
+          @left = OoxmlSize.new(value.value.to_f, unit)
+        when 'right'
+          @right = OoxmlSize.new(value.value.to_f, unit)
+        when 'bottom'
+          @bottom = OoxmlSize.new(value.value.to_f, unit)
+        when 'header'
+          @header = OoxmlSize.new(value.value.to_f, unit)
+        when 'footer'
+          @footer = OoxmlSize.new(value.value.to_f, unit)
+        when 'gutter'
+          @gutter = OoxmlSize.new(value.value.to_f, unit)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/page_properties/page_properties.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'document_grid'
+require_relative 'footnote_properties'
+require_relative 'page_size'
+require_relative 'page_margins'
+require_relative 'columns'
+require_relative 'note'
+module OoxmlParser
+  # Class for data of PageProperties
+  class PageProperties < OOXMLDocumentObject
+    attr_accessor :type, :size, :margins, :document_grid, :num_type, :form_prot, :text_direction, :page_borders, :columns,
+                  :notes
+    # @return [FootnoteProperties] properties of footnote
+    attr_accessor :footnote_properties
+    # @return [True, False] Specifies whether the section should have a different header and footer for its first page
+    attr_reader :title_page
+
+    def initialize(parent: nil)
+      @notes = []
+      super
+    end
+
+    # Parse PageProperties data
+    # @param [Nokogiri::XML:Element] node with PageProperties data
+    # @return [PageProperties] value of PageProperties data
+    def parse(node, default_paragraph, default_character)
+      node.xpath('*').each do |pg_size_subnode|
+        case pg_size_subnode.name
+        when 'pgSz'
+          @size = PageSize.new.parse(pg_size_subnode)
+        when 'pgBorders'
+          page_borders = Borders.new
+          page_borders.display = pg_size_subnode.attribute('display').value.to_sym unless pg_size_subnode.attribute('display').nil?
+          page_borders.offset_from = pg_size_subnode.attribute('offsetFrom').value.to_sym unless pg_size_subnode.attribute('offsetFrom').nil?
+          pg_size_subnode.xpath('w:bottom').each do |bottom|
+            page_borders.bottom = BordersProperties.new(parent: page_borders).parse(bottom)
+          end
+          pg_size_subnode.xpath('w:left').each do |left|
+            page_borders.bottom = BordersProperties.new(parent: page_borders).parse(left)
+          end
+          pg_size_subnode.xpath('w:top').each do |top|
+            page_borders.bottom = BordersProperties.new(parent: page_borders).parse(top)
+          end
+          pg_size_subnode.xpath('w:right').each do |right|
+            page_borders.bottom = BordersProperties.new(parent: page_borders).parse(right)
+          end
+          @page_borders = page_borders
+        when 'type'
+          @type = pg_size_subnode.attribute('val').value
+        when 'pgMar'
+          @margins = PageMargins.new(parent: self).parse(pg_size_subnode)
+        when 'pgNumType'
+          @num_type = pg_size_subnode.attribute('fmt').value unless pg_size_subnode.attribute('fmt').nil?
+        when 'formProt'
+          @form_prot = pg_size_subnode.attribute('val').value
+        when 'textDirection'
+          @text_direction = pg_size_subnode.attribute('val').value
+        when 'docGrid'
+          @document_grid = DocumentGrid.new(parent: self).parse(pg_size_subnode)
+        when 'titlePg'
+          @title_page = option_enabled?(pg_size_subnode)
+        when 'cols'
+          @columns = Columns.new.parse(pg_size_subnode)
+        when 'headerReference', 'footerReference'
+          target = OOXMLDocumentObject.get_link_from_rels(pg_size_subnode.attribute('id').value)
+          OOXMLDocumentObject.add_to_xmls_stack("word/#{target}")
+          note = Note.parse(default_paragraph: default_paragraph,
+                            default_character: default_character,
+                            target: target,
+                            assigned_to: pg_size_subnode.attribute('type').value,
+                            type: File.basename(target).sub('.xml', ''),
+                            parent: self)
+          @notes << note
+          OOXMLDocumentObject.xmls_stack.pop
+        when 'footnotePr'
+          @footnote_properties = FootnoteProperties.new(parent: self).parse(pg_size_subnode)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/page_properties/page_size.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for data of PageSize
+  class PageSize < OOXMLDocumentObject
+    attr_accessor :height, :width, :orientation
+
+    def initialize(height = nil, width = nil, orientation = :portrait)
+      @height = height
+      @width = width
+      @orientation = orientation
+      super(parent: nil)
+    end
+
+    # @return [String] convert to string
+    def to_s
+      "Height: #{@height} Width: #{@width} Orientation: #{@orientation}"
+    end
+
+    # @return [True, False] compare dimensions of size, ignoring orientation
+    def same_dimensions?(other)
+      (@height == other.height) && (@width == other.width) ||
+        (@height == other.width) && (@width == other.height)
+    end
+
+    # @return [String] get human format name
+    def name
+      return 'US Letter' if same_dimensions?(PageSize.new(OoxmlSize.new(27.94, :centimeter), OoxmlSize.new(21.59, :centimeter)))
+      return 'US Legal' if same_dimensions?(PageSize.new(OoxmlSize.new(35.56, :centimeter), OoxmlSize.new(21.59, :centimeter)))
+      return 'A4' if same_dimensions?(PageSize.new(OoxmlSize.new(29.7, :centimeter), OoxmlSize.new(21.0, :centimeter)))
+      return 'A5' if same_dimensions?(PageSize.new(OoxmlSize.new(20.99, :centimeter), OoxmlSize.new(14.81, :centimeter)))
+      return 'B5' if same_dimensions?(PageSize.new(OoxmlSize.new(25.01, :centimeter), OoxmlSize.new(17.6, :centimeter)))
+      return 'Envelope #10' if same_dimensions?(PageSize.new(OoxmlSize.new(24.13, :centimeter), OoxmlSize.new(10.48, :centimeter)))
+      return 'Envelope DL' if same_dimensions?(PageSize.new(OoxmlSize.new(22.01, :centimeter), OoxmlSize.new(11.01, :centimeter)))
+      return 'Tabloid' if same_dimensions?(PageSize.new(OoxmlSize.new(43.17, :centimeter), OoxmlSize.new(27.94, :centimeter)))
+      return 'A3' if same_dimensions?(PageSize.new(OoxmlSize.new(42.01, :centimeter), OoxmlSize.new(29.7, :centimeter)))
+      return 'Tabloid Oversize' if same_dimensions?(PageSize.new(OoxmlSize.new(45.71, :centimeter), OoxmlSize.new(30.48, :centimeter)))
+      return 'ROC 16K' if same_dimensions?(PageSize.new(OoxmlSize.new(27.3, :centimeter), OoxmlSize.new(19.68, :centimeter)))
+      return 'Envelope Choukei 3' if same_dimensions?(PageSize.new(OoxmlSize.new(23.49, :centimeter), OoxmlSize.new(11.99, :centimeter)))
+      return 'Super B/A3' if same_dimensions?(PageSize.new(OoxmlSize.new(48.25, :centimeter), OoxmlSize.new(33.02, :centimeter)))
+
+      "Unknown page size: Height #{@height} Width #{@width}"
+    end
+
+    # Parse PageSize
+    # @param [Nokogiri::XML:Element] node with PageSize
+    # @return [PageSize] value of Size
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'orient'
+          @orientation = value.value.to_sym
+        when 'h'
+          @height = OoxmlSize.new(value.value.to_f)
+        when 'w'
+          @width = OoxmlSize.new(value.value.to_f)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/styles/document_defaults/paragraph_properties_default.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:pPrDefault` tags
+  class ParagraphPropertiesDefault < OOXMLDocumentObject
+    # @return [ParagraphProperties] properties of run
+    attr_accessor :paragraph_properties
+
+    # Parse ParagraphPropertiesDefault object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ParagraphPropertiesDefault] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'pPr'
+          @paragraph_properties = ParagraphProperties.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/styles/document_defaults/run_properties_default.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:rPrDefault` tags
+  class RunPropertiesDefault < OOXMLDocumentObject
+    # @return [RunProperties] properties of run
+    attr_accessor :run_properties
+
+    # Parse RunPropertiesDefault object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [RunPropertiesDefault] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'rPr'
+          @run_properties = RunProperties.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/styles/document_defaults.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'document_defaults/paragraph_properties_default'
+require_relative 'document_defaults/run_properties_default'
+module OoxmlParser
+  # Class for parsing `w:docDefaults` tags
+  class DocumentDefaults < OOXMLDocumentObject
+    # @return [RunPropertiesDefault] default properties of run
+    attr_accessor :run_properties_default
+    # @return [RunPropertiesDefault] default properties of run
+    attr_accessor :paragraph_properties_default
+
+    # Parse Bookmark object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Bookmark] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'rPrDefault'
+          @run_properties_default = RunPropertiesDefault.new(parent: self).parse(node_child)
+        when 'pPrDefault'
+          @paragraph_properties_default = ParagraphPropertiesDefault.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/styles.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'styles/document_defaults'
+module OoxmlParser
+  # Class for parsing `styles.xml` file
+  class Styles < OOXMLDocumentObject
+    # @return [DocumentDefaults] defaults of document
+    attr_accessor :document_defaults
+    # @return [Array<DocumentStyle>] array of document styles
+    attr_reader :styles
+
+    def initialize(parent: nil)
+      @styles = []
+      super
+    end
+
+    # Parse styles data
+    # @return [Styles] result of parsing
+    def parse
+      doc = parse_xml("#{OOXMLDocumentObject.path_to_folder}word/styles.xml")
+      doc.xpath('w:styles/*').each do |node_child|
+        case node_child.name
+        when 'docDefaults'
+          @document_defaults = DocumentDefaults.new(parent: self).parse(node_child)
+        when 'style'
+          @styles << DocumentStyle.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+# noinspection RubyInstanceMethodNamingConvention
+require_relative 'document_structure/comments'
+require_relative 'document_structure/comments_extended'
+require_relative 'document_structure/docx_paragraph'
+require_relative 'document_structure/document_background'
+require_relative 'document_structure/document_properties'
+require_relative 'document_structure/document_structure_helpers'
+require_relative 'document_structure/document_style'
+require_relative 'document_structure/header_footer'
+require_relative 'document_structure/numbering'
+require_relative 'document_structure/page_properties/page_properties'
+require_relative 'document_structure/document_settings'
+require_relative 'document_structure/styles'
+module OoxmlParser
+  # Basic class for DocumentStructure
+  class DocumentStructure < CommonDocumentStructure
+    include DocumentStyleHelper
+    include DocumentStructureHelpers
+    # @return [Array<OOXMLDocumentObject>] list of elements
+    attr_accessor :elements
+    # @return [PageProperties] properties of document
+    attr_accessor :page_properties
+    # @return [Note] notes of document
+    attr_accessor :notes
+    # @return [DocumentBackground] background of document
+    attr_accessor :background
+    # @return [DocumentProperties] properties of document
+    attr_accessor :document_properties
+    # @return [Comments] comment of document
+    attr_accessor :comments
+    # @return [Numbering] store numbering data
+    attr_accessor :numbering
+    # @return [Styles] styles of document
+    attr_accessor :styles
+    # @return [PresentationTheme] theme of docx
+    attr_accessor :theme
+    # @return [Relationships] relationships
+    attr_accessor :relationships
+    # @return [DocumentSettings] settings
+    attr_accessor :settings
+    # @return [CommentsDocument] comments of whole document
+    attr_accessor :comments_document
+    # @return [CommentsExtended] extended comments
+    attr_accessor :comments_extended
+
+    def initialize
+      @elements = []
+      @notes = []
+      @document_properties = DocumentProperties.new
+      @comments = []
+      super
+    end
+
+    alias theme_colors theme
+
+    # Compare this object to other
+    # @param other [Object] any other object
+    # @return [True, False] result of comparision
+    def ==(other)
+      @elements == other.elements &&
+        @page_properties == other.page_properties &&
+        @notes == other.notes &&
+        @background == other.background &&
+        @document_properties == other.document_properties &&
+        @comments == other.comments
+    end
+
+    # Get element by it's type
+    # @param location [Symbol] location of object
+    # @param type [Symbol] type of object
+    # @return [OOXMLDocumentObject]
+    def element_by_description(location: :canvas, type: :docx_paragraph)
+      case location
+      when :canvas
+        case type
+        when :table
+          elements[1].rows[0].cells[0].elements
+        when :docx_paragraph, :simple, :paragraph
+          elements
+        when :shape
+          elements[0].nonempty_runs.first.alternate_content.office2007_content.data.text_box
+        else
+          raise 'Wrong location(Need One of ":table", ":paragraph", ":shape")'
+        end
+      when :footer
+        case type
+        when :table
+          note_by_description(:footer1).elements[0].rows[0].cells[0].elements
+        when :docx_paragraph, :simple, :paragraph
+          note_by_description(:footer1).elements
+        when :shape
+          note_by_description(:footer1).elements[0].nonempty_runs.first.alternate_content.office2007_content.data.text_box
+        else
+          raise 'Wrong location(Need One of ":table", ":simple", ":shape")'
+        end
+      when :header
+        case type
+        when :table
+          note_by_description(:header1).elements[0].rows[0].cells[0].elements
+        when :docx_paragraph, :simple, :paragraph
+          note_by_description(:header1).elements
+        when :shape
+          note_by_description(:header1).elements[0].nonempty_runs.first.alternate_content.office2007_content.data.text_box
+        else
+          raise 'Wrong location(Need One of ":table", ":simple", ":shape")'
+        end
+      when :comment
+        comments[0].paragraphs
+      else
+        raise 'Wrong global location(Need One of ":canvas", ":footer", ":header", ":comment")'
+      end
+    end
+
+    # Get note by it's description
+    # @param type [Symbol] note type
+    # @return [Note]
+    def note_by_description(type)
+      notes.each do |note|
+        return note if note.type.to_sym == type
+      end
+      raise 'There isn\'t this type of the note'
+    end
+
+    # Detect numbering type
+    # @param location [Symbol] location of object
+    # @param type [Symbol] type of object
+    # @param paragraph_number [Integer] number of object
+    # @return [Array<String,String>] type of numbering
+    def recognize_numbering(location: :canvas, type: :simple, paragraph_number: 0)
+      elements = element_by_description(location: location, type: type)
+      lvl_text = elements[paragraph_number].numbering.abstruct_numbering.level_list[0].text.value
+      num_format = elements[paragraph_number].numbering.abstruct_numbering.level_list[0].numbering_format.value
+      [num_format, lvl_text]
+    end
+
+    # Return outline type
+    # @param location [Symbol] location of object
+    # @param type [Symbol] type of object
+    # @param levels_count [Integer] count of levels to detect
+    # @return [Array<String,String>] type of outline
+    def outline(location: :canvas, type: :simple, levels_count: 1)
+      elements = element_by_description(location: location, type: type)
+      set = []
+      levels_count.times do |col|
+        set[0] = elements[col].numbering.abstruct_numbering.level_list[col].numbering_format.value
+        set[1] = elements[col].numbering.abstruct_numbering.level_list[col].text.value
+      end
+      set
+    end
+
+    # @return [Array<DocumentStyle>] style of documents
+    def document_styles
+      styles.styles
+    end
+
+    # Parse docx file
+    # @return [DocumentStructure] parsed structure
+    def self.parse
+      doc_structure = DocumentStructure.new
+      doc_structure.content_types = ContentTypes.new(parent: doc_structure).parse
+      OOXMLDocumentObject.root_subfolder = 'word/'
+      OOXMLDocumentObject.xmls_stack = []
+      @comments = []
+      DocumentStructure.default_paragraph_style = DocxParagraph.new
+      DocumentStructure.default_run_style = DocxParagraphRun.new(parent: doc_structure)
+      doc_structure.theme = PresentationTheme.parse('word/theme/theme1.xml')
+      doc_structure.relationships = Relationships.new(parent: self).parse_file("#{OOXMLDocumentObject.path_to_folder}word/_rels/document.xml.rels")
+      doc_structure.parse_styles
+      number = 0
+      OOXMLDocumentObject.add_to_xmls_stack('word/document.xml')
+      doc = doc_structure.parse_xml(OOXMLDocumentObject.current_xml)
+      doc.search('//w:document').each do |document|
+        document.xpath('w:background').each do |background|
+          doc_structure.background = DocumentBackground.new(parent: doc_structure).parse(background)
+        end
+        document.xpath('w:body').each do |body|
+          body.xpath('*').each do |element|
+            case element.name
+            when 'p'
+              child = element.child
+              unless child.nil? && doc_structure.elements.last.instance_of?(Table)
+                paragraph_style = DocumentStructure.default_paragraph_style.dup.parse(element, number, DocumentStructure.default_run_style, parent: doc_structure)
+                number += 1
+                doc_structure.elements << paragraph_style.dup
+              end
+            when 'tbl'
+              table = Table.new(parent: doc_structure).parse(element,
+                                                             number,
+                                                             TableProperties.new)
+              number += 1
+              doc_structure.elements << table
+            when 'sdt'
+              doc_structure.elements << StructuredDocumentTag.new(parent: doc_structure).parse(element)
+            end
+          end
+          body.xpath('w:sectPr').each do |sect_pr|
+            doc_structure.page_properties = PageProperties.new(parent: doc_structure).parse(sect_pr,
+                                                                                            DocumentStructure.default_paragraph_style,
+                                                                                            DocumentStructure.default_run_style)
+            doc_structure.notes = doc_structure.page_properties.notes # keep copy of notes to compatibility with previous docx models
+          end
+        end
+      end
+      OOXMLDocumentObject.xmls_stack.pop
+      doc_structure.document_properties = DocumentProperties.new(parent: doc_structure).parse
+      doc_structure.comments = Comments.new(parent: doc_structure).parse
+      doc_structure.comments_extended = CommentsExtended.new(parent: doc_structure).parse
+      doc_structure.comments_document = Comments.new(parent: doc_structure,
+                                                     file: "#{OOXMLDocumentObject.path_to_folder}word/#{doc_structure.relationships.target_by_type('commentsDocument').first}")
+                                                .parse
+      doc_structure.settings = DocumentSettings.new(parent: doc_structure).parse
+      doc_structure
+    end
+
+    # Parse default style
+    # @return [void]
+    def parse_default_style
+      doc = parse_xml("#{OOXMLDocumentObject.path_to_folder}word/styles.xml")
+      doc.search('//w:style').each do |style|
+        next if style.attribute('default').nil?
+
+        if (style.attribute('default').value == '1' ||
+            style.attribute('default').value == 'on' ||
+            style.attribute('default').value == 'true') &&
+           style.attribute('type').value == 'paragraph'
+          style.xpath('w:pPr').each do |paragraph_pr_tag|
+            DocumentStructure.default_paragraph_style = DocxParagraph.new.parse_paragraph_style(paragraph_pr_tag, DocumentStructure.default_run_style)
+          end
+          style.xpath('w:rPr').each do |character_pr_tag|
+            DocumentStructure.default_run_style.parse_properties(character_pr_tag)
+          end
+        elsif (style.attribute('default').value == '1' ||
+               style.attribute('default').value == 'on' ||
+               style.attribute('default').value == 'true') &&
+              style.attribute('type').value == 'character'
+          style.xpath('w:rPr').each do |character_pr_tag|
+            DocumentStructure.default_run_style.parse_properties(character_pr_tag)
+          end
+        end
+      end
+      DocumentStructure.default_table_paragraph_style = DocumentStructure.default_paragraph_style.dup
+      DocumentStructure.default_table_paragraph_style.spacing = Spacing.new(0, 0, 1, :auto)
+      DocumentStructure.default_table_run_style = DocumentStructure.default_run_style.dup
+      doc.search('//w:style').each do |style|
+        next if style.attribute('default').nil?
+        next unless (style.attribute('default').value == '1' ||
+                     style.attribute('default').value == 'on' ||
+                     style.attribute('default').value == 'true') &&
+                    style.attribute('type').value == 'table'
+
+        style.xpath('w:rPr').each do |table_character_pr_tag|
+          DocumentStructure.default_table_run_style.parse_properties(table_character_pr_tag)
+        end
+      end
+    end
+
+    # Perform parsing styles.xml
+    def parse_styles
+      file = "#{OOXMLDocumentObject.path_to_folder}/word/styles.xml"
+      DocumentStructure.default_paragraph_style = DocxParagraph.new(parent: self)
+      DocumentStructure.default_table_paragraph_style = DocxParagraph.new(parent: self)
+      DocumentStructure.default_run_style = DocxParagraphRun.new(parent: self)
+      DocumentStructure.default_table_run_style = DocxParagraphRun.new(parent: self)
+
+      return unless File.exist?(file)
+
+      doc = parse_xml(file)
+      # TODO: Remove this old way parsing in favor of doc_structure.styles.document_defaults
+      doc.search('//w:docDefaults').each do |doc_defaults|
+        doc_defaults.xpath('w:pPrDefault').each do |p_pr_defaults|
+          DocumentStructure.default_paragraph_style = DocxParagraph.new(parent: self).parse(p_pr_defaults, 0)
+        end
+        doc_defaults.xpath('w:rPrDefault').each do |r_pr_defaults|
+          r_pr_defaults.xpath('w:rPr').each do |r_pr|
+            DocumentStructure.default_run_style = DocxParagraphRun.new(parent: self).parse_properties(r_pr)
+          end
+        end
+      end
+      parse_default_style
+      @numbering = Numbering.new(parent: self).parse
+      @styles = Styles.new(parent: self).parse
+    end
+
+    class << self
+      attr_accessor :default_table_run_style, :default_table_paragraph_style, :default_paragraph_style, :default_run_style
+    end
+  end
+end