rubyXL-git-ref-6002046 2.0.0

data/lib/rubyXL/objects/formula.rb

@@ -0,0 +1,8 @@
+module RubyXL
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_dataValidation-1.html
+  class Formula < OOXMLObject
+    define_attribute(:_,                 :string, :accessor => :expression)
+    define_element_name 'f'
+  end
+
+end

data/lib/rubyXL/objects/ooxml_object.rb

@@ -0,0 +1,177 @@
+require 'pp'
+
+module RubyXL
+  class OOXMLObject
+
+    # Throughout this class, setting class variables through explicit method calls rather
+    # than by directly addressing the name of the variable because of context issues:
+    # addressing variable by name creates it in the context of defining class,
+    # while calling the setter/getter method addresses it in the context of descendant class, 
+    # which is what we need.
+    def self.obtain_class_variable(var_name, default = {})
+      if class_variable_defined?(var_name) then 
+        self.class_variable_get(var_name)
+      else
+        self.class_variable_set(var_name, default)
+      end
+    end
+
+    def obtain_class_variable(var_name, default = {})
+      self.class.obtain_class_variable(var_name, default)
+    end
+    private :obtain_class_variable
+
+    def self.define_attribute(attr_name, attr_type, extra_params = {})
+      attrs = obtain_class_variable(:@@ooxml_attributes)
+
+      accessor = extra_params[:accessor] || accessorize(attr_name)
+
+      attrs[accessor] = {
+        :attr_name  => attr_name.to_s,
+        :attr_type  => attr_type,
+        :optional   => !extra_params[:required], 
+        :default    => extra_params[:default],
+        :validation => extra_params[:values]
+      }
+
+      self.send(:attr_accessor, accessor)
+    end
+    
+    def self.define_child_node(klass, extra_params = {})
+      child_nodes = obtain_class_variable(:@@ooxml_child_nodes)
+      child_node_name = (extra_params[:node_name] || klass.class_variable_get(:@@ooxml_tag_name)).to_s
+      accessor = (extra_params[:accessor] || accessorize(child_node_name)).to_sym
+
+      child_nodes[child_node_name] = { 
+        :class => klass,
+        :is_array => extra_params[:collection],
+        :accessor => accessor
+      }
+
+      self.send(:attr_accessor, accessor)
+    end
+
+    def self.define_element_name(v)
+      self.class_variable_set(:@@ooxml_tag_name, v)
+    end
+
+    def self.set_countable
+      self.class_variable_set(:@@ooxml_countable, true)
+      self.send(:attr_accessor, :count)
+    end
+
+    def write_xml(xml, node_name_override = nil)
+      before_write_xml if self.respond_to?(:before_write_xml)
+      attrs = prepare_attributes
+      element_text = attrs.delete('_')
+      elem = xml.create_element(node_name_override || obtain_class_variable(:@@ooxml_tag_name), attrs, element_text)
+      child_nodes = obtain_class_variable(:@@ooxml_child_nodes)
+      child_nodes.each_pair { |child_node_name, child_node_params|
+        obj = self.send(child_node_params[:accessor])
+        unless obj.nil?
+          if child_node_params[:is_array] then obj.each { |item| elem << item.write_xml(xml) }
+          else elem << obj.write_xml(xml, child_node_name)
+          end
+        end
+      }
+      elem
+    end
+
+    def initialize(params = {})
+      obtain_class_variable(:@@ooxml_attributes).each_key { |k| instance_variable_set("@#{k}", params[k]) }
+      obtain_class_variable(:@@ooxml_child_nodes).each_pair { |k, v|
+
+        initial_value =
+          if params.has_key?(v[:accessor]) then params[v[:accessor]]
+          elsif v[:is_array] then []
+          else nil
+          end
+
+        instance_variable_set("@#{v[:accessor]}", initial_value)
+      }
+
+      instance_variable_set("@count", 0) if obtain_class_variable(:@@ooxml_countable, false)
+    end
+
+    def self.parse(node)
+      obj = self.new
+
+      obtain_class_variable(:@@ooxml_attributes).each_pair { |k, v|
+
+        raw_value = if v[:attr_name] == '_' then node.text
+                    else
+                      attr = node.attributes[v[:attr_name]]
+                      attr && attr.value
+                    end
+                    
+        val = raw_value &&
+                case v[:attr_type]
+                when :int    then Integer(raw_value)
+                when :float  then Float(raw_value)
+                when :string then raw_value
+                when :sqref  then RubyXL::Sqref.new(raw_value)
+                when :ref    then RubyXL::Reference.new(raw_value)
+                when :bool   then ['1', 'true'].include?(raw_value)
+                end              
+
+        obj.send("#{k}=", val)
+      }
+
+      known_child_nodes = obtain_class_variable(:@@ooxml_child_nodes)
+
+      unless known_child_nodes.empty?
+        node.element_children.each { |child_node|
+          child_node_name = child_node.name
+          child_node_params = known_child_nodes[child_node_name]
+          raise "Unknown child node: #{child_node_name}" if child_node_params.nil?
+          parsed_object = child_node_params[:class].parse(child_node)
+          if child_node_params[:is_array] then obj.send(child_node_params[:accessor]) << parsed_object
+          else obj.send("#{child_node_params[:accessor]}=", parsed_object)
+          end
+        }
+      end
+
+      obj
+    end
+
+    def dup
+      new_copy = super
+      new_copy.count = 0 if obtain_class_variable(:@@ooxml_countable, false)
+      new_copy
+    end
+
+    private
+    def self.accessorize(str)
+      acc = str.to_s.dup
+      acc.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      acc.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      acc.gsub!(':','_')
+      acc.downcase.to_sym
+    end
+
+    def prepare_attributes
+      xml_attrs = {}
+
+      obtain_class_variable(:@@ooxml_attributes).each_pair { |k, v|
+        val = self.send(k)
+
+        if val.nil? then
+          next if v[:optional]
+          val = v[:default]
+        end
+
+        val = val &&
+                case v[:attr_type]
+                when :bool  then val ? '1' : '0'
+                when :float then val.to_s.gsub(/\.0*$/, '') # Trim trailing zeroes
+                else val
+                end
+
+        xml_attrs[v[:attr_name]] = val
+      }
+
+      xml_attrs
+    end
+
+  end
+end

