ooxml_parser 0.1.2 → 0.2.0

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

@@ -1,18 +1,21 @@
 module OoxmlParser
-  class TextField
+  # Class for parsing `fld` tags
+  class TextField < OOXMLDocumentObject
     attr_accessor :id, :type, :text
 
-    def self.parse(text_field_node)
-      text_field = TextField.new
-      text_field.id = text_field_node.attribute('id').value
-      text_field.type = text_field_node.attribute('type').value
-      text_field_node.xpath('*').each do |text_field_node_child|
+    # Parse TextField object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TextField] result of parsing
+    def parse(node)
+      @id = node.attribute('id').value
+      @type = node.attribute('type').value
+      node.xpath('*').each do |text_field_node_child|
         case text_field_node_child.name
         when 't'
-          text_field.text = text_field_node_child.text
+          @text = text_field_node_child.text
         end
       end
-      text_field
+      self
     end
   end
 end

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

@@ -2,13 +2,19 @@ require_relative 'paragraph/paragraph_properties'
 require_relative 'paragraph/paragraph_run'
 require_relative 'paragraph/text_field'
 module OoxmlParser
-  class Paragraph
+  # Class for parsing `p` tags
+  class Paragraph < OOXMLDocumentObject
     attr_accessor :properties, :runs, :text_field, :formulas
+    # @return [AlternateContent] alternate content data
+    attr_accessor :alternate_content
 
-    def initialize(runs = [], formulas = [])
+    def initialize(runs = [],
+                   formulas = [],
+                   parent: nil)
       @runs = runs
       @formulas = formulas
       @runs = []
+      @parent = parent
     end
 
     alias characters runs
@@ -16,21 +22,23 @@ module OoxmlParser
     alias characters= runs=
     alias character_style_array= runs=
 
-    def self.parse(paragraph_node)
-      paragraph = Paragraph.new
-      paragraph_node.xpath('*').each do |paragraph_node_child|
-        case paragraph_node_child.name
+    # Parse Paragraph object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Paragraph] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'pPr'
-          paragraph.properties = ParagraphProperties.parse(paragraph_node_child)
+          @properties = ParagraphProperties.new(parent: self).parse(node_child)
         when 'fld'
-          paragraph.text_field = TextField.parse(paragraph_node_child)
+          @text_field = TextField.new(parent: self).parse(node_child)
         when 'r'
-          paragraph.characters << ParagraphRun.parse(paragraph_node_child)
-        when 'm'
-          # TODO: add parsing formulas in paragraph
+          @runs << ParagraphRun.new(parent: self).parse(node_child)
+        when 'AlternateContent'
+          @alternate_content = AlternateContent.new(parent: self).parse(node_child)
         end
       end
-      paragraph
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/relationships/relationship.rb

@@ -1,6 +1,6 @@
 module OoxmlParser
   # Class for single relationship
-  class Relationship
+  class Relationship < OOXMLDocumentObject
     # @return [String] id of relation
     attr_accessor :id
     # @return [String] type of relation
@@ -11,12 +11,18 @@ module OoxmlParser
     # Parse Relationship
     # @param [Nokogiri::XML:Node] node with Relationship
     # @return [Relationship] result of parsing
-    def self.parse(node)
-      rel = Relationship.new
-      rel.id = node.attribute('Id').value
-      rel.type = node.attribute('Type').value
-      rel.target = node.attribute('Target').value
-      rel
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'Id'
+          @id = value.value
+        when 'Type'
+          @type = value.value
+        when 'Target'
+          @target = value.value
+        end
+      end
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/relationships.rb

@@ -17,15 +17,47 @@ module OoxmlParser
     # Parse Relationships
     # @param [Nokogiri::XML:Node] node with Relationships
     # @return [Relationships] result of parsing
-    def self.parse(node)
-      rels = Relationships.new
+    def parse(node)
       node.xpath('*').each do |node_children|
         case node_children.name
         when 'Relationship'
-          rels.relationship << Relationship.parse(node_children)
+          @relationship << Relationship.new(parent: self).parse(node_children)
+        end
+      end
+      self
+    end
+
+    # Get target name by id
+    # @param id [String] id of target
+    # @return [String] target name
+    def target_by_id(id)
+      @relationship.each do |cur_rels|
+        return cur_rels.target if cur_rels.id == id
+      end
+      nil
+    end
+
+    # Get target name by type
+    # @param type [String] type of target
+    # @return [String] target name
+    def target_by_type(type)
+      @relationship.each do |cur_rels|
+        return cur_rels.target if cur_rels.type.include?(type)
+      end
+      nil
+    end
+
+    # Parse .rels file
+    # @param file_path [String] path to file
+    # @return [Relationships]
+    def self.parse_rels(file_path)
+      node = Nokogiri::XML(File.open(file_path))
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'Relationships'
+          return Relationships.new.parse(node_child)
         end
       end
