ooxml_parser 0.1.2 → 0.2.0

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

@@ -1,23 +1,27 @@
 # Class for parsing Run Outline properties
 module OoxmlParser
+  # Class for parsing `w:ln` tags
   class Outline < OOXMLDocumentObject
     attr_accessor :width
     attr_accessor :color_scheme
 
-    def initialize
-      @width = 0
+    def initialize(parent: nil)
+      @width = OoxmlSize.new(0)
+      @parent = parent
     end
 
-    def self.parse(node)
-      outline = Outline.new
+    # Parse Outline object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Outline] result of parsing
+    def parse(node)
       node.attributes.each do |key, value|
         case key
         when 'w'
-          outline.width = (value.value.to_f / 12_699.3).round(2)
+          @width = OoxmlSize.new(value.value.to_f, :emu)
         end
       end
-      outline.color_scheme = DocxColorScheme.parse(node)
-      outline
+      @color_scheme = DocxColorScheme.new(parent: self).parse(node)
+      self
     end
   end
 end

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

@@ -0,0 +1,20 @@
+module OoxmlParser
+  # Class for parsing `w:position` object
+  class Position < OOXMLDocumentObject
+    # @return [String] value of position
+    attr_accessor :value
+
+    # Parse Position
+    # @param [Nokogiri::XML:Node] node with Position
+    # @return [Position] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = OoxmlSize.new(value.value.to_f, :half_point)
+        end
+      end
+      self
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+module OoxmlParser
+  # Class for parsing `w:rStyle` object
+  class RunStyle < OOXMLDocumentObject
+    # @return [Integer] value of size
+    attr_accessor :value
+
+    # Parse RunStyle
+    # @param [Nokogiri::XML:Node] node with RunStyle
+    # @return [RunStyle] 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 [DocumentStyle] style which was referenced in RunStyle
+    def referenced
+      root_object.document_style_by_id(@value)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module OoxmlParser
+  # Class for parsing `w:shd` object
+  class Shade < OOXMLDocumentObject
+    # @return [Symbol] value of shade
+    attr_accessor :value
+    # @return [Symbol] color of shade
+    attr_accessor :color
+    # @return [Color] fill of shade
+    attr_accessor :fill
+
+    def initialize(value: nil,
+                   color: nil,
+                   fill: nil,
+                   parent: nil)
+      @value = value
+      @color = color
+      @fill = fill
+      @parent = parent
+    end
+
+    # Parse Shade
+    # @param [Nokogiri::XML:Node] node with Shade
+    # @return [Shade] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_sym
+        when 'color'
+          @color = value.value.to_sym
+        when 'fill'
+          @fill = Color.new(parent: self).parse_hex_string(value.value.to_s)
+        end
+      end
+      self
+    end
+  end
+end

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

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

@@ -1,79 +1,131 @@
+require_relative 'run_properties/language'
 require_relative 'run_properties/outline'
-require_relative 'run_properties/strikeout'
+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
     attr_accessor :font_style, :font_color, :space, :dirty, :font_name, :font_size, :baseline, :hyperlink, :caps,
                   :vertical_align, :outline
+    attr_accessor :shadow
+    attr_accessor :emboss
+    attr_accessor :vanish
+    attr_accessor :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 [Language] language property
+    attr_accessor :language
+    # @return [Position] position property
+    attr_accessor :position
+    # @return [Shade] shade property
+    attr_accessor :shade
+    # @return [RunStyle] run style
+    attr_accessor :run_style
+    # @return [Float]
+    # This element specifies the font size which shall be applied to all
+    # complex script characters in the contents of this run when displayed
+    attr_accessor :font_size_complex
 
-    def initialize(font_name = '', font_style = FontStyle.new, font_color = nil, space = nil, baseline = :baseline)
-      @font_name = font_name
-      @font_style = font_style
-      @font_color = font_color
-      @space = space
-      @baseline = baseline
+    def initialize(parent: nil)
+      @font_name = ''
+      @font_style = FontStyle.new
+      @baseline = :baseline
+      @parent = parent
     end
 
-    def self.parse(character_props_node)
-      character_properties = RunProperties.new
-      character_properties.font_style = Presentation.current_font_style.dup
-      character_props_node.attributes.each do |key, value|
+    # Parse RunProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [RunProperties] result of parsing
+    def parse(node)
+      @font_style = Presentation.current_font_style.dup
+      node.attributes.each do |key, value|
         case key
         when 'sz'
-          character_properties.font_size = value.value.to_f / 100.0
+          @font_size = value.value.to_f / 100.0
+        when 'szCs'
+          @font_size_complex = node.attribute('val').value.to_i / 2.0
         when 'spc'
