ooxml_parser 0.1.1

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

@@ -0,0 +1,83 @@
+require_relative 'table_style_elements'
+require_relative 'table_element'
+# Style of Table
+module OoxmlParser
+  class TableStyle < OOXMLDocumentObject
+    attr_accessor :id, :name, :whole_table, :banding_1_horizontal, :banding_2_horizontal, :banding_1_vertical, :banding_2_vertical,
+                  :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?
+        nodes = get_style_node(style_id)
+        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)
+          when 'band1H'
+            table_style.banding_1_horizontal = TableElement.parse(style_node_child)
+          when 'band2H', 'band2Horz'
+            table_style.banding_2_horizontal = TableElement.parse(style_node_child)
+          when 'band1V'
+            table_style.banding_1_vertical = TableElement.parse(style_node_child)
+          when 'band2V'
+            table_style.banding_2_vertical = TableElement.parse(style_node_child)
+          when 'lastCol'
+            table_style.last_column = TableElement.parse(style_node_child)
+          when 'firstCol'
+            table_style.first_column = TableElement.parse(style_node_child)
+          when 'lastRow'
+            table_style.last_row = TableElement.parse(style_node_child)
+          when 'firstRow'
+            table_style.first_row = TableElement.parse(style_node_child)
+          when 'seCell'
+            table_style.southeast_cell = TableElement.parse(style_node_child)
+          when 'swCell'
+            table_style.southwest_cell = TableElement.parse(style_node_child)
+          when 'neCell'
+            table_style.northeast_cell = TableElement.parse(style_node_child)
+          when 'nwCell'
+            table_style.northwest_cell = TableElement.parse(style_node_child)
+          end
+        end
+      end
+      table_style.id = style_id unless style_id.nil?
+      table_style
+    end
+
+    def self.get_style_node(style_id)
+      begin
+        doc = Nokogiri::XML(File.open(OOXMLDocumentObject.path_to_folder + 'ppt/tableStyles.xml'))
+      rescue StandardError
+        raise 'Can\'t find tableStyles.xml in ' + OOXMLDocumentObject.path_to_folder.to_s + '/ppt folder'
+      end
+      doc.xpath('a:tblStyleLst/a:tblStyle').each { |table_style_node| return table_style_node if table_style_node.attribute('styleId').value == style_id }
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Table Style in XLSX
+module OoxmlParser
+  class TableStyleElement
+    attr_accessor :cell_properties
+
+    def initialize
+      @cell_properties = CellProperties.new
+    end
+
+    def self.parse(style_node)
+      element_style = TableStyleElement.new
+      style_node.xpath('*').each do |style_node_child|
+        case style_node_child.name
+        when 'tcPr'
+          element_style.cell_properties = CellProperties.parse(style_node_child)
+        end
+      end
+      element_style
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/table/properties/whole_table/line_join.rb

@@ -0,0 +1,19 @@
+module OoxmlParser
+  class LineJoin
+    attr_accessor :type, :limit
+
+    def self.parse(parent_node)
+      line_join = LineJoin.new
+      parent_node.xpath('*').each do |line_join_node|
+        case line_join_node.name
+        when 'round', 'bevel'
+          line_join.type = line_join_node.name.to_sym
+        when 'miter'
+          line_join.type = :miter
+          line_join.limit = line_join_node.attribute('lim').value.to_f
+        end
+      end
+      line_join
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/table/properties/whole_table/table_cell_style.rb

