ooxml_parser 0.1.2 → 0.2.0

data/lib/ooxml_parser/common_parser/common_data/table/row/row/table_row_properties.rb

@@ -1,22 +1,32 @@
+require_relative 'table_row_properties/table_row_height'
 module OoxmlParser
   # Class for describing Table Row Properties
   class TableRowProperties < OOXMLDocumentObject
-    # @return [Float] Table Row Height
+    # @return [TableRowHeight] Table Row Height
     attr_accessor :height
-
-    def initialize
-      @height = nil
-    end
+    # @return [OoxmlSize] Table cell spacing
+    attr_accessor :cells_spacing
+    # @return [True, False]
+    # Specifies that the current row should
+    # be repeated at the top each new page on which the table is displayed.
+    # >ECMA-376, 3rd Edition (June, 2011), Fundamentals and Markup Language Reference 17.4.50
+    attr_accessor :table_header
 
     # Parse Columns data
     # @param [Nokogiri::XML:Element] node with Table Row Properties data
     # @return [TableRowProperties] value of Columns data
-    def self.parse(node)
-      properties = TableRowProperties.new
-      node.xpath('w:trHeight').each do |height|
-        properties.height = height.attribute('val').value.to_f
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'trHeight'
+          @height = TableRowHeight.new(parent: self).parse(node_child)
+        when 'tblCellSpacing'
+          @cells_spacing = OoxmlSize.new.parse(node_child)
+        when 'tblHeader'
+          @table_header = option_enabled?(node_child)
+        end
       end
-      properties
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/row/row.rb

@@ -2,32 +2,36 @@ require_relative 'cell/cell'
 require_relative 'row/table_row_properties'
 module OoxmlParser
   class TableRow < OOXMLDocumentObject
-    attr_accessor :height, :cells, :cells_spacing, :table_row_properties
+    attr_accessor :height, :cells, :table_row_properties
 
-    def initialize(cells = [])
+    def initialize(cells = [], parent: nil)
       @cells = cells
+      @parent = parent
     end
 
     alias table_row_height height
 
-    def self.parse(row_node)
-      row = TableRow.new
-      row.height = (row_node.attribute('h').value.to_f / 360_000.0).round(2) unless row_node.attribute('h').nil?
-      row_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:trPr").each do |table_prop_node|
-        row.table_row_properties = TableRowProperties.parse(table_prop_node)
+    # Parse TableRow object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableRow] result of parsing
+    def parse(node)
+      Presentation.current_font_style = FontStyle.new(true) # TODO: Add correct parsing of TableStyle.xml file and use it
+      node.attributes.each do |key, value|
+        case key
+        when 'h'
+          @height = OoxmlSize.new(value.value.to_f, :emu)
+        end
       end
-      row_node.xpath('*').each do |row_node_child|
-        row_node_child.xpath('*').each do |row_properties|
-          case row_properties.name
-          when 'tblCellSpacing'
-            row.cells_spacing = (row_properties.attribute('w').value.to_f / 283.3).round(2)
-          end
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'trPr'
+          @table_row_properties = TableRowProperties.new(parent: self).parse(node_child)
+        when 'tc'
+          @cells << TableCell.new(parent: self).parse(node_child)
         end
       end
-      Presentation.current_font_style = FontStyle.new(true) # TODO: Add correct parsing of TableStyle.xml file and use it
-      row_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:tc").each { |cell_node| row.cells << TableCell.parse(cell_node) }
       Presentation.current_font_style = FontStyle.new
-      row
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/table_grid/grid_column.rb

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

data/lib/ooxml_parser/common_parser/common_data/table/table_grid.rb

@@ -1,9 +1,33 @@
+require_relative 'table_grid/grid_column'
 module OoxmlParser
+  # Class for parsing `w:tblGrid` object
   class TableGrid < OOXMLDocumentObject
-    attr_accessor :columns, :mass_of_width_cells
+    # @return [Array, GridColumn] array of columns
+    attr_accessor :columns
 
-    def initialize(columns = [])
-      @columns = columns
+    def initialize(parent: nil)
+      @columns = []
+      @parent = parent
+    end
+
+    def ==(other)
+      @columns.each_with_index do |cur_column, index|
+        return false unless cur_column == other.columns[index]
+      end
+      true
+    end
+
+    # Parse TableGrid
+    # @param [Nokogiri::XML:Node] node with TableGrid
+    # @return [TableGrid] result of parsing
+    def parse(node)
+      node.xpath('*').each do |grid_child|
+        case grid_child.name
+        when 'gridCol'
+          @columns << GridColumn.new(parent: self).parse(grid_child)
+        end
+      end
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/table_properties/table_borders.rb

