csv_plus_plus 0.1.3 → 0.2.1

data/lib/csv_plus_plus/writer/google_sheets.rb

@@ -1,170 +1,64 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative '../google_api_client'
-require_relative 'base_writer'
-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
+    class GoogleSheets < ::CSVPlusPlus::Writer::Writer
       extend ::T::Sig
+      include ::CSVPlusPlus::GoogleApiClient
 
-      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]
-      # @param runtime [Runtime]
-      def initialize(options, runtime)
-        super(options, runtime)
+      sig do
+        params(options: ::CSVPlusPlus::Options::GoogleSheetsOptions, position: ::CSVPlusPlus::Runtime::Position).void
+      end
+      # @param options [Options::GoogleSheetsOptions]
+      # @param position [Runtime::Position]
+      def initialize(options, position)
+        super(position)
 
-        # @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)
+        @options = ::T.let(options, ::CSVPlusPlus::Options::GoogleSheetsOptions)
+        @reader = ::T.let(::CSVPlusPlus::Reader::GoogleSheets.new(options), ::CSVPlusPlus::Reader::GoogleSheets)
       end
 
       sig { override.params(template: ::CSVPlusPlus::Template).void }
-      # write a +template+ to Google Sheets
+      # Write a +template+ to Google Sheets
       #
       # @param template [Template]
       def write(template)
-        fetch_spreadsheet!
-        fetch_spreadsheet_values!
-
         create_sheet! if @options.create_if_not_exists
 
         update_cells!(template)
       end
 
       sig { override.void }
-      # write a backup of the google sheet
+      # Write a backup of the Google Sheet that is about to be written
       def write_backup
-        drive_client = ::CSVPlusPlus::GoogleApiClient.drive_client
-        drive_client.copy_file(@sheet_id)
+        drive_client.copy_file(@options.sheet_id)
       end
 
       private
 
-      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|
-            formula_value = formula_values.values[x][y]
-            if formula_value.is_a?(::String) && formula_value.start_with?('=')
-              formula_value
-            else
-              strip_to_nil(formatted_values.values[x][y])
-            end
-          end
-        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 }
-      end
-
-      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
-      end
-
       sig { void }
       def create_sheet!
-        return if sheet
+        return if @reader.sheet
 
-        @sheets_client.create_spreadsheet(@sheet_name)
-        fetch_spreadsheet!
-        @sheet_name = spreadsheet.sheets.last.properties.title
+        sheets_client.create_spreadsheet(@options.sheet_name)
       end
 
       sig { params(template: ::CSVPlusPlus::Template).void }
       def update_cells!(template)
-        @sheets_client.batch_update_spreadsheet(@sheet_id, builder(template).batch_update_spreadsheet_request)
+        sheets_client.batch_update_spreadsheet(@options.sheet_id, builder(template).batch_update_spreadsheet_request)
       end
 
-      sig { params(template: ::CSVPlusPlus::Template).returns(::CSVPlusPlus::Writer::GoogleSheetBuilder) }
+      sig { params(template: ::CSVPlusPlus::Template).returns(::CSVPlusPlus::Writer::GoogleSheetsBuilder) }
       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: ::T.must(@current_values)
+        ::CSVPlusPlus::Writer::GoogleSheetsBuilder.new(
+          options: @options,
+          position: @position,
+          reader: @reader,
+          rows: template.rows
         )
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/csv_plus_plus/writer/{google_sheet_builder.rb → google_sheets_builder.rb}

@@ -5,35 +5,27 @@ module CSVPlusPlus
   module Writer
     # Given +rows+ from a +Template+, build requests compatible with Google Sheets Ruby API
     # rubocop:disable Metrics/ClassLength
-    class GoogleSheetBuilder
+    class GoogleSheetsBuilder
       extend ::T::Sig
+      include ::CSVPlusPlus::Writer::Merger
 
       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)
+          options: ::CSVPlusPlus::Options::GoogleSheetsOptions,
+          position: ::CSVPlusPlus::Runtime::Position,
+          reader: ::CSVPlusPlus::Reader::GoogleSheets,
+          rows: ::T::Array[::CSVPlusPlus::Row]
         ).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 options [Options]
+      # @param position [Position] The current position.
+      # @param reader [::CSVPlusPlus::Reader::GoogleSheets]
       # @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
