calcsheet 0.1.0 → 0.2.0

data/lib/calcsheet/row.rb

@@ -60,8 +60,8 @@ module Calcsheet
     attr_reader :number
     # @return [Integer, nil] CSV: the physical line where the record starts; nil for XLSX and ODS
     attr_reader :line
-    # @return [Array] the values in file order, or in schema order with a schema. Without a schema, the trailing
-    #   blank cells are trimmed and, in header mode, the values padded with nil to the width of the header
+    # @return [Array] the values in file order, or in schema order with a schema. Without a schema, they are trimmed
+    #   at the end (see Reading) and, in header mode, padded with nil to the width of the header
     attr_reader :values
     # @return [Array<CellError>] frozen; empty with +on_error: :raise+
     attr_reader :errors

data/lib/calcsheet/row_builder.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require_relative "cast"
+require_relative "raw_row"
+
+module Calcsheet
+  # Builds the RawRows of a reader from its raw cells: casts each cell with a Cast and the declared type of its
+  # column, records the failures, and trims the row after its last cell with a value (see Reading for the backend
+  # contract). The reader parses, places and checks the cells; the builder is where they become values and errors.
+  #
+  # A cell has a kind: :text (a string, its text as written), :number, :iso_date (an ISO date or datetime text),
+  # :duration (an ISO duration, "PT12H30M05S"), :boolean ("1", "0", "true" or "false"), :error (an error cell, its
+  # text the error) or :missing (a typed cell without its value, its reason given by +missing:+). A cell is
+  # non-blank unless it is a :text of whitespace only; an empty :text is no cell at all. A row without a non-blank
+  # cell is blank; the row of a non-blank cell ends with its last non-blank cell or, after it, its last whitespace
+  # text that the declared type keeps as text (:string, or the native value).
+  #
+  # The values Array is sparse: a cell sets only its own position, and #finish trims it. The builder keeps its state
+  # in instance variables reset per row, so a cell allocates nothing beyond its value and, when its cast fails, its
+  # error. It uses Cast::NON_BLANK for the blank test, so that it loads without Reading. A reader that has a whole row
+  # of texts takes the shortcut of #text_row instead.
+  #
+  # calcsheet-native depends on this interface: change it only in a minor release and together with the protocol
+  # version (see NativeBackends).
+  #
+  # @api private
+  class RowBuilder
+    # The values of +number_errors:+.
+    NUMBER_ERRORS = %i[raw as_read].freeze
+
+    # @param cast [Cast]
+    # @param types [#[], nil] the declared type per column index (see Reading)
+    # @param number_errors [Symbol] the raw value of a failed cast: :raw, the cell's text (ODS, CSV); :as_read, for a
+    #   :not_integral failure of a :number cell the number as read (Cast#integer_number), not the full print of a
+    #   double that Excel writes (XLSX)
+    # @raise [ArgumentError] an unknown +number_errors+
+    def initialize(cast, types, number_errors: :raw)
+      unless NUMBER_ERRORS.include?(number_errors)
+        raise ArgumentError, "number_errors: must be :raw or :as_read, got #{number_errors.inspect}"
+      end
+
+      @cast = cast
+      @types = types
+      @as_read = number_errors == :as_read
+      @values = []
+      @errors = nil
+      @last = -1
+    end
+
+    # Adds the cell at +column+: its value, or the failure of its cast.
+    #
+    # @param column [Integer] 0-based
+    # @param kind [Symbol] see the class
+    # @param text [String] the raw cell, UTF-8
+    # @param format [Array(Symbol, Integer | nil), nil] for :number +[number_kind, pad]+ as Cast#number takes them
+    #   (nil for :general without padding); for :iso_date only its kind is read, :date or :datetime, the padding is
+    #   ignored (nil, or another kind, to let the text decide)
+    # @param missing [Symbol, nil] the reason of a :missing cell
+    # @return [nil]
+    # @raise [ArgumentError] an unknown +kind+
+    def add(column, kind, text, format = nil, missing: nil)
+      if kind == :text
+        return if text.empty?
+
+        @last = column if column > @last && !blank?(text)
+      elsif column > @last
+        @last = column
+      end
+      value = cast(kind, text, @types && @types[column], format, missing)
+      @values[column] = value unless value.nil?
+      nil
+    rescue Cast::Failure => failure
+      (@errors ||= []) << [ column, error_text(kind, text, failure), failure.reason ]
+      nil
+    end
+
+    # The row of a reader that has all its cells as texts and already knows the last non-blank one (CSV finds it
+    # from the end of its fields): the same row as an #add of each text at its index and a #finish, without the
+    # state of the builder and the blank test of each text. The cost of a CSV row is mostly its casts, and these
+    # would add a twentieth to it. It does not touch the row being built by #add.
+    #
+    # @param texts [Array<String, nil>] the raw cells from column 0, UTF-8; a nil or empty one is no cell
+    # @param last [Integer] the index of the last non-blank text, at most +texts.size - 1+; the texts after it are
+    #   whitespace, nil or empty
+    # @param number [Integer] see #finish
+    # @param line [Integer, nil] see #finish
+    # @return [RawRow, nil] nil when +last+ is negative
+    def text_row(texts, last, number, line: nil)
+      return if last.negative?
+
+      cast = @cast
+      types = @types
+      values = Array.new(last + 1)
+      errors = nil
+      column = 0
+      size = texts.size
+      while column < size
+        text = texts[column]
+        unless text.nil? || text.empty?
+          begin
+            value = cast.text(text, types && types[column])
+            values[column] = value unless value.nil?
+          rescue Cast::Failure => failure
+            (errors ||= []) << [ column, text, failure.reason ]
+          end
+        end
+        column += 1
+      end
+      # In column order: only the failures of whitespace after the row can be beyond it.
+      errors.pop while errors&.last && errors.last[0] >= values.size
+      errors = nil if errors&.empty?
+      RawRow.new(number: number, line: line, values: values, errors: errors)
+    end
+
+    # Adds the same raw cell to each column of +first..last+ (a repeated ODS cell): one value object, or one
+    # failure, per change of the declared type and the format of the columns.
+    #
+    # @param first [Integer] the first column, 0-based
+    # @param last [Integer] the last column
+    # @param kind [Symbol] see #add
+    # @param text [String] see #add
+    # @param missing [Symbol, nil] see #add
+    # @yieldparam column [Integer]
+    # @yieldreturn [Array(Symbol, Integer | nil), nil] the format of the column (see #add); without a block, nil
+    # @return [nil]
+    # @raise [ArgumentError] an unknown +kind+
+    def add_run(first, last, kind, text, missing: nil)
+      return if kind == :text && text.empty?
+
+      formatted = block_given?
+      type = format = value = failure = nil
+      index = first
+      while index <= last
+        wanted = @types && @types[index]
+        styled = formatted ? yield(index) : nil
+        # Identity, not equality: the formats are frozen Arrays shared by the cells of one style, so the same style
+        # gives the same object, and a check by identity costs nothing per column. An equal format of another style
+        # only casts once more.
+        if index == first || wanted != type || !styled.equal?(format)
+          type = wanted
+          format = styled
+          begin
+            failure = nil
+            value = cast(kind, text, wanted, styled, missing)
+          rescue Cast::Failure => error
+            failure = error
+          end
+        end
+        if failure then (@errors ||= []) << [ index, error_text(kind, text, failure), failure.reason ]
+        elsif !value.nil? then @values[index] = value
+        end
+        index += 1
+      end
+      @last = last if last > @last && (kind != :text || !blank?(text))
+      nil
+    end
+
+    # Ends the row: the builder starts the next one empty.
+    #
+    # @param number [Integer] the row number the user sees
+    # @param line [Integer, nil] the physical line where it starts (CSV)
+    # @return [RawRow, nil] the row, trimmed after its last non-blank cell or whitespace text kept as text; nil when no
+    #   cell is non-blank
+    def finish(number, line: nil)
+      if @last.negative?
+        @values.clear
+        @errors = nil
+        return
+      end
+
+      trim_row!
+      row = RawRow.new(number: number, line: line, values: @values, errors: @errors)
+      @values = []
+      @errors = nil
+      @last = -1
+      row
+    end
+
+    private
+
+    def cast(kind, text, type, format, missing)
+      case kind
+      when :text then @cast.text(text, type)
+      when :number
+        format ? @cast.number(text, format[0], type, pad: format[1]) : @cast.number(text, :general, type)
+      when :iso_date then @cast.iso_date(text, type, format && format[0])
+      when :duration then @cast.duration(text, type)
+      when :boolean then @cast.boolean(boolean(text), type)
+      when :error then raise Cast::Failure.new(:cell_error, text)
+      when :missing then raise Cast::Failure.new(missing, text)
+      else raise ArgumentError, "unknown cell kind: #{kind.inspect}"
+      end
+    end
+
+    # The raw value of a failed cast: the cell's text, or with +number_errors: :as_read+ the number as read for a
+    # :number cell that is not integral.
+    def error_text(kind, text, failure)
+      @as_read && failure.reason == :not_integral && kind == :number ? failure.value : text
+    end
+
+    # Ends the row with its last non-blank cell or, after it, its last whitespace text that got a value, and drops,
+    # like CSV, the cast failures of the whitespace after that. +@errors+ is nil when none is left, else sorted by
+    # column.
+    #
+    # Only a value sets a position, so the values Array already ends with the last cell that got one. A cell whose
+    # cast failed, or an error cell, sets nothing: when it is the last non-blank one and no whitespace text after it
+    # got a value, the Array is shorter than +@last+ + 1, and assigning nil at +@last+ extends it to that cell.
+    def trim_row!
+      @values[@last] = nil if @values.size <= @last
+      return unless @errors
+
+      width = @values.size
+      @errors.reject! { |error| error[0] >= width }
+      if @errors.empty? then @errors = nil
+      elsif @errors.size > 1 then @errors.sort_by!(&:first)
+      end
+    end
+
+    # Whitespace only, without a regexp for the common text that starts with a printable ASCII character.
+    def blank?(text)
+      byte = text.getbyte(0)
+      !(byte > 32 && byte < 128) && !Cast::NON_BLANK.match?(text)
+    end
+
+    # The texts of a boolean value in XLSX ("1", "0") and ODS ("true", "false"); both formats accept both. A case of
+    # String literals, which Ruby dispatches by hash, costs less per cell than a Hash or Array lookup.
+    def boolean(text)
+      case text
+      when "1", "true" then true
+      when "0", "false" then false
+      else raise Cast::Failure.new(:invalid_boolean, text)
+      end
+    end
+  end
+end

