rubyXL 1.2.10 → 2.1.1

data/lib/rubyXL/workbook.rb

@@ -1,450 +1,281 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','content_types_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','root_rels_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','app_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','core_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','theme_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','workbook_rels_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','workbook_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','styles_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','shared_strings_writer'))
-require File.expand_path(File.join(File.dirname(__FILE__),'writer','worksheet_writer'))
-require 'rubyXL/zip'
-require 'date'
+require 'rubyXL/writer/generic_writer'
+require 'rubyXL/writer/content_types_writer'
+require 'rubyXL/writer/root_rels_writer'
+require 'rubyXL/writer/core_writer'
+require 'rubyXL/writer/theme_writer'
+require 'rubyXL/writer/workbook_writer'
+require 'rubyXL/writer/styles_writer'
+require 'rubyXL/writer/worksheet_writer'
+require 'tmpdir'
+require 'zip'
 
 module RubyXL
-  class Workbook
+  module LegacyWorkbook
     include Enumerable
-    attr_accessor :worksheets, :filepath, :creator, :modifier, :created_at,
-      :modified_at, :company, :application, :appversion, :num_fmts, :num_fmts_hash, :fonts, :fills,
-      :borders, :cell_xfs, :cell_style_xfs, :cell_styles, :shared_strings, :calc_chain,
-      :num_strings, :size, :date1904, :external_links, :style_corrector, :drawings,
-      :worksheet_rels, :printer_settings, :macros, :colors, :shared_strings_XML, :defined_names, :column_lookup_hash
+    attr_accessor :worksheets, :filepath, :creator, :modifier, :created_at, :modified_at, :theme,
+      :media, :external_links, :external_links_rels, :drawings, :drawings_rels, :charts, :chart_rels,
+      :worksheet_rels, :printer_settings, :macros
 
+    attr_accessor :stylesheet, :shared_strings_container, :document_properties, :calculation_chain,
+                  :relationship_container
 
+    SHEET_NAME_TEMPLATE = 'Sheet%d'
     APPLICATION = 'Microsoft Macintosh Excel'
     APPVERSION  = '12.0000'
-    SHEET_NAME = 'Sheet1'
+
     def initialize(worksheets=[], filepath=nil, creator=nil, modifier=nil, created_at=nil,
                    company='', application=APPLICATION,
                    appversion=APPVERSION, date1904=0)
-      if worksheets.nil? || worksheets.empty?
-        @worksheets       = [Worksheet.new(self,SHEET_NAME)]
-      else
-        @worksheets       = worksheets
-      end
-      @filepath           = filepath
-      @creator            = creator
-      @modifier           = modifier
-      @company            = company
-      @application        = application
-      @appversion         = appversion
-      @num_fmts           = nil
-      @num_fmts_hash      = nil
-      @fonts              = nil
-      @fills              = nil
-      @borders            = nil
-      @cell_xfs           = nil
-      @cell_style_xfs     = nil
-      @cell_styles        = nil
-      @shared_strings     = nil
-      @calc_chain         = nil #unnecessary?
-      @num_strings        = 0 #num strings total
-      @size               = 0 #num strings in shared_strings array
-      @date1904           = date1904 > 0
-      @external_links     = nil
-      @style_corrector    = nil
-      @drawings           = nil
-      @worksheet_rels     = nil
-      @printer_settings   = nil
-      @macros             = nil
-      @colors             = nil
-      @shared_strings_XML = nil
-      @defined_names      = nil
-      @column_lookup_hash = {}
+      super()
+
+      # Order of sheets in the +worksheets+ array corresponds to the order of pages in Excel UI.
+      # SheetId's, rId's, etc. are completely unrelated to ordering.
+      @worksheets = worksheets
+      add_worksheet if @worksheets.empty?
+
+      @filepath            = filepath
+      @creator             = creator
+      @modifier            = modifier
+      self.date1904        = date1904 > 0
+      @media               = RubyXL::GenericStorage.new(File.join('xl', 'media')).binary
+      @external_links      = RubyXL::GenericStorage.new(File.join('xl', 'externalLinks'))
+      @external_links_rels = RubyXL::GenericStorage.new(File.join('xl', 'externalLinks', '_rels'))
+      @drawings            = RubyXL::GenericStorage.new(File.join('xl', 'drawings'))
+      @drawings_rels       = RubyXL::GenericStorage.new(File.join('xl', 'drawings', '_rels'))
+      @charts              = RubyXL::GenericStorage.new(File.join('xl', 'charts'))
+      @chart_rels          = RubyXL::GenericStorage.new(File.join('xl', 'charts', '_rels'))
+      @worksheet_rels      = RubyXL::GenericStorage.new(File.join('xl', 'worksheets', '_rels'))
+      @theme               = RubyXL::GenericStorage.new(File.join('xl', 'theme'))
+      @printer_settings    = RubyXL::GenericStorage.new(File.join('xl', 'printerSettings')).binary
+      @macros              = RubyXL::GenericStorage.new('xl').binary
+
+      @shared_strings_container = RubyXL::SharedStringsTable.new
+      @stylesheet               = RubyXL::Stylesheet.default
+      @document_properties      = RubyXL::DocumentProperties.new
+      @relationship_container   = RubyXL::WorkbookRelationships.new
+      @calculation_chain        = nil
+
+      self.company         = company
+      self.application     = application
+      self.appversion      = appversion
 
       begin
         @created_at       = DateTime.parse(created_at).strftime('%Y-%m-%dT%TZ')
       rescue