+      def initialize(options:, position:, reader:, rows:)
+        @options = options
+        @position = position
+        @reader = reader
         @rows = rows
-        @column_index = column_index
-        @row_index = row_index
-        @runtime = runtime
       end
 
       sig { returns(::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest) }
@@ -46,19 +38,23 @@ module CSVPlusPlus
 
       private
 
-      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?('=')
-          extended_value.formula_value = value
-        elsif v.match(/^-?[\d.]+$/)
-          extended_value.number_value = value
-        elsif v.downcase == 'true' || v.downcase == 'false'
-          extended_value.bool_value = value
-        else
-          extended_value.string_value = value
+      sig { params(value: ::T.nilable(::String)).returns(::Google::Apis::SheetsV4::ExtendedValue) }
+      # rubocop:disable Metrics/MethodLength
+      def build_extended_value(value)
+        ::Google::Apis::SheetsV4::ExtendedValue.new.tap do |xv|
+          v = value || ''
+          if v.start_with?('=')
+            xv.formula_value = value
+          elsif v.match(/^-?[\d.]+$/)
+            xv.number_value = value
+          elsif v.downcase == 'true' || v.downcase == 'false'
+            xv.bool_value = value
+          else
+            xv.string_value = value
+          end
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       sig { params(mod: ::CSVPlusPlus::Modifier::GoogleSheetModifier).returns(::Google::Apis::SheetsV4::CellFormat) }
       def build_cell_format(mod)
@@ -75,7 +71,6 @@ module CSVPlusPlus
       sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::GridRange) }
       def grid_range_for_cell(cell)
         ::Google::Apis::SheetsV4::GridRange.new(
-          sheet_id: @sheet_id,
           start_column_index: cell.index,
           end_column_index: cell.index + 1,
           start_row_index: cell.row_index,
@@ -83,25 +78,15 @@ module CSVPlusPlus
         )
       end
 
-      sig { params(row_index: ::Integer, cell_index: ::Integer).returns(::T.nilable(::String)) }
-      def current_value(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)
-        ::Google::Apis::SheetsV4::ExtendedValue.new.tap do |xv|
-          value =
-            if cell.value.nil?
-              current_value(cell.row_index, cell.index)
-            else
-              cell.evaluate(@runtime)
-            end
-
-          set_extended_value_type!(xv, value)
-        end
+        build_extended_value(
+          merge_cell_value(
+            existing_value: @reader.value_at(cell),
+            new_value: (ast = cell.ast) ? ast.evaluate(@position) : cell.value,
+            options: @options
+          )
+        )
       end
 
       sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::CellData) }
@@ -127,9 +112,8 @@ module CSVPlusPlus
         ::Google::Apis::SheetsV4::UpdateCellsRequest.new(
           fields: '*',
           start: ::Google::Apis::SheetsV4::GridCoordinate.new(
-            sheet_id: @sheet_id,
-            column_index: @column_index,
-            row_index: @row_index
+            column_index: @options.offset[1],
+            row_index: @options.offset[0]
           ),
           rows:
         )
@@ -159,7 +143,7 @@ module CSVPlusPlus
       def chunked_requests(rows)
         accum = []
         [].tap do |chunked|
-          @runtime.map_rows(rows) do |row|
+          @position.map_rows(rows) do |row|
             accum << build_row_data(row)
             next unless accum.length == 1000
 
@@ -181,7 +165,7 @@ module CSVPlusPlus
         ::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest.new.tap do |bu|
           bu.requests = chunked_requests(rows)
 
-          @runtime.map_rows(rows) do |row|
+          @position.map_rows(rows) do |row|
             row.cells.filter { |c| c.modifier.any_border? }
                .each do |cell|
                  bu.requests << build_update_borders_request(cell)