data/lib/calcsheet/sheet_list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Calcsheet
+  # The sheets of a book as a read selects them, from a backend that finds them only as far as they are read
+  # (+#each_sheet+, see Reading): the first visible sheet, or one named or indexed, costs the scan up to it, not of
+  # the whole file. +:all+ and the visible sheets read them all.
+  #
+  # @api private
+  class SheetList
+    include Enumerable
+
+    # @param backend [#each_sheet]
+    def initialize(backend)
+      @backend = backend
+    end
+
+    # @yieldparam sheet [SheetInfo]
+    def each(&)
+      return enum_for(:each) unless block_given?
+
+      @backend.each_sheet(&)
+      self
+    end
+  end
+end

data/lib/calcsheet/sheet_selection.rb

@@ -10,7 +10,8 @@ module Calcsheet
   module SheetSelection
     module_function
 
-    # @param sheets [Array<SheetInfo>] every sheet of the workbook
+    # @param sheets [Enumerable<SheetInfo>] every sheet of the workbook, in order: the default and a sheet given by
+    #   index or name read only as far as they need (see SheetList)
     # @param selector [nil, Integer, String, Array, :all] nil means the first visible sheet (the first sheet when
     #   every sheet is hidden)
     # @param include_hidden [Boolean] :all includes the hidden sheets too; the default stays the first visible one.