@@ -0,0 +1,20 @@
+require_relative 'line_join'
+# Table Cell Style in XLSX
+module OoxmlParser
+  class TableCellStyle
+    attr_accessor :borders, :fill
+
+    def self.parse(cell_style_node)
+      cell_style = TableCellStyle.new
+      cell_style_node.xpath('*').each do |cell_node_child|
+        case cell_node_child.name
+        when 'tcBdr'
+          cell_style.borders = Borders.parse(cell_node_child)
+        when 'fill'
+          cell_style.fill = PresentationFill.parse(cell_node_child)
+        end
+      end
+      cell_style
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_relative 'properties/borders'
+require_relative 'cell_properties'
+module OoxmlParser
+  class TableCell < OOXMLDocumentObject
+    attr_accessor :text_body, :properties, :grid_span, :horizontal_merge, :vertical_merge, :elements
+
+    def initialize(text_body = nil)
+      @text_body = text_body
+      @elements = []
+    end
+
+    alias cell_properties properties
+
+    def self.parse(cell_node)
+      cell = TableCell.new
+      cell_node.xpath('*').each do |cell_node_child|
+        case cell_node_child.name
+        when 'txBody'
+          cell.text_body = TextBody.parse(cell_node_child)
+        when 'tcPr'
+          cell.properties = CellProperties.parse(cell_node_child)
+        when 'p'
+          paragraph = DocxParagraph.parse(cell_node_child, 0, DocumentStructure.default_table_paragraph_style, DocumentStructure.default_table_run_style)
+          cell.elements << paragraph
+        when 'tbl'
+          table = Table.parse(cell_node_child)
+          cell.elements << table
+        end
+      end
+      cell_node.attributes.each do |key, value|
+        case key
+        when 'gridSpan'
+          cell.grid_span = value.value.to_i
+        when 'hMerge'
+          cell.horizontal_merge = value.value.to_i
+        when 'vMerge'
+          cell.vertical_merge = value.value.to_i
+        end
+      end
+      cell
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require_relative 'merge'
+module OoxmlParser
+  class CellProperties < OOXMLDocumentObject
+    attr_accessor :fill, :color, :borders, :margins, :text_direction, :anchor, :anchor_center, :horizontal_overflow, :merge, :table_cell_width, :borders_properties, :shd, :vertical_align
+
+    def initialize(borders = nil, color = nil)
+      @borders = borders
+      @color = color
+      @fill = fill
+      @shd = :none
+      @merge = false
+    end
+
+    alias table_cell_margin margins
+    alias table_cell_margin= margins=
+
+    def self.parse(cell_properties_node)
+      cell_properties = CellProperties.new(Borders.parse(cell_properties_node), PresentationFill.parse(cell_properties_node))
+      cell_properties.margins = ParagraphMargins.parse(cell_properties_node)
+      cell_properties_node.attributes.each do |key, value|
+        case key
+        when 'vert'
+          cell_properties.text_direction = value.value.to_sym
+        when 'anchor'
+          cell_properties.anchor = Alignment.parse(value)
+        when 'anchorCtr'
+          cell_properties.anchor_center = value.value
+        when 'horzOverflow'
+          cell_properties.horizontal_overflow = value.value.to_sym
+        end
+      end
+      cell_borders = Borders.new
+      parse_w_namespace = true
+      begin
+        cell_properties_node.xpath('w:vMerge') # TODO: Perform not so stupit check
+      rescue Nokogiri::XML::XPath::SyntaxError
+        parse_w_namespace = false
+      end
+      if parse_w_namespace
+        cell_properties_node.xpath('w:vMerge').each do |v_merge|
+          merge = v_merge.attribute('count_rows_in_span').nil? ? nil : v_merge.attribute('count_rows_in_span').value
+          cell_properties.merge = CellMerge.new('vertical', v_merge.attribute('val').value, merge)
+        end
+        cell_properties_node.xpath('w:vAlign').each do |valign_node|
+          cell_properties.vertical_align = valign_node.attribute('val').value.to_sym
+        end
+        cell_properties_node.xpath('w:gridSpan').each do |grid_span|
+          cell_properties.merge = CellMerge.new('horizontal', grid_span.attribute('val').value)
+        end
+        cell_properties_node.xpath('w:tcW').each do |table_cell_width|
+          cell_properties.table_cell_width = table_cell_width.attribute('w').value.to_f / 567.5
+        end
+        cell_properties_node.xpath('w:tcMar').each do |cell_margins_node|
+          cell_properties.table_cell_margin = TableMargins.parse(cell_margins_node)
+        end
+        cell_properties_node.xpath('w:textDirection').each do |text_direction|
+          cell_properties.text_direction = Alignment.parse(text_direction.attribute('val'))
+        end
+        cell_properties_node.xpath('w:tcBorders').each do |tc_boders|
+          tc_boders.xpath('w:top').each do |top|
+            top_border = BordersProperties.new
+            top_border.color = top.attribute('color').value
+            if !top.attribute('color').nil? && top.attribute('color').value != 'auto'
+              top_border.color = Color.from_int16(top.attribute('color').value)
+            end
+            top_border.sz = top.attribute('sz').value.to_f / 8.0
+            top_border.val = top.attribute('val').value
+            top_border.space = top.attribute('space').value
+            cell_borders.top = top_border
+          end
+          tc_boders.xpath('w:right').each do |right|
+            right_border = BordersProperties.new
+            right_border.color = right.attribute('color').value
+            if !right.attribute('color').nil? && right.attribute('color').value != 'auto'
+              right_border.color = Color.from_int16(right.attribute('color').value)
+            end
+            right_border.sz = right.attribute('sz').value.to_f / 8.0
+            right_border.val = right.attribute('val').value
+            right_border.space = right.attribute('space').value
+            cell_borders.right = right_border
+          end
+          tc_boders.xpath('w:left').each do |left|
+            left_border = BordersProperties.new
+            left_border.color = left.attribute('color').value
+            if !left.attribute('color').nil? && left.attribute('color').value != 'auto'
+              left_border.color = Color.from_int16(left.attribute('color').value)
+            end
+            left_border.sz = left.attribute('sz').value.to_f / 8.0
+            left_border.val = left.attribute('val').value
+            left_border.space = left.attribute('space').value
+            cell_borders.left = left_border
+          end
+          tc_boders.xpath('w:bottom').each do |bottom|
+            bottom_border = BordersProperties.new
+            bottom_border.color = bottom.attribute('color').value
+            if !bottom.attribute('color').nil? && bottom.attribute('color').value != 'auto'
+              bottom_border.color = Color.from_int16(bottom.attribute('color').value)
+            end
+            bottom_border.sz = bottom.attribute('sz').value.to_f / 8.0
+            bottom_border.val = bottom.attribute('val').value
+            bottom_border.space = bottom.attribute('space').value
+            cell_borders.bottom = bottom_border
+          end
+          tc_boders.xpath('w:tl2br').each do |tl2br|
+            top_left_to_bottom_right = BordersProperties.new
+            top_left_to_bottom_right.color = tl2br.attribute('color').value
+            if !tl2br.attribute('color').nil? && tl2br.attribute('color').value != 'auto'
+              top_left_to_bottom_right.color = Color.from_int16(tl2br.attribute('color').value)
+            end
+            top_left_to_bottom_right.sz = tl2br.attribute('sz').value.to_f / 8.0
+            top_left_to_bottom_right.val = tl2br.attribute('val').value
+            top_left_to_bottom_right.space = tl2br.attribute('space').value
+            cell_borders.top_left_to_bottom_right = top_left_to_bottom_right
+          end
+          tc_boders.xpath('w:tr2bl').each do |tr2bl|
+            top_right_to_bottom_left = BordersProperties.new
+            top_right_to_bottom_left.color = tr2bl.attribute('color').value
+            if !tr2bl.attribute('color').nil? && tr2bl.attribute('color').value != 'auto'
+              top_right_to_bottom_left.color = Color.from_int16(tr2bl.attribute('color').value)
+            end
+            top_right_to_bottom_left.sz = tr2bl.attribute('sz').value.to_f / 8.0
+            top_right_to_bottom_left.val = tr2bl.attribute('val').value
+            top_right_to_bottom_left.space = tr2bl.attribute('space').value
+            cell_borders.top_right_to_bottom_left = top_right_to_bottom_left
+          end
+        end
+        cell_properties_node.xpath('w:shd').each do |shd|
+          cell_properties.shd = shd.attribute('fill').value
+          if !shd.attribute('fill').nil? && shd.attribute('fill').value != 'auto'
+            cell_properties.shd = Color.from_int16(shd.attribute('fill').value)
+          end
+        end
+      else
+        cell_properties_node.xpath('a:fill').each do |fill|
+          cell_properties.fill = DocxColorScheme.parse(fill)
+        end
+      end
+      cell_properties.borders_properties = cell_borders
+      cell_properties
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module OoxmlParser
+  class CellMerge
+    attr_accessor :type, :count_of_merged_cells, :value
+
+    def initialize(type = 'horizontal', value = nil, count_of_merged_cells = 2)
+      @type = type
+      @count_of_merged_cells = count_of_merged_cells
+      @value = value
+    end
+
+    def self.parse_merge_hash(hash)
+      merge = CellMerge.new
+      merge.type = hash['type']
+      merge.count_of_merged_cells = hash['count_of_merged_cells']
+      merge
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/table/row/cell/properties/border.rb

