listen360-rubyXL 1.2.10.1

data/lib/rubyXL/private_class.rb

@@ -0,0 +1,265 @@
+module RubyXL
+  class PrivateClass
+    private
+
+    #validate and modify methods
+    def validate_horizontal_alignment(alignment)
+      if alignment.to_s == '' || alignment == 'center' || alignment == 'distributed' || alignment == 'justify' || alignment == 'left' || alignment == 'right'
+        return true
+      end
+      raise 'Only center, distributed, justify, left, and right are valid horizontal alignments'
+    end
+
+    def validate_vertical_alignment(alignment)
+      if alignment.to_s == '' || alignment == 'center' || alignment == 'distributed' || alignment == 'justify' || alignment == 'top' || alignment == 'bottom'
+        return true
+      end
+      raise 'Only center, distributed, justify, top, and bottom are valid vertical alignments'
+    end
+
+    def validate_border(weight)
+      if weight.to_s == '' || weight == 'thin' || weight == 'thick' || weight == 'hairline' || weight == 'medium'
+        return true
+      end
+      raise 'Border weights must only be "hairline", "thin", "medium", or "thick"'
+    end
+
+    def validate_nonnegative(row_or_col)
+      if row_or_col < 0
+        raise 'Row and Column arguments must be nonnegative'
+      end
+    end
+
+    # This method checks to see if there is an equivalent font that exists
+    def find_font(workbook, font)
+      workbook.fonts.each {|font_id, f|
+        if f[:font][:i] == font[:i] &&
+          f[:font][:b] == font[:b] &&
+          f[:font][:u] == font[:u] &&
+          f[:font][:strike] == font[:strike] &&
+          f[:font][:name][:attributes][:val] == font[:name][:attributes][:val] &&
+          f[:font][:sz][:attributes][:val] == font[:sz][:attributes][:val] &&
+          (f[:font][:color] && f[:font][:color][:attributes][:rgb]) == (font[:color] && font[:color][:attributes][:rgb])
+          return font_id
+        end
+      }
+      return nil
+    end
+
+    # Helper method to modify the font color
+    def modify_font_color(font, font_color)
+      if font[:color].nil?
+        font[:color] = {:attributes => {:rgb => ''}}
+      end
+      font[:color][:attributes][:rgb] = font_color.to_s
+      return font
+    end
+
+    # Helper method to modify the font's italics settings
+    def modify_font_italics(font, italicized)
+      if italicized
+        font[:i] = {}
+      else
+        font[:i] = nil
+      end
+      return font
+    end
+
+    # Helper method to modify the font's bold settings
+    def modify_font_bold(font, bolded)
+      if bolded
+        font[:b] = {}
+      else
+        font[:b] = nil
+      end
+      return font
+    end
+
+    # Helper method to modify the font's underline settings
+    def modify_font_underline(font, underlined)
+      if underlined
+        font[:u] = {}
+      else
+        font[:u] = nil
+      end
+      return font
+    end
+
+    # Helper method to modify the font's strikethrough settings
+    def modify_font_strikethrough(font, struckthrough)
+      if struckthrough
+        font[:strike] = {}
+      else
+        font[:strike] = nil
+      end
+      return font
+    end
+
+    # Determines if font exists
+    # If yes, return id of existing font
+    # If no, appends font to font array
+    def modify_font(workbook, font, old_font_id)
+      font_id = old_font_id
+      existing_font_id = find_font(workbook, font)
+      if !existing_font_id.nil?
+        font_id = existing_font_id
+        workbook.fonts[font_id][:count] += 1
+        workbook.fonts[old_font_id][:count] -= 1
+      elsif workbook.fonts[old_font_id.to_s][:count] > 1 || old_font_id == '0'
+        font_id = workbook.fonts.size.to_s
+        workbook.fonts[font_id] = {}
+        workbook.fonts[font_id][:font] = font
+        workbook.fonts[font_id][:count] = 1
+        workbook.fonts[old_font_id][:count] -= 1
+      else
+        workbook.fonts[font_id][:font] = font
+      end
+      return font_id
+    end
+
+    # This method checks to see if there is an equivalent xf that exists
+    def find_xf(workbook, xf)
+      workbook.cell_xfs[:xf].each_with_index {|xfs, index|
+        if xfs[:attributes][:borderId] == xf[:borderId] &&
+          xfs[:attributes][:xfId] == xf[:xfId] &&
+          xfs[:attributes][:fillId] == xf[:fillId] &&
+          xfs[:attributes][:numFmtId] == xf[:numFmtId] &&
+          xfs[:attributes][:fontId] == xf[:fontId]
+          return index
+        end
+      }
+      return nil
+    end
+
+    # Determines if xf exists
+    # If yes, return id of existing xf
+    # If no, appends xf to xf array
+    def modify_xf(workbook, xf)
+      existing_xf_id = find_xf(workbook, xf)
+      if !existing_xf_id.nil?
+        xf_id = existing_xf_id
+      else
+        if workbook.cell_xfs[:xf].is_a?Array
+          workbook.cell_xfs[:xf] << {:attributes=>xf}
+        else
+          workbook.cell_xfs[:xf] = [workbook.cell_xfs[:xf], {:attributes=>xf}]
+        end
+        xf[:applyFont] = '1'
+        workbook.cell_xfs[:attributes][:count] += 1
+        xf_id = workbook.cell_xfs[:xf].size - 1
+      end
+      return xf_id
+    end
+
+    #modifies fill array (copies, appends, adds color and solid attribute)
+    #then styles array (copies, appends)
+    def modify_fill(workbook, style_index, rgb)
+      xf_obj = workbook.get_style(style_index)
+      xf = workbook.get_style_attributes(xf_obj)
+      #modify fill array
+      fill_id = xf[:fillId]
+
+      fill = workbook.fills[fill_id.to_s][:fill]
+      if workbook.fills[fill_id.to_s][:count] > 1 || fill_id == 0 || fill_id == 1
+        old_size = workbook.fills.size.to_s
+        workbook.fills[old_size] = {}
+        workbook.fills[old_size][:fill] = deep_copy(fill)
+        workbook.fills[old_size][:count] = 1
+        workbook.fills[fill_id.to_s][:count] -= 1
+
+        change_wb_fill(workbook, old_size,rgb)
+
+        #modify styles array
+        fill_id = old_size
+        if workbook.cell_xfs[:xf].is_a?Array
+          workbook.cell_xfs[:xf] << deep_copy({:attributes=>xf})
+        else
+          workbook.cell_xfs[:xf] = [workbook.cell_xfs[:xf], deep_copy({:attributes=>xf})]
+        end
+        xf = workbook.get_style_attributes(workbook.cell_xfs[:xf].last)
+        xf[:fillId] = fill_id
+        xf[:applyFill] = '1'
+        workbook.cell_xfs[:attributes][:count] += 1
+        return workbook.cell_xfs[:xf].size-1
+      else
+        change_wb_fill(workbook, fill_id.to_s,rgb)
+        return style_index
+      end
+    end
+
+    def modify_border(workbook, style_index)
+      xf_obj = workbook.get_style(style_index)
+      xf = workbook.get_style_attributes(xf_obj)
+
+      border_id = Integer(xf[:borderId])
+      border = workbook.borders[border_id.to_s][:border]
+      if workbook.borders[border_id.to_s][:count] > 1 || border_id == 0 || border_id == 1
+        old_size = workbook.borders.size.to_s
+        workbook.borders[old_size] = {}
+        workbook.borders[old_size][:border] = deep_copy(border)
+        workbook.borders[old_size][:count] = 1
+
+        border_id = old_size
+
+        if workbook.cell_xfs[:xf].is_a?Array
+          workbook.cell_xfs[:xf] << deep_copy(xf_obj)
+        else
+          workbook.cell_xfs[:xf] = [workbook.cell_xfs[:xf], deep_copy(xf_obj)]
+        end
+
+        xf = workbook.get_style_attributes(workbook.cell_xfs[:xf].last)
+        xf[:borderId] = border_id
+        xf[:applyBorder] = '1'
+        workbook.cell_xfs[:attributes][:count] += 1
+        return workbook.cell_xfs[:xf].size-1
+      else
+        return style_index
+      end
+    end
+
+    #is_horizontal is true when doing horizontal alignment,
+    #false when doing vertical alignment
+    def modify_alignment(workbook, style_index, is_horizontal, alignment)
+      old_xf_obj = workbook.get_style(style_index)
+
+      xf_obj = deep_copy(old_xf_obj)
+
+      if xf_obj[:alignment].nil? || xf_obj[:alignment][:attributes].nil?
+        xf_obj[:alignment] = {:attributes=>{:horizontal=>nil, :vertical=>nil}}
+      end
+
+      if is_horizontal
+        xf_obj[:alignment][:attributes][:horizontal] = alignment.to_s
+      else
+        xf_obj[:alignment][:attributes][:vertical] = alignment.to_s
+      end
+
+      if workbook.cell_xfs[:xf].is_a?Array
+        workbook.cell_xfs[:xf] << deep_copy(xf_obj)
+      else
+        workbook.cell_xfs[:xf] = [workbook.cell_xfs[:xf], deep_copy(xf_obj)]
+      end
+
+      xf = workbook.get_style_attributes(workbook.cell_xfs[:xf].last)
+      xf[:applyAlignment] = '1'
+      workbook.cell_xfs[:attributes][:count] += 1
+      workbook.cell_xfs[:xf].size-1
+    end
+
+    #returns non-shallow copy of hash
+    def deep_copy(hash)
+      Marshal.load(Marshal.dump(hash))
+    end
+
+    def change_wb_fill(workbook, fill_index, rgb)
+      if workbook.fills[fill_index][:fill][:patternFill][:fgColor].nil?
+        workbook.fills[fill_index][:fill][:patternFill][:fgColor] = {:attributes => {:rgb => ''}}
+      end
+      workbook.fills[fill_index][:fill][:patternFill][:fgColor][:attributes][:rgb] = rgb
+
+      #previously none, doesn't show fill
+      workbook.fills[fill_index][:fill][:patternFill][:attributes][:patternType] = 'solid'
+    end
+
+  end
+end