-        t = Time.now
-        @created_at       = t.strftime('%Y-%m-%dT%TZ')
+        @created_at       = Time.now.strftime('%Y-%m-%dT%TZ')
       end
       @modified_at        = @created_at
+    end
 
-      fill_styles()
-      fill_shared_strings()
+    # Finds worksheet by its name or numerical index
+    def [](ind)
+      case ind
+      when Integer then worksheets[ind]
+      when String  then worksheets.find { |ws| ws.sheet_name == ind }
+      end
     end
 
-    # allows easier access to worksheets
-    def [](worksheet)
-      return worksheets[worksheet]
+    # Create new simple worksheet and add it to the workbook worksheets
+    #
+    # @param [String] The name for the new worksheet
+    def add_worksheet(name = nil)
+      if name.nil? then
+        n = 0
+
+        begin
+          name = SHEET_NAME_TEMPLATE % (n += 1)
+        end until self[name].nil?
+      end
+
+      new_worksheet = Worksheet.new(:workbook => self, :sheet_name => name || get_default_name)
+      worksheets << new_worksheet
+      new_worksheet
     end
 
     def each
       worksheets.each{|i| yield i}
     end
 
-    def num_fmts_by_id
-      
-      return @num_fmts_hash unless @num_fmts_hash.nil?
-      if num_fmts
-        @num_fmts_hash={}
-        num_fmts[:numFmt].each do |num_fmt|
-          @num_fmts_hash[num_fmt[:attributes][:numFmtId]]=num_fmt
-        end
-        @num_fmts_hash
-      else
-        {}
-      end
-    end
-
     #filepath of xlsx file (including file itself)
-    def write(filepath=@filepath)
-      validate_before_write
-      if !(filepath =~ /(.+)\.xls(x|m)/)
-        raise "Only xlsx and xlsm files are supported. Unsupported type for file: #{filepath}"
-      end
-      dirpath = ''
-      extension = 'xls'
-      if(filepath =~ /((.|\s)*)\.xls(x|m)$/)
-        dirpath = $1.to_s()
-        extension += $3.to_s
-      end
-      filename = ''
-      if(filepath =~ /\/((.|\s)*)\/((.|\s)*)\.xls(x|m)$/)
-        filename = $3.to_s()
+    def write(filepath = @filepath)
+      extension = File.extname(filepath)
+      unless %w{.xlsx .xlsm}.include?(extension)
+        raise "Only xlsx and xlsm files are supported. Unsupported extension: #{extension}"
       end
 