@@ -1,33 +1,40 @@
 module OoxmlParser
   # Class for describing Table Border Propertie
   class TableBorders < OOXMLDocumentObject
-    # @return [BordersProperties] left border propertie
+    # @return [BordersProperties] left border property
     attr_accessor :left
-    # @return [BordersProperties] right border propertie
+    # @return [BordersProperties] right border property
     attr_accessor :right
-    # @return [BordersProperties] top border propertie
+    # @return [BordersProperties] top border property
     attr_accessor :top
-    # @return [BordersProperties] bottom border propertie
+    # @return [BordersProperties] bottom border property
     attr_accessor :bottom
+    # @return [BordersProperties] inside vertical property
+    attr_accessor :inside_vertical
+    # @return [BordersProperties] inside horizontal property
+    attr_accessor :inside_horizontal
 
     # Parse Table Borders data
     # @param [Nokogiri::XML:Element] node with Table Borders data
     # @return [TableBorders] value of Table Borders data
-    def self.parse(node)
-      borders = TableBorders.new
-      node.xpath('*').each do |cell_borders_node|
-        case cell_borders_node.name
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'left'
-          borders.left = BordersProperties.parse(cell_borders_node)
+          @left = BordersProperties.new(parent: self).parse(node_child)
         when 'top'
-          borders.top = BordersProperties.parse(cell_borders_node)
+          @top = BordersProperties.new(parent: self).parse(node_child)
         when 'right'
-          borders.right = BordersProperties.parse(cell_borders_node)
+          @right = BordersProperties.new(parent: self).parse(node_child)
         when 'bottom'
-          borders.bottom = BordersProperties.parse(cell_borders_node)
+          @bottom = BordersProperties.new(parent: self).parse(node_child)
+        when 'insideV'
+          @inside_vertical = BordersProperties.new(parent: self).parse(node_child)
+        when 'insideH'
+          @inside_horizontal = BordersProperties.new(parent: self).parse(node_child)
         end
       end
-      borders
+      self
     end
   end
 end

data/lib/ooxml_parser/common_parser/common_data/table/table_properties.rb

@@ -1,80 +1,97 @@
 # Table Properties Data
-require_relative 'properties/table_cell_margin'
+require_relative 'properties/table_layout'
 require_relative 'properties/table_look'
 require_relative 'properties/table_style'
+require_relative 'properties/table_style_column_band_size'
+require_relative 'properties/table_style_row_band_size'
 require_relative 'properties/table_position'
+require_relative 'properties/table_style_properties'
 require_relative 'table_properties/table_borders'
 module OoxmlParser
+  # Class for parsing `w:tblPr` tags
   class TableProperties < OOXMLDocumentObject
-    attr_accessor :jc, :table_width, :shd, :table_borders, :table_properties, :table_positon, :table_cell_margin, :table_indent, :stretching, :table_style, :row_banding_size,
-                  :column_banding_size, :table_look, :grid_column, :right_to_left, :style
+    attr_accessor :jc, :table_width, :table_borders, :table_properties, :table_positon, :table_cell_margin, :table_indent, :stretching, :table_style, :row_banding_size,
+                  :column_banding_size, :table_look, :grid_column, :style
+    # @return [TableStyleColumnBandSize] table style column band size
+    attr_accessor :table_style_column_band_size
+    # @return [TableStyleRowBandSize] table style row band size
+    attr_accessor :table_style_row_band_size
+    # @return [TableLayout] table layout
+    attr_accessor :table_layout
+    # @return [OoxmlSize] table cell spacing
+    attr_accessor :table_cell_spacing
+    # @return [Shade] shade color of table
+    attr_accessor :shade
+    # @return [ValuedChild] caption of table
+    attr_accessor :caption
+    # @return [ValuedChild] description of table
+    attr_accessor :description
 
     alias table_properties table_positon
 
-    def initialize
-      @table_indent = nil
-      @table_cell_margin = nil
+    def initialize(parent: nil)
       @jc = :left
-      @shd = nil
-      @stretching = true
       @table_borders = TableBorders.new
-      @table_properties = nil
-      @table_width = nil
-      @grid_column = nil
-      @right_to_left = nil
-      @style = nil
+      @parent = parent
     end
 
     def copy
       table = TableProperties.new
       table.jc = @jc
       table.table_width = @table_width
-      table.shd = @shd
+      table.shade = @shade
       table.stretching = @stretching
       table.table_borders = @table_borders
       table.table_properties = @table_properties
       table.table_cell_margin = @table_cell_margin
       table.table_indent = @table_indent
       table.grid_column = @grid_column
