ooxml_parser 0.14.1-mingw32

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:fldSimple` tags
+  class FieldSimple < OOXMLDocumentObject
+    # @return [String] instruction value
+    attr_reader :instruction
+    # @return [Array<ParagraphRun>] instruction value
+    attr_reader :runs
+
+    def initialize(parent: nil)
+      @runs = []
+      super
+    end
+
+    # Parse FieldSimple object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [FieldSimple] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'instr'
+          @instruction = value.value.to_s
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'r'
+          @runs << ParagraphRun.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    # @return [True, False] is field simple page numbering
+    def page_numbering?
+      instruction.include?('PAGE')
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for data with FrameProperties
+  class FrameProperties < OOXMLDocumentObject
+    attr_accessor :drop_cap, :lines, :wrap, :vertical_anchor, :horizontal_anchor, :width, :height, :height_rule,
+                  :horizontal_align, :vertical_align, :anchor_lock, :vertical_space, :horizontal_space,
+                  :horizontal_position, :vertical_position
+
+    # Parse FrameProperties
+    # @param node [Nokogiri::XML:Element] with FrameProperties
+    # @return [FrameProperties] parsed result
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'dropCap'
+          @drop_cap = value.value.to_sym
+        when 'lines'
+          @lines = value.value.to_i
+        when 'wrap'
+          @lines = value.value.to_sym
+        when 'vAnchor'
+          @vertical_anchor = value.value.to_sym
+        when 'hAnchor'
+          @horizontal_anchor = value.value.to_sym
+        when 'w'
+          @width = OoxmlSize.new(value.value.to_f)
+        when 'h'
+          @height = OoxmlSize.new(value.value.to_f)
+        when 'hRule'
+          @height_rule = value.value.to_s.sub('atLeast', 'at_least').to_sym
+        when 'xAlign'
+          @horizontal_align = value.value.to_sym
+        when 'yAlign'
+          @vertical_align = value.value.to_sym
+        when 'anchorLock'
+          @anchor_lock = attribute_enabled?(value)
+        when 'vSpace'
+          @vertical_space = OoxmlSize.new(value.value.to_f)
+        when 'hSpace'
+          @horizontal_space = OoxmlSize.new(value.value.to_f)
+        when 'x'
+          @horizontal_position = OoxmlSize.new(value.value.to_f)
+        when 'y'
+          @vertical_position = OoxmlSize.new(value.value.to_f)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for working with Indents data
+  class Indents < OOXMLDocumentObject
+    attr_accessor :first_line_indent, :left_indent, :right_indent, :hanging_indent
+
+    def initialize(first_line_indent = OoxmlSize.new(0),
+                   left_indent = OoxmlSize.new(0),
+                   right_indent = OoxmlSize.new(0),
+                   hanging_indent = OoxmlSize.new(0),
+                   parent: nil)
+      @first_line_indent = first_line_indent
+      @left_indent = left_indent
+      @right_indent = right_indent
+      @hanging_indent = hanging_indent
+      super(parent: parent)
+    end
+
+    alias first_line first_line_indent
+    alias left left_indent
+    alias right right_indent
+    alias hanging hanging_indent
+
+    # Convert to string
+    # @return [String] result of conversion
+    def to_s
+      "first line indent: #{@first_line_indent}, left indent: #{@left_indent}, "\
+        "right indent: #{@right_indent}, hanging indent: #{@hanging_indent}"
+    end
+
+    # Parse Indents
+    # @param [Nokogiri::XML:Element] node with Indents
+    # @return [Indents] value of Indents
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'firstLine'
+          @first_line_indent = OoxmlSize.new(value.value.to_f)
+        when 'left'
+          @left_indent = OoxmlSize.new(value.value.to_f)
+        when 'right'
+          @right_indent = OoxmlSize.new(value.value.to_f)
+        when 'hanging'
+          @hanging_indent = OoxmlSize.new(value.value.to_f)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module OoxmlParser
+  # Class for parsing `w:ins` tag - Inserted Run Content
+  class Inserted < OOXMLDocumentObject
+    # @return [Integer] id of inserted
+    attr_accessor :id
+    # @return [String] author of insert
+    attr_accessor :author
+    # @return [Date] date of insert
+    attr_accessor :date
+    # @return [String] id of user
+    attr_accessor :user_id
+    # @return [ParagraphRun] inserted run
+    attr_accessor :run
+
+    # Parse Inserted object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Inserted] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'id'
+          @id = value.value.to_i
+        when 'author'
+          @author = value.value.to_s
+        when 'date'
+          @date = parse_date(value.value.to_s)
+        when 'oouserid'
+          @user_id = value.value.to_s
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'r'
+          @run = ParagraphRun.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    private
+
+    # Parse date and handle incorrect dates
+    # @param value [Sting] value of date
+    # @return [DateTime, String] if date correct or incorrect
+    def parse_date(value)
+      DateTime.parse(value)
+    rescue ArgumentError
+      warn "Date #{value} is incorrect format"
+      value
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/sdt/sdt_content.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:w:sdtContent` tags
+  class SDTContent < OOXMLDocumentObject
+    # @return [Array <ParagraphRun, Table, ParagraphRun>] list of all elements in SDT
+    attr_reader :elements
+
+    def initialize(parent: nil)
+      @elements = []
+      super
+    end
+
+    # Parse SDTContent object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [SDTContent] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'p'
+          @elements << DocxParagraph.new(parent: self).parse(node_child)
+        when 'r'
+          @elements << ParagraphRun.new(parent: self).parse(node_child)
+        when 'tbl'
+          @elements << Table.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    # @return [Array<DocxParagraphs>] list of paragraphs
+    def paragraphs
+      @elements.select { |obj| obj.is_a?(OoxmlParser::DocxParagraph) }
+    end
+
+    # @return [Array<ParagraphRun>] list of runs
+    def runs
+      @elements.select { |obj| obj.is_a?(OoxmlParser::ParagraphRun) }
+    end
+
+    # @return [Array<Table>] list of tables
+    def tables
+      @elements.select { |obj| obj.is_a?(OoxmlParser::Table) }
+    end
+  end
+end