-      #creates zip file, writes each type of file to zip folder
-      #zips package and renames it to xlsx.
-      zippath = File.join(dirpath, filename + '.zip')
-      File.unlink(zippath) if File.exists?(zippath)
-      FileUtils.mkdir_p(File.join(dirpath,zippath))
-      Zip::ZipFile.open(zippath, Zip::ZipFile::CREATE) do |zipfile|
-        writer = Writer::ContentTypesWriter.new(dirpath,self)
-        zipfile.get_output_stream('[Content_Types].xml') {|f| f.puts(writer.write())}
-
-        writer = Writer::RootRelsWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('_rels','.rels')) {|f| f.puts(writer.write())}
-
-        writer = Writer::AppWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('docProps','app.xml')) {|f| f.puts(writer.write())}
-
-        writer = Writer::CoreWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('docProps','core.xml')) {|f| f.puts(writer.write())}
-
-        writer = Writer::ThemeWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('xl','theme','theme1.xml')) {|f| f.puts(writer.write())}
-
-        writer = Writer::WorkbookRelsWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('xl','_rels','workbook.xml.rels')) {|f| f.puts(writer.write())}
-
-        writer = Writer::WorkbookWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('xl','workbook.xml')) {|f| f.puts(writer.write())}
-
-        writer = Writer::StylesWriter.new(dirpath,self)
-        zipfile.get_output_stream(File.join('xl','styles.xml')) {|f| f.puts(writer.write())}
-
-        unless @shared_strings.nil?
-          writer = Writer::SharedStringsWriter.new(dirpath,self)
-          zipfile.get_output_stream(File.join('xl','sharedStrings.xml')) {|f| f.puts(writer.write())}
-        end
-
-        #preserves external links (exactly, no modification allowed)
-        unless @external_links.nil?
-          #-1 because of rels
-          1.upto(@external_links.size-1) do |i|
-            zipfile.get_output_stream(
-              File.join('xl','externalLinks',"externalLink#{i}.xml")) {|f|
-                f.puts(@external_links[i])
-              }
-          end
-          @external_links['rels'].each_index do |i|
-            unless @external_links['rels'][i].nil?
-              zipfile.get_output_stream(
-                File.join('xl','externalLinks','_rels',"externalLink#{i}.xml.rels")) {|f|
-                  f.puts(@external_links['rels'][i])
-                }
-            end
-          end
-        end
-
-        #preserves drawings (exactly, no modification allowed)
-        unless @drawings.nil?
-          1.upto(@drawings.size) do |i|
-            zipfile.get_output_stream(
-            File.join('xl','drawings',"vmlDrawing#{i}.vml")) {|f|
-              f.puts(@drawings[i])
-            }
-          end
-        end
-
-        unless @printer_settings.nil?
-          1.upto(@printer_settings.size) do |i|
-            zipfile.get_output_stream(
-            File.join('xl','printerSettings',"printerSettings#{i}.bin")) {|f|
-              f.puts(@printer_settings[i])
-            }
-          end
-        end
-
-        unless @worksheet_rels.nil?
-          1.upto(@worksheet_rels.size) do |i|
-            zipfile.get_output_stream(
-            File.join('xl','worksheets','_rels',"sheet#{i}.xml.rels")) {|f|
-              f.puts(@worksheet_rels[i])
-            }
-          end
-        end
-
-        unless @macros.nil?
-          zipfile.get_output_stream(File.join('xl','vbaProject.bin')) {|f| f.puts(@macros)}
-        end
-
-        @worksheets.each_with_index do |sheet,i|
-          writer = Writer::WorksheetWriter.new(dirpath,self,i)
-          zipfile.get_output_stream(File.join('xl','worksheets',"sheet#{i+1}.xml")) {|f| f.puts(writer.write())}
-        end
-      end
+      dirpath  = File.dirname(filepath)
+      temppath = File.join(dirpath, Dir::Tmpname.make_tmpname([ File.basename(filepath), '.tmp' ], nil))
+      FileUtils.mkdir_p(temppath)
+      zippath  = File.join(temppath, 'file.zip')
+
+      ::Zip::File.open(zippath, ::Zip::File::CREATE) { |zipfile|
+        [ Writer::ContentTypesWriter, Writer::RootRelsWriter, Writer::CoreWriter,
+          Writer::ThemeWriter, Writer::WorkbookWriter, Writer::StylesWriter
+        ].each { |writer_class| writer_class.new(self).add_to_zip(zipfile) }
+
+        calculation_chain && calculation_chain.add_to_zip(zipfile)
+        shared_strings_container && shared_strings_container.add_to_zip(zipfile)
+        document_properties.add_to_zip(zipfile)
+        relationship_container.workbook = self
+        relationship_container.add_to_zip(zipfile)
+
+        [ @media, @external_links, @external_links_rels,
+          @drawings, @drawings_rels, @charts, @chart_rels,
+          @printer_settings, @worksheet_rels, @macros ].each { |s| s.add_to_zip(zipfile) }
+
+        @worksheets.each_index { |i| Writer::WorksheetWriter.new(self, i).add_to_zip(zipfile) }
+      }
+
+      FileUtils.mv(zippath, filepath)
+      FileUtils.rm_rf(temppath) if File.exist?(filepath)
 
