ooxml_parser 0.1.2 → 0.2.0

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

@@ -0,0 +1,65 @@
+require_relative 'numbering_level/level_justification'
+require_relative 'numbering_level/level_text'
+require_relative 'numbering_level/numbering_format'
+require_relative 'numbering_level/start'
+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)
+      @parent = parent
+      @suffix = Suffix.new(parent: self)
+    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 = Start.new(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,42 @@
+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 = []
+      @parent = parent
+    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/abstract_numbering_id.rb

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

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

@@ -0,0 +1,31 @@
+require_relative 'numbering_definition/abstract_numbering_id'
+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 [AbstractNumberingId] 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 = AbstractNumberingId.new(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,45 @@
+require_relative 'numbering/abstract_numbering'
+require_relative 'numbering/numbering_definition'
+
+module OoxmlParser
+  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 = []
+      @parent = parent
+    end
+
+    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
+
+    def parse
+      numbering_xml = OOXMLDocumentObject.path_to_folder + 'word/numbering.xml'
+      return nil unless File.exist?(numbering_xml)
+      node = Nokogiri::XML(File.open(numbering_xml), 'r:UTF-8')
+      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

@@ -1,10 +1,21 @@
 module OoxmlParser
-  class Column
+  # Class for parsing `w:col` object
+  class Column < OOXMLDocumentObject
     attr_accessor :width, :space, :separator
 
-    def initialize(width = nil, space = nil)
-      @width = width
-      @space = space
+    # 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

@@ -6,8 +6,10 @@ module OoxmlParser
     attr_accessor :equal_width
     alias equal_width? equal_width
     attr_accessor :column_array
+    # @return [OoxmlSize] space between columns
+    attr_accessor :space
 
-    def initialize(columns_count)
+    def initialize(columns_count = 0)
       @count = columns_count
       @column_array = []
     end
@@ -19,19 +21,28 @@ module OoxmlParser
 
     # Parse Columns data
     # @param [Nokogiri::XML:Element] node with Columns data
-    # @return [DocumentGrid] value of Columns data
-    def self.parse(columns_grid)
-      columns_count = 1
-      columns_count = columns_grid.attribute('num').value.to_i unless columns_grid.attribute('num').nil?
-      columns = Columns.new(columns_count)
-      columns.separator = columns_grid.attribute('sep').value unless columns_grid.attribute('sep').nil?
-      columns.equal_width = option_enabled?(columns_grid, 'equalWidth') unless columns_grid.attribute('equalWidth').nil?
-      columns_grid.xpath('w:col').each do |col|
-        width = (col.attribute('w').value.to_f / OoxmlParser.configuration.units_delimiter).round(2)
-        space = (col.attribute('space').value.to_f / OoxmlParser.configuration.units_delimiter).round(2) unless col.attribute('space').nil?
-        columns.column_array << Column.new(width, space)
+    # @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 = value.value
+        when 'equalWidth'
+          @equal_width = option_enabled?(node, 'equalWidth')
+        when 'space'
+          @space = OoxmlSize.new(value.value.to_f)
+        end
       end
-      columns
+
+      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

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

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

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

@@ -0,0 +1,32 @@
+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

@@ -2,16 +2,15 @@ module OoxmlParser
   class Note < OOXMLDocumentObject
     attr_accessor :type, :elements, :assigned_to
 
-    def initialize(type = nil, elements = [], assigned_to = nil)
-      @type = type
-      @elements = elements
-      @assigned_to = assigned_to
+    def initialize
+      @elements = []
     end
 
-    def self.parse(default_paragraph, default_character, target, assigned_to, type)
+    def self.parse(default_paragraph, default_character, target, assigned_to, type, parent: nil)
       note = Note.new
       note.type = type
       note.assigned_to = assigned_to
+      note.parent = parent
       doc = Nokogiri::XML(File.open(OOXMLDocumentObject.path_to_folder + "word/#{target}"))
       if type.include?('footer')
         xpath_note = '//w:ftr'
@@ -24,19 +23,19 @@ module OoxmlParser
         number = 0
         ftr.xpath('*').each do |sub_element|
           if sub_element.name == 'p'
-            note.elements << DocxParagraph.parse(sub_element, number, default_paragraph, default_character)
+            note.elements << default_paragraph.copy.parse(sub_element, number, default_character, parent: note)
             number += 1
           elsif sub_element.name == 'tbl'
-            note.elements << Table.parse(sub_element, number)
+            note.elements << Table.new(parent: note).parse(sub_element, number)
             number += 1
           elsif sub_element.name == 'std'
             sub_element.xpath('w:p').each do |p|
-              note.elements << DocxParagraph.parse(p, number, default_paragraph, default_character)
+              note.elements << default_paragraph.copy.parse(p, number, default_character)
               number += 1
             end
             sub_element.xpath('w:sdtContent').each do |sdt_content|
               sdt_content.xpath('w:p').each do |p|
-                note.elements << DocxParagraph.parse(p, number, default_paragraph, default_character)
+                note.elements << default_paragraph.copy.parse(p, number, default_character)
                 number += 1
               end
             end

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

@@ -1,8 +1,16 @@
 module OoxmlParser
-  class PageMargins
+  # Class for parsing `pgMar` tags
+  class PageMargins < OOXMLDocumentObject
     attr_accessor :top, :bottom, :left, :right, :footer, :gutter, :header
 
-    def initialize(top: nil, bottom: nil, left: nil, right: nil, header: nil, footer: nil, gutter: nil)
+    def initialize(top: nil,
+                   bottom: nil,
+                   left: nil,
+                   right: nil,
+                   header: nil,
+                   footer: nil,
+                   gutter: nil,
+                   parent: nil)
       @top = top
       @bottom = bottom
       @left = left
@@ -10,33 +18,32 @@ module OoxmlParser
       @header = header
       @footer = footer
       @gutter = gutter
-    end
-
-    def ==(other)
-      other.class == PageMargins &&
-        @top == other.top &&
-        @bottom == other.bottom &&
-        @left == other.left &&
-        @right == other.right &&
-        @footer == other.footer &&
-        @header == other.header &&
-        @gutter == other.gutter
+      @parent = parent
     end
 
     # Parse BordersProperties
     # @param [Nokogiri::XML:Element] node with PageMargins
     # @return [PageMargins] value of PageMargins
-    def self.parse(node)
-      margins = PageMargins.new
-      # TODO: implement and understand, why 566.929, but not `unit_delimiter`
-      margins.top = (node.attribute('top').value.to_f / 566.929).round(2)
-      margins.left = (node.attribute('left').value.to_f / 566.929).round(2)
-      margins.right = (node.attribute('right').value.to_f / 566.929).round(2)
-      margins.bottom = (node.attribute('bottom').value.to_f / 566.929).round(2)
-      margins.header = (node.attribute('header').value.to_f / 566.929).round(2) unless node.attribute('header').nil?
-      margins.footer = (node.attribute('footer').value.to_f / 566.929).round(2) unless node.attribute('footer').nil?
-      margins.gutter = (node.attribute('gutter').value.to_f / 566.929).round(2)
-      margins
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'top'
+          @top = OoxmlSize.new(value.value.to_f)
+        when 'left'
+          @left = OoxmlSize.new(value.value.to_f)
+        when 'right'
+          @right = OoxmlSize.new(value.value.to_f)
+        when 'bottom'
+          @bottom = OoxmlSize.new(value.value.to_f)
+        when 'header'
+          @header = OoxmlSize.new(value.value.to_f)
+        when 'footer'
+          @footer = OoxmlSize.new(value.value.to_f)
+        when 'gutter'
+          @gutter = OoxmlSize.new(value.value.to_f)
+        end
+      end
+      self
     end
   end
 end

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

@@ -1,5 +1,6 @@
 require_relative 'document_grid'
-require_relative 'size'
+require_relative 'footnote_properties'
+require_relative 'page_size'
 require_relative 'page_margins'
 require_relative 'columns'
 require_relative 'note'
@@ -7,75 +8,71 @@ module OoxmlParser
   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
 
-    def initialize
-      @type = nil
-      @size = nil
-      @margins = nil
-      @document_grid = nil
-      @num_type = nil
-      @form_prot = nil
-      @text_direction = nil
-      @columns = nil
+    def initialize(parent: nil)
       @notes = []
+      @parent = parent
     end
 
-    def self.parse(sect_pr, default_paragraph, default_character)
-      page_properties = PageProperties.new
-      sect_pr.xpath('w:pgSz').each do |pg_sz|
-        page_properties.size = Size.parse(pg_sz)
-      end
-      sect_pr.xpath('w:pgBorders').each do |pg_borders|
-        page_borders = Borders.new
-        unless pg_borders.attribute('display').nil?
-          page_borders.display = pg_borders.attribute('display').value.to_sym
-        end
-        unless pg_borders.attribute('offsetFrom').nil?
-          page_borders.offset_from = pg_borders.attribute('offsetFrom').value.to_sym
-        end
-        pg_borders.xpath('w:bottom').each do |bottom|
-          page_borders.bottom = BordersProperties.parse(bottom)
-        end
-        pg_borders.xpath('w:left').each do |left|
-          page_borders.bottom = BordersProperties.parse(left)
+    # 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
+          unless pg_size_subnode.attribute('display').nil?
+            page_borders.display = pg_size_subnode.attribute('display').value.to_sym
+          end
+          unless pg_size_subnode.attribute('offsetFrom').nil?
+            page_borders.offset_from = pg_size_subnode.attribute('offsetFrom').value.to_sym
+          end
+          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 '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_character, target,
+                            pg_size_subnode.attribute('type').value,
+                            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
-        pg_borders.xpath('w:top').each do |top|
-          page_borders.bottom = BordersProperties.parse(top)
-        end
-        pg_borders.xpath('w:right').each do |right|
-          page_borders.bottom = BordersProperties.parse(right)
-        end
-        page_properties.page_borders = page_borders
-      end
-      sect_pr.xpath('w:type').each do |type|
-        page_properties.type = type.attribute('val').value
-      end
-      sect_pr.xpath('w:pgMar').each do |pg_mar|
-        page_properties.margins = PageMargins.parse(pg_mar)
-      end
-      sect_pr.xpath('w:pgNumType').each do |pg_num_type|
-        page_properties.num_type = pg_num_type.attribute('fmt').value unless pg_num_type.attribute('fmt').nil?
-      end
-      sect_pr.xpath('w:formProt').each do |form_prot|
-        page_properties.form_prot = form_prot.attribute('val').value
-      end
-      sect_pr.xpath('w:textDirection').each do |text_direction|
-        page_properties.text_direction = text_direction.attribute('val').value
-      end
-      sect_pr.xpath('w:docGrid').each do |doc_grid|
-        page_properties.document_grid = DocumentGrid.parse(doc_grid)
-      end
-      sect_pr.xpath('w:cols').each do |columns_grid|
-        page_properties.columns = Columns.parse(columns_grid)
-      end
-      sect_pr.xpath('w:headerReference', 'w:footerReference').each do |doc_edge_reference|
-        target = OOXMLDocumentObject.get_link_from_rels(doc_edge_reference.attribute('id').value)
-        OOXMLDocumentObject.add_to_xmls_stack("word/#{target}")
-        note = Note.parse(default_paragraph, default_character, target, doc_edge_reference.attribute('type').value, File.basename(target).sub('.xml', ''))
-        page_properties.notes << note
-        OOXMLDocumentObject.xmls_stack.pop
       end
-      page_properties
+      self
     end
   end
 end