csv_plus_plus 0.1.1 → 0.1.3

data/lib/csv_plus_plus/writer/google_sheet_builder.rb

@@ -1,21 +1,42 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './google_sheet_modifier'
-
 module CSVPlusPlus
   module Writer
     # Given +rows+ from a +Template+, build requests compatible with Google Sheets Ruby API
     # rubocop:disable Metrics/ClassLength
     class GoogleSheetBuilder
-      # @param current_sheet_values
-      def initialize(current_sheet_values:, sheet_id:, rows:, column_index: 0, row_index: 0)
+      extend ::T::Sig
+
+      sig do
+        params(
+          current_sheet_values: ::T::Array[::T::Array[::T.nilable(::String)]],
+          runtime: ::CSVPlusPlus::Runtime::Runtime,
+          sheet_id: ::T.nilable(::Integer),
+          rows: ::T::Array[::CSVPlusPlus::Row],
+          column_index: ::T.nilable(::Integer),
+          row_index: ::T.nilable(::Integer)
+        ).void
+      end
+      # @param column_index [Integer] Offset the results by +column_index+
+      # @param current_sheet_values [Array<Array<::String, nil>>]
+      # @param sheet_id [::String] The sheet ID referencing the sheet in Google
+      # @param row_index [Integer] Offset the results by +row_index+
+      # @param rows [Array<Row>] The rows to render
+      # @param runtime [Runtime] The current runtime.
+      #
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(current_sheet_values:, runtime:, sheet_id:, rows:, column_index: 0, row_index: 0)
+        # rubocop:enable Metrics/ParameterLists
         @current_sheet_values = current_sheet_values
         @sheet_id = sheet_id
         @rows = rows
         @column_index = column_index
         @row_index = row_index
+        @runtime = runtime
       end
 
+      sig { returns(::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest) }
       # Build a Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest
       #
       # @return [Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest]
@@ -25,12 +46,7 @@ module CSVPlusPlus
 
       private
 
-      def sheets_ns
-        ::Google::Apis::SheetsV4
-      end
-
-      def sheets_color(color); end
-
+      sig { params(extended_value: ::Google::Apis::SheetsV4::ExtendedValue, value: ::T.nilable(::String)).void }
       def set_extended_value_type!(extended_value, value)
         v = value || ''
         if v.start_with?('=')
@@ -38,25 +54,27 @@ module CSVPlusPlus
         elsif v.match(/^-?[\d.]+$/)
           extended_value.number_value = value
         elsif v.downcase == 'true' || v.downcase == 'false'
-          extended_value.boolean_value = value
+          extended_value.bool_value = value
         else
           extended_value.string_value = value
         end
       end
 
+      sig { params(mod: ::CSVPlusPlus::Modifier::GoogleSheetModifier).returns(::Google::Apis::SheetsV4::CellFormat) }
       def build_cell_format(mod)
-        sheets_ns::CellFormat.new.tap do |cf|
+        ::Google::Apis::SheetsV4::CellFormat.new.tap do |cf|
           cf.text_format = mod.text_format
 
-          cf.horizontal_alignment = mod.halign
-          cf.vertical_alignment = mod.valign
-          cf.background_color = mod.color
-          cf.number_format = mod.numberformat
+          cf.horizontal_alignment = mod.horizontal_alignment
+          cf.vertical_alignment = mod.vertical_alignment
+          cf.background_color = mod.background_color
+          cf.number_format = mod.number_format
         end
       end
 
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::GridRange) }
       def grid_range_for_cell(cell)
-        sheets_ns::GridRange.new(
+        ::Google::Apis::SheetsV4::GridRange.new(
           sheet_id: @sheet_id,
           start_column_index: cell.index,
           end_column_index: cell.index + 1,
@@ -65,79 +83,105 @@ module CSVPlusPlus
         )
       end
 
+      sig { params(row_index: ::Integer, cell_index: ::Integer).returns(::T.nilable(::String)) }
       def current_value(row_index, cell_index)
-        @current_sheet_values[row_index][cell_index]
+        ::T.must(@current_sheet_values[row_index])[cell_index]
       rescue ::StandardError
         nil
       end
 
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::ExtendedValue) }
       def build_cell_value(cell)
