ooxml_parser 0.1.2 → 0.2.0

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/sheet_format_properties.rb

@@ -1,21 +1,21 @@
-# Class for storing SheetFormatProperties
 module OoxmlParser
-  class SheetFormatProperties
+  # Class for storing SheetFormatProperties
+  class SheetFormatProperties < OOXMLDocumentObject
     attr_accessor :default_column_width, :default_row_height
 
-    def initialize(column_width = nil, row_height = nil)
-      @default_column_width = column_width
-      @default_row_height = row_height
-    end
-
     # Parse SheetFormatProperties
     # @param node [Nokogiri::XML::Element] node to parse
     # @return [SheetFormatProperties] value of SheetFormatProperties
-    def self.parse(node)
-      format_properties = SheetFormatProperties.new
-      format_properties.default_column_width = node.attribute('defaultColWidth').value.to_f
-      format_properties.default_row_height = node.attribute('defaultRowHeight').value.to_f
-      format_properties
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'defaultColWidth'
+          @default_column_width = value.value.to_f
+        when 'defaultRowHeight'
+          @default_row_height = value.value.to_f
+        end
+      end
+      self
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/sheet_view/pane.rb

@@ -1,23 +1,25 @@
-# XLSX data of pane
 module OoxmlParser
-  class Pane
+  # Class for `pane` data
+  class Pane < OOXMLDocumentObject
     attr_accessor :state, :top_left_cell, :x_split, :y_split
 
-    def self.parse(pane_node)
-      pane = Pane.new
-      pane_node.attributes.each do |key, value|
+    # Parse Pane object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Pane] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'state'
-          pane.state = value.value.to_sym
+          @state = value.value.to_sym
         when 'topLeftCell'
-          pane.top_left_cell = Coordinates.parse_coordinates_from_string(value.value)
+          @top_left_cell = Coordinates.parse_coordinates_from_string(value.value)
         when 'xSplit'
-          pane.x_split = value.value
+          @x_split = value.value
         when 'ySplit'
-          pane.y_split = value.value
+          @y_split = value.value
         end
       end
-      pane
+      self
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/sheet_view.rb

@@ -1,18 +1,39 @@
 require_relative 'sheet_view/pane'
-# Class for Sheet View
 module OoxmlParser
-  class SheetView
+  # Class for `sheetView` data
+  class SheetView < OOXMLDocumentObject
     attr_accessor :pane
+    # @return [True, False] Flag indicating whether this sheet should display gridlines.
+    attr_accessor :show_gridlines
+    # @return [True, False] Flag indicating whether the sheet should display row and column headings.
+    attr_accessor :show_row_column_headers
 
-    def self.parse(sheet_view_node)
-      sheet_view = SheetView.new
-      sheet_view_node.xpath('*').each do |sheet_view_node_child|
-        case sheet_view_node_child.name
+    def initialize(parent: nil)
+      @parent = parent
+      @show_gridlines = true
+      @show_row_column_headers = true
+    end
+
+    # Parse SheetView object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [SheetView] result of parsing
+    def parse(node)
+      node.attributes.each do |key, _value|
+        case key
+        when 'showGridLines'
+          @show_gridlines = attribute_enabled?(node, key)
+        when 'showRowColHeaders'
+          @show_row_column_headers = attribute_enabled?(node, key)
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'pane'
-          sheet_view.pane = Pane.parse(sheet_view_node_child)
+          @pane = Pane.new(parent: self).parse(node_child)
         end
       end
-      sheet_view
+      self
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/table_part/extension_list/extension/x14_table.rb

@@ -0,0 +1,24 @@
+module OoxmlParser
+  # Class for `x14:table` data
+  class X14Table < OOXMLDocumentObject
+    # @return [String] alternate text for table
+    attr_accessor :alt_text
+    # @return [String] alternate text summary table
+    attr_accessor :alt_text_summary
+
+    # Parse X14Table data
+    # @param [Nokogiri::XML:Element] node with X14Table data
+    # @return [X14Table] value of X14Table data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'altText'
+          @alt_text = value.value.to_s
+        when 'altTextSummary'
+          @alt_text_summary = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/table_part/extension_list/extension.rb

@@ -0,0 +1,21 @@
+require_relative 'extension/x14_table'
+module OoxmlParser
+  # Class for `ext` data
+  class Extension < OOXMLDocumentObject
+    # @return [X14Table] table data in x14 namespace
+    attr_accessor :table
+
+    # Parse Extension data
+    # @param [Nokogiri::XML:Element] node with Extension data
+    # @return [Extension] value of Extension data
+    def parse(node)
+      node.xpath('*').each do |column_node|
+        case column_node.name
+        when 'table'
+          @table = X14Table.new(parent: self).parse(column_node)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/table_part/extension_list.rb