data/lib/rubyXL/workbook.rb

@@ -0,0 +1,450 @@
+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'
+
+module RubyXL
+  class Workbook
+    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
+
+
+    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 = {}
+
+      begin
+        @created_at       = DateTime.parse(created_at).strftime('%Y-%m-%dT%TZ')
+      rescue
+        t = Time.now
+        @created_at       = t.strftime('%Y-%m-%dT%TZ')
+      end
+      @modified_at        = @created_at
+
+      fill_styles()
+      fill_shared_strings()
+    end
+
+    # allows easier access to worksheets
+    def [](worksheet)
+      return worksheets[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()
+      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
+
+      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')
+      else
+        compare_date = DateTime.parse('December 31, 1899')
+      end
+      # add one day to compare date for erroneous 1900 leap year compatibility
+      date.ajd + 1 - compare_date.ajd
+    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
+    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]
+    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
+      end
+      return date_count > num_count
+    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
+
+      xf_obj = @cell_xfs[:xf]
+      if xf_obj.is_a?Array
+        xf_obj = xf_obj[Integer(style_index)]
+      end
+      xf_obj
+    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
+    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]
+      end
+    end
+
+
+    private
+
+    # 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 }
+                    }
+    end
+
+
+    #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
+            end
+          end
+        end
+
+        if string_hash.empty?
+          @shared_strings = nil
+        else
+          @shared_strings = string_hash
+          @size = string_index
+        end
+      end
+    end
+
+    def validate_before_write
+      ## TODO CHECK IF STYLE IS OK if not raise
+    end
+  end
+end