-      FileUtils.cp(zippath,File.join(dirpath,filename+".#{extension}"))
-      FileUtils.cp(File.join(dirpath,filename+".#{extension}"),filepath)
-      if File.exist?(filepath)
-        FileUtils.rm_rf(dirpath)
-      end
       return filepath
     end
 
-    def date_to_num(date)
-      return nil if date.nil?
-      if @date1904
-        compare_date = DateTime.parse('December 31, 1903')
+    def base_date
+      if date1904 then 
+        Date.new(1904, 1, 1)
       else
-        compare_date = DateTime.parse('December 31, 1899')
+        # Subtracting one day to accomodate for erroneous 1900 leap year compatibility only for 1900 based dates
+        Date.new(1899, 12, 31) - 1
       end
-      # add one day to compare date for erroneous 1900 leap year compatibility
-      date.ajd + 1 - compare_date.ajd
+    end
+    private :base_date
+
+    def date_to_num(date)
+      date && (date.ajd - base_date().ajd).to_i
     end
 
     def num_to_date(num)
-      return nil if num.nil?
-      if @date1904
-        compare_date = DateTime.parse('December 31, 1903')
-      else
-        compare_date = DateTime.parse('December 31, 1899')
-      end
-      # subtract one day to compare date for erroneous 1900 leap year compatibility
-      compare_date - 1 + num
+      num && (base_date + num)
     end
 
-    def date_num_fmt?(num_fmt)
-      @num_fmt_date_hash ||= {}
-      if @num_fmt_date_hash[num_fmt].nil?
-        @num_fmt_date_hash[num_fmt] = is_date_format?(num_fmt)
-      end
-      return @num_fmt_date_hash[num_fmt]
+    def get_fill_color(xf)
+      fill = fills[xf.fill_id]
+      pattern = fill && fill.pattern_fill
+      color = pattern && pattern.fg_color
+      color && color.rgb || 'ffffff'
     end
 
