axlsx 1.1.8 → 1.2.0

data/lib/axlsx/workbook/worksheet/row.rb

@@ -134,7 +134,7 @@ module Axlsx
     # @return [Cell]
     def add_cell(value="", options={})
       c = Cell.new(self, value, options)
-      worksheet.send(:update_column_info, self.cells, [], self.cells.map(&:style))
+      worksheet.send(:update_column_info, self.cells, [])
       c
     end
 

data/lib/axlsx/workbook/worksheet/sheet_data.rb

@@ -0,0 +1,25 @@
+module Axlsx
+
+  # This class manages the serialization of rows for worksheets
+  class SheetData
+
+    # Creates a new SheetData object
+    # @param [Worksheet] worksheet The worksheet that owns this sheet data.
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+    
+    attr_reader :worksheet
+
+    # Serialize the sheet data
+    # @param [String] str the string this objects serializaton will be concacted to.
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<sheetData>'
+      worksheet.rows.each_with_index{ |row, index| row.to_xml_string(index, str) }
+      str << '</sheetData>'
+    end
+    
+  end
+end

data/lib/axlsx/workbook/worksheet/sheet_pr.rb

@@ -0,0 +1,24 @@
+module Axlsx
+
+  # The SheetPr class manages serialization fo a worksheet's sheetPr element.
+  # Only fit_to_page is implemented
+  class SheetPr
+
+    # Creates a new SheetPr object
+    # @param [Worksheet] worksheet The worksheet that owns this SheetPr object
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+
+    attr_reader :worksheet
+
+    # Serialize the object
+    # @param [String] str serialized output will be appended to this object if provided.
+    # @return [String]
+    def to_xml_string(str = '')
+       return unless worksheet.fit_to_page?
+      str << "<sheetPr><pageSetUpPr fitToPage=\"%s\"></pageSetUpPr></sheetPr>" % worksheet.fit_to_page?
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/tables.rb

@@ -0,0 +1,31 @@
+module Axlsx
+
+  # A simple, self serializing class for storing tables
+  class Tables < SimpleTypedList
+
+    # creates a new Tables object
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      super Table
+      @worksheet = worksheet
+    end
+
+    # The worksheet that owns this collection of tables
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # returns the relationships required by this collection
+    def relationships
+      return [] if empty?
+      map{ |table| Relationship.new(TABLE_R, "../#{table.pn}") }
+    end
+
+    def to_xml_string(str = "")
+      return if empty?
+      str << "<tableParts count='#{size}'>"
+      @list.each { |table| str << "<tablePart r:id='#{table.rId}'/>" }
+      str << '</tableParts>'
+    end
+  end
+
+end

data/lib/axlsx/workbook/worksheet/worksheet.rb

@@ -4,9 +4,44 @@ module Axlsx
   # The Worksheet class represents a worksheet in the workbook.
   class Worksheet
 
+    # definition of characters which are less than the maximum width of 0-9 in the default font for use in String#count.
+    # This is used for autowidth calculations
+    # @return [String]
+    def self.thin_chars
+      @thin_chars ||= "^.acefijklrstxyzFIJL()-"
+    end
+
+    # Creates a new worksheet.
+    # @note the recommended way to manage worksheets is Workbook#add_worksheet
+    # @see Workbook#add_worksheet
+    # @option options [String] name The name of this worksheet.
+    # @option options [Hash] page_margins A hash containing page margins for this worksheet. @see PageMargins
+    # @option options [Hash] print_options A hash containing print options for this worksheet. @see PrintOptions
+    # @option options [Boolean] show_gridlines indicates if gridlines should be shown for this sheet.
+    def initialize(wb, options={})
+      self.workbook = wb
+      @workbook.worksheets << self
+      @sheet_protection = nil
+
+      initialize_page_options(options)
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+
+    # Initalizes page margin, setup and print options
+    # @param [Hash] options Options passed in from the initializer
+    def initialize_page_options(options)
+      @page_margins = PageMargins.new options[:page_margins] if options[:page_margins]
+      @page_setup = PageSetup.new options[:page_setup]  if options[:page_setup]
+      @print_options = PrintOptions.new options[:print_options] if options[:print_options]
+    end
+
     # The name of the worksheet
     # @return [String]
-    attr_reader :name
+    def name
+      @name ||=  "Sheet" + (index+1).to_s
+    end
 
     # The sheet protection object for this workbook
     # @return [SheetProtection]
@@ -17,12 +52,6 @@ module Axlsx
       @sheet_protection
     end
 