@@ -0,0 +1,30 @@
+require_relative 'extension_list/extension'
+module OoxmlParser
+  # Class for `extLst` data
+  class ExtensionList < OOXMLDocumentObject
+    attr_accessor :extension_array
+
+    def initialize(parent: nil)
+      @extension_array = []
+      @parent = parent
+    end
+
+    # @return [Array, Extension] accessor
+    def [](key)
+      @extension_array[key]
+    end
+
+    # Parse ExtensionList data
+    # @param [Nokogiri::XML:Element] node with ExtensionList data
+    # @return [ExtensionList] value of ExtensionList data
+    def parse(node)
+      node.xpath('*').each do |column_node|
+        case column_node.name
+        when 'ext'
+          @extension_array << Extension.new(parent: self).parse(column_node)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/table_part.rb

@@ -0,0 +1,37 @@
+require_relative 'table_part/extension_list'
+module OoxmlParser
+  # Class for `tablePart` data
+  class TablePart < OOXMLDocumentObject
+    attr_accessor :name, :display_name, :reference, :autofilter, :columns
+    # @return [ExtensionList] list of extensions
+    attr_accessor :extension_list
+
+    # Parse TablePart object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TablePart] result of parsing
+    def parse(node)
+      link_to_table_part_xml = OOXMLDocumentObject.get_link_from_rels(node.attribute('id').value)
+      doc = Nokogiri::XML(File.open(OOXMLDocumentObject.path_to_folder + link_to_table_part_xml.gsub('..', 'xl')))
+      table_node = doc.xpath('xmlns:table').first
+      table_node.attributes.each do |key, value|
+        case key
+        when 'name'
+          @name = value.value.to_s
+        when 'displayName'
+          @display_name = value.value.to_s
+        when 'ref'
+          @reference = Coordinates.parser_coordinates_range value.value.to_s
+        end
+      end
+      table_node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'autoFilter'
+          @autofilter = Coordinates.parser_coordinates_range node_child.attribute('ref').value
+        when 'extLst'
+          @extension_list = ExtensionList.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_column_properties.rb

@@ -1,21 +1,40 @@
-# Properties of XLSX column
 module OoxmlParser
+  # Properties of XLSX column
   class XlsxColumnProperties < OOXMLDocumentObject
     attr_accessor :from, :to, :width, :style
+    # @return [True, False] is width custom
+    attr_accessor :custom_width
+    # @return [True, False] Flag indicating if the
+    # specified column(s) is set to 'best fit'
+    attr_accessor :best_fit
 
-    def self.parse(col_node)
-      col = XlsxColumnProperties.new
-      col.from = col_node.attribute('min').value.to_i
-      col.to = col_node.attribute('max').value.to_i
-      col.style = CellStyle.parse(col_node.attribute('style').value) unless col_node.attribute('style').nil?
-      col.width = col_node.attribute('width').value.to_f - 0.7109375 if OOXMLDocumentObject.option_enabled?(col_node, 'customWidth')
-      col
+    # Parse XlsxColumnProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxColumnProperties] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'min'
+          @from = value.value.to_i
+        when 'max'
+          @to = value.value.to_i
+        when 'style'
+          @style = CellStyle.new(parent: self).parse(value.value)
+        when 'width'
+          @width = value.value.to_f - 0.7109375
+        when 'customWidth'
+          @custom_width = option_enabled?(node, 'customWidth')
+        when 'bestFit'
+          @best_fit = attribute_enabled?(value)
+        end
+      end
+      self
     end
 
-    def self.parse_list(columns_width_node)
+    def self.parse_list(columns_width_node, parent: nil)
       columns = []
       columns_width_node.xpath('xmlns:col').each do |col_node|
-        col = XlsxColumnProperties.parse(col_node)
+        col = XlsxColumnProperties.new(parent: parent).parse(col_node)
         columns << col
       end
       columns

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_drawing/xlsx_drawing_position_parameters.rb

@@ -0,0 +1,25 @@
+module OoxmlParser
+  # Class for parsing offset of drawing `xdr:from`, `xdr:to`
+  class XlsxDrawingPositionParameters < OOXMLDocumentObject
+    attr_accessor :column, :column_offset, :row, :row_offset
+
+    # Parse XlsxDrawingPositionParameters object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxDrawingPositionParameters] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'col'
+          @column = Coordinates.get_column_name(node_child.text.to_i + 1)
+        when 'colOff'
+          @column_offset = OoxmlSize.new(node_child.text.to_f, :emu)
+        when 'row'
+          @row = node_child.text.to_i + 1
+        when 'rowOff'
+          @row_offset = OoxmlSize.new(node_child.text.to_f, :emu)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_drawing.rb