-          character_properties.space = (value.value.to_f / 2_834.0).round(2)
+          @space = OoxmlSize.new(value.value.to_f, :one_100th_point)
         when 'b'
-          character_properties.font_style.bold = OOXMLDocumentObject.option_enabled?(character_props_node, 'b')
+          @font_style.bold = option_enabled?(node, 'b')
         when 'i'
-          character_properties.font_style.italic = OOXMLDocumentObject.option_enabled?(character_props_node, 'i')
+          @font_style.italic = option_enabled?(node, 'i')
         when 'u'
-          character_properties.font_style.underlined = Underline.parse(value.value)
+          @font_style.underlined = Underline.new(parent: self).parse(value.value)
         when 'strike'
-          character_properties.font_style.strike = Strikeout.parse(value)
+          @font_style.strike = value_to_symbol(value)
         when 'baseline'
           case value.value.to_i
           when -25_000, -30_000
-            character_properties.baseline = :subscript
+            @baseline = :subscript
           when 30_000
-            character_properties.baseline = :superscript
+            @baseline = :superscript
           when 0
-            character_properties.baseline = :baseline
+            @baseline = :baseline
           end
         when 'cap'
-          character_properties.caps = value.value.to_sym
+          @caps = value.value.to_sym
         end
       end
-      character_properties.font_color = DocxColorScheme.parse(character_props_node)
-      character_props_node.xpath('*').each do |properties_element|
-        case properties_element.name
+      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 = Color.parse_color_tag(node_child)
         when 'solidFill'
-          character_properties.font_color = Color.parse_color(properties_element.xpath('*').first)
+          @font_color = Color.parse_color(node_child.xpath('*').first)
         when 'latin'
-          character_properties.font_name = properties_element.attribute('typeface').value
+          @font_name = node_child.attribute('typeface').value
         when 'b'
-          character_properties.font_style.bold = OOXMLDocumentObject.option_enabled?(properties_element)
+          @font_style.bold = option_enabled?(node_child)
         when 'i'
-          character_properties.font_style.italic = OOXMLDocumentObject.option_enabled?(properties_element, 'i')
+          @font_style.italic = option_enabled?(node_child, 'i')
         when 'u'
-          character_properties.font_style.underlined = Underline.new(:single)
+          @font_style.underlined = Underline.new(:single)
         when 'vertAlign'
-          character_properties.vertical_align = properties_element.attribute('val').value.to_sym
+          @vertical_align = node_child.attribute('val').value.to_sym
         when 'rFont'
-          character_properties.font_name = properties_element.attribute('val').value
-        when 'color'
-          character_properties.font_color = Color.parse_color_tag(properties_element)
+          @font_name = node_child.attribute('val').value
+        when 'rFonts'
+          @font_name = node_child.attribute('ascii').value if node_child.attribute('ascii')
         when 'strike'
-          character_properties.font_style.strike = OOXMLDocumentObject.option_enabled?(properties_element)
+          @font_style.strike = option_enabled?(node_child)
         when 'hlinkClick'
-          character_properties.hyperlink = Hyperlink.parse(properties_element)
+          @hyperlink = Hyperlink.new(parent: self).parse(node_child)
         when 'ln'