@@ -22,7 +23,7 @@ module Calcsheet
       selected =
         case selector
         when nil then [ sheets.find { |sheet| !sheet.hidden? } || sheets.first ].compact
-        when :all then include_hidden ? sheets : visible_or_first(sheets)
+        when :all then include_hidden ? sheets.to_a : visible_or_first(sheets)
         when Integer, String then [ find(sheets, selector) ]
         when Array
           raise ArgumentError, "sheet: must not be an empty Array" if selector.empty?

data/lib/calcsheet/style.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "display_format"
+
+module Calcsheet
+  # How written cells look in XLSX and ODS (CSV ignores it): registered by name with WriteBook#style and applied with
+  # WriteSheet#add. Every attribute is optional; nil keeps the default (Calibri 11 in XLSX, the default cell style in
+  # ODS, unbordered, the column's own number format).
+  #
+  # @attr_reader name [Symbol] the name rows refer to it by
+  # @attr_reader bold [Boolean, nil]
+  # @attr_reader italic [Boolean, nil]
+  # @attr_reader size [Numeric, nil] the font size in points, 1 to 409
+  # @attr_reader color [String, nil] the font colour, "RRGGBB"
+  # @attr_reader fill [String, nil] the background colour, "RRGGBB"
+  # @attr_reader align [Symbol, nil] +:left+, +:center+ or +:right+
+  # @attr_reader valign [Symbol, nil] +:top+, +:center+ or +:bottom+
+  # @attr_reader wrap [Boolean, nil] wrap the text in the cell
+  # @attr_reader border [Style::Border, nil]
+  # @attr_reader format [DisplayFormat, nil] the number format, instead of the column's
+  Style = Data.define(:name, :bold, :italic, :size, :color, :fill, :align, :valign, :wrap, :border, :format) do
+    # @raise [ArgumentError] on an invalid attribute
+    def initialize(name:, bold: nil, italic: nil, size: nil, color: nil, fill: nil, align: nil, valign: nil, wrap: nil,
+                   border: nil, format: nil)
+      raise ArgumentError, "style: the name must be a Symbol, got #{name.inspect}" unless name.is_a?(Symbol)
+
+      super(name: name, bold: Style.flag(:bold, bold), italic: Style.flag(:italic, italic), size: Style.size(size),
+            color: Style.color(:color, color), fill: Style.color(:fill, fill),
+            align: Style.choice(:align, align, %i[left center right]), valign: Style.choice(:valign, valign, %i[top center bottom]),
+            wrap: Style.flag(:wrap, wrap), border: border.nil? || border.is_a?(Style::Border) ? border : Style::Border.from(border),
+            format: format.nil? || format.is_a?(DisplayFormat) ? format : DisplayFormat.parse(format))
+    end
+
+    # @return [Boolean] whether the style changes nothing of the default but the number format
+    def plain?
+      [ bold, italic, size, color, fill, align, valign, wrap, border ].all?(&:nil?)
+    end
+  end
+
+  class Style
+    # The font sizes Excel accepts.
+    SIZES = (1..409)
+    # A colour: six hexadecimal digits, or eight (ARGB, whose alpha is dropped), with or without a leading "#".
+    COLOR = /\A#?(?:\h{2})?(\h{6})\z/
+
+    # The border of a styled cell: a line style and colour on some of its edges.
+    #
+    # @attr_reader style [Symbol] one of STYLES
+    # @attr_reader color [String] "RRGGBB"
+    # @attr_reader edges [Array<Symbol>] some of EDGES, in that order
+    Border = Data.define(:style, :color, :edges) do
+      # @param entry [Hash] +{ style: :thin, color: "000000", edges: %i[top bottom left right] }+
+      # @return [Border]
+      # @raise [ArgumentError] on an invalid entry
+      def self.from(entry)
+        raise ArgumentError, "style: border: expected a Hash, got #{entry.inspect}" unless entry.is_a?(Hash)
+
+        unknown = entry.keys - members
+        raise ArgumentError, "style: border: unknown option(s) #{unknown.map(&:inspect).join(", ")}" unless unknown.empty?
+
+        new(**entry)
+      end
+
+      def initialize(style: :thin, color: "000000", edges: Border::EDGES)
+        Style.choice(:"border style", style, Border::STYLES)
+        unless edges.is_a?(Array) && !edges.empty? && (edges - Border::EDGES).empty?
+          raise ArgumentError, "style: border: edges must be some of #{Border::EDGES.inspect}, got #{edges.inspect}"
+        end
+
+        super(style: style, color: Style.color(:"border color", color), edges: (Border::EDGES & edges).freeze)
+      end
+    end
+
+    class Border
+      # The line styles, by their XLSX names.
+      STYLES = %i[thin medium thick dashed dotted double].freeze
+      EDGES = %i[top bottom left right].freeze
+    end
+
+    class << self
+      # @api private
+      def flag(name, value)
+        return value if value.nil? || value == true || value == false
+
+        raise ArgumentError, "style: #{name}: must be true, false or nil, got #{value.inspect}"
+      end
+
+      # @api private
+      def size(value)
+        return value if value.nil? || (value.is_a?(Numeric) && value.real? && SIZES.cover?(value))
+
+        raise ArgumentError, "style: size: must be a number from #{SIZES.min} to #{SIZES.max}, got #{value.inspect}"
+      end
+
+      # @api private
+      # @return [String, nil] "RRGGBB", upper case
+      def color(name, value)
+        return if value.nil?
+
+        match = value.is_a?(String) && COLOR.match(value)
+        return match[1].upcase.freeze if match
+
+        raise ArgumentError, "style: #{name}: must be a colour such as \"81B7C0\", got #{value.inspect}"
+      end
+
+      # @api private
+      def choice(name, value, allowed)
+        return value if value.nil? || allowed.include?(value)
+
+        raise ArgumentError, "style: #{name}: must be one of #{allowed.map(&:inspect).join(", ")}, got #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/calcsheet/version.rb