@@ -1,49 +1,43 @@
-require_relative 'xlsx_drawing/xlsx_drawing_position'
-require_relative 'xlsx_drawing/xlsx_shape_grouping'
+require_relative 'xlsx_drawing/xlsx_drawing_position_parameters'
 module OoxmlParser
   class XlsxDrawing < OOXMLDocumentObject
-    attr_accessor :position, :picture, :shape, :grouping
+    attr_accessor :picture, :shape, :grouping
+    # @return [XlsxDrawingPositionParameters] position from
+    attr_accessor :from
+    # @return [XlsxDrawingPositionParameters] position to
+    attr_accessor :to
 
-    def initialize(position = XlsxDrawingPosition.new)
-      @position = position
-    end
-
-    def self.parse(drawing_node)
-      drawing = XlsxDrawing.new
-      drawing.position = XlsxDrawingPosition.parse(drawing_node)
-      drawing_node.xpath('*').each do |drawing_node_child|
-        case drawing_node_child.name
+    # Parse XlsxDrawing object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxDrawing] result of parsing
+    def parse(node)
+      node.xpath('*').each do |child_node|
+        case child_node.name
+        when 'from'
+          @from = XlsxDrawingPositionParameters.new(parent: self).parse(child_node)
+        when 'to'
+          @to = XlsxDrawingPositionParameters.new(parent: self).parse(child_node)
         when 'sp'
-          drawing.shape = DocxShape.parse(drawing_node_child)
+          @shape = DocxShape.new(parent: self).parse(child_node)
         when 'grpSp'
-          drawing.grouping = XlsxShapeGrouping.parse(drawing_node_child)
+          @grouping = ShapesGrouping.new(parent: self).parse(child_node)
         when 'pic'
-          drawing.picture = DocxPicture.parse(drawing_node_child)
+          @picture = DocxPicture.new(parent: self).parse(child_node)
         when 'graphicFrame'
-          drawing.picture = DocxPicture.new
-          graphic_data_node = drawing_node_child.xpath('a:graphic/a:graphicData', 'xmlns:a' => 'http://schemas.openxmlformats.org/drawingml/2006/main')
+          @picture = DocxPicture.new
+          graphic_data_node = child_node.xpath('a:graphic/a:graphicData', 'xmlns:a' => 'http://schemas.openxmlformats.org/drawingml/2006/main')
           graphic_data_node.xpath('*').each do |graphic_data_node_child|
             case graphic_data_node_child.name
             when 'chart'
               path_to_chart_xml = OOXMLDocumentObject.get_link_from_rels(graphic_data_node_child.attribute('id').value)
               OOXMLDocumentObject.add_to_xmls_stack(path_to_chart_xml)
-              drawing.picture.chart = Chart.parse
+              @picture.chart = Chart.parse
               OOXMLDocumentObject.xmls_stack.pop
             end
           end
         end
       end
-      drawing
-    end
-
-    def self.parse_list(worksheet)
-      drawing_node = Nokogiri::XML(File.open(OOXMLDocumentObject.current_xml))
-      drawing_node.xpath('xdr:wsDr/*').each do |drawing_node_child|
-        case drawing_node_child.name
-        when 'twoCellAnchor'
-          worksheet.drawings << XlsxDrawing.parse(drawing_node_child)
-        end
-      end
+      self
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_row/xlsx_cell/cell_style/alignment.rb

@@ -1,30 +1,33 @@
-# Character Alignment in XLSX
 module OoxmlParser
-  class XlsxAlignment
+  # Character Alignment in XLSX
+  class XlsxAlignment < OOXMLDocumentObject
     attr_accessor :horizontal, :vertical, :wrap_text, :text_rotation
 
-    def initialize(horizontal = :left, vertical = :bottom, wrap_text = false)
+    def initialize(horizontal = :left, vertical = :bottom, wrap_text = false, parent: nil)
       @horizontal = horizontal
       @vertical = vertical
       @wrap_text = wrap_text
+      @parent = parent
     end
 