-      rels
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/margins/paragraph_margins.rb

@@ -1,10 +1,15 @@
 module OoxmlParser
   class ParagraphMargins < TableMargins
-    def initialize(top = 0.0, bottom = 0.0, left = 0.0, right = 0.0)
+    def initialize(top = OoxmlSize.new(0),
+                   bottom = OoxmlSize.new(0),
+                   left = OoxmlSize.new(0),
+                   right = OoxmlSize.new(0),
+                   parent: nil)
       @top = top
       @bottom = bottom
       @left = left
       @right = right
+      @parent = parent
     end
 
     def round(count_of_digits = 1)
@@ -15,21 +20,20 @@ module OoxmlParser
       ParagraphMargins.new(top, bottom, left, right)
     end
 
-    def self.parse(text_body_props_node)
-      margins = ParagraphMargins.new(0.127, 0.127, 0.254, 0.254)
+    def parse(text_body_props_node)
       text_body_props_node.attributes.each do |key, value|
         case key
         when 'bIns', 'marB'
-          margins.bottom = (value.value.to_f / 360_000.0).round(3)
+          @bottom = OoxmlSize.new(value.value.to_f, :emu)
         when 'tIns', 'marT'
-          margins.top = (value.value.to_f / 360_000.0).round(3)
+          @top = OoxmlSize.new(value.value.to_f, :emu)
         when 'lIns', 'marL'
-          margins.left = (value.value.to_f / 360_000.0).round(3)
+          @left = OoxmlSize.new(value.value.to_f, :emu)
         when 'rIns', 'marR'
-          margins.right = (value.value.to_f / 360_000.0).round(3)
+          @right = OoxmlSize.new(value.value.to_f, :emu)
         end
       end
-      margins
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/margins/table_margins.rb

@@ -1,47 +1,46 @@
 module OoxmlParser
-  class TableMargins
+  class TableMargins < OOXMLDocumentObject
     attr_accessor :is_default, :top, :bottom, :left, :right
 
-    def initialize(is_default = true, top = nil, bottom = nil, left = nil, right = nil)
+    def initialize(is_default = true, top = nil, bottom = nil, left = nil, right = nil, parent: nil)
       @is_default = is_default
       @top = top
       @bottom = bottom
       @left = left
       @right = right
+      @parent = parent
     end
 
+    # TODO: Separate @is_default attribute and remove this method
     def ==(other)
-      (@top - other.top).round(2) == 0 && (@bottom - other.bottom).round(2) == 0 &&
-        (@left - other.left).round(2) == 0 && (@right - other.right).round(2) == 0
+      instance_variables.each do |current_attribute|
+        next if current_attribute == :@parent
+        next if current_attribute == :@is_default
+        unless instance_variable_get(current_attribute) == other.instance_variable_get(current_attribute)
+          return false
+        end
+      end
+      true
     end
 
     def to_s
       'Default: ' + is_default.to_s + ' top: ' + @top.to_s + ', bottom: ' + @bottom.to_s + ', left: ' + @left.to_s + ', right: ' + @right.to_s
     end
 
-    def round(count_of_digits = 1)
-      top = @top.round(count_of_digits)
-      bottom = @bottom.round(count_of_digits)
-      left = @left.round(count_of_digits)
-      right = @right.round(count_of_digits)
-      TableMargins.new(@is_default, top, bottom, left, right)
-    end
-
-    def self.parse(margin_node)
-      cell_margins = TableMargins.new
+    def parse(margin_node)
       margin_node.xpath('*').each do |cell_margin_node|
         case cell_margin_node.name
         when 'left'
-          cell_margins.left = (cell_margin_node.attribute('w').value.to_f / 566.9).round(2)
+          @left = OoxmlSize.new(cell_margin_node.attribute('w').value.to_f)
         when 'top'
-          cell_margins.top = (cell_margin_node.attribute('w').value.to_f / 566.9).round(2)
+          @top = OoxmlSize.new(cell_margin_node.attribute('w').value.to_f)
         when 'right'
-          cell_margins.right = (cell_margin_node.attribute('w').value.to_f / 566.9).round(2)
+          @right = OoxmlSize.new(cell_margin_node.attribute('w').value.to_f)
         when 'bottom'
