ooxml_parser 0.1.2 → 0.2.0

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

@@ -0,0 +1,50 @@
+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 [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
+      @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 '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,23 @@
+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 [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/row/cell/cell.rb

@@ -1,43 +1,48 @@
 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(text_body = nil)
-      @text_body = text_body
+    def initialize(parent: nil)
       @elements = []
+      @parent = parent
     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|
+    # 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'
-          cell.grid_span = value.value.to_i
+          @grid_span = value.value.to_i
         when 'hMerge'
-          cell.horizontal_merge = value.value.to_i
+          @horizontal_merge = value.value.to_i
         when 'vMerge'
-          cell.vertical_merge = value.value.to_i
+          @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.copy.parse(node_child,
+                                                                                  0,
+                                                                                  DocumentStructure.default_table_run_style,
+                                                                                  parent: self)
+        when 'tbl'
+          @elements << Table.new(parent: self).parse(node_child)
         end
       end
-      cell
+      self
     end
   end
 end

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

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

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

@@ -1,85 +1,87 @@
+require_relative 'cell_properties/vertical_merge'
 require_relative 'merge'
 module OoxmlParser
+  # Class for parsing 'w:tcPr' element
   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
+    attr_accessor :fill, :color, :borders, :text_direction, :anchor, :anchor_center, :horizontal_overflow, :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
 
-    def initialize(borders = nil, color = nil)
-      @borders = borders
-      @color = color
-      @fill = fill
-      @shd = :none
-      @merge = false
-    end
+    alias table_cell_borders borders_properties
 
-    alias table_cell_margin margins
-    alias table_cell_margin= margins=
+    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 = VerticalMerge.new.parse(node_child)
+        when 'vAlign'
+          @vertical_align = node_child.attribute('val').value.to_sym
+        when 'gridSpan'
+          @grid_span = GridSpan.new.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 '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
 
-    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|
+      node.attributes.each do |key, value|
         case key
         when 'vert'
-          cell_properties.text_direction = value.value.to_sym
+          @text_direction = value.value.to_sym
         when 'anchor'
-          cell_properties.anchor = Alignment.parse(value)
+          @anchor = value_to_symbol(value)
         when 'anchorCtr'
-          cell_properties.anchor_center = value.value
+          @anchor_center = value.value
         when 'horzOverflow'
-          cell_properties.horizontal_overflow = value.value.to_sym
+          @horizontal_overflow = value.value.to_sym
         end
       end
-      cell_borders = Borders.new
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:vMerge").each do |v_merge|
-        cell_properties.merge = CellMerge.parse(v_merge)
-      end
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:vAlign").each do |valign_node|
-        cell_properties.vertical_align = valign_node.attribute('val').value.to_sym
-      end
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:gridSpan").each do |grid_span|
-        cell_properties.merge = CellMerge.new('horizontal', grid_span.attribute('val').value)
-      end
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}: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("#{OOXMLDocumentObject.namespace_prefix}:tcMar").each do |cell_margins_node|
-        cell_properties.table_cell_margin = TableMargins.parse(cell_margins_node)
-      end
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:textDirection").each do |text_direction|
-        cell_properties.text_direction = Alignment.parse(text_direction.attribute('val'))
-      end
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:tcBorders").each do |tc_boders|
-        tc_boders.xpath("#{OOXMLDocumentObject.namespace_prefix}:top").each do |top|
-          cell_borders.top = BordersProperties.parse(top)
-        end
-        tc_boders.xpath("#{OOXMLDocumentObject.namespace_prefix}:right").each do |right|
-          cell_borders.right = BordersProperties.parse(right)
-        end
-        tc_boders.xpath("#{OOXMLDocumentObject.namespace_prefix}:left").each do |left|
-          cell_borders.left = BordersProperties.parse(left)
-        end
-        tc_boders.xpath("#{OOXMLDocumentObject.namespace_prefix}:bottom").each do |bottom|
-          cell_borders.bottom = BordersProperties.parse(bottom)
-        end
-        tc_boders.xpath("#{OOXMLDocumentObject.namespace_prefix}:tl2br").each do |tl2br|
-          cell_borders.top_left_to_bottom_right = BordersProperties.parse(tl2br)
-        end
-        tc_boders.xpath("#{OOXMLDocumentObject.namespace_prefix}:tr2bl").each do |tr2bl|
-          cell_borders.top_right_to_bottom_left = BordersProperties.parse(tr2bl)
-        end
-      end
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:shd").each do |shd|
-        next if shd.attribute('val').value == 'nil'
-        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
-      cell_properties_node.xpath("#{OOXMLDocumentObject.namespace_prefix}:fill").each do |fill|
-        cell_properties.fill = DocxColorScheme.parse(fill)
-      end
-      cell_properties.borders_properties = cell_borders
-      cell_properties
+      self
     end
   end
 end

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

@@ -1,5 +1,5 @@
 module OoxmlParser
-  class CellMerge
+  class GridSpan
     attr_accessor :type, :count_of_merged_cells, :value
 
     def initialize(type = 'horizontal', value = nil, count_of_merged_cells = 2)
@@ -8,15 +8,23 @@ module OoxmlParser
       @value = value
     end
 
-    # Parse Merge data
-    # @param [Nokogiri::XML:Element] node with Merge data
-    # @return [CellMerge] value of CellMerge
-    def self.parse(node)
-      merge = CellMerge.new
-      merge.count_of_merged_cells = node.attribute('count_rows_in_span').nil? ? nil : node.attribute('count_rows_in_span').value
-      merge.value = node.attribute('val').nil? ? nil : node.attribute('val').value.to_sym
-      merge.type = node.attribute('type').nil? ? nil : node.attribute('type').value.to_sym
-      merge
+    alias count_rows_in_span count_of_merged_cells
+
+    # Parse Grid Span data
+    # @param [Nokogiri::XML:Element] node with GridSpan data
+    # @return [GridSpan] value of GridSpan
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'count_rows_in_span'
+          @count_of_merged_cells = value.value
+        when 'val'
+          @value = value.value.to_i
+        when 'type'
+          @type = value.value.to_sym
+        end
+      end
+      self
     end
   end
 end

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

@@ -1,25 +1,27 @@
 require_relative 'table_cell_line'
-# Border Data
 module OoxmlParser
-  class Border
+  # Border Data
+  class Border < OOXMLDocumentObject
     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
+    # Parse Border object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Border] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'style'
+          @style = value_to_symbol(value)
+        end
+      end
 
-    def to_s
-      "Border style: #{style}, color: #{color}"
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'color'
+          @color = Color.parse_color_tag(node_child)
+        end
+      end
+      self
     end
   end
 end

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

@@ -1,6 +1,6 @@
 require_relative 'border'
 module OoxmlParser
-  class Borders < OOXMLDocumentObject
+  class Borders < ParagraphBorders
     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
 
@@ -8,12 +8,14 @@ module OoxmlParser
                    right = BordersProperties.new,
                    top = BordersProperties.new,
                    bottom = BordersProperties.new,
-                   between = BordersProperties.new)
+                   between = BordersProperties.new,
+                   parent: nil)
       @left = left
       @right = right
       @top = top
       @bottom = bottom
       @between = between