-    def self.parse(alignment_node)
-      alignment = XlsxAlignment.new
-      alignment_node.attributes.each do |key, value|
+    # Parse XlsxAlignment object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxAlignment] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'horizontal'
-          alignment.horizontal = value.value.to_sym
-          alignment.wrap_text = true if alignment.horizontal == :justify
+          @horizontal = value.value.to_sym
+          @wrap_text = true if @horizontal == :justify
         when 'vertical'
-          alignment.vertical = value.value.to_sym
+          @vertical = value.value.to_sym
         when 'wrapText'
-          alignment.wrap_text = value.value.to_s == '1'
+          @wrap_text = value.value.to_s == '1'
         when 'textRotation'
-          alignment.text_rotation = value.value.to_i
+          @text_rotation = value.value.to_i
         end
       end
-      alignment
+      self
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_row/xlsx_cell/cell_style.rb

@@ -1,7 +1,6 @@
-require_relative 'cell_style/foreground_color'
 require_relative 'cell_style/alignment'
-require_relative 'cell_style/ooxml_font'
 module OoxmlParser
+  # Class for parsing cell style
   class CellStyle < OOXMLDocumentObject
     ALL_FORMAT_VALUE = %w|0 0.00 #,##0 #,##0.00 $#,##0_);($#,##0) $#,##0_);[Red]($#,##0) $#,##0.00_);($#,##0.00)
                           $#,##0.00_);[Red]($#,##0.00)
@@ -49,47 +48,81 @@ module OoxmlParser
     attr_accessor :font, :borders, :fill_color, :numerical_format, :alignment
     # @return [True, False] check if style should add QuotePrefix (' symbol) to start of the string
     attr_accessor :quote_prefix
+    # @return [True, False] is font applied
+    attr_accessor :apply_font
+    # @return [True, False] is border applied
+    attr_accessor :apply_border
+    # @return [True, False] is fill applied
+    attr_accessor :apply_fill
+    # @return [True, False] is number format applied
+    attr_accessor :apply_number_format
+    # @return [True, False] is alignment applied
+    attr_accessor :apply_alignment
+    # @return [Integer] id of font
+    attr_accessor :font_id
+    # @return [Integer] id of border
+    attr_accessor :border_id
+    # @return [Integer] id of fill
+    attr_accessor :fill_id
+    # @return [Integer] id of number format
+    attr_accessor :number_format_id
 
-    def initialize(font = nil, borders = nil, fill_color = ForegroundColor.new, numerical_format = 'General', alignment = nil)
-      @font = font
-      @borders = borders
-      @fill_color = fill_color
-      @numerical_format = numerical_format
-      @alignment = alignment
+    def initialize(parent: nil)
+      @numerical_format = 'General'
+      @alignment = XlsxAlignment.new
+      @parent = parent
     end
 
-    def self.parse(style_number)
-      current_cell_style = XLSXWorkbook.styles_node.xpath('//xmlns:cellXfs/xmlns:xf')[style_number.to_i]
-      cell_style = CellStyle.new
-      cell_style.alignment = XlsxAlignment.new
-      cell_style.font = if current_cell_style.attribute('applyFont').nil? || current_cell_style.attribute('applyFont').value == '0'
-                          OOXMLFont.parse(0)
-                        else
-                          OOXMLFont.parse(current_cell_style.attribute('fontId').value.to_i)
-                        end
-      unless current_cell_style.attribute('applyBorder').nil? || current_cell_style.attribute('applyBorder').value == '0'
-        cell_style.borders = Borders.parse_from_style(current_cell_style.attribute('borderId').value.to_i)
-      end
-      unless current_cell_style.attribute('applyFill').nil? || current_cell_style.attribute('applyFill').value == '0'
-        cell_style.fill_color = ForegroundColor.parse(current_cell_style.attribute('fillId').value.to_i)
-      end
-      unless current_cell_style.attribute('applyNumberFormat').nil? || current_cell_style.attribute('applyNumberFormat').value == '0'
-        format_id = current_cell_style.attribute('numFmtId').value.to_i
-        XLSXWorkbook.styles_node.xpath('//xmlns:numFmt').each do |numeric_format|
-          if format_id == numeric_format.attribute('numFmtId').value.to_i
-            cell_style.numerical_format = numeric_format.attribute('formatCode').value
-          elsif CellStyle::ALL_FORMAT_VALUE[format_id - 1]
-            cell_style.numerical_format = CellStyle::ALL_FORMAT_VALUE[format_id - 1]
-          end
+    # Parse CellStyle object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [CellStyle] result of parsing
+    def parse(node)
+      style_node = XLSXWorkbook.styles_node.xpath('//xmlns:cellXfs/xmlns:xf')[node.to_i]
+      style_node.attributes.each do |key, value|
+        case key
+        when 'applyFont'
+          @apply_font = attribute_enabled?(value)
+        when 'applyBorder'
+          @apply_border = attribute_enabled?(value)
+        when 'applyFill'
+          @apply_fill = attribute_enabled?(value)
+        when 'applyNumberFormat'
+          @apply_number_format = attribute_enabled?(value)
+        when 'applyAlignment'
+          @apply_alignment = attribute_enabled?(value)
+        when 'fontId'
+          @font_id = value.value.to_i
+        when 'borderId'
+          @border_id = value.value.to_i
+        when 'fillId'
+          @fill_id = value.value.to_i
+        when 'numFmtId'
+          @number_format_id = value.value.to_i
+        when 'quotePrefix'
+          @quote_prefix = attribute_enabled?(value)
         end