@@ -2,5 +2,5 @@
 
 module Calcsheet
   # The version of the gem.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/calcsheet/write_book.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "formula"
 require_relative "sheet_names"
+require_relative "style"
 require_relative "time_zone"
 require_relative "write_sheet"
 
@@ -22,15 +24,22 @@ module Calcsheet
   #   call, which win over presets. It runs before anything is written, also when Calcsheet.stream builds its body.
   # - +.new(io, options)+: +io+ responds to +write(string)+ and +<<(string)+ and may be non-seekable; +options+ are
   #   those prepared, frozen. The backend must not close +io+.
-  # - +#start_sheet(name, columns, header:)+, for each sheet and each continuation: +name+ is valid and unique,
-  #   +columns+ an Array of frozen Column, and with +header: true+ the backend writes the header row (the column
-  #   headers) itself.
-  # - +#row(values)+: one value per column, in column order: nil (empty cell), or a value of the column type —
-  #   String in UTF-8 (:string), Integer (:integer), Integer or finite BigDecimal (:decimal, written unrounded;
-  #   +scale+ is display only), Date (:date), true/false (:boolean), and for :datetime a UTC Time in whole seconds
-  #   whose fields are the wall clock to write (the +time_zone:+ conversion is already applied). A value the format
-  #   cannot hold (a date beyond its range, a text too long) raises WriteError, and nothing of the row may stay
-  #   written: the sheet goes on with the next row.
+  # - +#start_sheet(name, columns, header:, widths: nil, auto_width: false)+, for each sheet and each continuation:
+  #   +name+ is valid and unique, +columns+ an Array of frozen Column, or nil for a free sheet (no columns: each
+  #   cell has the type of its value, see #row), whose column widths +widths+ gives (an Array of Numeric or nil, by
+  #   column index); with +header: true+ (never for a free sheet) the backend writes the header row (the column
+  #   headers) itself. With +auto_width: true+ the widths of the columns without one come with #end_sheet, after the
+  #   rows: the backend keeps the rows (in a temporary file) until then.
+  # - +#row(values, styles = nil)+: one value per column, in column order: nil (empty cell), a Formula, or a value of
+  #   the column type — String in UTF-8 (:string), Integer (:integer), Integer or finite BigDecimal (:decimal,
+  #   written unrounded; +scale+ is display only), Date (:date), true/false (:boolean), and for :datetime a UTC
+  #   Time in whole seconds whose fields are the wall clock to write (the +time_zone:+ conversion is already
+  #   applied). In a free sheet the values may be fewer or more than in other rows, and each one's class is its type.
+  #   +styles+ is nil or an Array of Style or nil by column index, possibly longer than +values+: a styled nil is a
+  #   styled empty cell. A value the format cannot hold (a date beyond its range, a text too long) raises WriteError,
+  #   and nothing of the row may stay written: the sheet goes on with the next row.
+  # - +#merge(range)+ (optional; CSV has none): a CellRange of the sheet to merge, declared before the row of its
+  #   first cell is written, never overlapping another; the cells it covers but the first are nil (styles allowed).
   # - +#text_bytesize(text, column_index)+ (optional): the bytes the backend writes for a text of that column, when
   #   it adds to it (the CSV formula prefix); the facade asks it only for a text of +max_cell_bytes+ bytes or more,
   #   and refuses one the readers would refuse with a WriteError. Without it, the bytes of the text count.