-      table.right_to_left = @right_to_left
       table.style = style
       table
     end
 
-    def self.parse(table_properties_node)
-      table_properties = TableProperties.new
-      table_properties_node.xpath('*').each do |table_props_node_child|
-        case table_props_node_child.name
+    # Parse TableProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableProperties] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'tableStyleId'
-          table_properties.style = TableStyle.parse(style_id: table_props_node_child.text)
+          @style = TableStyle.new(parent: self).parse(style_id: node_child.text)
         when 'tblBorders'
-          table_properties.table_borders = TableBorders.parse(table_props_node_child)
+          @table_borders = TableBorders.new(parent: self).parse(node_child)
         when 'tblStyle'
-          style = DocxParagraphRun.get_style_by_id(table_props_node_child.attribute('val').value)
-          next if style.nil?
-          table_properties.table_style = TableStyle.parse(table_style_node: style)
+          @table_style = root_object.document_style_by_id(node_child.attribute('val').value)
         when 'tblW'
-          table_properties.table_width = table_props_node_child.attribute('w').text.to_f / 567.0
+          @table_width = OoxmlSize.new.parse(node_child)
         when 'jc'
-          table_properties.jc = table_props_node_child.attribute('val').text.to_sym
+          @jc = node_child.attribute('val').text.to_sym
         when 'shd'
-          unless table_props_node_child.attribute('fill').nil?
-            background_color = Color.from_int16(table_props_node_child.attribute('fill').value)
-            table_properties.shd = background_color
-          end
+          @shade = Shade.new(parent: self).parse(node_child)
         when 'tblLook'
-          table_properties.table_look = TableLook.parse(table_props_node_child)
+          @table_look = TableLook.new(parent: self).parse(node_child)
         when 'tblInd'
-          table_properties.table_indent = table_props_node_child.attribute('w').text.to_f / 567.0
+          @table_indent = OoxmlSize.new(node_child.attribute('w').text.to_f)
         when 'tblpPr'
-          table_properties.table_positon = TablePosition.parse(table_props_node_child)
+          @table_positon = TablePosition.new(parent: self).parse(node_child)
         when 'tblCellMar'
-          table_properties.table_cell_margin = TableMargins.parse(table_props_node_child)
+          @table_cell_margin = TableMargins.new(parent: table_properties).parse(node_child)
+        when 'tblStyleColBandSize'
+          @table_style_column_band_size = TableStyleColumnBandSize.new(parent: self).parse(node_child)
+        when 'tblStyleRowBandSize'
+          @table_style_row_band_size = TableStyleRowBandSize.new(parent: self).parse(node_child)
+        when 'tblLayout'
+          @table_layout = TableLayout.new(parent: self).parse(node_child)
+        when 'tblCellSpacing'
+          @table_cell_spacing = OoxmlSize.new.parse(node_child)
+        when 'tblCaption'
+          @caption = ValuedChild.new(:string, parent: self).parse(node_child)
+        when 'tblDescription'
+          @description = ValuedChild.new(:string, parent: self).parse(node_child)
         end
       end
-      table_properties.table_look = TableLook.parse(table_properties_node) if table_properties.table_look.nil?
-      table_properties.right_to_left = OOXMLDocumentObject.option_enabled?(table_properties_node, 'rtl')
-      table_properties
+      @table_look = TableLook.new(parent: self).parse(node) if @table_look.nil?
+      self
     end
   end
 end

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

@@ -7,35 +7,41 @@ module OoxmlParser
   class Table < OOXMLDocumentObject
     attr_accessor :grid, :rows, :properties, :number
 
-    def initialize(rows = [])
+    def initialize(rows = [], parent: nil)
       @rows = rows
+      @parent = parent
     end
 
     alias table_properties properties
 
-    def self.parse(table_node, number = 0, default_table_properties = TableProperties.new, default_paragraph = DocxParagraph.new, default_run = DocxParagraphRun.new)
+    def to_s
+      "Rows: #{@rows.join(',')}"
+    end
+
+    def inspect
+      to_s
+    end
+
+    # Parse Table object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Table] result of parsing
+    def parse(node,
+              number = 0,
+              default_table_properties = TableProperties.new)
       table_properties = default_table_properties.copy
       table_properties.jc = :left