-    # A collection of protected ranges in the worksheet
-    # @note The recommended way to manage protected ranges is with Worksheet#protect_range
-    # @see Worksheet#protect_range
-    # @return [SimpleTypedList] The protected ranges for this worksheet
-    attr_reader :protected_ranges
-
     # The sheet view object for this worksheet
     # @return [SheetView]
     # @see [SheetView]
@@ -38,50 +67,35 @@ module Axlsx
 
     # The tables in this worksheet
     # @return [Array] of Table
-    attr_reader :tables
-
-    # The comments associated with this worksheet
-    # @return [SimpleTypedList]
-    attr_reader :comments
+    def tables
+      @tables ||=  Tables.new self
+    end
+    
+    # The a shortcut to the worksheet_comments list of comments
+    # @return [Array|SimpleTypedList]
+    def comments
+      worksheet_comments.comments if worksheet_comments.has_comments?
+    end
 
     # The rows in this worksheet
     # @note The recommended way to manage rows is Worksheet#add_row
     # @return [SimpleTypedList]
     # @see Worksheet#add_row
-    attr_reader :rows
-
-    # An array of content based calculated column widths.
-    # @note a single auto fit data item is a hash with :longest => [String] and :sz=> [Integer] members.
-    # @return [Array] of Hash
-    attr_reader :auto_fit_data
+    def rows
+      @rows ||=  SimpleTypedList.new Row
+    end
 
-    # An array of merged cell ranges e.d "A1:B3"
-    # Content and formatting is read from the first cell.
-    # @return Array
-    attr_reader :merged_cells
+    # returns the sheet data as columnw
+    def cols
+      @rows.transpose
+    end
 
     # An range that excel will apply an autfilter to "A1:B3"
     # This will turn filtering on for the cells in the range.
     # The first row is considered the header, while subsequent rows are considerd to be data.
-    # @return Array
-    attr_reader :auto_filter
-
-    # Indicates if the worksheet should show gridlines or not
-    # @return Boolean
-    # @deprecated Use {SheetView#show_grid_lines} instead.
-    def show_gridlines
-      warn('axlsx::DEPRECIATED: Worksheet#show_gridlines has been depreciated. This value can get over SheetView#show_grid_lines.')
-      sheet_view.show_grid_lines
-    end
-
-    # Indicates if the worksheet is selected in the workbook
-    # It is possible to have more than one worksheet selected, however it might cause issues
-    # in some older versions of excel when using copy and paste.
-    # @return Boolean
-    # @deprecated Use {SheetView#tab_selected} instead.
-    def selected
-      warn('axlsx::DEPRECIATED: Worksheet#selected has been depreciated. This value can get over SheetView#tab_selected.')
-      sheet_view.tab_selected
+    # @return String 
+    def auto_filter
+      @auto_filter ||= AutoFilter.new self
     end
 
     # Indicates if the worksheet will be fit by witdh or height to a specific number of pages.
@@ -90,14 +104,16 @@ module Axlsx
     # @return Boolean
     # @see #page_setup
     def fit_to_page?
-      return false unless @page_setup
-      @page_setup.fit_to_page?
+      return false unless self.instance_values.keys.include?('page_setup')
+      page_setup.fit_to_page?
     end
 
 
     # Column info for the sheet
     # @return [SimpleTypedList]
-    attr_reader :column_info
+    def column_info
+      @column_info ||= Cols.new self
+    end
 
     # Page margins for printing the worksheet.
     # @example
@@ -166,77 +182,12 @@ module Axlsx
       @print_options
     end
 
-    # definition of characters which are less than the maximum width of 0-9 in the default font for use in String#count.
-    # This is used for autowidth calculations
-    # @return [String]
-    def self.thin_chars
-      @thin_chars ||= "^.acefijklrstxyzFIJL()-"
-    end
-
-    # Creates a new worksheet.
-    # @note the recommended way to manage worksheets is Workbook#add_worksheet
-    # @see Workbook#add_worksheet
-    # @option options [String] name The name of this worksheet.
-    # @option options [Hash] page_margins A hash containing page margins for this worksheet. @see PageMargins
-    # @option options [Hash] print_options A hash containing print options for this worksheet. @see PrintOptions
-    # @option options [Boolean] show_gridlines indicates if gridlines should be shown for this sheet.
-    def initialize(wb, options={})
-      self.workbook = wb
-      @workbook.worksheets << self
-      @page_marging = @page_setup = @print_options = nil
-      @drawing = @page_margins = @auto_filter = @sheet_protection = @sheet_view = nil
-      @merged_cells = []
-      @auto_fit_data = []
-      @conditional_formattings = []
-      @data_validations = []
-      @comments = Comments.new(self)
-      self.name = "Sheet" + (index+1).to_s
-      @page_margins = PageMargins.new options[:page_margins] if options[:page_margins]
-      @page_setup = PageSetup.new options[:page_setup]  if options[:page_setup]
-      @print_options = PrintOptions.new options[:print_options] if options[:print_options]
-      @rows = SimpleTypedList.new Row
-      @column_info = SimpleTypedList.new Col
-      @protected_ranges = SimpleTypedList.new ProtectedRange
-      @tables = SimpleTypedList.new Table
-
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end
-
     # convinience method to access all cells in this worksheet
     # @return [Array] cells
     def cells
       rows.flatten
     end
 