@@ -40,7 +49,8 @@ module Calcsheet
   # - +#row_problem(values)+ (optional): the row #row would refuse with a WriteError, as +[column_index, reason]+, or
   #   nil; asked, without writing, for the row that overflows into a continuation sheet, so that a refused row
   #   opens none.
-  # - +#end_sheet+ after the last row of each sheet.
+  # - +#end_sheet(widths = nil)+ after the last row of each sheet: with +auto_width: true+, the width of every
+  #   column (an Array of Numeric or nil by column index), measured on the rows written or given.
   # - +#finish+ once, after the last sheet, also when the book has none: writes what completes the file.
   #
   # When the caller's block raises, the facade stops calling the backend and the output is left incomplete.
@@ -140,31 +150,53 @@ module Calcsheet
       @limit = options.max_rows_per_sheet
       @max_cell_bytes = options.max_cell_bytes
       @names = SheetNames.new(sanitize: options.sanitize_sheet_names)
+      @styles = {}
       @sheet = nil
       @failed = nil
       @finished = false
     end
 
+    # Registers a style that rows of any sheet can use by name (WriteSheet#add). XLSX and ODS apply it; CSV ignores
+    # it.
+    #
+    # @param name [Symbol]
+    # @param attributes [Hash] see Style: +bold:+, +italic:+, +size:+, +color:+, +fill:+, +align:+, +valign:+,
+    #   +wrap:+, +border:+ (+{ style:, color:, edges: }+) and +format:+ (see DisplayFormat)
+    # @return [Style]
+    # @raise [ArgumentError] an invalid attribute, or a name already registered
+    def style(name, **attributes)
+      check_usable
+      raise ArgumentError, "style #{name.inspect} is already defined" if @styles.key?(name)
+
+      @styles[name] = Style.new(name: name, **attributes)
+    end
+
     # Writes one sheet: yields it, then ends it. When the block raises (or leaves with break or throw), the sheet is
     # left incomplete and the book refuses any further sheet or #finish with a WriteError.
     #
     # @param name [String] valid and unique (see SheetNames), unless +sanitize_sheet_names: true+ repairs it