data/lib/csv_plus_plus/writer/merger.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    # A merging strategy for when we want to write to a cell but it has a value
+    module Merger
+      extend ::T::Sig
+      include ::Kernel
+
+      sig do
+        type_parameters(:V)
+          .params(
+            existing_value: ::T.nilable(::T.all(::T.type_parameter(:V), ::BasicObject)),
+            new_value: ::T.nilable(::T.all(::T.type_parameter(:V), ::BasicObject)),
+            options: ::CSVPlusPlus::Options::Options
+          ).returns(::T.nilable(::T.type_parameter(:V)))
+      end
+      # Consistently enforce our strategy for resolving differences between new changes and existing. By default we
+      # overwrite values that are currently in the spreadsheet but you can override that with the --safe flag
+      def merge_cell_value(existing_value:, new_value:, options:)
+        merged_value = merge_with_strategy(existing_value:, new_value:, options:)
+
+        return merged_value unless options.verbose
+
+        if options.overwrite_values && merged_value != existing_value
+          warn("Overwriting existing value: \"#{existing_value}\" with \"#{new_value}\"")
+        # rubocop:disable Style/MissingElse
+        elsif !options.overwrite_values && new_value != merged_value
+          # rubocop:enable Style/MissingElse
+          warn("Keeping old value: \"#{existing_value}\" rather than new value: \"#{new_value}\"")
+        end
+
+        merged_value
+      end
+
+      private
+
+      sig do
+        type_parameters(:V)
+          .params(
+            existing_value: ::T.nilable(::T.all(::T.type_parameter(:V), ::BasicObject)),
+            new_value: ::T.nilable(::T.all(::T.type_parameter(:V), ::BasicObject)),
+            options: ::CSVPlusPlus::Options::Options
+          ).returns(::T.nilable(::T.type_parameter(:V)))
+      end
+      def merge_with_strategy(existing_value:, new_value:, options:)
+        if options.overwrite_values
+          new_value || existing_value
+        else
+          existing_value || new_value
+        end
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/writer/open_document.rb

@@ -4,16 +4,30 @@
 module CSVPlusPlus
   module Writer
     # A class that can output a +Template+ to an Excel file
-    class OpenDocument < ::CSVPlusPlus::Writer::BaseWriter
+    class OpenDocument < ::CSVPlusPlus::Writer::Writer
       extend ::T::Sig
-
       include ::CSVPlusPlus::Writer::FileBackerUpper
 
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions, position: ::CSVPlusPlus::Runtime::Position).void }
+      # @param options [Options::FileOptions]
+      # @param position [Runtime::Position]
+      def initialize(options, position)
+        super(position)
+
+        @options = options
+      end
+
       sig { override.params(template: ::CSVPlusPlus::Template).void }
       # write a +template+ to an OpenDocument file
       def write(template)
         # TODO
       end
+
+      sig { override.void }
+      # write a backup of the google sheet
+      def write_backup
+        backup_file(@options)
+      end
     end
   end
 end

data/lib/csv_plus_plus/writer/rubyxl_builder.rb

@@ -5,39 +5,38 @@ 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 output_filename [Pathname, nil] The filename being written to
     # @attr_reader rows [Array<Row>] The rows being written
     # rubocop:disable Metrics/ClassLength
     class RubyXLBuilder
       extend ::T::Sig
+      include ::CSVPlusPlus::Writer::Merger
 
       RubyXLCell = ::T.type_alias { ::T.all(::RubyXL::Cell, ::RubyXL::CellConvenienceMethods) }
       public_constant :RubyXLCell
 
-      sig { returns(::T.nilable(::String)) }
-      attr_reader :input_filename
+      RubyXLValue = ::T.type_alias { ::T.any(::String, ::Numeric, ::Date) }
+      public_constant :RubyXLValue
 
       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)
+          options: ::CSVPlusPlus::Options::FileOptions,
+          position: ::CSVPlusPlus::Runtime::Position,
+          rows: ::T::Array[::CSVPlusPlus::Row]
         ).void
       end
-      # @param input_filename [::String] The file to write to
+      # @param options [Options::FileOptions]
+      # @param position [Position] The current position
       # @param rows [Array<Row>] The rows to write
-      # @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)
+      def initialize(options:, position:, rows:)
+        @options = options
+        @position = position
         @rows = rows
-        @input_filename = input_filename
-        @runtime = runtime
-        @sheet_name = sheet_name
         @worksheet = ::T.let(open_worksheet, ::RubyXL::Worksheet)
+        @reader = ::T.let(::CSVPlusPlus::Reader::RubyXL.new(@options, @worksheet), ::CSVPlusPlus::Reader::RubyXL)
       end
 
       sig { returns(::RubyXL::Workbook) }