-        sheets_ns::ExtendedValue.new.tap do |xv|
+        ::Google::Apis::SheetsV4::ExtendedValue.new.tap do |xv|
           value =
             if cell.value.nil?
               current_value(cell.row_index, cell.index)
             else
-              cell.to_csv
+              cell.evaluate(@runtime)
             end
 
           set_extended_value_type!(xv, value)
         end
       end
 
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::CellData) }
       def build_cell_data(cell)
-        mod = ::CSVPlusPlus::Writer::GoogleSheetModifier.new(cell.modifier)
+        mod = cell.modifier
 
-        sheets_ns::CellData.new.tap do |cd|
-          cd.user_entered_format = build_cell_format(mod)
+        ::Google::Apis::SheetsV4::CellData.new.tap do |cd|
+          cd.user_entered_format = build_cell_format(::T.cast(mod, ::CSVPlusPlus::Modifier::GoogleSheetModifier))
           cd.note = mod.note if mod.note
 
-          # XXX apply data validation
+          # TODO: apply data validation
           cd.user_entered_value = build_cell_value(cell)
         end
       end
 
+      sig { params(row: ::CSVPlusPlus::Row).returns(::Google::Apis::SheetsV4::RowData) }
       def build_row_data(row)
-        sheets_ns::RowData.new(values: row.cells.map { |cell| build_cell_data(cell) })
+        ::Google::Apis::SheetsV4::RowData.new(values: row.cells.map { |cell| build_cell_data(cell) })
       end
 
+      sig { params(rows: ::T::Array[::CSVPlusPlus::Row]).returns(::Google::Apis::SheetsV4::UpdateCellsRequest) }
       def build_update_cells_request(rows)
-        sheets_ns::UpdateCellsRequest.new(
+        ::Google::Apis::SheetsV4::UpdateCellsRequest.new(
           fields: '*',
-          start: sheets_ns::GridCoordinate.new(
+          start: ::Google::Apis::SheetsV4::GridCoordinate.new(
             sheet_id: @sheet_id,
             column_index: @column_index,
             row_index: @row_index
           ),
-          rows: rows.map { |row| build_row_data(row) }
+          rows:
         )
       end
 
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::UpdateBordersRequest) }
       def build_border(cell)
-        mod = cell.modifier
-        # TODO: allow different border styles per side
-        border = sheets_ns::Border.new(color: mod.bordercolor || '#000000', style: mod.borderstyle || 'solid')
-        sheets_ns::UpdateBordersRequest.new(
-          top: mod.border_along?('top') ? border : nil,
-          right: mod.border_along?('right') ? border : nil,
-          left: mod.border_along?('left') ? border : nil,
-          bottom: mod.border_along?('bottom') ? border : nil,
+        mod = ::T.cast(cell.modifier, ::CSVPlusPlus::Modifier::GoogleSheetModifier)
+        border = mod.border
+
+        ::Google::Apis::SheetsV4::UpdateBordersRequest.new(
+          top: mod.border_along?(::CSVPlusPlus::Modifier::BorderSide::Top) ? border : nil,
+          right: mod.border_along?(::CSVPlusPlus::Modifier::BorderSide::Right) ? border : nil,
+          left: mod.border_along?(::CSVPlusPlus::Modifier::BorderSide::Left) ? border : nil,
+          bottom: mod.border_along?(::CSVPlusPlus::Modifier::BorderSide::Bottom) ? border : nil,
           range: grid_range_for_cell(cell)
         )
       end
 
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::Request) }
       def build_update_borders_request(cell)
-        sheets_ns::Request.new(update_borders: build_border(cell))
+        ::Google::Apis::SheetsV4::Request.new(update_borders: build_border(cell))
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      sig { params(rows: ::T::Array[::CSVPlusPlus::Row]).returns(::T::Array[::Google::Apis::SheetsV4::Request]) }
+      # rubocop:disable Metrics/MethodLength
+      def chunked_requests(rows)
+        accum = []
+        [].tap do |chunked|
+          @runtime.map_rows(rows) do |row|
+            accum << build_row_data(row)
+            next unless accum.length == 1000
+
+            chunked << ::Google::Apis::SheetsV4::Request.new(update_cells: build_update_cells_request(accum))
+            accum = []
+          end
+
+          unless accum.empty?
+            chunked << ::Google::Apis::SheetsV4::Request.new(update_cells: build_update_cells_request(accum))
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      sig do
+        params(rows: ::T::Array[::CSVPlusPlus::Row]).returns(::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest)
+      end
       def build_batch_request(rows)