-    # Add conditional formatting to this worksheet.
-    #
-    # @param [String] cells The range to apply the formatting to
-    # @param [Array|Hash] rules An array of hashes (or just one) to create Conditional formatting rules from.
-    # @example This would format column A whenever it is FALSE.
-    #        # for a longer example, see examples/example_conditional_formatting.rb (link below)
-    #        worksheet.add_conditional_formatting( "A1:A1048576", { :type => :cellIs, :operator => :equal, :formula => "FALSE", :dxfId => 1, :priority => 1 }
-    #
-    # @see ConditionalFormattingRule#initialize
-    # @see file:examples/example_conditional_formatting.rb
-    def add_conditional_formatting(cells, rules)
-      cf = ConditionalFormatting.new( :sqref => cells )
-      cf.add_rules rules
-      @conditional_formattings << cf
-    end
-
-    # Add data validation to this worksheet.
-    #
-    # @param [String] cells The cells the validation will apply to.
-    # @param [hash] data_validation options defining the validation to apply.
-    # @see  examples/data_validation.rb for an example
-    def add_data_validation(cells, data_validation)
-      dv = DataValidation.new(data_validation)
-      dv.sqref = cells
-      @data_validations << dv
-    end
-
     # Creates merge information for this worksheet.
     # Cells can be merged by calling the merge_cells method on a worksheet.
     # @example This would merge the three cells C1..E1    #
@@ -247,12 +198,7 @@ module Axlsx
     #        worksheet["C1"].merge worksheet["E1"]
     # @param [Array, string] cells
     def merge_cells(cells)
-      @merged_cells << if cells.is_a?(String)
-                         cells
-      elsif cells.is_a?(Array)
-        cells = cells.sort { |x, y| [x.index, x.row.index] <=> [y.index, y.row.index] }
-        "#{cells.first.r}:#{cells.last.r}"
-      end
+      merged_cells.add cells
     end
 
     # Adds a new protected cell range to the worksheet. Note that protected ranges are only in effect when sheet protection is enabled.
@@ -260,23 +206,21 @@ module Axlsx
     # @return [ProtectedRange]
     # @note When using an array of cells, a contiguous range is created from the minimum top left to the maximum top bottom of the cells provided.
     def protect_range(cells)
-      sqref = if cells.is_a?(String)
-                cells
-              elsif cells.is_a?(SimpleTypedList)
-                cells = cells.sort { |x, y| [x.index, x.row.index] <=> [y.index, y.row.index] }
-                "#{cells.first.r}:#{cells.last.r}"
-              end
-      @protected_ranges << ProtectedRange.new(:sqref => sqref, :name => 'Range#{@protected_ranges.size}')
-      @protected_ranges.last
+      protected_ranges.add_range(cells)
     end
 
-    # The demensions of a worksheet. This is not actually a required element by the spec,
+    # The dimensions of a worksheet. This is not actually a required element by the spec,
     # but at least a few other document readers expect this for conversion
-    # @return [String] the A1:B2 style reference for the first and last row column intersection in the workbook
+    # @return [Dimension]
     def dimension
-      dim_start = rows.first.cells.first == nil ? 'A1' : rows.first.cells.first.r
-      dim_end = rows.last.cells.last == nil ? 'AA200' : rows.last.cells.last.r
-      "#{dim_start}:#{dim_end}"
+      @dimension ||= Dimension.new self
+    end
+
+    # The sheet properties for this workbook.
+    # Currently only pageSetUpPr -> fitToPage is implemented
+    # @return [SheetPr]
+    def sheet_pr
+      @sheet_pr ||= SheetPr.new self
     end
 
     # Indicates if gridlines should be shown in the sheet.
@@ -298,6 +242,23 @@ module Axlsx
       sheet_view.tab_selected = v
     end
 