-        cell_style.numerical_format = CellStyle::ALL_FORMAT_VALUE[format_id - 1] if CellStyle::ALL_FORMAT_VALUE[format_id - 1]
       end
-      unless current_cell_style.attribute('applyAlignment').nil? || current_cell_style.attribute('applyAlignment').value == '0'
-        alignment_node = current_cell_style.xpath('xmlns:alignment').first
-        cell_style.alignment = XlsxAlignment.parse(alignment_node) unless alignment_node.nil?
+      style_node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'alignment'
+          @alignment.parse(node_child) if @apply_alignment
+        end
       end
-      cell_style.quote_prefix = option_enabled?(current_cell_style, 'quotePrefix')
-      cell_style
+      calculate_values
+      self
+    end
+
+    def calculate_values
+      @font = root_object.style_sheet.fonts[@font_id]
+      @borders = Borders.parse_from_style(@border_id) if @apply_border
+      @fill_color = root_object.style_sheet.fills[@fill_id] if @apply_fill
+      return unless @apply_number_format
+      format = root_object.style_sheet.number_formats.format_by_id(@number_format_id)
+      @numerical_format = if format
+                            format.format_code
+                          else
+                            CellStyle::ALL_FORMAT_VALUE[@number_format_id - 1]
+                          end
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_row/xlsx_cell.rb

@@ -7,25 +7,29 @@ module OoxmlParser
     # @return [String] text without applying any style modificators, like quote_prefix
     attr_accessor :raw_text
 
-    def initialize(style = nil, text = '')
+    def initialize(style = nil, text = '', parent: nil)
       @style = style
       @text = text
       @raw_text = ''
+      @parent = parent
     end
 
-    def self.parse(cell_node)
+    # Parse XlsxCell object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxCell] result of parsing
+    def parse(node)
       text_string_id = nil
-      text_string_id = cell_node.attribute('s').value unless cell_node.attribute('s').nil?
-      cell = XlsxCell.new(CellStyle.parse(text_string_id))
-      if cell_node.attribute('t').nil?
-        cell.raw_text = cell_node.xpath('xmlns:v').text
+      text_string_id = node.attribute('s').value unless node.attribute('s').nil?
+      @style = CellStyle.new(parent: self).parse(text_string_id)
+      if node.attribute('t').nil?
+        @raw_text = node.xpath('xmlns:v').text
       else
-        cell_node.attribute('t').value == 's' ? get_shared_string(cell_node.xpath('xmlns:v').text, cell) : cell.raw_text = cell_node.xpath('xmlns:v').text
+        node.attribute('t').value == 's' ? XlsxCell.get_shared_string(node.xpath('xmlns:v').text, self) : @raw_text = node.xpath('xmlns:v').text
       end
-      cell.formula = cell_node.xpath('xmlns:f').text unless cell_node.xpath('xmlns:f').text == ''
-      cell.text = cell.raw_text.dup unless cell.raw_text.nil?
-      cell.text.insert(0, "'") if cell.style.quote_prefix
-      cell
+      @formula = node.xpath('xmlns:f').text unless node.xpath('xmlns:f').text == ''
+      @text = @raw_text.dup unless @raw_text.nil?
+      @text.insert(0, "'") if @style.quote_prefix
+      self
     end
 
     # Get shared string by it's number
@@ -37,7 +41,7 @@ module OoxmlParser
       XLSXWorkbook.shared_strings[value.to_i].xpath('*').each do |si_node_child|
         case si_node_child.name
         when 'r'
-          cell.character = ParagraphRun.parse(si_node_child)
+          cell.character = ParagraphRun.new(parent: cell).parse(si_node_child)
         when 't'
           cell.raw_text = si_node_child.text
         end