-        sheets_ns::BatchUpdateSpreadsheetRequest.new.tap do |bu|
-          bu.requests =
-            rows.each_slice(1000).to_a.map do |chunked_rows|
-              sheets_ns::Request.new(update_cells: build_update_cells_request(chunked_rows))
-            end
+        ::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest.new.tap do |bu|
+          bu.requests = chunked_requests(rows)
 
-          rows.each do |row|
+          @runtime.map_rows(rows) do |row|
             row.cells.filter { |c| c.modifier.any_border? }
                .each do |cell|
                  bu.requests << build_update_borders_request(cell)
@@ -145,7 +189,6 @@ module CSVPlusPlus
           end
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     end
     # rubocop:enable Metrics/ClassLength
   end

data/lib/csv_plus_plus/writer/google_sheets.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require_relative '../google_api_client'
@@ -7,25 +8,37 @@ require_relative 'google_sheet_builder'
 module CSVPlusPlus
   module Writer
     # A class that can write a +Template+ to Google Sheets (via their API)
+    # rubocop:disable Metrics/ClassLength
     class GoogleSheets < ::CSVPlusPlus::Writer::BaseWriter
+      extend ::T::Sig
+
+      sig { returns(::String) }
+      attr_reader :sheet_id
+
+      sig { returns(::T.nilable(::String)) }
+      attr_reader :sheet_name
+
       # TODO: it would be nice to raise this but we shouldn't expand out more than necessary for our data
       SPREADSHEET_INFINITY = 1000
       public_constant :SPREADSHEET_INFINITY
 
+      sig { params(options: ::CSVPlusPlus::Options, runtime: ::CSVPlusPlus::Runtime::Runtime).void }
       # @param options [Options]
-      def initialize(options)
-        super(options)
-
-        @sheet_id = options.google.sheet_id
-        @sheet_name = options.sheet_name
+      # @param runtime [Runtime]
+      def initialize(options, runtime)
+        super(options, runtime)
+
+        # @current_values = ::T.let(nil, ::T.nilable(::T::Array
+        @sheet_id = ::T.let(::T.must(options.google).sheet_id, ::String)
+        @sheet_name = ::T.let(options.sheet_name, ::T.nilable(::String))
+        @sheets_client = ::T.let(::CSVPlusPlus::GoogleApiClient.sheets_client, ::Google::Apis::SheetsV4::SheetsService)
       end
 
+      sig { override.params(template: ::CSVPlusPlus::Template).void }
       # write a +template+ to Google Sheets
       #
       # @param template [Template]
       def write(template)
-        @sheets_client = ::CSVPlusPlus::GoogleApiClient.sheets_client
-
         fetch_spreadsheet!
         fetch_spreadsheet_values!
 
@@ -34,6 +47,7 @@ module CSVPlusPlus
         update_cells!(template)
       end
 
+      sig { override.void }
       # write a backup of the google sheet
       def write_backup
         drive_client = ::CSVPlusPlus::GoogleApiClient.drive_client
@@ -42,23 +56,12 @@ module CSVPlusPlus
 
       private
 
-      def format_range(range)
-        @sheet_name ? "'#{@sheet_name}'!#{range}" : range
-      end
-
-      def full_range
-        format_range('A1:Z1000')
-      end
-
-      def fetch_spreadsheet_values!
-        formatted_values = get_all_spreadsheet_values('FORMATTED_VALUE')
-        formula_values = get_all_spreadsheet_values('FORMULA')
-
-        return if formula_values.values.nil? || formatted_values.values.nil?
-
-        @current_values = extract_current_values(formatted_values, formula_values)
+      sig do
+        params(
+          formatted_values: ::Google::Apis::SheetsV4::ValueRange,
+          formula_values: ::Google::Apis::SheetsV4::ValueRange
+        ).returns(::T::Array[::T::Array[::T.nilable(::String)]])
       end