+    # Indicates if the worksheet should show gridlines or not
+    # @return Boolean
+    # @deprecated Use {SheetView#show_grid_lines} instead.
+    def show_gridlines
+      warn('axlsx::DEPRECIATED: Worksheet#show_gridlines has been depreciated. This value can get over SheetView#show_grid_lines.')
+      sheet_view.show_grid_lines
+    end
+
+    # Indicates if the worksheet is selected in the workbook
+    # It is possible to have more than one worksheet selected, however it might cause issues
+    # in some older versions of excel when using copy and paste.
+    # @return Boolean
+    # @deprecated Use {SheetView#tab_selected} instead.
+    def selected
+      warn('axlsx::DEPRECIATED: Worksheet#selected has been depreciated. This value can get over SheetView#tab_selected.')
+      sheet_view.tab_selected
+    end
 
     # (see #fit_to_page)
     # @return [Boolean]
@@ -306,33 +267,12 @@ module Axlsx
       fit_to_page?
     end
 
-
-    # returns the column and row index for a named based cell
-    # @param [String] name The cell or cell range to return. "A1" will return the first cell of the first row.
-    # @return [Cell]
-    def name_to_cell(name)
-      col_index, row_index = *Axlsx::name_to_indices(name)
-      r = rows[row_index]
-      r.cells[col_index] if r
-    end
-
     # The name of the worksheet
     # The name of a worksheet must be unique in the workbook, and must not exceed 31 characters
-    # @param [String] v
-    def name=(v)
-      DataTypeValidator.validate "Worksheet.name", String, v
-      raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % v) if v.size > 31
-      raise ArgumentError, (ERR_SHEET_NAME_COLON_FORBIDDEN % v) if v.include? ':'
-      v = Axlsx::coder.encode(v) 
-      sheet_names = @workbook.worksheets.map { |s| s.name }
-      raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % v) if sheet_names.include?(v)
-      @name=v
-    end
-
-    # The absolute auto filter range
-    # @see auto_filter
-    def abs_auto_filter
-      Axlsx.cell_range(@auto_filter.split(':').collect { |name| name_to_cell(name)}) if @auto_filter
+    # @param [String] name 
+    def name=(name)
+      validate_sheet_name name
+      @name=Axlsx::coder.encode(name)
     end
 
     # The auto filter range for the worksheet
@@ -340,7 +280,7 @@ module Axlsx
     # @see auto_filter
     def auto_filter=(v)
       DataTypeValidator.validate "Worksheet.auto_filter", String, v
-      @auto_filter = v
+      auto_filter.range = v
     end
 
     # The part name of this worksheet
@@ -372,7 +312,7 @@ module Axlsx
     # @return [Drawing]
     # @see Worksheet#add_chart
     def drawing
-      @drawing || @drawing = Axlsx::Drawing.new(self)
+      worksheet_drawing.drawing
     end
 
     # Adds a row to the worksheet and updates auto fit data.
@@ -416,73 +356,39 @@ module Axlsx
     # @option options [Float] height the row's height (in points)
     def add_row(values=[], options={})
       Row.new(self, values, options)
-      update_column_info @rows.last.cells, options.delete(:widths) ||[], options.delete(:style) || []
-      # update_auto_fit_data @rows.last.cells, options.delete(:widths) || []
+      update_column_info @rows.last.cells, options.delete(:widths) || []
       yield @rows.last if block_given?
       @rows.last
     end
 
     alias :<< :add_row
 