-          cell_margins.bottom = (cell_margin_node.attribute('w').value.to_f / 566.9).round(2)
+          @bottom = OoxmlSize.new(cell_margin_node.attribute('w').value.to_f)
         end
       end
-      cell_margins
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/properties/table_element.rb

@@ -1,20 +1,21 @@
-require_relative 'whole_table/table_cell_style'
 # Describe single table element
 module OoxmlParser
-  class TableElement
+  class TableElement < OOXMLDocumentObject
     attr_accessor :cell_style
 
     alias cell_properties cell_style
 
-    def self.parse(whole_table_node)
-      table_element = TableElement.new
-      whole_table_node.xpath('*').each do |whole_table_node_child|
-        case whole_table_node_child.name
+    # Parse TableElement object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableElement] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'tcStyle', 'tcPr'
-          table_element.cell_style = CellProperties.parse(whole_table_node_child)
+          @cell_style = CellProperties.new(parent: self).parse(node_child)
         end
       end
-      table_element
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/properties/table_layout.rb

@@ -0,0 +1,23 @@
+module OoxmlParser
+  # Class for parsing `w:tblLayout` object
+  # Whether a table uses a fixed width or autofit method for laying out the table
+  # contents is specified with the <w:tblLayout> element within the <w:tblPr> element.
+  # If <w:tblLayout> is omitted, autofit is assumed.
+  class TableLayout < OOXMLDocumentObject
+    # @return [Symbol] Specifies the method of laying out the contents of the table
+    attr_accessor :type
+
+    # Parse TableLayout
+    # @param [Nokogiri::XML:Node] node with TableLayout
+    # @return [TableLayout] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'type'
+          @type = value.value.to_sym
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/table/properties/table_look.rb

@@ -1,10 +1,10 @@
-# Describe look of table
 module OoxmlParser
+  # Describe look of table, parsed `w:tblLook`
   class TableLook < OOXMLDocumentObject
     attr_accessor :first_row, :first_column, :last_row, :last_column, :banding_row, :banding_column, :no_horizontal_banding,
                   :no_vertical_banding
 
-    def initialize
+    def initialize(parent: nil)
       @first_row = false
       @first_column = false
       @last_row = false
@@ -13,31 +13,34 @@ module OoxmlParser
       @banding_column = false
       @no_horizontal_banding = false
       @no_horizontal_banding = false
+      @parent = parent
     end
 
-    def self.parse(table_look_node)
-      table_look = TableLook.new
-      table_look_node.attributes.each do |key, value|
+    # Parse TableLook object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableLook] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'firstRow'
-          table_look.first_row = OOXMLDocumentObject.option_enabled?(value)
+          @first_row = attribute_enabled?(value)
         when 'lastRow'
-          table_look.last_row = OOXMLDocumentObject.option_enabled?(value)
+          @last_row = attribute_enabled?(value)
         when 'firstCol', 'firstColumn'
-          table_look.first_column = OOXMLDocumentObject.option_enabled?(value)
+          @first_column = attribute_enabled?(value)
         when 'lastCol', 'lastColumn'
-          table_look.last_column = OOXMLDocumentObject.option_enabled?(value)
+          @last_column = attribute_enabled?(value)
         when 'noHBand'
-          table_look.no_horizontal_banding = OOXMLDocumentObject.option_enabled?(value)
+          @no_horizontal_banding = attribute_enabled?(value)
         when 'noVBand'
-          table_look.no_vertical_banding = OOXMLDocumentObject.option_enabled?(value)
+          @no_vertical_banding = attribute_enabled?(value)
         when 'bandRow'
-          table_look.banding_row = OOXMLDocumentObject.option_enabled?(value)
+          @banding_row = attribute_enabled?(value)
         when 'bandCol'
-          table_look.banding_column = OOXMLDocumentObject.option_enabled?(value)
+          @banding_column = attribute_enabled?(value)
         end
       end
-      table_look
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/properties/table_position.rb

@@ -1,49 +1,42 @@
 # Table Position Data
 module OoxmlParser
-  class TablePosition
+  class TablePosition < OOXMLDocumentObject
     attr_accessor :left, :right, :top, :bottom, :position_x, :position_y, :horizontal_anchor, :vertical_anchor, :vertical_align_from_anchor,
                   :horizontal_align_from_anchor
 