@@ -0,0 +1,25 @@
+require_relative 'table_cell_line'
+# Border Data
+module OoxmlParser
+  class Border
+    attr_accessor :style, :color
+
+    def initialize(style = nil, color = nil)
+      @style = style
+      @color = color
+    end
+
+    def ==(other)
+      return true if nil? && other.nil?
+      return false if nil? && !other.nil?
+      return false if !nil? && other.nil?
+      return false if style != other.style
+      return false if color != other.color
+      true
+    end
+
+    def to_s
+      "Border style: #{style}, color: #{color}"
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/table/row/cell/properties/borders.rb

@@ -0,0 +1,125 @@
+require_relative 'border'
+module OoxmlParser
+  class Borders < OOXMLDocumentObject
+    attr_accessor :left, :right, :top, :bottom, :inner_vertical, :inner_horizontal, :display, :between, :bar,
+                  :top_left_to_bottom_right, :top_right_to_bottom_left, :offset_from
+
+    def initialize(left = BordersProperties.new,
+                   right = BordersProperties.new,
+                   top = BordersProperties.new,
+                   bottom = BordersProperties.new,
+                   between = BordersProperties.new)
+      @left = left
+      @right = right
+      @top = top
+      @bottom = bottom
+      @between = between
+    end
+
+    def copy
+      new_borders = Borders.new(@left, @right, @top, @bottom)
+      new_borders.inner_vertical = @inner_vertical unless @inner_vertical.nil?
+      new_borders.inner_horizontal = @inner_horizontal unless @inner_horizontal.nil?
+      new_borders.between = @between unless @between.nil?
+      new_borders.display = @display unless @display.nil?
+      new_borders.bar = @bar unless bar.nil?
+      new_borders
+    end
+
+    def ==(other)
+      @left == other.left && @right == other.right && @top == other.top && @bottom == other.bottom if other.is_a?(Borders)
+    end
+
+    def each_border
+      yield(bottom)
+      yield(inner_horizontal)
+      yield(inner_vertical)
+      yield(left)
+      yield(right)
+      yield(top)
+    end
+
+    def each_side
+      yield(bottom)
+      yield(left)
+      yield(right)
+      yield(top)
+    end
+
+    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]
+      return result.first if result.size == 1
+    end
+
+    def to_s
+      "Left border: #{left}, Right: #{right}, Top: #{top}, Bottom: #{bottom}"
+    end
+
+    def visible?
+      visible = false
+      each_side do |current_size|
+        visible ||= current_size.visible?
+      end
+      visible
+    end
+
+    def self.parse(borders_node)
+      borders = Borders.new
+      borders_node.xpath('*').each do |border_node|
+        case border_node.name
+        when 'lnL', 'left'
+          borders.left = TableCellLine.parse(border_node)
+        when 'lnR', 'right'
+          borders.right = TableCellLine.parse(border_node)
+        when 'lnT', 'top'
+          borders.top = TableCellLine.parse(border_node)
+        when 'lnB', 'bottom'
+          borders.bottom = TableCellLine.parse(border_node)
+        when 'lnTlToBr', 'tl2br'
+          borders.top_left_to_bottom_right = TableCellLine.parse(border_node)
+        when 'lnBlToTr', 'tr2bl'
+          borders.top_right_to_bottom_left = TableCellLine.parse(border_node)
+        when 'insideV'
+          borders.inner_vertical = TableCellLine.parse(border_node)
+        when 'insideH'
+          borders.inner_horizontal = TableCellLine.parse(border_node)
+        end
+      end
+      borders
+    end
+
+    def self.parse_from_style(style_number)
+      border_style_node = XLSXWorkbook.styles_node.xpath('//xmlns:border')[style_number.to_i]
+      cell_borders = Borders.new
+      unless border_style_node.xpath('xmlns:bottom')[0].attribute('style').nil?
+        cell_borders.bottom = Border.new
+        cell_borders.bottom.style = border_style_node.xpath('xmlns:bottom')[0].attribute('style').value
+        cell_borders.bottom.color = Color.parse_color_tag(border_style_node.xpath('xmlns:bottom/xmlns:color')[0])
+      end
+      unless border_style_node.xpath('xmlns:top')[0].attribute('style').nil?
+        cell_borders.top = Border.new
+        cell_borders.top.style = border_style_node.xpath('xmlns:top')[0].attribute('style').value
+        cell_borders.top.color = Color.parse_color_tag(border_style_node.xpath('xmlns:top/xmlns:color')[0])
+      end
+      unless border_style_node.xpath('xmlns:right')[0].attribute('style').nil?
+        cell_borders.right = Border.new
+        cell_borders.right.style = border_style_node.xpath('xmlns:right')[0].attribute('style').value
+        cell_borders.right.color = Color.parse_color_tag(border_style_node.xpath('xmlns:right/xmlns:color')[0])
+      end
+      unless border_style_node.xpath('xmlns:left')[0].attribute('style').nil?
+        cell_borders.left = Border.new
+        cell_borders.left.style = border_style_node.xpath('xmlns:left')[0].attribute('style').value
+        cell_borders.left.color = Color.parse_color_tag(border_style_node.xpath('xmlns:left/xmlns:color')[0])
+      end
+      cell_borders
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/table/row/cell/properties/table_cell_line.rb