-      table_paragraph = default_paragraph.copy
-      table_character = default_run.copy
-      table = Table.new
-      table_node.xpath('*').each do |table_node_child|
-        case table_node_child.name
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'tblGrid'
-          table.grid = TableGrid.new
-          table_node_child.xpath('gridCol').each do |grid_col_node|
-            table.grid.columns << (grid_col_node.attribute('w').value.to_f / 360_000.0).round(2)
-          end
+          @grid = TableGrid.new(parent: self).parse(node_child)
         when 'tr'
-          table.rows << TableRow.parse(table_node_child)
+          @rows << TableRow.new(parent: self).parse(node_child)
         when 'tblPr'
-          table.properties = TableProperties.parse(table_node_child)
-        when ''
-          DocxParagraph.parse_paragraph_style(table_node_child, table_paragraph, table_character)
+          @properties = TableProperties.new(parent: self).parse(node_child)
         end
       end
-      table.number = number
-      table
+      @number = number
+      self
     end
   end
 end

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

@@ -1,11 +1,12 @@
-# Class for working Underline style parameter
 module OoxmlParser
-  class Underline
+  # Class for parsing `u` tags
+  class Underline < OOXMLDocumentObject
     attr_accessor :style, :color
 
-    def initialize(style = :none, color = nil)
-      @style = (style == 'single') ? :single : style
+    def initialize(style = :none, color = nil, parent: nil)
+      @style = style == 'single' ? :single : style
       @color = color
+      @parent = parent
     end
 
     def ==(other)
@@ -26,15 +27,17 @@ module OoxmlParser
       end
     end
 
-    def self.parse(attribute_value)
-      underline = Underline.new
-      case attribute_value
+    # Parse Underline object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Underline] result of parsing
+    def parse(node)
+      case node
       when 'sng'
-        underline.style = :single
+        @style = :single
       when 'none'
-        underline.style = :none
+        @style = :none
       end
-      underline
+      self
     end
   end
 end

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

@@ -0,0 +1,29 @@
+module OoxmlParser
+  # Class for working with any tag contained only value
+  class ValuedChild < OOXMLDocumentObject
+    # @return [String] value of tag
+    attr_accessor :value
+    # @return [String] type of value
+    attr_reader :type
+
+    def initialize(type = :string, parent: nil)
+      @parent = parent
+      @type = type
+    end
+
+    # Parse ValuedChild object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ValuedChild] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'val'
+          @value = value.value.to_s if type == :string
+          @value = value_to_symbol(value) if type == :symbol
+          @value = value.value.to_i if type == :integer
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/parser.rb

@@ -1,17 +1,45 @@
 module OoxmlParser
   class Parser
-    # Base method to parse document of any type
+    # Base method to yield parse document of any type
     # @param path_to_file [String] file
     # @return [CommonDocumentStructure] structure of doc
-    def self.parse(path_to_file)
+    def self.parse_format(path_to_file)
       return nil if OOXMLDocumentObject.encrypted_file?(path_to_file)
       path_to_zip_file = OOXMLDocumentObject.copy_file_and_rename_to_zip(path_to_file)
       OOXMLDocumentObject.path_to_folder = path_to_zip_file.sub(File.basename(path_to_zip_file), '')
       OOXMLDocumentObject.unzip_file(path_to_zip_file, OOXMLDocumentObject.path_to_folder)
       model = yield
-      model.file_path = path_to_file
-      FileUtils.remove_dir(OOXMLDocumentObject.path_to_folder)
+      model.file_path = path_to_file if model
+      FileUtils.rm_rf(OOXMLDocumentObject.path_to_folder)
       model
     end
+
+    # Base method to parse document of any type
+    # @param path_to_file [String] file
+    # @return [CommonDocumentStructure] structure of doc
+    def self.parse(path_to_file)
+      Parser.parse_format(path_to_file) do
+        format = Parser.recognize_folder_format
+        case format
+        when :docx
+          DocumentStructure.parse
+        when :xlsx
+          XLSXWorkbook.parse
+        when :pptx
+          Presentation.parse
+        else
+          warn "#{path_to_file} is a simple zip file without OOXML content"
+        end
+      end
+    end
+
+    # Recognize folder format
+    # @param directory [String] path to dirctory
+    # @return [Symbol] type of document
+    def self.recognize_folder_format(directory = OOXMLDocumentObject.path_to_folder)
+      return :docx if Dir.exist?("#{directory}/word")
+      return :xlsx if Dir.exist?("#{directory}/xl")
+      return :pptx if Dir.exist?("#{directory}/ppt")
+    end
   end
 end

data/lib/ooxml_parser/configuration.rb

@@ -1,20 +1,10 @@
 module OoxmlParser
   class Configuration