-    def initialize
-      @left = nil
-      @right = nil
-      @top = nil
-      @bottom = nil
-      @position_x = nil
-      @position_y = nil
-    end
-
     def to_s
       'Table position left: ' + @left.to_s + ', right: ' + @right.to_s + ', top: ' + @top.to_s + ', bottom: ' + @bottom.to_s + 'position x: ' + position_x.to_s + 'position y: ' + position_x.to_s
     end
 
-    def self.parse(node)
-      table_p_properties = TablePosition.new
+    # Parse TablePosition object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TablePosition] result of parsing
+    def parse(node)
       node.attributes.each do |key, value|
         case key
         when 'leftFromText'
-          table_p_properties.left = value.value.to_f / 567.5
+          @left = OoxmlSize.new(value.value.to_f)
         when 'rightFromText'
-          table_p_properties.right = value.value.to_f / 567.5
+          @right = OoxmlSize.new(value.value.to_f)
         when 'topFromText'
-          table_p_properties.top = value.value.to_f / 567.5
+          @top = OoxmlSize.new(value.value.to_f)
         when 'bottomFromText'
-          table_p_properties.bottom = value.value.to_f / 567.5
+          @bottom = OoxmlSize.new(value.value.to_f)
         when 'tblpX'
-          table_p_properties.position_x = (value.value.to_f / 566.9).round(3)
+          @position_x = OoxmlSize.new(value.value.to_f)
         when 'tblpY'
-          table_p_properties.position_y = (value.value.to_f / 566.9).round(3)
+          @position_y = OoxmlSize.new(value.value.to_f)
         when 'vertAnchor'
-          table_p_properties.vertical_anchor = value.value.to_sym
+          @vertical_anchor = value.value.to_sym
         when 'horzAnchor'
-          table_p_properties.horizontal_anchor = value.value.to_sym
+          @horizontal_anchor = value.value.to_sym
         when 'tblpXSpec'
-          table_p_properties.horizontal_align_from_anchor = value.value.to_sym
+          @horizontal_align_from_anchor = value.value.to_sym
         when 'tblpYSpec'
-          table_p_properties.vertical_align_from_anchor = value.value.to_sym
+          @vertical_align_from_anchor = value.value.to_sym
         end
       end
-      table_p_properties
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/properties/table_style.rb

@@ -1,4 +1,3 @@
-require_relative 'table_style_elements'
 require_relative 'table_element'
 # Style of Table
 module OoxmlParser
@@ -7,71 +6,53 @@ module OoxmlParser
                   :last_column, :first_column, :last_row, :first_row, :southeast_cell, :southwest_cell, :northeast_cell,
                   :northwest_cell
 
-    def initialize(id = nil)
-      @id = id
-      @banding_1_horizontal = TableStyleElement.new
-      @banding_2_horizontal = TableStyleElement.new
-      @banding_1_vertical = TableStyleElement.new
-      @banding_2_vertical = TableStyleElement.new
-      @last_column = TableStyleElement.new
-      @first_column = TableStyleElement.new
-      @last_row = TableStyleElement.new
-      @first_row = TableStyleElement.new
-      @southeast_cell = TableStyleElement.new
-      @southwest_cell = TableStyleElement.new
-      @northeast_cell = TableStyleElement.new
-      @northwest_cell = TableStyleElement.new
-    end
-
-    def self.parse(style_id: nil, table_style_node: nil)
-      table_style = TableStyle.new
-      if !style_id.nil?
+    # Parse TableStyle object
+    # @param style_id [String] id to parse
+    # @return [TableStyle] result of parsing
+    def parse(style_id: nil)
+      unless style_id.nil?
         nodes = get_style_node(style_id)
         return nil if nodes.nil?
         xpath = '*'
         attributes = 'style_node_child.name'
-      elsif !table_style_node.nil?
-        nodes = table_style_node
-        xpath = 'w:tblStylePr'
-        attributes = "style_node_child.attribute('type').value"
       end
       begin
         nodes.xpath(xpath).each do |style_node_child|
           case instance_eval(attributes)
           when 'wholeTbl'
-            table_style.whole_table = TableElement.parse(style_node_child)
+            @whole_table = TableElement.new(parent: self).parse(style_node_child)
           when 'band1H'
-            table_style.banding_1_horizontal = TableElement.parse(style_node_child)
+            @banding_1_horizontal = TableElement.new(parent: self).parse(style_node_child)
           when 'band2H', 'band2Horz'
-            table_style.banding_2_horizontal = TableElement.parse(style_node_child)
+            @banding_2_horizontal = TableElement.new(parent: self).parse(style_node_child)
           when 'band1V'