@@ -0,0 +1,35 @@
+module OoxmlParser
+  class TableCellLine < OOXMLDocumentObject
+    attr_accessor :fill, :dash, :line_join, :head_end, :tail_end, :align, :width, :cap_type, :compound_line_type
+
+    def initialize(fill = nil, line_join = nil)
+      @fill = fill
+      @line_join = line_join
+    end
+
+    def self.parse(border_node)
+      line = TableCellLine.new(PresentationFill.parse(border_node), LineJoin.parse(border_node))
+      border_node.xpath('*').each do |border_node_child|
+        case border_node_child.name
+        when 'prstDash'
+        when 'custDash'
+        when 'headEnd'
+          line.head_end = LineEnd.parse(border_node_child)
+        when 'tailEnd'
+          line.tail_end = LineEnd.parse(border_node_child)
+        when 'ln'
+          return TableCellLine.parse(border_node_child)
+        end
+      end
+      border_node.attributes.each do |key, value|
+        case key
+        when 'w'
+          line.width = value.value.to_f / 12_700.0
+        when 'algn'
+          line.align = Alignment.parse(value)
+        end
+      end
+      line
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module OoxmlParser
+  # Class for describing Table Row Properties
+  class TableRowProperties
+    # @return [Float] Table Row Height
+    attr_accessor :height
+
+    def initialize
+      @height = nil
+    end
+
+    # 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
+      end
+      properties
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative 'cell/cell'
+require_relative 'row/table_row_properties'
+module OoxmlParser
+  class TableRow < OOXMLDocumentObject
+    attr_accessor :height, :cells, :cells_spacing, :table_row_properties
+
+    def initialize(cells = [])
+      @cells = cells
+    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)
+      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
+        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
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module OoxmlParser
+  class TableGrid
+    attr_accessor :columns, :mass_of_width_cells
+
+    def initialize(columns = [])
+      @columns = columns
+    end
+  end
+end