@@ -52,24 +51,12 @@ module CSVPlusPlus
       private
 
       sig { void }
-      # rubocop:disable Metrics/MethodLength
       def build_workbook!
-        @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)
-          )
+        @position.map_all_cells(@rows) do |cell|
+          build_cell(cell)
+          format_cell!(cell)
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       sig do
         params(
@@ -160,30 +147,68 @@ module CSVPlusPlus
         cell.change_contents(cell.value)
       end
 
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::T.nilable(::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLValue)) }
+      def value_to_rubyxl(cell)
+        return cell.value unless (ast = cell.ast)
+
+        case ast
+        when ::CSVPlusPlus::Entities::Number, ::CSVPlusPlus::Entities::Date
+          ast.value
+        else
+          ast.evaluate(@position)
+        end
+      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)
-          do_borders!(cell, modifier)
-          do_fill!(cell, modifier)
-          do_fonts!(cell, modifier)
-          do_formats!(cell, modifier)
-          do_number_formats!(cell, modifier)
+        params(
+          cell: ::CSVPlusPlus::Cell,
+          existing_value: ::T.nilable(::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLValue)
+        ).returns(::T.nilable(::CSVPlusPlus::Writer::RubyXLBuilder::RubyXLValue))
+      end
+      def merge_value(cell, existing_value)
+        merge_cell_value(existing_value:, new_value: value_to_rubyxl(cell), options: @options)
+      end
+
+      sig { params(cell: ::CSVPlusPlus::Cell).void }
+      def format_cell!(cell)
+        modifier = ::T.cast(cell.modifier, ::CSVPlusPlus::Modifier::RubyXLModifier)
+        @reader.value_at(cell).tap do |rubyxl_cell|
+          do_alignments!(rubyxl_cell, modifier)
+          do_borders!(rubyxl_cell, modifier)
+          do_fill!(rubyxl_cell, modifier)
+          do_fonts!(rubyxl_cell, modifier)
+          do_formats!(rubyxl_cell, modifier)
+          do_number_formats!(rubyxl_cell, modifier)
         end
       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)
+        if ::File.exist?(@options.output_filename)
+          workbook = ::RubyXL::Parser.parse(@options.output_filename)
+          workbook[@options.sheet_name] || workbook.add_worksheet(@options.sheet_name)
         else
           workbook = ::RubyXL::Workbook.new
-          workbook.worksheets[0].tap { |w| w.sheet_name = @sheet_name }
+          workbook.worksheets[0].tap { |w| w.sheet_name = @options.sheet_name }
         end
       end
+
+      sig { params(cell: ::CSVPlusPlus::Cell).void }
+      # rubocop:disable Metrics/MethodLength
+      def build_cell(cell)
+        if (existing_cell = @reader.value_at(cell))
+          merged_value = merge_value(cell, existing_cell.value)
+          existing_cell.change_contents(
+            cell.ast ? '' : merged_value,
+            cell.ast ? merged_value : nil
+          )
+        elsif (ast = cell.ast)
+          @worksheet.add_cell(cell.row_index, cell.index, '', ast.evaluate(@position))
+        else
+          @worksheet.add_cell(cell.row_index, cell.index, cell.value)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
     end
     # rubocop:enable Metrics/ClassLength
   end

data/lib/csv_plus_plus/writer/writer.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    # Some shared functionality that all Writers should build on
+    #
+    # @attr_reader position [Position] The current position - needed to resolve variables and display useful error
+    #   messages
+    class Writer
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      abstract!
+
+      sig { returns(::CSVPlusPlus::Runtime::Position) }
+      attr_reader :position
+
+      protected
+
+      sig do
+        params(position: ::CSVPlusPlus::Runtime::Position).void
+      end
+      # Open a CSV outputter to the +output_filename+ specified by the +Options+
+      #
+      # @param position [Position] The current position.
+      def initialize(position)
+        @position = position
+      end
+
+      sig { abstract.params(template: ::CSVPlusPlus::Template).void }
+      # Write the given +template+.
+      #
+      # @param template [Template]
+      def write(template); end
+
+      sig { abstract.void }
+      # Write a backup of the current spreadsheet.
+      def write_backup; end
+    end
+  end
+end