-    # @param columns [Array<Hash, Column>] see Column.from
-    # @param header [Boolean] write the column headers as the first row
+    # @param columns [Array<Hash, Column>, nil] see Column.from; nil for a free sheet, whose rows hold any number of
+    #   values, each written with the type of its class (see WriteSheet#add)
+    # @param header [Boolean, nil] write the column headers as the first row; default true, never for a free sheet
+    # @param widths [Array<Numeric, nil>, nil] a free sheet's column widths in characters, by column index (a typed
+    #   sheet has its columns' +width:+)
+    # @param auto_width [Boolean] the columns without a width get the width of their longest value (XLSX and ODS):
+    #   the rows are kept in a temporary file until the sheet ends
     # @yieldparam sheet [WriteSheet]
     # @return [nil]
-    # @raise [ArgumentError] a missing block, invalid columns or name, too many columns for the format, a sheet
-    #   opened inside another one's block, or a book already finished
+    # @raise [ArgumentError] a missing block, invalid columns, widths or name, too many columns for the format, a
+    #   sheet opened inside another one's block, or a book already finished
     # @raise [WriteError] an earlier sheet block raised; a second sheet in CSV; a header longer than an XLSX cell, or
     #   (written) than +max_cell_bytes+; the sheet is not started
-    def sheet(name, columns:, header: true)
+    def sheet(name, columns: nil, header: nil, widths: nil, auto_width: false)
       raise ArgumentError, "a block is required" unless block_given?
 
       check_usable
       raise ArgumentError, "sheet #{Untrusted.show(@sheet.name)} is still open" if @sheet
 
-      sheet = @sheet = WriteSheet.new(@writer, @names, name, columns, header: header, limit: @limit, zone: @zone,
-                                      max_cell_bytes: @max_cell_bytes)
+      sheet = @sheet = WriteSheet.new(@writer, @names, name, columns, header: header.nil? ? !columns.nil? : header,
+                                      limit: @limit, zone: @zone, max_cell_bytes: @max_cell_bytes, styles: @styles,
+                                      widths: widths, auto_width: auto_width)
       completed = false
       begin
         yield sheet