data/lib/rubyXL/objects/reference.rb

@@ -0,0 +1,98 @@
+module RubyXL
+  class Reference
+    ROW_MAX = 1024*1024
+    COL_MAX = 16393
+
+    attr_reader :row_range, :col_range
+
+    # RubyXL::Reference.new(row, col)
+    # RubyXL::Reference.new(row_from, row_to, col_from, col_to)
+    # RubyXL::Reference.new(reference_string)
+    def initialize(*params)
+      row_from = row_to = col_from = col_to = nil
+
+      case params.size
+      when 4 then row_from, row_to, col_from, col_to = params
+      when 2 then row_from, col_from = params
+      when 1 then
+        raise ArgumentError.new("invalid value for #{self.class}: #{params[0].inspect}") unless params[0].is_a?(String)
+        from, to = params[0].split(':')
+        row_from, col_from = self.class.ref2ind(from)
+        row_to, col_to = self.class.ref2ind(to) unless to.nil?
+      end      
+
+      @row_range = Range.new(row_from || 0, row_to || row_from || ROW_MAX)
+      @col_range = Range.new(col_from || 0, col_to || col_from || COL_MAX)
+    end
+
+    def single_cell?
+      (@row_range.begin == @row_range.end) && (@col_range.begin == @col_range.end)
+    end
+
+    def first_row
+      @row_range.begin
+    end
+
+    def last_row
+      @row_range.end
+    end
+
+    def first_col
+      @col_range.begin
+    end
+
+    def last_col
+      @col_range.end
+    end
+
+    def ==(other)
+      !other.nil? && (@row_range == other.row_range) && (@col_range == other.col_range)
+    end
+
+    def cover?(other)
+      !other.nil? && (@row_range.cover?(other.row_range.begin) && @row_range.cover?(other.row_range.end) && 
+                      @col_range.cover?(other.col_range.begin) && @col_range.cover?(other.col_range.end))
+    end
+
+    def to_s
+      if single_cell? then
+        self.class.ind2ref(@row_range.begin, @col_range.begin)
+      else
+        self.class.ind2ref(@row_range.begin, @col_range.begin) + ':' + self.class.ind2ref(@row_range.end, @col_range.end)
+      end
+    end
+
+    def inspect
+      if single_cell? then
+        "#<#{self.class} @row=#{@row_range.begin} @col=#{@col_range.begin}>"
+      else
+        "#<#{self.class} @row_range=#{@row_range} @col_range=#{@col_range}>"
+      end
+    end
+
+    # Converts +row+ and +col+ zero-based indices to Excel-style cell reference
+    # (0) A...Z, AA...AZ, BA... ...ZZ, AAA... ...AZZ, BAA... ...XFD (16383)
+    def self.ind2ref(row = 0, col = 0)
+      RubyXL::ColumnRange.ind2ref(col) + (row + 1).to_s
+    end
+
+    # Converts Excel-style cell reference to +row+ and +col+ zero-based indices.
+    def self.ref2ind(str)
+      return [ -1, -1 ] unless str =~ /^([A-Z]+)(\d+)$/
+      [ $2.to_i - 1, RubyXL::ColumnRange.ref2ind($1) ]
+    end  
+
+  end
+
+  class Sqref < Array
+
+    def initialize(str)
+      str.split.each { |ref_str| self << RubyXL::Reference.new(ref_str) }
+    end
+
+    def to_s
+      self.collect{ |ref| ref.to_s }.join(' ')
+    end
+
+  end
+end

