ooxml_parser 0.14.1-mingw32

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Describe single table element
+  class TableElement < OOXMLDocumentObject
+    attr_accessor :cell_style
+
+    alias cell_properties cell_style
+
+    # 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'
+          @cell_style = CellProperties.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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(parent: nil)
+      @first_row = false
+      @first_column = false
+      @last_row = false
+      @last_column = false
+      @banding_row = false
+      @banding_column = false
+      @no_horizontal_banding = false
+      @no_horizontal_banding = false
+      super
+    end
+
+    # 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'
+          @first_row = attribute_enabled?(value)
+        when 'lastRow'
+          @last_row = attribute_enabled?(value)
+        when 'firstCol', 'firstColumn'
+          @first_column = attribute_enabled?(value)
+        when 'lastCol', 'lastColumn'
+          @last_column = attribute_enabled?(value)
+        when 'noHBand'
+          @no_horizontal_banding = attribute_enabled?(value)
+        when 'noVBand'
+          @no_vertical_banding = attribute_enabled?(value)
+        when 'bandRow'
+          @banding_row = attribute_enabled?(value)
+        when 'bandCol'
+          @banding_column = attribute_enabled?(value)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Table Position Data
+  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
+
+    # @return [String] result of convert of object to string
+    def to_s
+      "Table position left: #{left}, "\
+        "right: #{right}, "\
+        "top: #{top}, "\
+        "bottom #{bottom}, "\
+        "position x: #{position_x}, "\
+        "position y: #{position_y}"
+    end
+
+    # 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'
+          @left = OoxmlSize.new(value.value.to_f)
+        when 'rightFromText'
+          @right = OoxmlSize.new(value.value.to_f)
+        when 'topFromText'
+          @top = OoxmlSize.new(value.value.to_f)
+        when 'bottomFromText'
+          @bottom = OoxmlSize.new(value.value.to_f)
+        when 'tblpX'
+          @position_x = OoxmlSize.new(value.value.to_f)
+        when 'tblpY'
+          @position_y = OoxmlSize.new(value.value.to_f)
+        when 'vertAnchor'
+          @vertical_anchor = value.value.to_sym
+        when 'horzAnchor'
+          @horizontal_anchor = value.value.to_sym
+        when 'tblpXSpec'
+          @horizontal_align_from_anchor = value.value.to_sym
+        when 'tblpYSpec'
+          @vertical_align_from_anchor = value.value.to_sym
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'table_element'
+module OoxmlParser
+  # Style of Table
+  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
+    # @return [String] value of table style
+    attr_reader :value
+
+    # Parse TableStyle object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableStyle] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'styleId'
+          @id = value.value.to_s
+        when 'styleName'
+          @name = value.value.to_s
+        when 'val'
+          @value = value.value.to_s
+        end
+      end
+
+      node.xpath('*').each do |style_node_child|
+        case style_node_child.name
+        when 'wholeTbl'
+          @whole_table = TableElement.new(parent: self).parse(style_node_child)
+        when 'band1H'
+          @banding_1_horizontal = TableElement.new(parent: self).parse(style_node_child)
+        when 'band2H', 'band2Horz'
+          @banding_2_horizontal = TableElement.new(parent: self).parse(style_node_child)
+        when 'band1V'
+          @banding_1_vertical = TableElement.new(parent: self).parse(style_node_child)
+        when 'band2V'
+          @banding_2_vertical = TableElement.new(parent: self).parse(style_node_child)
+        when 'lastCol'
+          @last_column = TableElement.new(parent: self).parse(style_node_child)
+        when 'firstCol'
+          @first_column = TableElement.new(parent: self).parse(style_node_child)
+        when 'lastRow'
+          @last_row = TableElement.new(parent: self).parse(style_node_child)
+        when 'firstRow'
+          @first_row = TableElement.new(parent: self).parse(style_node_child)
+        when 'seCell'
+          @southeast_cell = TableElement.new(parent: self).parse(style_node_child)
+        when 'swCell'
+          @southwest_cell = TableElement.new(parent: self).parse(style_node_child)
+        when 'neCell'
+          @northeast_cell = TableElement.new(parent: self).parse(style_node_child)
+        when 'nwCell'
+          @northwest_cell = TableElement.new(parent: self).parse(style_node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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,45 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Helper method for working with TableStyleProperties
+  module TableStylePropertiesHelper
+    # [Hash] short names for table styles
+    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.each do |key, value|
+      define_method(key) do
+        @table_style_properties_list.each do |table_style|
+          return table_style if table_style.type == value
+        end
+      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.each_value 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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'table_style_properties/table_style_properties_helper'
+module OoxmlParser
+  # Class for parsing `w:tblStylePr`
+  class TableStyleProperties < OOXMLDocumentObject
+    # @return [Symbol] type of Table Style Properties
+    attr_accessor :type
+    # @return [RunProperties] properties of run
+    attr_accessor :run_properties
+    # @return [CellProperties] properties of table cell
+    attr_accessor :table_cell_properties
+    # @return [TableProperties] properties of table
+    attr_accessor :table_properties
+    # @return [TableRowProperties] properties of table row
+    attr_reader :table_row_properties
+    # @return [ParagraphProperties] properties of paragraph
+    attr_accessor :paragraph_properties
+
+    alias cell_properties table_cell_properties
+
+    def initialize(type: nil, parent: nil)
+      @type = type
+      @run_properties = nil
+      @table_cell_properties = CellProperties.new
+      super(parent: parent)
+    end
+
+    # Parse table style property
+    # @param node [Nokogiri::XML::Element] node to parse
+    # @return [TableStyleProperties]
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'type'
+          @type = value.value.to_sym
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'rPr'
+          @run_properties = RunProperties.new(parent: self).parse(node_child)
+        when 'tcPr'
+          @table_cell_properties = CellProperties.new(parent: self).parse(node_child)
+        when 'tblPr'
+          @table_properties = TableProperties.new(parent: self).parse(node_child)
+        when 'trPr'
+          @table_row_properties = TableRowProperties.new(parent: self).parse(node_child)
+        when 'pPr'
+          @paragraph_properties = ParagraphProperties.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `w:tblStyleRowBandSize` object
+  # When a style specifies the format for a band for
+  # rows in a table (a set of contiguous rows), this
+  # specifies the number of rows in a band.
+  class TableStyleRowBandSize < OOXMLDocumentObject
+    # @return [Integer] value of table style column band size
+    attr_accessor :value
+
+    # Parse TableStyleRowBandSize
+    # @param [Nokogiri::XML:Node] node with TableStyleRowBandSize
+    # @return [TableStyleRowBandSize] 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/row/cell/cell.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'properties/borders'
+require_relative 'cell_properties'
+module OoxmlParser
+  # Class for parsing `tc` tags
+  class TableCell < OOXMLDocumentObject
+    attr_accessor :text_body, :properties, :grid_span, :horizontal_merge, :vertical_merge, :elements
+
+    def initialize(parent: nil)
+      @elements = []
+      super
+    end
+
+    alias cell_properties properties
+
+    # Parse TableCell object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableCell] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'gridSpan'
+          @grid_span = value.value.to_i
+        when 'hMerge'
+          @horizontal_merge = value.value.to_i
+        when 'vMerge'
+          @vertical_merge = value.value.to_i
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'txBody'
+          @text_body = TextBody.new(parent: self).parse(node_child)
+        when 'tcPr'
+          @properties = CellProperties.new(parent: self).parse(node_child)
+        when 'p'
+          @elements << DocumentStructure.default_table_paragraph_style.dup.parse(node_child,
+                                                                                 0,
+                                                                                 DocumentStructure.default_table_run_style,
+                                                                                 parent: self)
+        when 'sdt'
+          @elements << StructuredDocumentTag.new(parent: self).parse(node_child)
+        when 'tbl'
+          @elements << Table.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative 'grid_span'
+module OoxmlParser
+  # Class for parsing 'w:tcPr' element
+  class CellProperties < OOXMLDocumentObject
+    attr_accessor :fill, :color, :borders, :text_direction, :anchor, :table_cell_width, :borders_properties, :vertical_align
+    # @return [GridSpan] data about grid span
+    attr_accessor :grid_span
+    # @return [TableMargins] margins
+    attr_accessor :vertical_merge
+    # @return [ParagraphMargins] margins of text in cell
+    attr_accessor :margins
+    # @return [Shade] shade of cell
+    attr_accessor :shade
+    # @return [TableMargins] margins of cell
+    attr_accessor :table_cell_margin
+    # @return [True, False] This element will prevent text from
+    # wrapping in the cell under certain conditions. If the cell width is fixed,
+    # then noWrap specifies that the cell will not be smaller than that fixed
+    # value when other cells in the row are not at their minimum. If the cell
+    # width is set to auto or pct, then the content of the cell will not wrap.
+    # > ECMA-376, 3rd Edition (June, 2011), Fundamentals and Markup Language Reference 17.4.30.
+    attr_accessor :no_wrap
+
+    alias table_cell_borders borders_properties
+
+    # Parse CellProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [CellProperties] result of parsing
+    def parse(node)
+      @borders_properties = Borders.new
+      @margins = ParagraphMargins.new(parent: self).parse(node)
+      @color = PresentationFill.new(parent: self).parse(node)
+      @borders = Borders.new(parent: self).parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'vMerge'
+          @vertical_merge = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        when 'vAlign'
+          @vertical_align = node_child.attribute('val').value.to_sym
+        when 'gridSpan'
+          @grid_span = GridSpan.new(parent: self).parse(node_child)
+        when 'tcW'
+          @table_cell_width = OoxmlSize.new(node_child.attribute('w').value.to_f)
+        when 'tcMar'
+          @table_cell_margin = TableMargins.new(parent: self).parse(node_child)
+        when 'textDirection'
+          @text_direction = value_to_symbol(node_child.attribute('val'))
+        when 'noWrap'
+          @no_wrap = option_enabled?(node_child)
+        when 'shd'
+          @shade = Shade.new(parent: self).parse(node_child)
+        when 'fill'
+          @fill = DocxColorScheme.new(parent: self).parse(node_child)
+        when 'tcBdr'
+          @borders_properties = Borders.new(parent: self).parse(node_child)
+        when 'tcBorders'
+          node_child.xpath('*').each do |border_child|
+            case border_child.name
+            when 'top'
+              @borders_properties.top = BordersProperties.new(parent: self).parse(border_child)
+            when 'right'
+              @borders_properties.right = BordersProperties.new(parent: self).parse(border_child)
+            when 'left'
+              @borders_properties.left = BordersProperties.new(parent: self).parse(border_child)
+            when 'bottom'
+              @borders_properties.bottom = BordersProperties.new(parent: self).parse(border_child)
+            when 'tl2br'
+              @borders_properties.top_left_to_bottom_right = BordersProperties.new(parent: self).parse(border_child)
+            when 'tr2bl'
+              @borders_properties.top_right_to_bottom_left = BordersProperties.new(parent: self).parse(border_child)
+            end
+          end
+        end
+      end
+
+      node.attributes.each do |key, value|
+        case key
+        when 'vert'
+          @text_direction = value.value.to_sym
+        when 'anchor'
+          @anchor = value_to_symbol(value)
+        end
+      end
+      self
+    end
+  end
+end