-
       def extract_current_values(formatted_values, formula_values)
         formatted_values.values.map.each_with_index do |row, x|
           row.map.each_with_index do |_cell, y|
@@ -72,49 +75,96 @@ module CSVPlusPlus
         end
       end
 
+      sig { void }
+      # rubocop:disable Metrics/MethodLength
+      def fetch_spreadsheet_values!
+        formatted_values = get_all_spreadsheet_values('FORMATTED_VALUE')
+        formula_values = get_all_spreadsheet_values('FORMULA')
+
+        @current_values =
+          ::T.let(
+            if formula_values.values.nil? || formatted_values.values.nil?
+              []
+            else
+              extract_current_values(formatted_values, formula_values)
+            end,
+            ::T.nilable(::T::Array[::T::Array[::T.nilable(::String)]])
+          )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      sig { params(range: ::String).returns(::String) }
+      def format_range(range)
+        @sheet_name ? "'#{@sheet_name}'!#{range}" : range
+      end
+
+      sig { returns(::String) }
+      def full_range
+        format_range('A1:Z1000')
+      end
+
+      sig { params(str: ::String).returns(::T.nilable(::String)) }
       def strip_to_nil(str)
         str.strip.empty? ? nil : str
       end
 
+      sig { params(render_option: ::String).returns(::Google::Apis::SheetsV4::ValueRange) }
       def get_all_spreadsheet_values(render_option)
         @sheets_client.get_spreadsheet_values(@sheet_id, full_range, value_render_option: render_option)
       end
 
+      sig { returns(::T.nilable(::Google::Apis::SheetsV4::Sheet)) }
       def sheet
         return unless @sheet_name
 
-        @spreadsheet.sheets.find { |s| s.properties.title.strip == @sheet_name.strip }
+        spreadsheet.sheets.find { |s| s.properties.title.strip == @sheet_name.strip }
       end
 
-      def fetch_spreadsheet!
-        @spreadsheet = @sheets_client.get_spreadsheet(@sheet_id)
+      sig { returns(::Google::Apis::SheetsV4::Spreadsheet) }
+      def spreadsheet
+        @spreadsheet ||= ::T.let(
+          @sheets_client.get_spreadsheet(@sheet_id),
+          ::T.nilable(::Google::Apis::SheetsV4::Spreadsheet)
+        )
+
+        raise(::CSVPlusPlus::Error::WriterError, 'Unable to connect to google spreadsheet') unless @spreadsheet
 
+        @spreadsheet
+      end
+
+      sig { void }
+      def fetch_spreadsheet!
         return unless @sheet_name.nil?
 
-        @sheet_name = @spreadsheet.sheets&.first&.properties&.title
+        @sheet_name = spreadsheet.sheets&.first&.properties&.title
       end
 
+      sig { void }
       def create_sheet!
         return if sheet
 
         @sheets_client.create_spreadsheet(@sheet_name)
         fetch_spreadsheet!
-        @sheet_name = @spreadsheet.sheets.last.properties.title
+        @sheet_name = spreadsheet.sheets.last.properties.title
       end
 
+      sig { params(template: ::CSVPlusPlus::Template).void }
       def update_cells!(template)
         @sheets_client.batch_update_spreadsheet(@sheet_id, builder(template).batch_update_spreadsheet_request)
       end
 
+      sig { params(template: ::CSVPlusPlus::Template).returns(::CSVPlusPlus::Writer::GoogleSheetBuilder) }
       def builder(template)
         ::CSVPlusPlus::Writer::GoogleSheetBuilder.new(
+          runtime: @runtime,
           rows: template.rows,
           sheet_id: sheet&.properties&.sheet_id,
           column_index: @options.offset[1],
           row_index: @options.offset[0],
-          current_sheet_values: @current_values
+          current_sheet_values: ::T.must(@current_values)
         )
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/csv_plus_plus/writer/open_document.rb

@@ -1,10 +1,15 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   module Writer
-    ##
     # A class that can output a +Template+ to an Excel file
     class OpenDocument < ::CSVPlusPlus::Writer::BaseWriter