data/lib/rubyXL/objects/sheet_view.rb

@@ -0,0 +1,62 @@
+module RubyXL
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_pane-1.html
+  class Pane < OOXMLObject
+    define_attribute(:xSplit,      :int)
+    define_attribute(:ySplit,      :int)
+    define_attribute(:topLeftCell, :string)
+    define_attribute(:activePane,  :string, :default => 'topLeft',
+                       :values => %w{ bottomRight topRight bottomLeft topLeft })
+    define_attribute(:state,       :string, :default=> 'split',
+                       :values => %w{ split frozen frozenSplit })
+    define_element_name 'pane'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_selection-1.html
+  class Selection < OOXMLObject
+    define_attribute(:pane,         :string,
+                       :values => %w{ bottomRight topRight bottomLeft topLeft })
+    define_attribute(:activeCell,   :ref)
+    define_attribute(:activeCellId, :int)   # 0-based index of @active_cell in @sqref
+    define_attribute(:sqref,        :sqref) # Array of references to the selected cells.
+    define_element_name 'selection'
+
+    def before_write_xml
+      # Normally, rindex of activeCellId in sqref:
+      # <selection activeCell="E12" activeCellId="9" sqref="A4 B6 C8 D10 E12 A4 B6 C8 D10 E12"/>
+      if @active_cell_id.nil? && !@active_cell.nil? && @sqref.size > 1 then
+        # But, things can be more complex:
+        # <selection activeCell="E8" activeCellId="2" sqref="A4:B4 C6:D6 E8:F8"/>
+        # Not using .reverse.each here to avoid memory reallocation.
+        @sqref.each_with_index { |ref, ind| @active_cell_id = ind if ref.cover?(@active_cell) } 
+      end
+    end
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_sheetView-1.html
+  class SheetView < OOXMLObject
+    define_attribute(:windowProtection,         :bool, :default => false)
+    define_attribute(:showFormulas,             :bool, :default => false)
+    define_attribute(:showGridLines,            :bool, :default => true)
+    define_attribute(:showRowColHeaders,        :bool, :default => true)
+    define_attribute(:showZeros,                :bool, :default => true)
+    define_attribute(:rightToLeft,              :bool, :default => false)
+    define_attribute(:tabSelected,              :bool, :default => false)
+    define_attribute(:showRuler,                :bool, :default => true)
+    define_attribute(:showOutlineSymbols,       :bool, :default => true)
+    define_attribute(:defaultGridColor,         :bool, :default => true)
+    define_attribute(:showWhiteSpace,           :bool, :default => true)
+    define_attribute(:view,                     :string, :default => 'normal',
+                       :values => %w{ normal pageBreakPreview pageLayout })
+    define_attribute(:topLeftCell,              :ref)
+    define_attribute(:colorId,                  :int, :default => 64)
+    define_attribute(:zoomScale,                :int, :default => 100)
+    define_attribute(:zoomScaleNormal,          :bool, :default => 0)
+    define_attribute(:zoomScaleSheetLayoutView, :bool, :default => 0)
+    define_attribute(:zoomScalePageLayoutView,  :bool, :default => 0)
+    define_attribute(:workbookViewId,           :int, :required => true, :default => 0 )
+    define_child_node(RubyXL::Pane)
+    define_child_node(RubyXL::Selection, :collection => true, :accessor => :selections )
+    define_element_name 'sheetView'
+  end
+
+end