-    # Set the style for cells in a specific row
-    # @param [Integer] index or range of indexes in the table
-    # @param [Integer] style the cellXfs index
-    # @param [Hash] options the options used when applying the style
-    # @option [Integer] :col_offset only cells after this column will be updated.
-    # @note You can also specify the style in the add_row call
-    # @see Worksheet#add_row
-    # @see README.md for an example
-    def row_style(index, style, options={})
-      offset = options.delete(:col_offset) || 0
-      rs = @rows[index]
-      if rs.is_a?(Array)
-        rs.each { |r| r.cells[(offset..-1)].each { |c| c.style = style } }
-      else
-        rs.cells[(offset..-1)].each { |c| c.style = style }
-      end
-    end
-
-    # returns the sheet data as columnw
-    def cols
-      @rows.transpose
-    end
-
-
-    # Set the style for cells in a specific column
-    # @param [Integer] index the index of the column
-    # @param [Integer] style the cellXfs index
-    # @param [Hash] options
-    # @option [Integer] :row_offset only cells after this column will be updated.
-    # @note You can also specify the style for specific columns in the call to add_row by using an array for the :styles option
-    # @see Worksheet#add_row
-    # @see README.md for an example
-    def col_style(index, style, options={})
-      offset = options.delete(:row_offset) || 0
-      @rows[(offset..-1)].each do |r|
-        cells = r.cells[index]
-        next unless cells
-        if cells.is_a?(Array)
-          cells.each { |c| c.style = style }
-        else
-          cells.style = style
-        end
-      end
+    # Add conditional formatting to this worksheet.
+    #
+    # @param [String] cells The range to apply the formatting to
+    # @param [Array|Hash] rules An array of hashes (or just one) to create Conditional formatting rules from.
+    # @example This would format column A whenever it is FALSE.
+    #        # for a longer example, see examples/example_conditional_formatting.rb (link below)
+    #        worksheet.add_conditional_formatting( "A1:A1048576", { :type => :cellIs, :operator => :equal, :formula => "FALSE", :dxfId => 1, :priority => 1 }
+    #
+    # @see ConditionalFormattingRule#initialize
+    # @see file:examples/example_conditional_formatting.rb
+    def add_conditional_formatting(cells, rules)
+      cf = ConditionalFormatting.new( :sqref => cells )
+      cf.add_rules rules
+      conditional_formattings << cf
+      conditional_formattings      
     end
 
-    # This is a helper method that Lets you specify a fixed width for multiple columns in a worksheet in one go.
-    # Axlsx is sparse, so if you have not set data for a column, you cannot set the width.
-    # Setting a fixed column width to nil will revert the behaviour back to calculating the width for you.
-    # @example This would set the first and third column widhts but leave the second column in autofit state.
-    #      ws.column_widths 7.2, nil, 3
-    # @note For updating only a single column it is probably easier to just set the width of the ws.column_info[col_index].width directly
-    # @param [Integer|Float|Fixnum|nil] widths
-    def column_widths(*widths)
-      widths.each_with_index do |value, index|
-        next if value == nil
-        Axlsx::validate_unsigned_numeric(value) unless value == nil
-        @column_info[index] ||= Col.new index+1, index+1
-        @column_info[index].width = value
-      end
+    # Add data validation to this worksheet.
+    #
+    # @param [String] cells The cells the validation will apply to.
+    # @param [hash] data_validation options defining the validation to apply.
+    # @see  examples/data_validation.rb for an example
+    def add_data_validation(cells, data_validation)
+      dv = DataValidation.new(data_validation)
+      dv.sqref = cells
+      data_validations << dv
     end
 
     # Adds a chart to this worksheets drawing. This is the recommended way to create charts for your worksheet. This method wraps the complexity of dealing with ooxml drawing, anchors, markers graphic frames chart objects and all the other dirty details.
@@ -499,68 +405,84 @@ module Axlsx
     # @see Line3DChart
     # @see README for examples
     def add_chart(chart_type, options={})
-      chart = drawing.add_chart(chart_type, options)
+      chart = worksheet_drawing.add_chart(chart_type, options)
       yield chart if block_given?
       chart
     end
 
     # needs documentation
     def add_table(ref, options={})
-      table = Table.new(ref, self, options)
-      @tables << table
-      yield table if block_given?
-      table
+      tables << Table.new(ref, self, options)
+      yield tables.last if block_given?
+      tables.last
     end
 
-
-    # Shortcut to comments#add_comment
+    # Shortcut to worsksheet_comments#add_comment
     def add_comment(options={})
-      @comments.add_comment(options)
+      worksheet_comments.add_comment(options)
     end
 
     # Adds a media item to the worksheets drawing
     # @option [Hash] options options passed to drawing.add_image
     def add_image(options={})
-      image = drawing.add_image(options)
+      image = worksheet_drawing.add_image(options)
       yield image if block_given?
       image
     end
 