data/lib/ooxml_parser/docx_parser/docx_data/document_structure/docx_paragraph/sdt/sdt_properties.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:sdtPr` tags
+  class SDTProperties < OOXMLDocumentObject
+    # @return [ValuedChild] alias value
+    attr_reader :alias
+    # @return [ValuedChild] tag value
+    attr_reader :tag
+    # @return [ValuedChild] Locking Setting
+    attr_reader :lock
+
+    # Parse SDTProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [SDTProperties] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'alias'
+          @alias = ValuedChild.new(:string, parent: self).parse(node_child)
+        when 'tag'
+          @tag = ValuedChild.new(:string, parent: self).parse(node_child)
+        when 'lock'
+          @lock = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'sdt/sdt_content'
+require_relative 'sdt/sdt_properties'
+module OoxmlParser
+  # Class for parsing `w:std`
+  class StructuredDocumentTag < OOXMLDocumentObject
+    # @return [SDTContent] content of sdt
+    attr_reader :sdt_content
+    # @return [SDTProperties] properties of sdt
+    attr_reader :properties
+
+    # Parse StructuredDocumentTag object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [StructuredDocumentTag] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'sdtContent'
+          @sdt_content = SDTContent.new(parent: self).parse(node_child)
+        when 'sdtPr'
+          @properties = SDTProperties.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Style Parameter Data
+  class StyleParametres < OOXMLDocumentObject
+    attr_accessor :q_format, :hidden, :name
+
+    def initialize(params = {})
+      @name = params[:name]
+      @q_format = params.fetch(:q_format, false)
+      @hidden = params.fetch(:hidden, false)
+      super(parent: params[:parent])
+    end
+
+    # Parse StyleParametres data
+    # @param [Nokogiri::XML:Element] node with StyleParametres data
+    # @return [StyleParametres] value of Columns data
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'name'
+          @name = node_child.attribute('val').value
+        when 'qFormat'
+          @q_format = option_enabled?(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+# noinspection RubyTooManyInstanceVariablesInspection
+require_relative 'docx_paragraph/bookmark_start'
+require_relative 'docx_paragraph/bookmark_end'
+require_relative 'docx_paragraph/comment_range_end'
+require_relative 'docx_paragraph/comment_range_start'
+require_relative 'docx_paragraph/docx_paragraph_helper'
+require_relative 'docx_paragraph/docx_paragraph_run'
+require_relative 'docx_paragraph/field_simple'
+require_relative 'docx_paragraph/indents'
+require_relative 'docx_paragraph/inserted'
+require_relative 'docx_paragraph/structured_document_tag'
+require_relative 'docx_paragraph/frame_properties'
+require_relative 'docx_paragraph/docx_formula'
+require_relative 'docx_paragraph/style_parametres'
+module OoxmlParser
+  # Class for data of DocxParagraph
+  class DocxParagraph < OOXMLDocumentObject
+    include DocxParagraphHelper
+    attr_accessor :number, :bookmark_start, :bookmark_end, :align, :spacing, :ind, :numbering,
+                  :character_style_array, :page_break, :borders, :keep_lines,
+                  :contextual_spacing, :sector_properties, :page_numbering, :section_break, :style, :keep_next,
+                  :orphan_control
+    # @return [Hyperlink] hyperlink in paragraph
+    attr_reader :hyperlink
+    # @return [ParagraphProperties] Properties of current paragraph
+    attr_accessor :paragraph_properties
+    # @return [Inserted] data inserted by review
+    attr_accessor :inserted
+    # @return [FieldSimple] field simple
+    attr_reader :field_simple
+    # @return [Integer] id of paragraph (for comment)
+    attr_accessor :paragraph_id
+    # @return [MathParagraph] math paragraph
+    attr_reader :math_paragraph
+    # @return [Integer] id of text (for comment)
+    attr_accessor :text_id
+
+    def initialize(parent: nil)
+      @number = 0
+      @bookmark_start = []
+      @bookmark_end = []
+      @align = :left
+      @spacing = Spacing.new
+      @ind = Indents.new
+      @character_style_array = []
+      @page_break = false
+      @borders = Borders.new
+      @keep_lines = false
+      @contextual_spacing = false
+      @page_numbering = false
+      @keep_next = false
+      @orphan_control = true
+      super
+    end
+
+    alias elements character_style_array
+
+    # Constructor for copy of object
+    # @param source [DocxParagraph] original object
+    # @return [void]
+    def initialize_copy(source)
+      super
+      @bookmark_start = source.bookmark_start.clone
+      @bookmark_end = source.bookmark_end.clone
+      @character_style_array = source.character_style_array.clone
+      @spacing = source.spacing.clone
+    end
+
+    # @return [Array<OOXMLDocumentObject>] array of child objects that contains data
+    def nonempty_runs
+      @character_style_array.select do |cur_run|
+        case cur_run
+        when DocxParagraphRun, ParagraphRun
+          !cur_run.empty?
+        when DocxFormula, StructuredDocumentTag, BookmarkStart, BookmarkEnd, CommentRangeStart, CommentRangeEnd
+          true
+        end
+      end
+    end
+
+    alias runs character_style_array
+
+    # @return [True, false] if structure contain any user data
+    def with_data?
+      !nonempty_runs.empty? || paragraph_properties&.section_properties
+    end
+
+    # Compare this object to other
+    # @param other [Object] any other object
+    # @return [True, False] result of comparision
+    def ==(other)
+      ignored_attributes = %i[@number @parent]
+      all_instance_variables = instance_variables
+      significan_attribues = all_instance_variables - ignored_attributes
+      significan_attribues.each do |current_attributes|
+        return false unless instance_variable_get(current_attributes) == other.instance_variable_get(current_attributes)
+      end
+      true
+    end
+
+    # Parse object
+    # @param node [Nokogiri::XML:Node] node with DocxParagraph
+    # @param par_number [Integer] number of paragraph
+    # @param default_character [DocxParagraphRun] style for paragraph
+    # @param parent [OOXMLDocumentObject] parent of run
+    # @return [DocxParagraph] result of parse
+    def parse(node, par_number = 0, default_character = DocxParagraphRun.new, parent: nil)
+      @parent ||= parent
+      default_character_style = default_character.dup
+      character_styles_array = []
+      custom_character_style = default_character_style.dup
+      custom_character_style.parent = self
+      char_number = 0
+      comments = []
+      node.attributes.each do |key, value|
+        case key
+        when 'paraId'
+          @paragraph_id = value.value.to_i
+        when 'textId'
+          @text_id = value.value.to_i
+        end
+      end
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'bookmarkStart'
+          character_styles_array << BookmarkStart.new(parent: self).parse(node_child)
+        when 'bookmarkEnd'
+          character_styles_array << BookmarkEnd.new(parent: self).parse(node_child)
+        when 'pPr'
+          @paragraph_properties = ParagraphProperties.new(parent: self).parse(node_child)
+          parse_paragraph_style(node_child, custom_character_style)
+        when 'commentRangeStart'
+          character_styles_array << CommentRangeStart.new(parent: self).parse(node_child)
+        when 'commentRangeEnd'
+          character_styles_array << CommentRangeEnd.new(parent: self).parse(node_child)
+        when 'fldSimple'
+          @field_simple = FieldSimple.new(parent: self).parse(node_child)
+          @page_numbering = true if field_simple.page_numbering?
+          character_styles_array += field_simple.runs
+        when 'r'
+          character_style = custom_character_style.dup
+          node_child.xpath('w:instrText').each do |insrt_text|
+            @page_numbering = true if insrt_text.text.include?('PAGE')
+          end
+          character_style.parse(node_child, char_number, parent: self)
+          character_style.comments = comments.dup
+          character_styles_array << character_style.dup
+          character_styles_array.last.shape = character_style.shape if character_style.shape
+          char_number += 1
+        when 'hyperlink'
+          @hyperlink = Hyperlink.new(parent: self).parse(node_child)
+          character_style = default_character_style.dup
+          character_style.parent = self
+          if node_child.attribute('id')
+            character_style.link = Hyperlink.new(parent: character_style).parse(node_child)
+          elsif node_child.attribute('anchor')
+            character_style.link = node_child.attribute('anchor').value
+          end
+          node_child.xpath('w:r').each do |r_tag|
+            character_style.parse(r_tag, char_number, parent: self)
+            character_styles_array << character_style.dup
+            char_number += 1
+          end
+          node_child.xpath('w:fldSimple').each do |simple_field|
+            hyperlink_field_simple = FieldSimple.new(parent: self).parse(simple_field)
+            character_styles_array += hyperlink_field_simple.runs
+          end
+        when 'oMathPara'
+          @math_paragraph = MathParagraph.new(parent: self).parse(node_child)
+          character_styles_array << math_paragraph.math
+        when 'ins'
+          @inserted = Inserted.new(parent: self).parse(node_child)
+        when 'sdt'
+          character_styles_array << StructuredDocumentTag.new(parent: self).parse(node_child)
+        end
+      end
+      @number = par_number
+      character_styles_array.last.text = character_styles_array.last.text.rstrip if character_styles_array.last.instance_of?(DocxParagraphRun)
+      @character_style_array = character_styles_array
+      @parent = parent
+      self
+    end
+
+    # Parse style
+    # @param node [Nokogiri::XML:Node] node with style
+    # @param default_char_style [DocxParagraphRun] style for paragraph
+    # @return [DocxParagraph] result of parse
+    def parse_paragraph_style(node, default_char_style = DocxParagraphRun.new(parent: self))
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'pageBreakBefore'
+          @page_break = true if node_child.attribute('val').nil? || node_child.attribute('val').value != 'false'
+        when 'pBdr'
+          @borders = ParagraphBorders.new(parent: self).parse(node_child)
+        when 'keepLines'
+          if node_child.attribute('val').nil?
+            @keep_lines = true
+          else
+            @keep_lines = true unless node_child.attribute('val').value == 'false'
+          end
+        when 'widowControl'
+          @orphan_control = option_enabled?(node_child)
+        when 'keepNext'
+          @keep_next = true
+        when 'contextualSpacing'
+          @contextual_spacing = true
+        when 'pStyle'
+          parse_paragraph_style_xml(node_child.attribute('val').value, default_char_style)
+        when 'ind'
+          @ind = DocumentStructure.default_paragraph_style.ind.dup.parse(node_child)
+        when 'numPr'
+          @numbering = NumberingProperties.new(parent: self).parse(node_child)
+        when 'jc'
+          @align = node_child.attribute('val').value.to_sym unless node_child.attribute('val').nil?
+          @align = :justify if node_child.attribute('val').value == 'both'
+        when 'spacing'
+          @spacing.before = (node_child.attribute('before').value.to_f / 566.9).round(2) unless node_child.attribute('before').nil?
+          @spacing.after = (node_child.attribute('after').value.to_f / 566.9).round(2) unless node_child.attribute('after').nil?
+          @spacing.line_rule = node_child.attribute('lineRule').value.sub('atLeast', 'at_least').to_sym unless node_child.attribute('lineRule').nil?
+          unless node_child.attribute('line').nil?
+            @spacing.line = (@spacing.line_rule == :auto ? (node_child.attribute('line').value.to_f / 240.0).round(2) : (node_child.attribute('line').value.to_f / 566.9).round(2))
+          end
+        when 'sectPr'
+          @sector_properties = PageProperties.new(parent: self).parse(node_child, self, default_char_style)
+          @section_break = case @sector_properties.type
+                           when 'oddPage'
+                             'Odd page'
+                           when 'continuous'
+                             'Current Page'
+                           else
+                             'Next Page'
+                           end
+        end
+      end
+      @parent = parent
+      self
+    end
+
+    # Parse style xml
+    # @param id [String] id of style to parse
+    # @param character_style [DocxParagraphRun] style to parse
+    # @return [void]
+    def parse_paragraph_style_xml(id, character_style)
+      doc = parse_xml("#{OOXMLDocumentObject.path_to_folder}word/styles.xml")
+      doc.search('//w:style').each do |style|
+        next unless style.attribute('styleId').value == id
+
+        style.xpath('w:pPr').each do |p_pr|
+          parse_paragraph_style(p_pr, character_style)
+          @style = StyleParametres.new(parent: self).parse(style)
+        end
+        style.xpath('w:rPr').each do |r_pr|
+          character_style.parse_properties(r_pr)
+        end
+        break
+      end
+    end
+
+    extend Gem::Deprecate
+    deprecate :page_numbering, 'field_simple.page_numbering?', 2020, 1
+
+    # @return [OoxmlParser::StructuredDocumentTag] Return first sdt element
+    def sdt
+      @character_style_array.each do |cur_element|
+        return cur_element if cur_element.is_a?(StructuredDocumentTag)
+      end
+      nil
+    end
+    deprecate :sdt, 'nonempty_runs[i]', 2020, 1
+  end
+end