data/lib/rubyXL/objects/worksheet.rb

@@ -0,0 +1,11 @@
+module RubyXL
+
+  # Eventually, the entire code for Worksheet will be moved here. One small step at a time!
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_legacyDrawing-1.html
+  class LegacyDrawing < OOXMLObject
+    define_attribute(:'r:id',            :string, :required => true)
+    define_element_name 'legacyDrawing'
+  end
+
+end

data/lib/rubyXL/parser.rb

@@ -0,0 +1,307 @@
+require 'rubygems'
+require 'nokogiri'
+require 'zip'
+require 'rubyXL/generic_storage'
+
+module RubyXL
+
+  class Parser
+    def self.parse(file_path, opts = {})
+      self.new(opts).parse(file_path)
+    end
+
+    # +:data_only+ allows only the sheet data to be parsed, so as to speed up parsing
+    # However, using this option will result in date-formatted cells being interpreted as numbers
+    def initialize(opts = {})
+      @data_only = opts.is_a?(TrueClass) || opts[:data_only]
+      @skip_filename_check = opts[:skip_filename_check]
+    end
+
+    def data_only
+      @data_only = true
+      self
+    end
+
+    def parse(file_path, opts = {})
+
+      # options handling
+
+      wb = Workbook.new([], file_path)
+
+      raise 'Not .xlsx or .xlsm excel file' unless @skip_filename_check ||
+                                              %w{.xlsx .xlsm}.include?(File.extname(file_path))
+
+      dir_path = File.join(File.dirname(file_path), Dir::Tmpname.make_tmpname(['rubyXL', '.tmp'], nil))
+
+      MyZip.new.unzip(file_path, dir_path)
+
+      files = {}
+
+      workbook_file = Nokogiri::XML.parse(File.open(File.join(dir_path,'xl','workbook.xml'),'r'))
+      rels_doc = Nokogiri::XML.parse(File.open(File.join(dir_path, 'xl', '_rels', 'workbook.xml.rels'), 'r'))
+
+      if(File.exist?(File.join(dir_path,'xl','sharedStrings.xml')))
+        shared_string_file = Nokogiri::XML.parse(File.open(File.join(dir_path,'xl','sharedStrings.xml'),'r'))
+      end
+
+      unless @data_only
+        wb.media = RubyXL::GenericStorage.new(File.join('xl', 'media')).binary.load_dir(dir_path)
+        wb.external_links = RubyXL::GenericStorage.new(File.join('xl', 'externalLinks')).load_dir(dir_path)
+        wb.external_links_rels = RubyXL::GenericStorage.new(File.join('xl', 'externalLinks', '_rels')).load_dir(dir_path)
+        wb.drawings = RubyXL::GenericStorage.new(File.join('xl', 'drawings')).load_dir(dir_path)
+        wb.drawings_rels = RubyXL::GenericStorage.new(File.join('xl', 'drawings', '_rels')).load_dir(dir_path)
+        wb.charts = RubyXL::GenericStorage.new(File.join('xl', 'charts')).load_dir(dir_path)
+        wb.chart_rels = RubyXL::GenericStorage.new(File.join('xl', 'charts', '_rels')).load_dir(dir_path)
+        wb.printer_settings = RubyXL::GenericStorage.new(File.join('xl', 'printerSettings')).binary.load_dir(dir_path)
+        wb.worksheet_rels = RubyXL::GenericStorage.new(File.join('xl', 'worksheets', '_rels')).load_dir(dir_path)
+        wb.macros = RubyXL::GenericStorage.new('xl').binary.load_file(dir_path, 'vbaProject.bin')
+        wb.theme = RubyXL::GenericStorage.new(File.join('xl', 'theme')).load_file(dir_path, 'theme1.xml')
+
+        core_file = Nokogiri::XML.parse(File.open(File.join(dir_path, 'docProps', 'core.xml'), 'r'))
+        wb.creator = core_file.css('dc|creator').children.to_s
+        wb.modifier = core_file.css('cp|last_modified_by').children.to_s
+        wb.created_at = core_file.css('dcterms|created').children.to_s
+        wb.modified_at = core_file.css('dcterms|modified').children.to_s
+
+        app_file = Nokogiri::XML.parse(File.open(File.join(dir_path, 'docProps', 'app.xml'), 'r'))
+        wb.company = app_file.css('Company').children.to_s
+        wb.application = app_file.css('Application').children.to_s
+        wb.appversion = app_file.css('AppVersion').children.to_s
+      end
+
+      styles_xml = Nokogiri::XML.parse(File.open(File.join(dir_path, 'xl', 'styles.xml'), 'r'))
+
+      defined_names = workbook_file.css('definedNames definedName')
+      wb.defined_names = defined_names.collect { |node| RubyXL::DefinedName.parse(node) }
+
+      wb.date1904 = workbook_file.css('workbookPr').attribute('date1904').to_s == '1'
+
+      wb.shared_strings_XML = shared_string_file.to_s
+
+      unless shared_string_file.nil?
+        sst = shared_string_file.css('sst')
+
+        # According to http://msdn.microsoft.com/en-us/library/office/gg278314.aspx,
+        # these attributes may be either both missing, or both present. Need to validate.
+        wb.shared_strings.count_attr = sst.attribute('count').value.to_i
+        wb.shared_strings.unique_count_attr = sst.attribute('uniqueCount').value.to_i
+
+        # Note that the strings may contain text formatting, such as changing font color/properties
+        # in the middle of the string. We do not support that in this gem... at least yet!
+        # If you save the file, this formatting will be destoyed.
+        shared_string_file.css('si').each_with_index { |node, i|
+          wb.shared_strings.add(node.css('t').inject(''){ |s, c| s + c.text }, i)
+        }
+
+      end
+
+      fills = styles_xml.css('fills fill')
+      wb.fills = fills.collect { |node| RubyXL::Fill.parse(node) }
+
+      colors = styles_xml.css('colors').first
+
+      if colors then
+        colors.element_children.each { |color_type_node|
+          wb.colors[color_type_node.name] ||= []
+          color_type_node.element_children.each { |color_node|
+            wb.colors[color_type_node.name] << RubyXL::Color.parse(color_node)
+          }
+        }
+      end
+
+      borders = styles_xml.css('borders border')
+      wb.borders = borders.collect { |node| RubyXL::Border.parse(node) }
+
+      fonts = styles_xml.css('fonts font')
+      wb.fonts = fonts.collect { |node| RubyXL::Font.parse(node) }
+
+      cell_styles = styles_xml.css('cellStyles cellStyle')
+      wb.cell_styles = cell_styles.collect { |node| RubyXL::CellStyle.parse(node) }
+
+      num_fmts = styles_xml.css('numFmts numFmt')
+      wb.num_fmts = num_fmts.collect { |node| RubyXL::NumFmt.parse(node) }
+
+      csxfs = styles_xml.css('cellStyleXfs xf')
+      wb.cell_style_xfs = csxfs.collect { |node| RubyXL::XF.parse(node) }
+
+      cxfs = styles_xml.css('cellXfs xf')
+      wb.cell_xfs = cxfs.collect { |node| RubyXL::XF.parse(node) }
+
+      #fills out count information for each font, fill, and border
+      wb.cell_xfs.each { |style|
+        id = style.font_id
+        wb.fonts[id].count += 1 #unless id.nil?
+
+        id = style.fill_id
+        wb.fills[id].count += 1 #unless id.nil?
+
+        id = style.border_id
+        wb.borders[id].count += 1 #unless id.nil?
+      }
+
+      # Not sure why they were getting sheet names from god knows where.
+      # There *may* have been a good reason behind it, so not tossing this code out entirely yet.
+      # sheet_names = app_file.css('TitlesOfParts vt|vector vt|lpstr').children
+
+      workbook_file.css('sheets sheet').each_with_index { |sheet_node, i|
+        sheet_rid = sheet_node.attributes['id'].value 
+        sheet_file_path = rels_doc.css("Relationships Relationship[Id=#{sheet_rid}]").first.attributes['Target']
+        worksheet_xml = Nokogiri::XML.parse(File.read(File.join(dir_path, 'xl', sheet_file_path)))
+        parse_worksheet(wb, i, worksheet_xml, sheet_node.attributes['name'].value,
+                               sheet_node.attributes['sheetId'].value )
+      }
+
+      FileUtils.remove_entry_secure(dir_path)
+
+      return wb
+    end
+
+    private
+
+    # Parse the incoming +worksheet_xml+ into a new +Worksheet+ object 
+    def parse_worksheet(wb, i, worksheet_xml, worksheet_name, sheet_id)
+      worksheet = Worksheet.new(wb, worksheet_name)
+      wb.worksheets[i] = worksheet # Due to "validate_workbook" issues. Should remove that validation eventually.
+      worksheet.sheet_id = sheet_id
+
+      dimensions_node = worksheet_xml.css('dimension').first
+      return nil if dimensions_node.nil? # Temporary plug for Issue #76
+
+      dimensions = RubyXL::Reference.new(dimensions_node.attribute('ref').value)
+      cols = dimensions.last_col
+
+      # Create empty arrays for workcells. Using +downto()+ here so memory for +sheet_data[]+ is
+      # allocated on the first iteration (in case of +upto()+, +sheet_data[]+ would end up being
+      # reallocated on every iteration).
+      dimensions.last_row.downto(0) { |i| worksheet.sheet_data[i] = Array.new(cols + 1) }
+
+      namespaces = worksheet_xml.root.namespaces
+
+      if @data_only
+        row_xpath = '/xmlns:worksheet/xmlns:sheetData/xmlns:row[xmlns:c[xmlns:v]]'
+        cell_xpath = './xmlns:c[xmlns:v[text()]]'
+      else
+        row_xpath = '/xmlns:worksheet/xmlns:sheetData/xmlns:row'
+        cell_xpath = './xmlns:c'
+
+        sheet_views_nodes = worksheet_xml.xpath('/xmlns:worksheet/xmlns:sheetViews/xmlns:sheetView', namespaces)
+        worksheet.sheet_views = sheet_views_nodes.collect { |node| RubyXL::SheetView.parse(node) }
+
+        col_node_set = worksheet_xml.xpath('/xmlns:worksheet/xmlns:cols/xmlns:col',namespaces)
+        worksheet.column_ranges = col_node_set.collect { |col_node| RubyXL::ColumnRange.parse(col_node) }
+
+        merged_cells_nodeset = worksheet_xml.xpath('/xmlns:worksheet/xmlns:mergeCells/xmlns:mergeCell', namespaces)
+        worksheet.merged_cells = merged_cells_nodeset.collect { |child| RubyXL::Reference.new(child.attributes['ref'].text) }
+
+#        worksheet.pane = worksheet.sheet_view[:pane]
+
+        data_validations = worksheet_xml.xpath('/xmlns:worksheet/xmlns:dataValidations/xmlns:dataValidation', namespaces)
+        worksheet.validations = data_validations.collect { |node| RubyXL::DataValidation.parse(node) }
+
+# Currently  not working #TODO#
+#        ext_list_node = worksheet_xml.xpath('/xmlns:worksheet/xmlns:extLst', namespaces)
+
+        legacy_drawing_nodes = worksheet_xml.xpath('/xmlns:worksheet/xmlns:legacyDrawing', namespaces)
+        worksheet.legacy_drawings = legacy_drawing_nodes.collect { |node| RubyXL::LegacyDrawing.parse(node) }
+
+        drawing_nodes = worksheet_xml.xpath('/xmlns:worksheet/xmlns:drawing', namespaces)
+        worksheet.drawings = drawing_nodes.collect { |n| n.attributes['id'] }
+      end
+
+      worksheet_xml.xpath(row_xpath, namespaces).each { |row|
+        unless @data_only
+          ##row styles##
+          row_attributes = row.attributes
+          row_style = row_attributes['s'] && Integer(row_attributes['s'].value) || 0
+          row_num = Integer(row_attributes['r'].content)
+
+          worksheet.row_styles[row_num] = { :style => row_style  }
+
+          if !row_attributes['ht'].nil?  && (!row_attributes['ht'].content.nil? || row_attributes['ht'].content.strip != "" )
+            worksheet.change_row_height(row_num - 1, Float(row_attributes['ht'].value))
+          end
+          ##end row styles##
+        end
+
+        row.search(cell_xpath).each { |value|
+          #attributes is from the excel cell(c) and is basically location information and style and type
+          value_attributes = value.attributes
+          # r attribute contains the location like A1
+          cell_index = RubyXL::Reference.ref2ind(value_attributes['r'].content)
+          style_index = 0
+          # t is optional and contains the type of the cell
+          data_type = value_attributes['t'].content if value_attributes['t']
+          element_hash ={}
+
+          value.children.each { |node| element_hash["#{node.name()}_element"] = node }
+
+          # v is the value element that is part of the cell
+          if element_hash["v_element"]
+            v_element_content = element_hash["v_element"].content
+          else
+            v_element_content=""
+          end
+
+          if v_element_content == "" # no data
+            cell_data = nil
+          elsif data_type == RubyXL::Cell::SHARED_STRING
+            str_index = Integer(v_element_content)
+            cell_data = wb.shared_strings[str_index].to_s
+          elsif data_type == RubyXL::Cell::RAW_STRING
+            cell_data = v_element_content
+          elsif data_type == RubyXL::Cell::ERROR
+            cell_data = v_element_content
+          else# (value.css('v').to_s != "") && (value.css('v').children.to_s != "") #is number
+            data_type = ''
+            if(v_element_content =~ /\./ or v_element_content =~ /\d+e\-?\d+/i) #is float
+              cell_data = Float(v_element_content)
+            else
+              cell_data = Integer(v_element_content)
+            end
+          end
+
+          # f is the formula element
+          cell_formula = nil
+          fmla_css = element_hash["f_element"]
+          if fmla_css && fmla_css.content
+            fmla_css_content= fmla_css.content
+            if(fmla_css_content != "")
+              cell_formula = fmla_css_content
+              cell_formula_attr = {}
+              fmla_css_attributes = fmla_css.attributes
+              cell_formula_attr['t'] = fmla_css_attributes['t'].content if fmla_css_attributes['t']
+              cell_formula_attr['ref'] = fmla_css_attributes['ref'].content if fmla_css_attributes['ref']
+              cell_formula_attr['si'] = fmla_css_attributes['si'].content if fmla_css_attributes['si']
+            end
+          end
+
+          style_index = value['s'].to_i #nil goes to 0 (default)
+
+          worksheet.sheet_data[cell_index[0]][cell_index[1]] =
+            Cell.new(worksheet,cell_index[0],cell_index[1],cell_data,cell_formula,
+              data_type,style_index,cell_formula_attr)
+          cell = worksheet.sheet_data[cell_index[0]][cell_index[1]]
+        }
+      }
+
+      worksheet
+    end
+
+    def self.attr_int(node, attr_name) 
+      attr = node.attributes[attr_name]
+      attr && Integer(attr.value)
+    end
+
+    def self.attr_float(node, attr_name) 
+      attr = node.attributes[attr_name]
+      attr && Float(attr.value)
+    end
+
+    def self.attr_string(node, attr_name) 
+      attr = node.attributes[attr_name]
+      attr && attr.value
+    end
+
+  end
+end
+