-    attr_accessor :units
+    # @return [Integer] accuracy of digits in fraction part
+    attr_accessor :accuracy
 
     def initialize
-      @units = :centimeters
-    end
-
-    # @return [Float] by which divide units values
-    def units_delimiter
-      return (20 * 635.0) if @units == :points
-      return (566.929 * 635.0) if @units == :centimeters
-      return 1 if @units == :dxa
-      return 1440 if @units == :inches
-      return (1.0 / 635.0) if @units == :emu
-      warn "Cannot recognize #{@units} unit. Will use dxa by default"
-      1
+      @accuracy = 2
     end
   end
 end

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

@@ -17,7 +17,7 @@ module OoxmlParser
         document.xpath('w:comment').each do |comment_tag|
           comment = Comment.new(comment_tag.attribute('id').value)
           comment_tag.xpath('w:p').each_with_index do |p, index|
-            comment.paragraphs << DocxParagraph.parse(p, index)
+            comment.paragraphs << DocxParagraph.new.parse(p, index)
           end
           comments << comment.dup
         end

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

@@ -1,36 +1,36 @@
 module OoxmlParser
   # Class for describing Document Background `w:background`
-  class DocumentBackground
-    attr_accessor :color1, :size, :color2, :image, :type
+  class DocumentBackground < OOXMLDocumentObject
+    attr_accessor :color1, :size, :color2, :type
+    # @return [FileReference] image structure
+    attr_accessor :file_reference
 
-    def initialize(color1 = nil, type = 'simple')
-      @color1 = color1
-      @type = type
+    def initialize(parent: nil)
+      @color1 = nil
+      @type = 'simple'
+      @parent = parent
     end
 
     # Parse DocumentBackground object
     # @param node [Nokogiri::XML:Element] node to parse
     # @return [DocumentBackground] result of parsing
-    def self.parse(node)
-      background = DocumentBackground.new
-      background.color1 = Color.from_int16(node.attribute('color').value)
+    def parse(node)
+      @color1 = Color.new(parent: self).parse_hex_string(node.attribute('color').value)
       node.xpath('v:background').each do |second_color|
         unless second_color.attribute('targetscreensize').nil?
-          background.size = second_color.attribute('targetscreensize').value.sub(',', 'x')
+          @size = second_color.attribute('targetscreensize').value.sub(',', 'x')
         end
         second_color.xpath('v:fill').each do |fill|
           if !fill.attribute('color2').nil?
-            background.color2 = Color.from_int16(fill.attribute('color2').value.split(' ').first.delete('#'))
-            background.type = fill.attribute('type').value
+            @color2 = Color.new(parent: self).parse_hex_string(fill.attribute('color2').value.split(' ').first.delete('#'))
+            @type = fill.attribute('type').value
           elsif !fill.attribute('id').nil?
-            path_to_media_file = OOXMLDocumentObject.get_link_from_rels(fill.attribute('id').value)
-            path_to_image = OOXMLDocumentObject.copy_media_file("#{OOXMLDocumentObject.root_subfolder}/#{path_to_media_file.gsub('..', '')}")
-            background.image = path_to_image
-            background.type = 'image'
+            @file_reference = FileReference.new(parent: self).parse(fill)
+            @type = 'image'
           end
         end
       end
-      background
+      self
     end
   end
 end

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

@@ -1,26 +1,31 @@
-# Document Properties
 module OoxmlParser
+  # Document Properties
   class DocumentProperties < OOXMLDocumentObject
     attr_accessor :pages, :words
 
-    def initialize(pages = nil, words = nil)
-      @pages = pages
-      @words = words
-    end
-
     # Parse Document properties
     # @return [DocumentProperties]
-    def self.parse
-      properties = DocumentProperties.new
+    def parse
       properties_file = "#{OOXMLDocumentObject.path_to_folder}docProps/app.xml"
       unless File.exist?(properties_file)
         warn "There is no 'docProps/app.xml' in docx. It may be some problem with it"
-        return properties
+        return self
+      end
+      node = Nokogiri::XML(File.open(properties_file))
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'Properties'
+          node_child.xpath('*').each do |node_child_child|
+            case node_child_child.name
+            when 'Pages'
+              @pages = node_child_child.text.to_i
+            when 'Words'
+              @words = node_child_child.text.to_i
+            end
+          end
+        end
       end
-      doc_props = XmlSimple.xml_in(File.open(properties_file))
-      properties.pages = doc_props['Pages'].first.to_i unless doc_props['Pages'].nil?
-      properties.words = doc_props['Words'].first.to_i unless doc_props['Words'].nil?
-      properties
+      self
     end
   end
 end