+    # This is a helper method that Lets you specify a fixed width for multiple columns in a worksheet in one go.
+    # Axlsx is sparse, so if you have not set data for a column, you cannot set the width.
+    # Setting a fixed column width to nil will revert the behaviour back to calculating the width for you on the next call to add_row.
+    # @example This would set the first and third column widhts but leave the second column in autofit state.
+    #      ws.column_widths 7.2, nil, 3
+    # @note For updating only a single column it is probably easier to just set the width of the ws.column_info[col_index].width directly
+    # @param [Integer|Float|Fixnum|nil] widths
+    def column_widths(*widths)
+      widths.each_with_index do |value, index|
+        next if value == nil
+        Axlsx::validate_unsigned_numeric(value) unless value == nil
+        find_or_create_column_info(index).width = value
+      end
+    end
+
+    # Set the style for cells in a specific column
+    # @param [Integer] index the index of the column
+    # @param [Integer] style the cellXfs index
+    # @param [Hash] options
+    # @option [Integer] :row_offset only cells after this column will be updated.
+    # @note You can also specify the style for specific columns in the call to add_row by using an array for the :styles option
+    # @see Worksheet#add_row
+    # @see README.md for an example
+    def col_style(index, style, options={})
+      offset = options.delete(:row_offset) || 0
+      cells = @rows[(offset..-1)].map { |row| row.cells[index] }.flatten.compact
+      cells.each { |cell| cell.style = style }
+    end
+
+    # Set the style for cells in a specific row
+    # @param [Integer] index or range of indexes in the table
+    # @param [Integer] style the cellXfs index
+    # @param [Hash] options the options used when applying the style
+    # @option [Integer] :col_offset only cells after this column will be updated.
+    # @note You can also specify the style in the add_row call
+    # @see Worksheet#add_row
+    # @see README.md for an example
+    def row_style(index, style, options={})
+      offset = options.delete(:col_offset) || 0
+      cells = cols[(offset..-1)].map { |column| column[index] }.flatten.compact
+      cells.each { |cell| cell.style = style }
+    end
+
     # Serializes the worksheet object to an xml string
     # This intentionally does not use nokogiri for performance reasons
     # @return [String]
     def to_xml_string
       str = '<?xml version="1.0" encoding="UTF-8"?>'
       str << worksheet_node
-      str << sheet_pr_node
-      str << dimension_node
-      @sheet_view.to_xml_string(str) if @sheet_view
-      str << cols_node
-      str << sheet_data_node
-
-      str << auto_filter_node
-      @sheet_protection.to_xml_string(str) if @sheet_protection
-      str << protected_ranges_node
-      str << merged_cells_node
-      @print_options.to_xml_string(str) if @print_options
-      page_margins.to_xml_string(str) if @page_margins
-      page_setup.to_xml_string(str) if @page_setup
-      str << drawing_node
-      str << legacy_drawing_node
-      str << table_parts_node
-      str << conditional_formattings_node
-      str << data_validations_node 
+      serializable_parts.each do |item|
+        item.to_xml_string(str) if item
+      end
       str << '</worksheet>'
-      # User reported that when parsing some old data that had control characters excel chokes.
-      # All of the following are defined as illegal xml characters in the xml spec, but for now I am only dealing with control 
-      # characters. Thanks to asakusarb and @hsbt's flash of code on the screen!
-      # [#x1-#x8], [#xB-#xC], [#xE-#x1F], [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF],
-      # [#x1FFFE-#x1FFFF], [#x2FFFE-#x2FFFF], [#x3FFFE-#x3FFFF],
-      # [#x4FFFE-#x4FFFF], [#x5FFFE-#x5FFFF], [#x6FFFE-#x6FFFF],
-      # [#x7FFFE-#x7FFFF], [#x8FFFE-#x8FFFF], [#x9FFFE-#x9FFFF],
-      # [#xAFFFE-#xAFFFF], [#xBFFFE-#xBFFFF], [#xCFFFE-#xCFFFF],
-      # [#xDFFFE-#xDFFFF], [#xEFFFE-#xEFFFF], [#xFFFFE-#xFFFFF],
-      # [#x10FFFE-#x10FFFF].
       str.gsub(/[[:cntrl:]]/,'')
     end
 
@@ -568,15 +490,9 @@ module Axlsx
     # @return [Relationships]
     def relationships
       r = Relationships.new
-      @tables.each do |table|
-        r << Relationship.new(TABLE_R, "../#{table.pn}")
-      end
-
-      r << Relationship.new(VML_DRAWING_R, "../#{@comments.vml_drawing.pn}") if @comments.size > 0
-      r << Relationship.new(COMMENT_R, "../#{@comments.pn}") if @comments.size > 0
-      r << Relationship.new(COMMENT_R_NULL, "NULL") if @comments.size > 0
-
-      r << Relationship.new(DRAWING_R, "../#{@drawing.pn}") if @drawing
+      r + [tables.relationships, 
+           worksheet_comments.relationships, 
+           worksheet_drawing.relationship].flatten.compact || []
       r
     end
 
@@ -585,163 +501,130 @@ module Axlsx
     # @return [Cell, Array]
     def [] (cell_def)
       return rows[cell_def] if cell_def.is_a?(Integer)
-
-      parts = cell_def.split(':')
-      first = name_to_cell parts[0]
+      parts = cell_def.split(':').map{ |part| name_to_cell part }
       if parts.size == 1
