ooxml_parser 0.14.1-mingw32

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:sz` object
+  class Size < OOXMLDocumentObject
+    # @return [Integer] value of size
+    attr_accessor :value
+
+    # Parse Size
+    # @param [Nokogiri::XML:Node] node with Size
+    # @return [Size] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_f
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative 'run_properties/outline'
+require_relative 'run_properties/position'
+require_relative 'run_properties/size'
+require_relative 'run_properties/run_spacing'
+require_relative 'run_properties/run_style'
+require_relative 'run_properties/shade'
+module OoxmlParser
+  # Data about `rPr` object
+  class RunProperties < OOXMLDocumentObject
+    # @return [FontStyle] font style of run
+    attr_accessor :font_style
+    # @return [Color, DocxColorScheme] color of run
+    attr_reader :font_color
+    # @return [OoxmlSize] space size
+    attr_reader :space
+    # @return [string] name of font
+    attr_reader :font_name
+    # @return [Float] font size
+    attr_reader :font_size
+    # @return [Symbol] baseline of run
+    attr_reader :baseline
+    # @return [Hyperlink] hyperlink of run
+    attr_reader :hyperlink
+    # @return [Symbol] caps data
+    attr_reader :caps
+    # @return [Symbol] vertical align data
+    attr_reader :vertical_align
+    # @return [Outline] outline data
+    attr_reader :outline
+    # @return [True, False] is text shadow
+    attr_reader :shadow
+    # @return [True, False] is text emboss
+    attr_reader :emboss
+    # @return [True, False] is text vanish
+    attr_reader :vanish
+    # @return [True, False] is text rtl
+    attr_reader :rtl
+    # @return [Size] get run size
+    attr_accessor :size
+    # @return [RunSpacing] get run spacing
+    attr_accessor :spacing
+    # @return [RunSpacing] get color
+    attr_accessor :color
+    # @return [ValuedChild] language property
+    attr_reader :language
+    # @return [Position] position property
+    attr_accessor :position
+    # @return [Shade] shade property
+    attr_accessor :shade
+    # @return [RunStyle] run style
+    attr_accessor :run_style
+
+    def initialize(params = {})
+      @font_name = params.fetch(:font_name, '')
+      @font_style = FontStyle.new
+      @baseline = :baseline
+      super(parent: params[:parent])
+    end
+
+    # Parse RunProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [RunProperties] result of parsing
+    def parse(node)
+      @font_style = root_object.default_font_style.dup
+      node.attributes.each do |key, value|
+        case key
+        when 'sz'
+          @font_size = value.value.to_f / 100.0
+        when 'spc'
+          @space = OoxmlSize.new(value.value.to_f, :one_100th_point)
+        when 'b'
+          @font_style.bold = option_enabled?(node, 'b')
+        when 'i'
+          @font_style.italic = option_enabled?(node, 'i')
+        when 'u'
+          @font_style.underlined = Underline.new(parent: self).parse(value.value)
+        when 'strike'
+          @font_style.strike = value_to_symbol(value)
+        when 'baseline'
+          case value.value.to_i
+          when -25_000, -30_000
+            @baseline = :subscript
+          when 30_000
+            @baseline = :superscript
+          when 0
+            @baseline = :baseline
+          end
+        when 'cap'
+          @caps = value.value.to_sym
+        end
+      end
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'sz'
+          @size = Size.new.parse(node_child)
+        when 'shadow'
+          @shadow = option_enabled?(node_child)
+        when 'emboss'
+          @emboss = option_enabled?(node_child)
+        when 'vanish'
+          @vanish = option_enabled?(node_child)
+        when 'rtl'
+          @rtl = option_enabled?(node_child)
+        when 'spacing'
+          @spacing = RunSpacing.new(parent: self).parse(node_child)
+        when 'color'
+          @color = OoxmlColor.new(parent: self).parse(node_child)
+        when 'solidFill'
+          @font_color = Color.new(parent: self).parse_color(node_child.xpath('*').first)
+        when 'latin'
+          @font_name = node_child.attribute('typeface').value
+        when 'b'
+          @font_style.bold = option_enabled?(node_child)
+        when 'i'
+          @font_style.italic = option_enabled?(node_child, 'i')
+        when 'u'
+          @font_style.underlined = Underline.new(:single)
+        when 'vertAlign'
+          @vertical_align = node_child.attribute('val').value.to_sym
+        when 'rFont'
+          @font_name = node_child.attribute('val').value
+        when 'rFonts'
+          @font_name = node_child.attribute('ascii').value if node_child.attribute('ascii')
+        when 'strike'
+          @font_style.strike = option_enabled?(node_child)
+        when 'hlinkClick'
+          @hyperlink = Hyperlink.new(parent: self).parse(node_child)
+        when 'ln'
+          @outline = Outline.new(parent: self).parse(node_child)
+        when 'lang'
+          @language = ValuedChild.new(:string, parent: self).parse(node_child)
+        when 'position'
+          @position = Position.new(parent: self).parse(node_child)
+        when 'shd'
+          @shade = Shade.new(parent: self).parse(node_child)
+        when 'rStyle'
+          @run_style = RunStyle.new(parent: self).parse(node_child)
+        end
+      end
+      @font_color = DocxColorScheme.new(parent: self).parse(node)
+      @font_name = root_object.default_font_typeface if @font_name.empty?
+      @font_size ||= root_object.default_font_size
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragraph_run/text.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `t` tags
+  class Text < OOXMLDocumentObject
+    # @return [Symbol] space values
+    attr_reader :space
+    # @return [String] text value
+    attr_reader :text
+
+    # Parse Text object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Text] result of parsing
+    def parse(node)
+      @text = node.text
+      node.attributes.each do |key, value|
+        case key
+        when 'space'
+          @space = value_to_symbol(value)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'paragraph_run/run_properties'
+require_relative 'paragraph_run/text'
+module OoxmlParser
+  # Class for parsing `r` tags
+  class ParagraphRun < OOXMLDocumentObject
+    attr_accessor :properties, :text
+    # @return [Text] text of run
+    attr_reader :t
+    # @return [Tab] tab of paragraph
+    attr_reader :tab
+
+    def initialize(properties = RunProperties.new, text = '', parent: nil)
+      @properties = properties
+      @text = text
+      super(parent: parent)
+    end
+
+    # Parse ParagraphRun object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ParagraphRun] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'rPr'
+          @properties = RunProperties.new(parent: self).parse(node_child)
+        when 't'
+          @t = Text.new(parent: self).parse(node_child)
+          @text = t.text
+        when 'tab'
+          @tab = Tab.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    # @return [True, False] is current run empty
+    def empty?
+      text.empty?
+    end
+
+    # @return [String] instruction applied to paragraph
+    def instruction
+      parent.instruction
+    end
+
+    # @return [True, False] is page number applyed
+    def page_number
+      parent.page_numbering?
+    end
+
+    # @return [Hyperlink] link of run
+    def link
+      parent.parent.hyperlink
+    end
+
+    extend Gem::Deprecate
+    deprecate :instruction, 'parent.instruction', 2020, 1
+    deprecate :page_number, 'parent.page_numbering?', 2020, 1
+    deprecate :link, 'parent.parent.hyperlink', 2020, 1
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/numbering_properties.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `numPr` tags
+  class NumberingProperties < OOXMLDocumentObject
+    attr_accessor :size, :font, :symbol, :start_at, :type, :ilvl, :numbering_properties
+
+    def initialize(ilvl = 0, parent: nil)
+      @ilvl = ilvl
+      super(parent: parent)
+    end
+
+    # @return [AbstractNumbering] AbstractNumbering of current properties
+    def abstruct_numbering
+      root_object.numbering.properties_by_num_id(@numbering_properties)
+    end
+
+    # Parse NumberingProperties
+    # @param [Nokogiri::XML:Node] node with NumberingProperties
+    # @return [NumberingProperties] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'ilvl'
+          @ilvl = node_child.attribute('val').value.to_i
+        when 'numId'
+          @numbering_properties = node_child.attribute('val').value.to_i
+        end
+      end
+      self
+    end
+
+    # @return [AbstractNumbering] level list of current numbering
+    def numbering_level_current
+      abstruct_numbering.level_list.each do |current_ilvl|
+        return current_ilvl if current_ilvl.ilvl == @ilvl
+      end
+      nil
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/paragraph_borders.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:pBdr` element
+  class ParagraphBorders < OOXMLDocumentObject
+    # @return [BordersProperties] bottom properties
+    attr_accessor :bottom
+    # @return [BordersProperties] left properties
+    attr_accessor :left
+    # @return [BordersProperties] top properties
+    attr_accessor :top
+    # @return [BordersProperties] right properties
+    attr_accessor :right
+    # @return [BordersProperties] between properties
+    attr_accessor :between
+    # @return [BordersProperties] bar properties
+    attr_accessor :bar
+
+    # @return [Symbol] type of border in visual editor
+    def border_visual_type
+      result = []
+      result << :left if @left.val == :single
+      result << :right if @right.val == :single
+      result << :top if @top.val == :single
+      result << :bottom if @bottom.val == :single
+      result << :inner if @between.val == :single
+      return :none if result == []
+      return :all if result == %i[left right top bottom inner]
+      return :outer if result == %i[left right top bottom]
+
+      result.first if result.size == 1
+    end
+
+    # Parse Paragraph Borders data
+    # @param [Nokogiri::XML:Element] node with Paragraph Borders data
+    # @return [ParagraphBorders] value of Paragraph Borders data
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'bottom'
+          @bottom = BordersProperties.new(parent: self).parse(node_child)
+        when 'left'
+          @left = BordersProperties.new(parent: self).parse(node_child)
+        when 'top'
+          @top = BordersProperties.new(parent: self).parse(node_child)
+        when 'right'
+          @right = BordersProperties.new(parent: self).parse(node_child)
+        when 'between'
+          @between = BordersProperties.new(parent: self).parse(node_child)
+        when 'bar'
+          @bar = BordersProperties.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/paragraph_spacing.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing Paragraph Spacing in paragraph properties `w:spacing`
+  class ParagraphSpacing < OOXMLDocumentObject
+    # @return [OoxmlSize] value of before spacing
+    attr_accessor :before
+    # @return [OoxmlSize] value of after spacing
+    attr_accessor :after
+    # @return [OoxmlSize] value of line spacing
+    attr_accessor :line
+    # @return [Symbol] value of line rule style
+    attr_accessor :line_rule
+
+    # Parse ParagraphSpacing
+    # @param [Nokogiri::XML:Node] node with ParagraphSpacing
+    # @return [ParagraphSpacing] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'before'
+          @before = OoxmlSize.new(value.value.to_f)
+        when 'after'
+          @after = OoxmlSize.new(value.value.to_f)
+        when 'lineRule'
+          @line_rule = value.value.sub('atLeast', 'at_least').to_sym
+        when 'line'
+          @line = if @line_rule == :auto
+                    OoxmlSize.new(value.value.to_f, :one_240th_cm)
+                  else
+                    OoxmlSize.new(value.value.to_f)
+                  end
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/paragraph_stlye_ref.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `pStyle` tags
+  class ParagraphStyleRef < OOXMLDocumentObject
+    # @return [Integer] value of ParagraphStyleRef
+    attr_reader :value
+
+    # Parse ParagraphStyleRef object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ParagraphStyleRef] 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
+
+    # @return [ParagraphStyle] which was referenced
+    def referenced_style
+      root_object.document_style_by_id(value)
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/spacing/line_spacing.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class to describe spacing
+  class LineSpacing < OOXMLDocumentObject
+    # @return [ValuedChild] spacing percent
+    attr_reader :spacing_percent
+    # @return [ValuedChild] spacing point
+    attr_reader :spacing_points
+
+    # Parse LineSpacing object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [LineSpacing] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'spcPct'
+          @spacing_percent = ValuedChild.new(:integer, parent: self).parse(node_child)
+        when 'spcPts'
+          @spacing_points = ValuedChild.new(:integer, parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    # @return [Symbol] rule used to determine line spacing
+    def rule
+      return :multiple if @spacing_percent
+
+      :exact
+    end
+  end
+end