-            table_style.banding_1_vertical = TableElement.parse(style_node_child)
+            @banding_1_vertical = TableElement.new(parent: self).parse(style_node_child)
           when 'band2V'
-            table_style.banding_2_vertical = TableElement.parse(style_node_child)
+            @banding_2_vertical = TableElement.new(parent: self).parse(style_node_child)
           when 'lastCol'
-            table_style.last_column = TableElement.parse(style_node_child)
+            @last_column = TableElement.new(parent: self).parse(style_node_child)
           when 'firstCol'
-            table_style.first_column = TableElement.parse(style_node_child)
+            @first_column = TableElement.new(parent: self).parse(style_node_child)
           when 'lastRow'
-            table_style.last_row = TableElement.parse(style_node_child)
+            @last_row = TableElement.new(parent: self).parse(style_node_child)
           when 'firstRow'
-            table_style.first_row = TableElement.parse(style_node_child)
+            @first_row = TableElement.new(parent: self).parse(style_node_child)
           when 'seCell'
-            table_style.southeast_cell = TableElement.parse(style_node_child)
+            @southeast_cell = TableElement.new(parent: self).parse(style_node_child)
           when 'swCell'
-            table_style.southwest_cell = TableElement.parse(style_node_child)
+            @southwest_cell = TableElement.new(parent: self).parse(style_node_child)
           when 'neCell'
-            table_style.northeast_cell = TableElement.parse(style_node_child)
+            @northeast_cell = TableElement.new(parent: self).parse(style_node_child)
           when 'nwCell'
-            table_style.northwest_cell = TableElement.parse(style_node_child)
+            @northwest_cell = TableElement.new(parent: self).parse(style_node_child)
           end
         end
       end
-      table_style.id = style_id unless style_id.nil?
-      table_style
+      @id = style_id unless style_id.nil?
+      self
     end
 
-    def self.get_style_node(style_id)
+    def get_style_node(style_id)
       begin
         doc = Nokogiri::XML(File.open(OOXMLDocumentObject.path_to_folder + 'ppt/tableStyles.xml'))
       rescue StandardError

data/lib/ooxml_parser/common_parser/common_data/table/properties/table_style_column_band_size.rb

@@ -0,0 +1,23 @@
+module OoxmlParser
+  # Class for parsing `w:tblStyleColBandSize` object
+  # When a style specifies the format for a band of columns in a
+  # table (a set of contiguous columns),
+  # this specifies the number of columns in a band.
+  class TableStyleColumnBandSize < OOXMLDocumentObject
+    # @return [Integer] value of table style column band size
+    attr_accessor :value
+
+    # Parse TableStyleColumnBandSize
+    # @param [Nokogiri::XML:Node] node with TableStyleColumnBandSize
+    # @return [TableStyleColumnBandSize] 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/common_parser/common_data/table/properties/table_style_properties/table_style_properties_helper.rb

@@ -0,0 +1,42 @@
+module OoxmlParser
+  # Helper method for working with TableStyleProperties
+  module TableStylePropertiesHelper
+    TABLE_STYLES_NAMES_HASH = { first_column: :firstCol,
+                                last_column: :lastCol,
+                                whole_table: :wholeTbl,
+                                banding_1_horizontal:  :band1Horz,
+                                banding_2_horizontal: :band2Horz,
+                                banding_1_vertical: :band1Vert,
+                                banding_2_vertical: :band2Vert,
+                                southeast_cell: :seCell,
+                                southwest_cell: :swCell,
+                                northeast_cell: :neCell,
+                                northwest_cell: :nwCell,
+                                first_row: :firstRow,
+                                last_row: :lastRow }.freeze
+
+    TABLE_STYLES_NAMES_HASH.keys.each do |table_style_name|
+      define_method(table_style_name) do
+        @table_style_properties_list.each do |table_style|
+          return table_style if table_style.type == TABLE_STYLES_NAMES_HASH[table_style_name]
+        end
+        nil
+      end
+    end
+
+    # Fill all empty tables styles with default value
+    # To make last changes in parsing table styles compatible
+    # with `ooxml_parser` 0.1.2 and earlier
+    # @return [Nothing]
+    def fill_empty_table_styles
+      TABLE_STYLES_NAMES_HASH.values.each do |current_table_style|
+        style_exist = false
+        @table_style_properties_list.each do |existing_style|
+          style_exist = true if existing_style.type == current_table_style
+        end
+        next if style_exist
+        @table_style_properties_list << TableStyleProperties.new(type: current_table_style)
+      end
+    end
+  end
+end