ooxml_parser 0.14.1-mingw32

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class Header Footer classes
+  class HeaderFooter < OOXMLDocumentObject
+    # @return [Integer] id of header-footer
+    attr_reader :id
+    # @return [Array<OOXMLDocumentObject>] list of elements if object
+    attr_reader :elements
+    # @return [Symbol] `:header` or `:footer`
+    attr_reader :type
+    # @return [String] suffix for object files
+    attr_reader :path_suffix
+
+    def initialize(type = :header, parent: nil)
+      @type = type
+      @elements = []
+      super(parent: parent)
+    end
+
+    # @return [String] string for search of xpath
+    def xpath_for_search
+      "//w:#{path_suffix}"
+    end
+
+    # @return [String] string with xml path
+    def xml_path
+      "word/#{path_suffix}s.xml"
+    end
+
+    # Parse type and path suffix by node type
+    # @param [Nokogiri::XML:Node] node with HeaderFooter
+    def parse_type(node)
+      case node.name
+      when 'footnoteReference'
+        @path_suffix = 'footnote'
+        @type = :header
+      when 'endnoteReference'
+        @path_suffix = 'endnote'
+        @type = :footer
+      end
+    end
+
+    # Parse HeaderFooter
+    # @param [Nokogiri::XML:Node] node with HeaderFooter
+    # @return [HeaderFooter] result of parsing
+    def parse(node)
+      @id = node.attribute('id').value.to_i
+      parse_type(node)
+      doc = parse_xml(OOXMLDocumentObject.path_to_folder + xml_path)
+      doc.search(xpath_for_search).each do |footnote|
+        next unless footnote.attribute('id').value.to_i == @id
+
+        paragraph_number = 0
+        footnote.xpath('w:p').each do |paragraph|
+          @elements << DocumentStructure.default_paragraph_style.dup.parse(paragraph, paragraph_number, DocumentStructure.default_run_style, parent: self)
+          paragraph_number += 1
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/numbering/abstract_numbering/multilevel_type.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # This element specifies the type of numbering defined by a given abstract numbering type
+  class MultilevelType < OOXMLDocumentObject
+    # @return [String] value of Multilevel Type
+    attr_accessor :value
+
+    # Parse MultilevelType
+    # @param [Nokogiri::XML:Node] node with MultilevelType
+    # @return [MultilevelType] 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/numbering/abstract_numbering/numbering_level/level_justification.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for storing Level Justification, `lvlJc` tag
+  class LevelJustification < OOXMLDocumentObject
+    # @return [String] value of start
+    attr_accessor :value
+
+    # Parse LevelJustification
+    # @param [Nokogiri::XML:Node] node with LevelJustification
+    # @return [LevelJustification] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/numbering/abstract_numbering/numbering_level/level_text.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for storing Level Text, `lvlText` tag
+  class LevelText < OOXMLDocumentObject
+    # @return [String] value of start
+    attr_accessor :value
+
+    # Parse LevelText
+    # @param [Nokogiri::XML:Node] node with LevelText
+    # @return [LevelText] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/numbering/abstract_numbering/numbering_level/numbering_format.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for storing Numbering Format data, `numFmt` tag
+  class NumberingFormat < OOXMLDocumentObject
+    # @return [String] value of start
+    attr_accessor :value
+
+    # Parse NumberingFormat
+    # @param [Nokogiri::XML:Node] node with NumberingFormat
+    # @return [NumberingFormat] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/numbering/abstract_numbering/numbering_level/suffix.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for storing Suffix `w:suff`
+  # This element specifies the content which
+  # shall be added between a given numbering level's text and the text of
+  # every numbered paragraph which references that numbering level.
+  # If this element is omitted, then its value shall be assumed to be tab.
+  # >ECMA-376, 3rd Edition (June, 2011), Fundamentals and Markup Language Reference 17.9.29.
+  class Suffix < OOXMLDocumentObject
+    # @return [String] value of suffix
+    attr_accessor :value
+
+    def initialize(value = :tab,
+                   parent: nil)
+      @value = value
+      super(parent: parent)
+    end
+
+    # Parse Suffix
+    # @param [Nokogiri::XML:Node] node with Suffix
+    # @return [Suffix] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_sym
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/numbering/abstract_numbering/numbering_level.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'numbering_level/level_justification'
+require_relative 'numbering_level/level_text'
+require_relative 'numbering_level/numbering_format'
+require_relative 'numbering_level/suffix'
+module OoxmlParser
+  # This element specifies the appearance and behavior of a numbering level
+  # within a given abstract numbering
+  class NumberingLevel < OOXMLDocumentObject
+    # @return [Integer] level id
+    attr_accessor :ilvl
+    # @return [Start] start data
+    attr_accessor :start
+    # @return [NumberingFormat] numbering format data
+    attr_accessor :numbering_format
+    # @return [LevelText] level text
+    attr_accessor :text
+    # @return [LevelJustification] justification of level
+    attr_accessor :justification
+    # @return [ParagraphProperties] properties of paragraph
+    attr_accessor :paragraph_properties
+    # @return [RunProperties] properties of run
+    attr_accessor :run_properties
+    # @return [Suffix] value of Suffix
+    attr_accessor :suffix
+
+    def initialize(parent: nil)
+      @suffix = Suffix.new(parent: self)
+      super
+    end
+
+    # Parse Numbering Level data
+    # @param [Nokogiri::XML:Element] node with Numbering Level data
+    # @return [NumberingLevel] value of Numbering Level data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'ilvl'
+          @ilvl = value.value.to_f
+        end
+      end
+
+      node.xpath('*').each do |num_level_child|
+        case num_level_child.name
+        when 'start'
+          @start = ValuedChild.new(:integer, parent: self).parse(num_level_child)
+        when 'numFmt'
+          @numbering_format = NumberingFormat.new(parent: self).parse(num_level_child)
+        when 'lvlText'
+          @text = LevelText.new(parent: self).parse(num_level_child)
+        when 'lvlJc'
+          @justification = LevelJustification.new(parent: self).parse(num_level_child)
+        when 'pPr'
+          @paragraph_properties = ParagraphProperties.new(parent: self).parse(num_level_child)
+        when 'rPr'
+          @run_properties = RunProperties.new(parent: self).parse(num_level_child)
+        when 'suff'
+          @suffix = @suffix.parse(num_level_child)
+        end
+      end
+
+      self
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'abstract_numbering/multilevel_type'
+require_relative 'abstract_numbering/numbering_level'
+module OoxmlParser
+  # This element specifies a set of properties which shall dictate the appearance and
+  # behavior of a set of numbered
+  # paragraphs in a WordprocessingML document.
+  class AbstractNumbering < OOXMLDocumentObject
+    # @return [Integer] abstruct numbering id
+    attr_accessor :id
+    # @return [MultilevelType] myltylevel type
+    attr_accessor :multilevel_type
+    # @return [Array, NumberingLevel] numbering level data list
+    attr_accessor :level_list
+
+    def initialize(parent: nil)
+      @level_list = []
+      super
+    end
+
+    # Parse Abstract Numbering data
+    # @param [Nokogiri::XML:Element] node with Abstract Numbering data
+    # @return [AbstractNumbering] value of Abstract Numbering data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'abstractNumId'
+          @id = value.value.to_f
+        end
+      end
+
+      node.xpath('*').each do |numbering_child_node|
+        case numbering_child_node.name
+        when 'multiLevelType'
+          @multilevel_type = MultilevelType.new(parent: self).parse(numbering_child_node)
+        when 'lvl'
+          @level_list << NumberingLevel.new(parent: self).parse(numbering_child_node)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # This element specifies a unique instance of numbering information that can be referenced by zero or more
+  # paragraphs within the parent WordprocessingML document.
+  class NumberingDefinition < OOXMLDocumentObject
+    # @return [Integer] num id
+    attr_accessor :id
+    # @return [ValuedChild] abstract numbering id
+    attr_accessor :abstract_numbering_id
+
+    # Parse NumberingDefinition data
+    # @param [Nokogiri::XML:Element] node with NumberingDefinition data
+    # @return [NumberingDefinition] value of Abstract Numbering data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'numId'
+          @id = value.value.to_f
+        end
+      end
+
+      node.xpath('*').each do |numbering_child_node|
+        case numbering_child_node.name
+        when 'abstractNumId'
+          @abstract_numbering_id = ValuedChild.new(:integer, parent: self).parse(numbering_child_node)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'numbering/abstract_numbering'
+require_relative 'numbering/numbering_definition'
+
+module OoxmlParser
+  # Class for data of Numbering
+  class Numbering < OOXMLDocumentObject
+    # @return [Array, AbstractNumbering] abstract numbering list
+    attr_accessor :abstract_numbering_list
+    # @return [Array, NumberingDefinition] numbering definition list
+    attr_accessor :numbering_definition_list
+
+    def initialize(parent: nil)
+      @abstract_numbering_list = []
+      @numbering_definition_list = []
+      super
+    end
+
+    # Get properties by number id
+    # @param num_id [Integer] index of number id
+    # @return [nil, AbstractNumbering] result of search
+    def properties_by_num_id(num_id)
+      abstract_num_id = nil
+      @numbering_definition_list.each do |num_def|
+        next unless num_id == num_def.id
+
+        abstract_num_id = num_def.abstract_numbering_id.value
+        break
+      end
+      return nil if abstract_num_id.nil?
+
+      @abstract_numbering_list.each do |abstract_num_item|
+        return abstract_num_item if abstract_num_id == abstract_num_item.id
+      end
+    end
+
+    # Parse Numbering data
+    # @return [Numbering] result of parse
+    def parse
+      numbering_xml = "#{OOXMLDocumentObject.path_to_folder}word/numbering.xml"
+      return nil unless File.exist?(numbering_xml)
+
+      node = parse_xml(File.open(numbering_xml))
+      node.xpath('w:numbering/*').each do |numbering_child_node|
+        case numbering_child_node.name
+        when 'abstractNum'
+          @abstract_numbering_list << AbstractNumbering.new(parent: self).parse(numbering_child_node)
+        when 'num'
+          @numbering_definition_list << NumberingDefinition.new(parent: self).parse(numbering_child_node)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:col` object
+  class Column < OOXMLDocumentObject
+    attr_accessor :width, :space, :separator
+
+    # Parse Column
+    # @param [Nokogiri::XML:Node] node with Column
+    # @return [Column] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'w'
+          @width = OoxmlSize.new(value.value.to_f)
+        when 'space'
+          @space = OoxmlSize.new(value.value.to_f)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'columns/column'
+module OoxmlParser
+  # Class for data of Columns
+  class Columns < OOXMLDocumentObject
+    # @return [Integer] count of columns
+    attr_accessor :count
+    # @return [True, False] is columns are equal width
+    attr_accessor :equal_width
+    alias equal_width? equal_width
+    # @return [Array<Column>] list of colujmns
+    attr_accessor :column_array
+    # @return [Boolean] Draw Line Between Columns
+    attr_reader :separator
+    # @return [OoxmlSize] space between columns
+    attr_accessor :space
+
+    def initialize(columns_count = 0)
+      @count = columns_count
+      @column_array = []
+      super(parent: nil)
+    end
+
+    # @return [Array, Column] accessor
+    def [](key)
+      @column_array[key]
+    end
+
+    # Parse Columns data
+    # @param [Nokogiri::XML:Element] node with Columns data
+    # @return [Columns] value of Columns data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'num'
+          @count = value.value.to_i
+        when 'sep'
+          @separator = option_enabled?(node, 'sep')
+        when 'equalWidth'
+          @equal_width = option_enabled?(node, 'equalWidth')
+        when 'space'
+          @space = OoxmlSize.new(value.value.to_f)
+        end
+      end
+
+      node.xpath('*').each do |column_node|
+        case column_node.name
+        when 'col'
+          @column_array << Column.new(parent: self).parse(column_node)
+        end
+      end
+      self
+    end
+  end
+end