-          character_properties.outline = Outline.parse(properties_element)
+          @outline = Outline.new(parent: self).parse(node_child)
+        when 'lang'
+          @language = Language.new(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
-      character_properties.font_color = DocxColorScheme.parse(character_props_node)
-      character_properties.font_name = Presentation.default_font_typeface if character_properties.font_name.empty?
-      character_properties.font_size = Presentation.default_font_size if character_properties.font_size.nil?
-      character_properties
+      @font_color = DocxColorScheme.new(parent: self).parse(node)
+      @font_name = Presentation.default_font_typeface if @font_name.empty?
+      @font_size = Presentation.default_font_size if @font_size.nil?
+      self
     end
   end
 end

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

@@ -1,24 +1,28 @@
 require_relative 'paragraph_run/run_properties'
 module OoxmlParser
+  # Class for parsing `r` tags
   class ParagraphRun < OOXMLDocumentObject
     attr_accessor :properties, :text
 
-    def initialize(properties = RunProperties.new, text = '')
+    def initialize(properties = RunProperties.new, text = '', parent: nil)
       @properties = properties
       @text = text
+      @parent = parent
     end
 
-    def self.parse(character_node)
-      character = ParagraphRun.new
-      character_node.xpath('*').each do |character_node_child|
-        case character_node_child.name
+    # 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'
-          character.properties = RunProperties.parse(character_node_child)
+          @properties = RunProperties.new(parent: self).parse(node_child)
         when 't'
-          character.text = character_node_child.text
+          @text = node_child.text
         end
       end
-      character
+      self
     end
   end
 end

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

@@ -0,0 +1,37 @@
+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
+      @parent = parent
+    end
+
+    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
+
+    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,53 @@
+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
+
+    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 == [:left, :right, :top, :bottom, :inner]
+      return :outer if result == [: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,36 @@
+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 Position
+    # @param [Nokogiri::XML:Node] node with Position
+    # @return [Position] 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/spacing.rb

@@ -30,8 +30,10 @@ module OoxmlParser
       else
         self.line_rule = line_rule.to_sym if line_rule.instance_of?(String)
 
-        if @before.to_f.round(2) == other.before.to_f.round(2) && @after.to_f.round(2) == other.after.to_f.round(2) &&
-           @line.to_f.round(2) == other.line.to_f.round(2) && @line_rule.to_s == other.line_rule.to_s
+        if @before == other.before &&
+           @after == other.after &&
+           @line == other.line &&
+           @line_rule.to_s == other.line_rule.to_s
           return true
         else
           return false
@@ -87,11 +89,9 @@ module OoxmlParser
       node.xpath('*').each do |spacing_node_child|
         case spacing_node_child.name
         when 'spcPct'
-          return (spacing_node_child.attribute('val').value.to_f / 100_000.0).round(2)
+          return OoxmlSize.new(spacing_node_child.attribute('val').value.to_f, :one_1000th_percent)
         when 'spcPts'
-          return (spacing_node_child.attribute('val').value.to_f / 2_834.0).round(2)
-        else
-          return (spacing_node_child.attribute('val').value.to_f / 1_000.0).round(2)
+          return OoxmlSize.new(spacing_node_child.attribute('val').value.to_f, :spacing_point)
         end
       end
     end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/tab_list/presentation_tab.rb

@@ -0,0 +1,26 @@
+module OoxmlParser
+  # Class for storing `a:tab` data
+  class PresentationTab < OOXMLDocumentObject
+    # @return [Symbol] Specifies the style of the tab.
+    attr_accessor :value
+    # @return [OOxmlSize] Specifies the position of the tab stop.
+    attr_accessor :position
+
+    alias align value
+
+    # Parse ParagraphTab object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ParagraphTab] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'algn'
+          @value = value_to_symbol(value)
+        when 'pos'
+          @position = OoxmlSize.new(value.value.to_f, :emu)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative 'tab_list/presentation_tab'
+module OoxmlParser
+  # Class for working with `a:tabLst`
+  class TabList < OOXMLDocumentObject
+    # @return [Array, ParagraphTabs]
+    attr_accessor :tabs_array
+
+    def initialize(parent: nil)
+      @tabs_array = []
+      @parent = parent
+    end
+
+    # @return [Array, Column] accessor
+    def [](key)
+      @tabs_array[key]
+    end
+
+    # @return [True, False] if empty
+    def empty?
+      @tabs_array.empty?
+    end
+
+    # Parse Tabs data
+    # @param [Nokogiri::XML:Element] node with Tabs data
+    # @return [Tabs] value of Columns data
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'tab'
+          @tabs_array << PresentationTab.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/paragraph/paragrpah_properties/tabs/paragraph_tab.rb

@@ -0,0 +1,26 @@
+module OoxmlParser
+  # Class for storing `w:tab` data
+  class ParagraphTab < OOXMLDocumentObject
+    # @return [Symbol] Specifies the style of the tab.
+    attr_accessor :value
+    # @return [OOxmlSize] Specifies the position of the tab stop.
+    attr_accessor :position
+
+    alias align value
+
+    # Parse ParagraphTab object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ParagraphTab] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_sym
+        when 'pos'
+          @position = OoxmlSize.new(value.value.to_f)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative 'tabs/paragraph_tab'
+module OoxmlParser
+  # Class for working with `w:tabs`
+  class Tabs < OOXMLDocumentObject
+    # @return [Array, ParagraphTabs]
+    attr_accessor :tabs_array
+
+    def initialize(parent: nil)
+      @tabs_array = []
+      @parent = parent
+    end
+
+    # @return [Array, Column] accessor
+    def [](key)
+      @tabs_array[key]
+    end
+
+    # @return [True, False] if empty
+    def empty?
+      @tabs_array.empty?
+    end
+
+    # Parse Tabs data
+    # @param [Nokogiri::XML:Element] node with Tabs data
+    # @return [Tabs] value of Columns data
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'tab'
+          @tabs_array << ParagraphTab.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end