-     def is_date_format?(num_fmt)
-      skip_chars = ['$', '-', '+', '/', '(', ')', ':', ' ']
-      num_chars = ['0', '#', '?']
-      non_date_formats = ['0.00E+00', '##0.0E+0', 'General', 'GENERAL', 'general', '@']
-      date_chars = ['y','m','d','h','s']
-
-      state = 0
-      s = ''
-      num_fmt.split(//).each do |c|
-        if state == 0
-          if c == '"'
-            state = 1
-          elsif ['\\', '_', '*'].include?(c)
-            state = 2
-          elsif skip_chars.include?(c)
-            next
-          else
-            s << c
-          end
-        elsif state == 1
-          if c == '"'
-            state = 0
-          end
-        elsif state == 2
-          state = 0
-        end
-      end
-      s.gsub!(/\[[^\]]*\]/, '')
-      if non_date_formats.include?(s)
-        return false
-      end
-      separator = ';'
-      got_sep = 0
-      date_count = 0
-      num_count = 0
-      s.split(//).each do |c|
-        if date_chars.include?(c)
-          date_count += 1
-        elsif num_chars.include?(c)
-          num_count += 1
-        elsif c == separator
-          got_sep = 1
-        end
-      end
-      if date_count > 0 && num_count == 0
-        return true
-      elsif num_count > 0 && date_count == 0
-        return false
-      elsif date_count
-        # ambiguous result
-      elsif got_sep == 0
-        # constant result
+    def register_new_fill(new_fill, old_xf)
+      new_xf = old_xf.dup
+
+      unless fills[old_xf.fill_id].count == 1 && old_xf.fill_id > 2 # If the old fill is not used anymore, just replace it
+        new_xf.fill_id = fills.find_index { |x| x == new_fill } # Use existing fill, if it exists
+        new_xf.fill_id ||= fills.size # If this fill has never existed before, add it to collection.
       end
-      return date_count > num_count
+
+      fills[old_xf.fill_id].count -= 1
+      new_fill.count += 1
+      fills[new_xf.fill_id] = new_fill
+
+      new_xf.apply_fill = true
+      new_xf
     end
 
-    #gets style object from style array given index
-    def get_style(style_index)
-      if !@cell_xfs[:xf].is_a?Array
-        @cell_xfs[:xf] = [@cell_xfs[:xf]]
-      end
+    def register_new_font(new_font, old_xf)
+      new_xf = old_xf.dup
 
-      xf_obj = @cell_xfs[:xf]
-      if xf_obj.is_a?Array
-        xf_obj = xf_obj[Integer(style_index)]
+      unless fonts[old_xf.font_id].count == 1 && old_xf.font_id > 1 # If the old font is not used anymore, just replace it
+        new_xf.font_id = fonts.find_index { |x| x == new_font } # Use existing font, if it exists
+        new_xf.font_id ||= fonts.size # If this font has never existed before, add it to collection.
       end
-      xf_obj
+
+      fonts[old_xf.font_id].count -= 1
+      new_font.count += 1
+      fonts[new_xf.font_id] = new_font
+
+      new_xf.apply_font = true
+      new_xf
     end
 
-    #gets attributes of above style object
-    #necessary because can take the form of hash or array,
-    #based on odd behavior of Nokogiri
-    def get_style_attributes(xf_obj)
-      if xf_obj.is_a?Array
-        xf = xf_obj[1]
-      else
-        xf = xf_obj[:attributes]
-      end
+    def register_new_xf(new_xf, old_style_index)
+      new_xf_id = cell_xfs.find_index { |xf| xf == new_xf } # Use existing XF, if it exists
+      new_xf_id ||= cell_xfs.size # If this XF has never existed before, add it to collection.
+
+      cell_xfs[old_style_index].count -= 1
+      new_xf.count += 1
+      cell_xfs[new_xf_id] = new_xf
+
+      new_xf_id
     end
 
-    def get_fill_color(xf_attributes)
-      if @fills[xf_attributes[:fillId]].nil? || @fills[xf_attributes[:fillId]][:fill].nil? || @fills[xf_attributes[:fillId]][:fill][:patternFill].nil? || @fills[xf_attributes[:fillId]][:fill][:patternFill][:fgColor].nil?
-        'ffffff' #white
-      else
-        @fills[xf_attributes[:fillId]][:fill][:patternFill][:fgColor][:attributes][:rgb]
+    def modify_text_wrap(style_index, wrap = false)
+      xf = cell_xfs[style_index].dup
+      xf.alignment = RubyXL::Alignment.new(:wrap_text => wrap, :apply_alignment => true)
+      register_new_xf(xf, style_index)
+    end
+
+    def modify_alignment(style_index, is_horizontal, alignment)
+      xf = cell_xfs[style_index].dup
+      xf.alignment = RubyXL::Alignment.new(:apply_alignment => true,
+                                           :horizontal => is_horizontal ? alignment : nil, 
+                                           :vertical   => is_horizontal ? nil : alignment)
+      register_new_xf(xf, style_index)
+    end
+
+    def modify_fill(style_index, rgb)
+      xf = cell_xfs[style_index].dup
+      new_fill = RubyXL::Fill.new(:pattern_fill => 
+                   RubyXL::PatternFill.new(:pattern_type => 'solid',
+                                           :fg_color => RubyXL::Color.new(:rgb => rgb)))
+      new_xf = register_new_fill(new_fill, xf)
+      register_new_xf(new_xf, style_index)
+    end
+
+    def modify_border(style_index, direction, weight)
+      old_xf = cell_xfs[style_index].dup
+      new_border = borders[old_xf.border_id].dup
+      new_border.set_edge_style(direction, weight)
+
+      new_xf = old_xf.dup
+
+      unless borders[old_xf.border_id].count == 1 && old_xf.border_id > 0 # If the old border not used anymore, just replace it
+        new_xf.border_id = borders.find_index { |x| x == new_border } # Use existing border, if it exists
+        new_xf.border_id ||= borders.size # If this border has never existed before, add it to collection.
       end
+
+      borders[old_xf.border_id].count -= 1
+      new_border.count += 1
+      borders[new_xf.border_id] = new_border
+
+      new_xf.apply_border = true
+
+      register_new_xf(new_xf, style_index)
     end
 
+    def cell_xfs # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.cell_xf_container.xfs
+    end
 
-    private
+    def fonts # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.font_container.fonts
+    end
 
-    # Do not change. Excel requires that some of these styles be default,
-    # and will simply assume that the 0 and 1 indexed fonts are the default values.
-    def fill_styles()
-      @fonts = {
-                 '0' => {
-                          :font => {
-                                     :sz   => { :attributes => { :val => 10 } },
-                                     :name => { :attributes => { :val => "Verdana" } }
-                                   },
-                          :count=>1
-                        },
-                 '1' => {
-                          :font => {
-                                     :sz   => { :attributes => { :val => 8 } },
-                                     :name => { :attributes => { :val => "Verdana" } }
-                                   },
-                          :count=>0
-                        }
-               }
-
-      @fills = {
-                 '0' => {
-                          :fill => {
-                                     :patternFill => { :attributes => { :patternType => "none" } }
-                                   },
-                  :count=>1} ,
-                 '1' => {
-                          :fill => {
-                                     :patternFill => { :attributes => { :patternType => "gray125" } }
-                                   },
-                          :count=>0
-                        }
-               }
-
-      @borders = {
-                   '0' => {
-                            :border => {
-                                         :left => { },
-                                         :right => { },
-                                         :top => { },
-                                         :bottom => { },
-                                         :diagonal => { }
-                                       },
-                            :count => 1 #count = how many styles reference it
-                          }
-                 }
-
-      @cell_style_xfs = {
-                        :attributes => {
-                                         :count => 1
-                                       },
-                        :xf => {
-                                 :attributes => { :numFmtId => 0, :fontId => 0, :fillId => 0, :borderId => 0 }
-                               }
-                      }
-      @cell_xfs = {
-                        :attributes => {
-                                         :count => 1
-                                       },
-                        :xf => {
-                                 :attributes => { :numFmtId => 0, :fontId => 0, :fillId => 0, :borderId => 0, :xfId => 0 }
-                               }
-                      }
-      @cell_styles = {
-                      :cellStyle => {
-                                      :attributes => { :builtinId=>0, :name=>"Normal", :xfId=>0 }
-                                    },
-                      :attributes => { :count => 1 }
-                    }
+    def fills # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.fill_container.fills
     end
 
+    def borders # Stylesheet should be pre-filled with defaults on initialize()
+      stylesheet.border_container.borders
+    end
 
+    private
+
+=begin
     #fills shared strings hash, contains each unique string
     def fill_shared_strings()
-      if @shared_strings.nil?
-        string_hash = {}
-        string_index = 0
-        @num_strings = 0
-        #fill hash for shared strings
-        @worksheets.each do |sheet|
-          unless sheet.nil?
-            sheet.sheet_data.each do |row|
-              row.each do |cell|
-                unless cell.nil? || cell.value.nil?
-                  #if string not already seen, add it to hash
-                  if cell.datatype == 's'
-                    if string_hash[cell.value.to_s].nil?
-                      string_hash[string_index]=cell.value.to_s
-                      string_hash[cell.value.to_s]=string_index
-                      string_index += 1
-                    end
-                    @num_strings += 1
-                  end
-                end
-              end
+      @worksheets.compact.each { |sheet|
+        sheet.sheet_data.rows.each { |row|
+          row.cells.each { |cell|
+            if cell && cell.value && cell.datatype == RubyXL::Cell::SHARED_STRING then
+              get_index(cell.value.to_s, :add_if_missing)
             end
-          end
-        end
-
-        if string_hash.empty?
-          @shared_strings = nil
-        else
-          @shared_strings = string_hash
-          @size = string_index
-        end
-      end
+          }
+        }
+      }
     end
+=end
 
-    def validate_before_write
-      ## TODO CHECK IF STYLE IS OK if not raise
-    end
   end
 end