ooxml_parser 0.14.1-mingw32

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/xlsx_header_footer/header_footer_child.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing header or footer
+  class HeaderFooterChild < OOXMLDocumentObject
+    # @return [Symbol] type of header
+    attr_reader :type
+    # @return [String] raw text of header
+    attr_reader :raw_string
+
+    def initialize(type: nil, raw_string: nil, parent: nil)
+      @type = type
+      @raw_string = raw_string
+      super(parent: parent)
+    end
+
+    # Parse HeaderFooterChild data
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [HeaderFooterChild] result of parsing
+    def parse(node)
+      @raw_string = node.text
+      self
+    end
+
+    # @return [String] right part of header
+    def right
+      return @right if @right
+
+      right = @raw_string.match(/&R(.+)/)
+      return nil unless right
+
+      @right = right[1]
+    end
+
+    # @return [String] center part of header
+    def center
+      return @center if @center
+
+      center = @raw_string.split('&R').first.match(/&C(.+)/)
+      return nil unless center
+
+      @center = center[1]
+    end
+
+    # @return [String] left part of header
+    def left
+      return @left if @left
+
+      left = @raw_string.gsub("&R#{right}", '')
+      left = left.gsub("&C#{center}", '')
+      return nil if left == ''
+
+      left.gsub('&L', '')
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'xlsx_header_footer/header_footer_child'
+module OoxmlParser
+  # Class for parsing <headerFooter> tag
+  class XlsxHeaderFooter < OOXMLDocumentObject
+    # @return [Symbol] Specifies whether to align header with margins
+    attr_reader :align_with_margins
+    # @return [Symbol] Specifies whether first header is different
+    attr_reader :different_first
+    # @return [Symbol] Specifies whether odd and even headers are different
+    attr_reader :different_odd_even
+    # @return [Symbol] Specifies whether to scale header with document
+    attr_reader :scale_with_document
+    # @return [String] odd header
+    attr_reader :odd_header
+    # @return [String] odd footer
+    attr_reader :odd_footer
+    # @return [String] even header
+    attr_reader :even_header
+    # @return [String] even footer
+    attr_reader :even_footer
+    # @return [String] first header
+    attr_reader :first_header
+    # @return [String] first footer
+    attr_reader :first_footer
+
+    # Parse Header Footer data
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxHeaderFooter] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'alignWithMargins'
+          @align_with_margins = attribute_enabled?(value)
+        when 'differentFirst'
+          @different_first = attribute_enabled?(value)
+        when 'differentOddEven'
+          @different_odd_even = attribute_enabled?(value)
+        when 'scaleWithDoc'
+          @scale_with_document = attribute_enabled?(value)
+        end
+
+        node.xpath('*').each do |node_child|
+          case node_child.name
+          when 'oddHeader'
+            @odd_header = HeaderFooterChild.new(parent: parent, type: odd_header).parse(node_child)
+          when 'oddFooter'
+            @odd_footer = HeaderFooterChild.new(parent: parent, type: odd_footer).parse(node_child)
+          when 'evenHeader'
+            @even_header = HeaderFooterChild.new(parent: parent, type: even_header).parse(node_child)
+          when 'evenFooter'
+            @even_footer = HeaderFooterChild.new(parent: parent, type: even_footer).parse(node_child)
+          when 'firstHeader'
+            @first_header = HeaderFooterChild.new(parent: parent, type: first_header).parse(node_child)
+          when 'firstFooter'
+            @first_footer = HeaderFooterChild.new(parent: parent, type: first_footer).parse(node_child)
+          end
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `formulas` <f>
+  class Formula < OOXMLDocumentObject
+    # @return [Coordinates] reference coordinates
+    attr_reader :reference
+    # @return [StringIndex] string index
+    attr_reader :string_index
+    # @return [String] type
+    attr_reader :type
+    # @return [String] value
+    attr_reader :value
+
+    # Parse Formula object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Formula] parsed object
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'ref'
+          @reference = Coordinates.parser_coordinates_range(value.value.to_s)
+        when 'si'
+          @string_index = value.value.to_i
+        when 't'
+          @type = value.value.to_s
+        end
+      end
+
+      @value = node.text unless node.text.empty?
+      self
+    end
+
+    # @return [True, False] check if formula empty
+    def empty?
+      !(reference || string_index || type || value)
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'xlsx_cell/formula'
+module OoxmlParser
+  # Single Cell of XLSX
+  class XlsxCell < OOXMLDocumentObject
+    attr_accessor :formula, :character
+
+    # @return [String] text without applying any style modificators, like quote_prefix
+    attr_accessor :raw_text
+    # @return [Integer] index of style
+    attr_reader :style_index
+    # @return [String] value of cell
+    attr_reader :value
+    # @return [String] type of string
+    attr_reader :type
+
+    def initialize(parent: nil)
+      @style_index = 0 # default style is zero
+      @raw_text = ''
+      super
+    end
+
+    # Parse XlsxCell object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxCell] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 's'
+          @style_index = value.value.to_i
+        when 't'
+          @type = value.value.to_s
+        end
+      end
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'f'
+          @formula = Formula.new(parent: self).parse(node_child)
+        when 'v'
+          @value = TextValue.new(parent: self).parse(node_child)
+        end
+      end
+      parse_text_data
+      self
+    end
+
+    # @return [Xf] style of cell
+    def style
+      return nil unless @style_index
+
+      root_object.style_sheet.cell_xfs.xf_array[@style_index]
+    end
+
+    # @return [String] text with modifiers
+    def text
+      return '' unless @raw_text
+      return @raw_text.dup.insert(0, "'") if style.quote_prefix
+
+      @raw_text
+    end
+
+    private
+
+    # @return [Nothing] parse text data
+    def parse_text_data
+      if @type && @value
+        type == 's' ? get_shared_string(value.value) : @raw_text = value.value
+      elsif @value
+        @raw_text = value.value if @value
+      end
+    end
+
+    # Get shared string by it's number
+    # @return [Nothing]
+    def get_shared_string(value)
+      return '' if value == ''
+
+      string = root_object.shared_strings_table.string_indexes[value.to_i]
+      @character = string.run
+      @raw_text = string.text
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'xlsx_row/xlsx_cell'
+module OoxmlParser
+  # Single Row of XLSX
+  class XlsxRow < OOXMLDocumentObject
+    attr_accessor :cells, :height, :style, :hidden
+    # @return [True, False] true if the row height has been manually set.
+    attr_accessor :custom_height
+    # @return [Integer] Indicates to which row in the sheet this <row> definition corresponds.
+    attr_accessor :index
+
+    def initialize(parent: nil)
+      @cells = []
+      super
+    end
+
+    # Parse XlsxRow object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [XlsxRow] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'customHeight'
+          @custom_height = option_enabled?(node, 'customHeight')
+        when 'ht'
+          @height = OoxmlSize.new(value.value.to_f, :point)
+        when 'hidden'
+          @hidden = option_enabled?(node, 'hidden')
+        when 'r'
+          @index = value.value.to_i
+        end
+      end
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'c'
+          @cells[Coordinates.parse_coordinates_from_string(node_child.attribute('r').value.to_s).column_number.to_i - 1] = XlsxCell.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative 'worksheet/excel_comments'
+require_relative 'worksheet/ole_objects'
+require_relative 'worksheet/page_setup'
+require_relative 'worksheet/sheet_format_properties'
+require_relative 'worksheet/sheet_view'
+require_relative 'worksheet/table_part'
+require_relative 'worksheet/worksheet_helper'
+require_relative 'worksheet/xlsx_column_properties'
+require_relative 'worksheet/xlsx_drawing'
+require_relative 'worksheet/xlsx_row'
+require_relative 'worksheet/xlsx_header_footer'
+module OoxmlParser
+  # Properties of worksheet
+  class Worksheet < OOXMLDocumentObject
+    include WorksheetHelper
+    attr_accessor :name, :rows, :merge, :charts, :hyperlinks, :drawings, :comments, :columns, :sheet_format_properties,
+                  :autofilter, :table_parts, :sheet_views
+    # @return [String] xml name of sheet
+    attr_accessor :xml_name
+    # @return [Relationships] array of relationships
+    attr_accessor :relationships
+    # @return [Relationships] array of ole objects
+    attr_accessor :ole_objects
+    # @return [PageMargins] page margins settings
+    attr_reader :page_margins
+    # @return [PageSetup] page setup settings
+    attr_reader :page_setup
+    # @return [ExtensionList] list of extensions
+    attr_accessor :extension_list
+    # @return [XlsxHeaderFooter] header and footer
+    attr_reader :header_footer
+
+    def initialize(parent: nil)
+      @columns = []
+      @name = ''
+      @rows = []
+      @merge = []
+      @charts = []
+      @hyperlinks = []
+      @drawings = []
+      @sheet_views = []
+      @table_parts = []
+      super
+    end
+
+    # Perform parsing of relationships
+    # @return [nil]
+    def parse_relationships
+      OOXMLDocumentObject.add_to_xmls_stack("#{OOXMLDocumentObject.root_subfolder}/worksheets/_rels/#{@xml_name}.rels")
+      @relationships = Relationships.new(parent: self).parse_file(OOXMLDocumentObject.current_xml) if File.exist?(OOXMLDocumentObject.current_xml)
+      OOXMLDocumentObject.xmls_stack.pop
+    end
+
+    # @return [True, false] if structure contain any user data
+    def with_data?
+      return true unless @rows.empty?
+      return true unless default_columns?
+      return true unless @drawings.empty?
+      return true unless @charts.empty?
+      return true unless @hyperlinks.empty?
+
+      false
+    end
+
+    # Parse list of drawings in file
+    def parse_drawing
+      drawing_node = parse_xml(OOXMLDocumentObject.current_xml)
+      drawing_node.xpath('xdr:wsDr/*').each do |drawing_node_child|
+        @drawings << XlsxDrawing.new(parent: self).parse(drawing_node_child)
+      end
+    end
+
+    # Parse data of Worksheet
+    # @param path_to_xml_file [String] path to file to parse
+    # @return [Worksheet] parsed worksheet
+    def parse(path_to_xml_file)
+      @xml_name = File.basename path_to_xml_file
+      parse_relationships
+      OOXMLDocumentObject.add_to_xmls_stack("#{OOXMLDocumentObject.root_subfolder}/worksheets/#{File.basename(path_to_xml_file)}")
+      doc = parse_xml(OOXMLDocumentObject.current_xml)
+      sheet = doc.search('//xmlns:worksheet').first
+      sheet.xpath('*').each do |worksheet_node_child|
+        case worksheet_node_child.name
+        when 'sheetData'
+          worksheet_node_child.xpath('xmlns:row').each do |row_node|
+            @rows[row_node.attribute('r').value.to_i - 1] = XlsxRow.new(parent: self).parse(row_node)
+            @rows[row_node.attribute('r').value.to_i - 1].style = root_object.style_sheet.cell_xfs.xf_array[row_node.attribute('s').value.to_i] if row_node.attribute('s')
+          end
+        when 'sheetFormatPr'
+          if !worksheet_node_child.attribute('defaultColWidth').nil? && !worksheet_node_child.attribute('defaultRowHeight').nil?
+            @sheet_format_properties = SheetFormatProperties.new(parent: self).parse(worksheet_node_child)
+          end
+        when 'mergeCells'
+          worksheet_node_child.xpath('xmlns:mergeCell').each do |merge_node|
+            @merge << merge_node.attribute('ref').value.to_s
+          end
+        when 'drawing'
+          path_to_drawing = OOXMLDocumentObject.get_link_from_rels(worksheet_node_child.attribute('id').value)
+          unless path_to_drawing.nil?
+            OOXMLDocumentObject.add_to_xmls_stack(path_to_drawing)
+            parse_drawing
+            OOXMLDocumentObject.xmls_stack.pop
+          end
+        when 'hyperlinks'
+          worksheet_node_child.xpath('xmlns:hyperlink').each do |hyperlink_node|
+            @hyperlinks << Hyperlink.new(parent: self).parse(hyperlink_node).dup
+          end
+        when 'cols'
+          @columns = XlsxColumnProperties.parse_list(worksheet_node_child, parent: self)
+        when 'autoFilter'
+          @autofilter = Autofilter.new(parent: self).parse(worksheet_node_child)
+        when 'tableParts'
+          worksheet_node_child.xpath('*').each do |part_node|
+            @table_parts << TablePart.new(parent: self).parse(part_node)
+          end
+        when 'sheetViews'
+          worksheet_node_child.xpath('*').each do |view_child|
+            @sheet_views << SheetView.new(parent: self).parse(view_child)
+          end
+        when 'oleObjects'
+          @ole_objects = OleObjects.new(parent: self).parse(worksheet_node_child)
+        when 'pageMargins'
+          @page_margins = PageMargins.new(parent: self).parse(worksheet_node_child, :inch)
+        when 'pageSetup'
+          @page_setup = PageSetup.new(parent: self).parse(worksheet_node_child)
+        when 'extLst'
+          @extension_list = ExtensionList.new(parent: self).parse(worksheet_node_child)
+        when 'headerFooter'
+          @header_footer = XlsxHeaderFooter.new(parent: self).parse(worksheet_node_child)
+        end
+      end
+      parse_comments
+      OOXMLDocumentObject.xmls_stack.pop
+      self
+    end
+
+    private
+
+    # Do work for parsing shared comments file
+    def parse_comments
+      return unless relationships
+
+      comments_target = relationships.target_by_type('comment')
+      return if comments_target.empty?
+
+      comments_file = "#{OOXMLDocumentObject.path_to_folder}/#{OOXMLDocumentObject.root_subfolder}/#{comments_target.first.gsub('..', '')}"
+      @comments = ExcelComments.new(parent: self).parse(comments_file)
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative 'workbook/chartsheet'
+require_relative 'workbook/pivot_cache'
+require_relative 'workbook/pivot_table_definition'
+require_relative 'workbook/defined_name'
+require_relative 'workbook/shared_string_table'
+require_relative 'workbook/style_sheet'
+require_relative 'workbook/worksheet'
+require_relative 'workbook/workbook_helpers'
+module OoxmlParser
+  # Class for storing XLSX Workbook
+  class XLSXWorkbook < CommonDocumentStructure
+    include WorkbookHelpers
+    attr_accessor :worksheets
+    # @return [PresentationTheme] theme of Workbook
+    attr_accessor :theme
+    # @return [Relationships] rels of book
+    attr_accessor :relationships
+    # @return [StyleSheet] styles of book
+    attr_accessor :style_sheet
+    # @return [SharedStringTable] styles of book
+    attr_accessor :shared_strings_table
+    # @return [Array<PivotCache>] list of pivot caches
+    attr_accessor :pivot_caches
+    # @return [Array<PivotTableDefintion>] list of pivot table defitions
+    attr_accessor :pivot_table_definitions
+    # @return [Array<DefinedName>] list of defined names
+    attr_reader :defined_names
+
+    def initialize(params = {})
+      @worksheets = []
+      @pivot_caches = []
+      @pivot_table_definitions = []
+      @defined_names = []
+      super
+    end
+
+    # Return cell by coordinates
+    # @param column [String, Integer] number or numeric digit of column
+    # @param row [Integer] row to find
+    # @param sheet [Integer] number of sheet
+    # @return [XlsxCell] result
+    def cell(column, row, sheet = 0)
+      column = Coordinates.new(row, column).column_number unless StringHelper.numeric?(column.to_s)
+
+      if StringHelper.numeric?(sheet.to_s)
+        row = @worksheets[sheet].rows[row.to_i - 1]
+        return nil if row.nil?
+
+        return row.cells[column.to_i - 1]
+      elsif sheet.is_a?(String)
+        @worksheets.each do |worksheet|
+          next unless worksheet.name == sheet
+          next unless worksheet.rows[row.to_i - 1]
+
+          return worksheet.rows[row.to_i - 1].cells[column.to_i - 1]
+        end
+        return nil
+      end
+      raise "Error. Wrong sheet value: #{sheet}"
+    end
+
+    # Get all values of formulas.
+    # @param [Fixnum] precision of formulas counting
+    # @return [Array, String] all formulas
+    def all_formula_values(precision = 14)
+      formulas = []
+      worksheets.each do |c_sheet|
+        next unless c_sheet
+
+        c_sheet.rows.each do |c_row|
+          next unless c_row
+
+          c_row.cells.each do |c_cell|
+            next unless c_cell
+            next unless c_cell.formula
+            next if c_cell.formula.empty?
+
+            text = c_cell.raw_text
+            if StringHelper.numeric?(text)
+              text = text.to_f.round(10).to_s[0..precision]
+            elsif StringHelper.complex?(text)
+              complex_number = Complex(text.tr(',', '.'))
+              real_part = complex_number.real
+              real_rounded = real_part.to_f.round(10).to_s[0..precision].to_f
+
+              imag_part = complex_number.imag
+              imag_rounded = imag_part.to_f.round(10).to_s[0..precision].to_f
+              complex_rounded = Complex(real_rounded, imag_rounded)
+              text = complex_rounded.to_s
+            end
+            formulas << text
+          end
+        end
+      end
+      formulas
+    end
+
+    # Do work for parsing shared strings file
+    def parse_shared_strings
+      shared_strings_target = relationships.target_by_type('sharedString')
+      return if shared_strings_target.empty?
+
+      shared_string_file = "#{OOXMLDocumentObject.path_to_folder}/xl/#{shared_strings_target.first}"
+      @shared_strings_table = SharedStringTable.new(parent: self).parse(shared_string_file)
+    end
+
+    # Parse content of Workbook
+    # @return [XLSXWorkbook]
+    def parse
+      @content_types = ContentTypes.new(parent: self).parse
+      @relationships = Relationships.new(parent: self).parse_file("#{OOXMLDocumentObject.path_to_folder}xl/_rels/workbook.xml.rels")
+      parse_shared_strings
+      OOXMLDocumentObject.xmls_stack = []
+      OOXMLDocumentObject.root_subfolder = 'xl/'
+      OOXMLDocumentObject.add_to_xmls_stack('xl/workbook.xml')
+      @doc = Nokogiri::XML.parse(File.open(OOXMLDocumentObject.current_xml))
+      @theme = PresentationTheme.parse("xl/#{link_to_theme_xml}") if link_to_theme_xml
+      @style_sheet = StyleSheet.new(parent: self).parse
+      @doc.xpath('xmlns:workbook/xmlns:sheets/xmlns:sheet').each do |sheet|
+        file = @relationships.target_by_id(sheet.attribute('id').value)
+        if file.start_with?('worksheets')
+          @worksheets << Worksheet.new(parent: self).parse(file)
+          @worksheets.last.name = sheet.attribute('name').value
+        elsif file.start_with?('chartsheets')
+          @worksheets << Chartsheet.new(parent: self).parse(file)
+        end
+      end
+      parse_pivot_cache
+      parse_pivot_table
+      parse_defined_names
+      OOXMLDocumentObject.xmls_stack.pop
+      self
+    end
+
+    private
+
+    def link_to_theme_xml
+      relationships.target_by_type('theme').first
+    end
+
+    # Perform parsing of pivot cache
+    def parse_pivot_cache
+      @doc.xpath('xmlns:workbook/xmlns:pivotCaches/xmlns:pivotCache').each do |pivot_cache|
+        @pivot_caches << PivotCache.new(parent: self).parse(pivot_cache)
+      end
+    end
+
+    # Perform parsing of pivot table
+    def parse_pivot_table
+      files = @content_types.by_type('application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml')
+      files.each do |file|
+        @pivot_table_definitions << PivotTableDefinition.new(parent: self).parse(file.part_name)
+      end
+    end
+
+    # Perform parsing of defined names
+    def parse_defined_names
+      @doc.xpath('xmlns:workbook/xmlns:definedNames/xmlns:definedName').each do |defined_name|
+        @defined_names << DefinedName.new(parent: self).parse(defined_name)
+      end
+    end
+  end
+end