+      @parent = parent
     end
 
     def copy
@@ -46,19 +48,6 @@ module OoxmlParser
       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
@@ -71,53 +60,47 @@ module OoxmlParser
       visible
     end
 
-    def self.parse(borders_node)
-      borders = Borders.new
-      borders_node.xpath('*').each do |border_node|
-        case border_node.name
+    # Parse Borders object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Borders] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'lnL', 'left'
-          borders.left = TableCellLine.parse(border_node)
+          @left = TableCellLine.new(parent: self).parse(node_child)
         when 'lnR', 'right'
-          borders.right = TableCellLine.parse(border_node)
+          @right = TableCellLine.new(parent: self).parse(node_child)
         when 'lnT', 'top'
-          borders.top = TableCellLine.parse(border_node)
+          @top = TableCellLine.new(parent: self).parse(node_child)
         when 'lnB', 'bottom'
-          borders.bottom = TableCellLine.parse(border_node)
+          @bottom = TableCellLine.new(parent: self).parse(node_child)
         when 'lnTlToBr', 'tl2br'
-          borders.top_left_to_bottom_right = TableCellLine.parse(border_node)
+          @top_left_to_bottom_right = TableCellLine.new(parent: self).parse(node_child)
         when 'lnBlToTr', 'tr2bl'
-          borders.top_right_to_bottom_left = TableCellLine.parse(border_node)
+          @top_right_to_bottom_left = TableCellLine.new(parent: self).parse(node_child)
         when 'insideV'
-          borders.inner_vertical = TableCellLine.parse(border_node)
+          @inner_vertical = TableCellLine.new(parent: self).parse(node_child)
         when 'insideH'
-          borders.inner_horizontal = TableCellLine.parse(border_node)
+          @inner_horizontal = TableCellLine.new(parent: self).parse(node_child)
         end
       end
-      borders
+      self
     end
 
     def self.parse_from_style(style_number)
-      border_style_node = XLSXWorkbook.styles_node.xpath('//xmlns:border')[style_number.to_i]
+      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])
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'bottom'
+          cell_borders.bottom = Border.new(parent: cell_borders).parse(node_child)
+        when 'top'
+          cell_borders.top = Border.new(parent: cell_borders).parse(node_child)
+        when 'right'
+          cell_borders.right = Border.new(parent: cell_borders).parse(node_child)
+        when 'left'
+          cell_borders.left = Border.new(parent: cell_borders).parse(node_child)
+        end
       end
       cell_borders
     end

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

@@ -0,0 +1,21 @@
+module OoxmlParser
+  class LineJoin < OOXMLDocumentObject
+    attr_accessor :type, :limit
+
+    # Parse LineJoin object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [LineJoin] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'round', 'bevel'
+          @type = node_child.name.to_sym
+        when 'miter'
+          @type = :miter
+          @limit = node_child.attribute('lim').value.to_f
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -1,35 +1,41 @@
+require_relative 'table_cell_line/line_join'
 module OoxmlParser
+  # Class for parsing Table Cell Lines
   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)
+    def initialize(fill = nil, line_join = nil, parent: nil)
       @fill = fill
       @line_join = line_join
+      @parent = parent
     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|
+    # Parse TableCellLine object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TableCellLine] result of parsing
+    def parse(node)
+      @fill = PresentationFill.new(parent: self).parse(node)
+      @line_join = LineJoin.new(parent: self).parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'w'
-          line.width = value.value.to_f / 12_700.0
+          @width = OoxmlSize.new(value.value.to_f, :emu)
         when 'algn'
-          line.align = Alignment.parse(value)
+          @align = value_to_symbol(value)
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'headEnd'
+          @head_end = LineEnd.new(parent: self).parse(node_child)
+        when 'tailEnd'
+          @tail_end = LineEnd.new(parent: self).parse(node_child)
+        when 'ln'
+          return TableCellLine.new(parent: self).parse(node_child)
         end
       end
-      line
+      self
     end
   end
 end

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

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