+      extend ::T::Sig
+
+      include ::CSVPlusPlus::Writer::FileBackerUpper
+
+      sig { override.params(template: ::CSVPlusPlus::Template).void }
       # write a +template+ to an OpenDocument file
       def write(template)
         # TODO

data/lib/csv_plus_plus/writer/rubyxl_builder.rb

@@ -1,53 +1,93 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './rubyxl_modifier'
-
 module CSVPlusPlus
   module Writer
     # Build a RubyXL workbook formatted according to the given +rows+
     #
     # @attr_reader input_filename [String] The filename being written to
     # @attr_reader rows [Array<Row>] The rows being written
+    # rubocop:disable Metrics/ClassLength
     class RubyXLBuilder
-      attr_reader :input_filename, :rows
+      extend ::T::Sig
+
+      RubyXLCell = ::T.type_alias { ::T.all(::RubyXL::Cell, ::RubyXL::CellConvenienceMethods) }
+      public_constant :RubyXLCell
+
+      sig { returns(::T.nilable(::String)) }
+      attr_reader :input_filename
 
-      # @param input_filename [String] The file to write to
+      sig { returns(::T::Array[::CSVPlusPlus::Row]) }
+      attr_reader :rows
+
+      sig do
+        params(
+          input_filename: ::T.nilable(::String),
+          rows: ::T::Array[::CSVPlusPlus::Row],
+          runtime: ::CSVPlusPlus::Runtime::Runtime,
+          sheet_name: ::T.nilable(::String)
+        ).void
+      end
+      # @param input_filename [::String] The file to write to
       # @param rows [Array<Row>] The rows to write
-      # @param sheet_name [String] The name of the sheet within the workbook to write to
-      def initialize(input_filename:, rows:, sheet_name:)
+      # @param runtime [Runtime] The current runtime
+      # @param sheet_name [::String] The name of the sheet within the workbook to write to
+      def initialize(input_filename:, rows:, runtime:, sheet_name: nil)
         @rows = rows
         @input_filename = input_filename
+        @runtime = runtime
         @sheet_name = sheet_name
+        @worksheet = ::T.let(open_worksheet, ::RubyXL::Worksheet)
       end
 
+      sig { returns(::RubyXL::Workbook) }
       # Build a +RubyXL::Workbook+ with the given +@rows+ in +sheet_name+
       #
       # @return [RubyXL::Workbook]
       def build_workbook
-        open_workbook.tap do |workbook|
-          @worksheet = workbook[@sheet_name]
-          build_workbook!
-        end
+        build_workbook!
+        @worksheet.workbook
       end
 
       private
 
+      sig { void }
+      # rubocop:disable Metrics/MethodLength
       def build_workbook!
-        @rows.each_with_index do |row, x|
-          row.cells.each_with_index do |cell, y|
-            modifier = ::CSVPlusPlus::Writer::RubyXLModifier.new(cell.modifier)
-
-            @worksheet.add_cell(x, y, cell.to_csv)
-            format_cell!(x, y, modifier)
+        @runtime.map_all_cells(@rows) do |cell|
+          value = cell.evaluate(@runtime)
+          if value&.start_with?('=')
+            @worksheet.add_cell(@runtime.row_index, @runtime.cell_index, '', value.gsub(/^=/, ''))
+          else
+            @worksheet.add_cell(@runtime.row_index, @runtime.cell_index, value)
           end
+
+          format_cell!(
+            @runtime.row_index,
+            @runtime.cell_index,
+            ::T.cast(cell.modifier, ::CSVPlusPlus::Modifier::RubyXLModifier)
+          )
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
+      sig do
+        params(
+          cell: ::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLCell,
+          modifier: ::CSVPlusPlus::Modifier::RubyXLModifier
+        ).void
+      end
       def do_alignments!(cell, modifier)
-        cell.change_horizontal_alignment(modifier.halign) if modifier.halign
-        cell.change_vertical_alignment(modifier.valign) if modifier.valign
+        cell.change_horizontal_alignment(modifier.horizontal_alignment) if modifier.halign
+        cell.change_vertical_alignment(modifier.vertical_alignment) if modifier.valign
       end
 