-        first
+        parts.first
       else
-        cells = []
-        last = name_to_cell(parts[1])
-        rows[(first.row.index..last.row.index)].each do |r|
-          r.cells[(first.index..last.index)].each do |c|
-            cells << c
-          end
-        end
-        cells
+        range(*parts)
       end
     end
 
-    private
-
-    # Helper method for parsingout the root node for worksheet
-    # @return [String]
-    def worksheet_node
-      "<worksheet xmlns=\"%s\" xmlns:r=\"%s\">" % [XML_NS, XML_NS_R]
+    # returns the column and row index for a named based cell
+    # @param [String] name The cell or cell range to return. "A1" will return the first cell of the first row.
+    # @return [Cell]
+    def name_to_cell(name)
+      col_index, row_index = *Axlsx::name_to_indices(name)
+      r = rows[row_index]
+      r.cells[col_index] if r
     end
 
-    # Helper method fo parsing out the sheetPr node
-    # @return [String]
-    def sheet_pr_node
-      return '' unless fit_to_page?
-      "<sheetPr><pageSetUpPr fitToPage=\"%s\"></pageSetUpPr></sheetPr>" % fit_to_page?
+    # shortcut method to access styles direclty from the worksheet
+    # This lets us do stuff like:
+    # @example
+    #     p = Axlsx::Package.new
+    #     p.workbook.add_worksheet(:name => 'foo') do |sheet|
+    #       my_style = sheet.styles.add_style { :bg_color => "FF0000" }
+    #       sheet.add_row ['Oh No!'], :styles => my_style
+    #     end
+    #     p.serialize 'foo.xlsx'
+    def styles
+      @styles ||= self.workbook.styles
     end
 
-    # Helper method for parsing out the demension node
-    # @return [String]
-    def dimension_node
-      return '' if rows.size == 0
-      "<dimension ref=\"%s\"></dimension>" % dimension
+
+    private
+
+    def validate_sheet_name(name)
+      DataTypeValidator.validate "Worksheet.name", String, name
+      raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % name) if name.size > 31
+      raise ArgumentError, (ERR_SHEET_NAME_COLON_FORBIDDEN % name) if name.include? ':'
+      name = Axlsx::coder.encode(name) 
+      sheet_names = @workbook.worksheets.map { |s| s.name }
+      raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % name) if sheet_names.include?(name)
     end
 
-    # Helper method for parsing out the sheetData node
-    # @return [String]
-    def sheet_data_node
-      str = '<sheetData>'
-      @rows.each_with_index { |row, index| row.to_xml_string(index, str) }
-      str << '</sheetData>'
+
+    def serializable_parts
+      [sheet_pr, dimension, sheet_view, column_info,
+       sheet_data, @sheet_protection, protected_ranges,
+       auto_filter, merged_cells, conditional_formattings,
+       data_validations, print_options, page_margins,
+       page_setup, worksheet_drawing, worksheet_comments,
+       tables]
     end
 
-    # Helper method for parsing out the autoFilter node
-    # @return [String]
-    def auto_filter_node
-      return '' unless @auto_filter
-      "<autoFilter ref='%s'></autoFilter>" % @auto_filter
+    def range(*cell_def)
+      first, last = cell_def
+      cells = []
+      rows[(first.row.index..last.row.index)].each do |r|
+        r.cells[(first.index..last.index)].each do |c|
+          cells << c
+        end
+      end
+      cells
     end
 
-    # Helper method for parsing out the cols node
-    # @return [String]
-    def cols_node
-      return '' if @column_info.empty?
-      str = "<cols>"
-      @column_info.each { |col| col.to_xml_string(str) }
-      str << '</cols>'
-    end 
-
-    # Helper method for parsing out the protectedRanges node
-    # @return [String]
-    def protected_ranges_node
-      return '' if @protected_ranges.empty?
-      str = '<protectedRanges>'
-      @protected_ranges.each { |pr| pr.to_xml_string(str) }
-      str << '</protectedRanges>'
+    # A collection of protected ranges in the worksheet
+    # @note The recommended way to manage protected ranges is with Worksheet#protect_range
+    # @see Worksheet#protect_range
+    # @return [SimpleTypedList] The protected ranges for this worksheet
+    def protected_ranges
+      @protected_ranges ||= ProtectedRanges.new self 
+      # SimpleTypedList.new ProtectedRange
     end
 
