ooxml_parser 0.1.1

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

@@ -0,0 +1,20 @@
+require_relative 'excel_comment/excel_comment_character'
+# Single Comment of XLSX
+module OoxmlParser
+  class ExcelComment < OOXMLDocumentObject
+    attr_accessor :characters
+
+    def initialize(characters = [])
+      @characters = characters
+    end
+
+    def self.parse(comment_node)
+      comment = ExcelComment.new
+      comment_node.xpath('xmlns:text/xmlns:r').each do |character_node|
+        character = ExcelCommentCharacter.parse(character_node)
+        comment.characters << character.dup
+      end
+      comment
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_relative 'excel_comments/excel_comment'
+# All Comments of single XLSX
+module OoxmlParser
+  class ExcelComments
+    attr_accessor :authors, :comments
+
+    def initialize(authors = [], comments = [])
+      @authors = authors
+      @comments = comments
+    end
+
+    def self.parse(file)
+      doc = Nokogiri::XML(File.open(file))
+      excel_comments = ExcelComments.new
+      comments_node = doc.search('//xmlns:comments').first
+      comments_node.xpath('*').each do |comments_node_child|
+        case comments_node_child.name
+        when 'authors'
+          comments_node_child.xpath('xmlns:author').each do |author_node|
+            excel_comments.authors << author_node.text
+          end
+        when 'commentList'
+          comments_node_child.xpath('xmlns:comment').each do |comment_node|
+            excel_comments.comments << ExcelComment.parse(comment_node)
+          end
+        end
+      end
+      excel_comments
+    end
+
+    def self.parse_file(file_name, path_to_folder)
+      path_to_comments_xml = ''
+      return nil unless File.exist?(path_to_folder + "xl/worksheets/_rels/#{file_name}.rels")
+      relationships = XmlSimple.xml_in(File.open(path_to_folder + "xl/worksheets/_rels/#{file_name}.rels"))
+      if relationships['Relationship']
+        relationships['Relationship'].each do |relationship|
+          path_to_comments_xml = path_to_folder + 'xl/' + relationship['Target'].gsub('..', '') if File.basename(relationship['Target']).include?('comment')
+        end
+      end
+      ExcelComments.parse(path_to_comments_xml) unless path_to_comments_xml == ''
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Class for storing SheetFormatProperties
+module OoxmlParser
+  class SheetFormatProperties
+    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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# XLSX data of pane
+module OoxmlParser
+  class Pane
+    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|
+        case key
+        when 'state'
+          pane.state = value.value.to_sym
+        when 'topLeftCell'
+          pane.top_left_cell = Coordinates.parse_coordinates_from_string(value.value)
+        when 'xSplit'
+          pane.x_split = value.value
+        when 'ySplit'
+          pane.y_split = value.value
+        end
+      end
+      pane
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'sheet_view/pane'
+# Class for Sheet View
+module OoxmlParser
+  class SheetView
+    attr_accessor :pane
+
+    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
+        when 'pane'
+          sheet_view.pane = Pane.parse(sheet_view_node_child)
+        end
+      end
+      sheet_view
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# Properties of XLSX column
+module OoxmlParser
+  class XlsxColumnProperties < OOXMLDocumentObject
+    attr_accessor :from, :to, :width, :style
+
+    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
+    end
+
+    def self.parse_list(columns_width_node)
+      columns = []
+      columns_width_node.xpath('xmlns:col').each do |col_node|
+        col = XlsxColumnProperties.parse(col_node)
+        columns << col
+      end
+      columns
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module OoxmlParser
+  class XlsxDrawingPositionParameters
+    attr_accessor :column, :column_offset, :row, :row_offset
+
+    def self.parse(position_node)
+      drawing_position_parameters = XlsxDrawingPositionParameters.new
+      position_node.xpath('*').each do |position_node_child|
+        case position_node_child.name
+        when 'col'
+          drawing_position_parameters.column = Coordinates.get_column_name(position_node_child.text.to_i + 1)
+        when 'colOff'
+          drawing_position_parameters.column_offset = (position_node_child.text.to_f / 360_000.0).round(3)
+        when 'row'
+          drawing_position_parameters.row = position_node_child.text.to_i + 1
+        when 'rowOff'
+          drawing_position_parameters.row_offset = (position_node_child.text.to_f / 360_000.0).round(3)
+        end
+      end
+      drawing_position_parameters
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require_relative 'xlsx_drawing_position/xlsx_drawing_position_parameters'
+module OoxmlParser
+  class XlsxDrawingPosition
+    attr_accessor :from, :to
+
+    # Parse XlsxDrawingPosition
+    # @param node [Nokogiri::XML::Element] node to parse
+    # @return [XlsxDrawingPosition] value of XlsxDrawingPosition
+    def self.parse(node)
+      position = XlsxDrawingPosition.new
+      node.xpath('*').each do |drawing_node_child|
+        case drawing_node_child.name
+        when 'from'
+          position.from = XlsxDrawingPositionParameters.parse(drawing_node_child)
+        when 'to'
+          position.to = XlsxDrawingPositionParameters.parse(drawing_node_child)
+        end
+      end
+      position
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module OoxmlParser
+  class XlsxShapeGrouping
+    attr_accessor :properties, :shapes, :pictures, :grouping
+
+    def initialize(shapes = [], pictures = [])
+      @shapes = shapes
+      @pictures = pictures
+    end
+
+    def self.parse(grouping_node)
+      grouping = XlsxShapeGrouping.new
+      grouping_node.xpath('*').each do |grouping_node_child|
+        case grouping_node_child.name
+        when 'grpSpPr'
+          grouping.properties = DocxShapeProperties.parse(grouping_node_child)
+        when 'grpSp'
+          grouping.grouping = parse(grouping_node_child)
+        when 'sp'
+          grouping.shapes << DocxShape.parse(grouping_node_child)
+        when 'pic'
+          grouping.pictures << DocxPicture.parse(grouping_node_child)
+        when 'graphicFrame'
+          picture = DocxPicture.new
+          graphic_data_node = grouping_node_child.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'
+              picture.chart = Chart.parse
+            end
+          end
+          grouping.pictures << picture
+        end
+      end
+      grouping
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require_relative 'xlsx_drawing/xlsx_drawing_position'
+require_relative 'xlsx_drawing/xlsx_shape_grouping'
+module OoxmlParser
+  class XlsxDrawing < OOXMLDocumentObject
+    attr_accessor :position, :picture, :shape, :grouping
+
+    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
+        when 'sp'
+          drawing.shape = DocxShape.parse(drawing_node_child)
+        when 'grpSp'
+          drawing.grouping = XlsxShapeGrouping.parse(drawing_node_child)
+        when 'pic'
+          drawing.picture = DocxPicture.parse(drawing_node_child)
+        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')
+          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
+              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
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# Character Alignment in XLSX
+module OoxmlParser
+  class XlsxAlignment
+    attr_accessor :horizontal, :vertical, :wrap_text, :text_rotation
+
+    def initialize(horizontal = :left, vertical = :bottom, wrap_text = false)
+      @horizontal = horizontal
+      @vertical = vertical
+      @wrap_text = wrap_text
+    end
+
+    def self.parse(alignment_node)
+      alignment = XlsxAlignment.new
+      alignment_node.attributes.each do |key, value|
+        case key
+        when 'horizontal'
+          alignment.horizontal = value.value.to_sym
+          alignment.wrap_text = true if alignment.horizontal == :justify
+        when 'vertical'
+          alignment.vertical = value.value.to_sym
+        when 'wrapText'
+          alignment.wrap_text = value.value.to_s == '1'
+        when 'textRotation'
+          alignment.text_rotation = value.value.to_i
+        end
+      end
+      alignment
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# Foreground Color Data
+module OoxmlParser
+  class ForegroundColor < OOXMLDocumentObject
+    attr_accessor :type, :color
+
+    def initialize(type = nil, color = Color.new)
+      @type = type
+      @color = color
+    end
+
+    def nil?
+      @type.nil? && @color.nil?
+    end
+
+    def self.parse(style_number)
+      fill_color = ForegroundColor.new
+      fill_style_node = XLSXWorkbook.styles_node.xpath('//xmlns:fill')[style_number.to_i].xpath('xmlns:patternFill')
+      if fill_style_node && !fill_style_node.empty?
+        fill_color.type = fill_style_node.attribute('patternType').value.to_sym
+        fill_color.color = Color.parse_color_tag(fill_style_node.xpath('xmlns:fgColor').first)
+      end
+      fill_color
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# Font Data
+module OoxmlParser
+  class OOXMLFont < OOXMLDocumentObject
+    attr_accessor :name, :size, :font_style, :color
+
+    def initialize(name = 'Calibri', size = '11', font_style = nil, color = nil)
+      @name = name
+      @size = size
+      @font_style = font_style
+      @color = color
+    end
+
+    def self.parse(style_number)
+      font = OOXMLFont.new
+      font_style_node = XLSXWorkbook.styles_node.xpath('//xmlns:font')[style_number.to_i]
+      font.name = font_style_node.xpath('xmlns:name').first.attribute('val').value
+      font.size = font_style_node.xpath('xmlns:sz').first.attribute('val').value.to_i if font_style_node.xpath('xmlns:sz').first
+      font.font_style = FontStyle.new
+      font_style_node.xpath('*').each do |font_style_node_child|
+        case font_style_node_child.name
+        when 'b'
+          font.font_style.bold = true
+        when 'i'
+          font.font_style.italic = true
+        when 'strike'
+          font.font_style.strike = :single
+        when 'u'
+          unless font_style_node_child.attribute('val').value == 'none' && font_style_node_child
+            font.font_style.underlined = Underline.new((font_style_node_child.attribute('val').value || :single).to_sym)
+          end
+        when 'color'
+          font.color = Color.parse_color_tag(font_style_node_child)
+        end
+      end
+      font
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require_relative 'cell_style/foreground_color'
+require_relative 'cell_style/alignment'
+require_relative 'cell_style/ooxml_font'
+module OoxmlParser
+  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)
+                          0.00% 0.00%
+                          0.00E+00
+                          #\ ?/?
+                          #\ ??/??
+                          m/d/yyyy
+                          d-mmm-yy
+                          d-mmm
+                          mmm-yy
+                          h:mm AM/PM
+                          h:mm:ss AM/PM
+                          h:mm
+                          h:mm:ss
+                          m/d/yyyy h:mm
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          0
+                          #,##0_);(#,##0)
+                          #,##0_);[Red](#,##0)
+                          #,##0.00_);(#,##0.00)
+                          #,##0.00_);[Red](#,##0.00)
+                          0
+                          0
+                          0
+                          0
+                          mm:ss
+                          General
+                          mm:ss.0
+                          ##0.0E+0
+                          @|.freeze
+
+    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
+
+    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
+    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
+        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?
+      end
+      cell_style.quote_prefix = option_enabled?(current_cell_style, 'quotePrefix')
+      cell_style
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative 'xlsx_cell/cell_style'
+# Single Cell of XLSX
+module OoxmlParser
+  class XlsxCell < OOXMLDocumentObject
+    attr_accessor :style, :text, :formula, :character
+
+    # @return [String] text without applying any style modificators, like quote_prefix
+    attr_accessor :raw_text
+
+    def initialize(style = nil, text = '')
+      @style = style
+      @text = text
+      @raw_text = ''
+    end
+
+    def self.parse(cell_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
+      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
+      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
+    end
+
+    # Get shared string by it's number
+    # @param [String] value number of shared string
+    # @param [XlsxCell] cell to write value of string
+    # @return [Nothing]
+    def self.get_shared_string(value, cell)
+      return '' if value == ''
+      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)
+        when 't'
+          cell.raw_text = si_node_child.text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative 'xlsx_row/xlsx_cell'
+# Single Row of XLSX
+module OoxmlParser
+  class XlsxRow < OOXMLDocumentObject
+    attr_accessor :cells, :height, :style, :hidden
+
+    def initialize(cells = [])
+      @cells = cells
+    end
+
+    def self.parse(row_node)
+      row = XlsxRow.new
+      row.height = row_node.attribute('ht').value if OOXMLDocumentObject.option_enabled?(row_node, 'customHeight')
+      row.hidden = OOXMLDocumentObject.option_enabled?(row_node, 'hidden')
+      row_node.xpath('xmlns:c').each { |cell_node| row.cells[Coordinates.parse_coordinates_from_string(cell_node.attribute('r').value.to_s).get_column_number.to_i - 1] = XlsxCell.parse(cell_node) }
+      row
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# Table in xlsx
+module OoxmlParser
+  class XlsxTable < OOXMLDocumentObject
+    attr_accessor :name, :display_name, :reference, :autofilter, :columns
+
+    def self.parse(table_part_node)
+      table = XlsxTable.new
+      link_to_table_part_xml = OOXMLDocumentObject.get_link_from_rels(table_part_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'
+          table.name = value.value.to_s
+        when 'displayName'
+          table.display_name = value.value.to_s
+        when 'ref'
+          table.reference = Coordinates.parser_coordinates_range value.value.to_s
+        end
+      end
+      table_node.xpath('*').each do |table_node_child|
+        case table_node_child.name
+        when 'autoFilter'
+          table.autofilter = Coordinates.parser_coordinates_range table_node_child.attribute('ref').value
+        end
+      end
+      table
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require_relative 'worksheet/excel_comments'
+require_relative 'worksheet/sheet_format_properties'
+require_relative 'worksheet/sheet_view'
+require_relative 'worksheet/xlsx_column_properties'
+require_relative 'worksheet/xlsx_drawing'
+require_relative 'worksheet/xlsx_row'
+require_relative 'worksheet/xlsx_table'
+# Properties of worksheet
+module OoxmlParser
+  class Worksheet < OOXMLDocumentObject
+    attr_accessor :name, :rows, :merge, :charts, :hyperlinks, :drawings, :comments, :columns, :sheet_format_properties,
+                  :autofilter, :table_parts, :sheet_views
+
+    def initialize
+      @columns = []
+      @name = ''
+      @rows = []
+      @merge = []
+      @charts = []
+      @hyperlinks = []
+      @drawings = []
+      @sheet_views = []
+      @table_parts = []
+    end
+
+    def self.parse(path_to_xml_file)
+      worksheet = Worksheet.new
+      @current_sheet_xml_name = File.basename path_to_xml_file
+      OOXMLDocumentObject.add_to_xmls_stack("#{OOXMLDocumentObject.root_subfolder}/worksheets/#{File.basename(path_to_xml_file)}")
+      doc = Nokogiri::XML(File.open(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|
+            worksheet.rows[row_node.attribute('r').value.to_i - 1] = XlsxRow.parse(row_node)
+            worksheet.rows[row_node.attribute('r').value.to_i - 1].style = CellStyle.parse(row_node.attribute('s').value) unless row_node.attribute('s').nil?
+          end
+        when 'sheetFormatPr'
+          if !worksheet_node_child.attribute('defaultColWidth').nil? && !worksheet_node_child.attribute('defaultRowHeight').nil?
+            worksheet.sheet_format_properties = SheetFormatProperties.parse(worksheet_node_child)
+          end
+        when 'mergeCells'
+          worksheet_node_child.xpath('xmlns:mergeCell').each do |merge_node|
+            worksheet.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)
+            XlsxDrawing.parse_list(worksheet)
+            OOXMLDocumentObject.xmls_stack.pop
+          end
+        when 'hyperlinks'
+          worksheet_node_child.xpath('xmlns:hyperlink').each do |hyperlink_node|
+            worksheet.hyperlinks << Hyperlink.parse(hyperlink_node).dup
+          end
+        when 'cols'
+          worksheet.columns = XlsxColumnProperties.parse_list(worksheet_node_child)
+        when 'autoFilter'
+          worksheet.autofilter = Coordinates.parser_coordinates_range(worksheet_node_child.attribute('ref').value.to_s)
+        when 'tableParts'
+          worksheet.table_parts = []
+          worksheet_node_child.xpath('xmlns:tablePart').each { |table_part_node| worksheet.table_parts << XlsxTable.parse(table_part_node) }
+        when 'sheetViews'
+          worksheet_node_child.xpath('xmlns:sheetView').each { |sheet_view_node| worksheet.sheet_views << SheetView.parse(sheet_view_node) }
+        end
+      end
+      worksheet.comments = ExcelComments.parse_file(File.basename(path_to_xml_file), OOXMLDocumentObject.path_to_folder)
+      OOXMLDocumentObject.xmls_stack.pop
+      worksheet
+    end
+  end
+end