+      sig do
+        params(
+          cell: ::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLCell,
+          modifier: ::CSVPlusPlus::Modifier::RubyXLModifier
+        ).void
+      end
       # rubocop:disable Metrics/MethodLength
       def do_borders!(cell, modifier)
         return unless modifier.any_border?
@@ -62,29 +102,56 @@ module CSVPlusPlus
           end
         else
           modifier.borders.each do |direction|
-            cell.change_border(direction, color || weight)
+            # TODO: move direction.serialize into the RubyXLModifier
+            cell.change_border(direction.serialize, color || weight)
           end
         end
       end
       # rubocop:enable Metrics/MethodLength
 
+      sig do
+        params(
+          cell: ::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLCell,
+          modifier: ::CSVPlusPlus::Modifier::RubyXLModifier
+        ).void
+      end
       def do_fill!(cell, modifier)
-        cell.change_fill(modifier.color.to_hex) if modifier.color
+        return unless modifier.color
+
+        cell.change_fill(modifier.color&.to_hex)
       end
 
+      sig do
+        params(
+          cell: ::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLCell,
+          modifier: ::CSVPlusPlus::Modifier::RubyXLModifier
+        ).void
+      end
       def do_formats!(cell, modifier)
-        cell.change_font_bold(true) if modifier.formatted?('bold')
-        cell.change_font_italics(true) if modifier.formatted?('italic')
-        cell.change_font_underline(true) if modifier.formatted?('underline')
-        cell.change_font_strikethrough(true) if modifier.formatted?('strikethrough')
+        cell.change_font_bold(true) if modifier.formatted?(::CSVPlusPlus::Modifier::TextFormat::Bold)
+        cell.change_font_italics(true) if modifier.formatted?(::CSVPlusPlus::Modifier::TextFormat::Italic)
+        cell.change_font_underline(true) if modifier.formatted?(::CSVPlusPlus::Modifier::TextFormat::Underline)
+        cell.change_font_strikethrough(true) if modifier.formatted?(::CSVPlusPlus::Modifier::TextFormat::Strikethrough)
       end
 
+      sig do
+        params(
+          cell: ::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLCell,
+          modifier: ::CSVPlusPlus::Modifier::RubyXLModifier
+        ).void
+      end
       def do_fonts!(cell, modifier)
-        cell.change_font_color(modifier.fontcolor.to_hex) if modifier.fontcolor
+        cell.change_font_color(::T.must(modifier.fontcolor).to_hex) if modifier.fontcolor
         cell.change_font_name(modifier.fontfamily) if modifier.fontfamily
         cell.change_font_size(modifier.fontsize) if modifier.fontsize
       end
 
+      sig do
+        params(
+          cell: ::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLCell,
+          modifier: ::CSVPlusPlus::Modifier::RubyXLModifier
+        ).void
+      end
       def do_number_formats!(cell, modifier)
         return unless modifier.numberformat
 
@@ -93,6 +160,9 @@ module CSVPlusPlus
         cell.change_contents(cell.value)
       end
 
+      sig do
+        params(row_index: ::Integer, cell_index: ::Integer, modifier: ::CSVPlusPlus::Modifier::RubyXLModifier).void
+      end
       def format_cell!(row_index, cell_index, modifier)
         @worksheet.sheet_data[row_index][cell_index].tap do |cell|
           do_alignments!(cell, modifier)
@@ -104,17 +174,17 @@ module CSVPlusPlus
         end
       end
 
-      def open_workbook
-        if ::File.exist?(@input_filename)
-          ::RubyXL::Parser.parse(@input_filename).tap do |workbook|
-            workbook.add_worksheet(@sheet_name) unless workbook[@sheet_name]
-          end
+      sig { returns(::RubyXL::Worksheet) }
+      def open_worksheet
+        if @input_filename && ::File.exist?(@input_filename)
+          workbook = ::RubyXL::Parser.parse(@input_filename)
+          workbook[@sheet_name] || workbook.add_worksheet(@sheet_name)
         else
-          ::RubyXL::Workbook.new.tap do |workbook|
-            workbook.worksheets[0].sheet_name = @sheet_name
-          end
+          workbook = ::RubyXL::Workbook.new
+          workbook.worksheets[0].tap { |w| w.sheet_name = @sheet_name }
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end