-    # Helper method for parsing out the mergedCells node
-    # @return [String]
-    def merged_cells_node
-      return '' if @merged_cells.size == 0
-      str = "<mergeCells count='#{@merged_cells.size}'>"
-      @merged_cells.each { |merged_cell| str << "<mergeCell ref='#{merged_cell}'></mergeCell>" }
-      str << '</mergeCells>'
+    # conditional formattings
+    # @return [Array]
+    def conditional_formattings
+      @conditional_formattings ||= ConditionalFormattings.new self
     end
 
-    # Helper method for parsing out the drawing node
-    # @return [String]
-    def drawing_node
-      return '' unless @drawing
-      "<drawing r:id='rId" << (relationships.index{ |r| r.Type == DRAWING_R } + 1).to_s << "'/>" 
+    # data validations array
+    # @return [Array]
+    def data_validations
+      @data_validations ||= DataValidations.new self 
     end
 
-    # Helper method for parsing out the legacyDrawing node required for comments
-    # @return [String]
-    def legacy_drawing_node
-      return '' if @comments.empty?
-      "<legacyDrawing r:id='rId" << (relationships.index{ |r| r.Type == VML_DRAWING_R } + 1).to_s << "'/>" 
+    # merged cells array
+    # @return [Array]
+    def merged_cells
+      @merged_cells ||= MergedCells.new self
     end
 
-    # Helper method for parsing out the tableParts node
+
+    # Helper method for parsingout the root node for worksheet
     # @return [String]
-    def table_parts_node
-      return '' if @tables.empty?
-      str = "<tableParts count='#{@tables.size}'>"
-      @tables.each { |table| str << "<tablePart r:id='#{table.rId}'/>" }
-      str << '</tableParts>'
+    def worksheet_node
+      "<worksheet xmlns=\"%s\" xmlns:r=\"%s\">" % [XML_NS, XML_NS_R]
     end
 
-    # Helper method for parsing out the conditional formattings
-    # @return [String]
-    def conditional_formattings_node
-      return '' if @conditional_formattings.size == 0
-      str = ''
-      @conditional_formattings.each { |conditional_formatting| str << conditional_formatting.to_xml_string }
-      str
+    def sheet_data
+      @sheet_data ||= SheetData.new self
     end
 
-    # Helper method for parsing out the dataValidations node
-    # @return [String]
-    def data_validations_node
-      return '' if @data_validations.size == 0
-      str = "<dataValidations count='#{@data_validations.size}'>"
-      @data_validations.each { |data_validation| str << data_validation.to_xml_string }
-      str << '</dataValidations>'
+    def worksheet_drawing
+      @worksheet_drawing ||= WorksheetDrawing.new self
     end
 
+    # The comments associated with this worksheet
+    # @return [SimpleTypedList]
+    def worksheet_comments
+      @worksheet_comments ||= WorksheetComments.new self
+    end
 
-    # assigns the owner workbook for this worksheet
     def workbook=(v) DataTypeValidator.validate "Worksheet.workbook", Workbook, v; @workbook = v; end
 
-
-    # TODO this needs cleanup!
-    def update_column_info(cells, widths=[], style=[])
-      styles = self.workbook.styles
-      cellXfs, fonts = styles.cellXfs, styles.fonts
-      sz = 11
-
+    def update_column_info(cells, widths=[])
       cells.each_with_index do |cell, index|
-        @column_info[index] ||= Col.new index+1, index+1
-        col = @column_info[index]
-        width = widths[index]
-        col.width = width if [Integer, Float, Fixnum].include?(width.class)
-        c_style = style[index] if [Integer, Fixnum].include?(style[index].class)
-        next if width == :ignore || (cell.value.is_a?(String) && cell.value.start_with?('=') || cell.value == nil)
-        if self.workbook.use_autowidth
-          cell_xf = cellXfs[(c_style || 0)]
-          font = fonts[(cell_xf.fontId || 0)]
-          sz = cell.sz || font.sz || sz
-          col.width = [(col.width || 0), calculate_width(cell.value.to_s, sz)].max
-        end
+        col = find_or_create_column_info(index)
+        next if widths[index] == :ignore
+        col.update_width(cell, widths[index], workbook.use_autowidth)
       end
     end
 
-
-    # This is still not perfect...
-    #  - scaling is not linear as font sizes increst
-    #  - different fonts have different mdw and char widths
-    def calculate_width(text, sz)
-      mdw = 1.78 #This is the widest width of 0..9 in arial@10px)
-      font_scale = (sz/10.0).to_f
-      ((text.count(Worksheet.thin_chars) * mdw + 5) / mdw * 256) / 256.0 * font_scale
+    def find_or_create_column_info(index)
+      column_info[index] ||= Col.new(index + 1, index + 1)
     end
+
   end
 end