csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/writer/google_sheets_builder.rb

@@ -0,0 +1,179 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    # Given +rows+ from a +Template+, build requests compatible with Google Sheets Ruby API
+    # rubocop:disable Metrics/ClassLength
+    class GoogleSheetsBuilder
+      extend ::T::Sig
+      include ::CSVPlusPlus::Writer::Merger
+
+      sig do
+        params(
+          options: ::CSVPlusPlus::Options::GoogleSheetsOptions,
+          position: ::CSVPlusPlus::Runtime::Position,
+          reader: ::CSVPlusPlus::Reader::GoogleSheets,
+          rows: ::T::Array[::CSVPlusPlus::Row]
+        ).void
+      end
+      # @param options [Options]
+      # @param position [Position] The current position.
+      # @param reader [::CSVPlusPlus::Reader::GoogleSheets]
+      # @param rows [Array<Row>] The rows to render
+      def initialize(options:, position:, reader:, rows:)
+        @options = options
+        @position = position
+        @reader = reader
+        @rows = rows
+      end
+
+      sig { returns(::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest) }
+      # Build a Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest
+      #
+      # @return [Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest]
+      def batch_update_spreadsheet_request
+        build_batch_request(@rows)
+      end
+
+      private
+
+      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)
+        ::Google::Apis::SheetsV4::CellFormat.new.tap do |cf|
+          cf.text_format = mod.text_format
+
+          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)
+        ::Google::Apis::SheetsV4::GridRange.new(
+          start_column_index: cell.index,
+          end_column_index: cell.index + 1,
+          start_row_index: cell.row_index,
+          end_row_index: cell.row_index + 1
+        )
+      end
+
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::ExtendedValue) }
+      def build_cell_value(cell)
+        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) }
+      def build_cell_data(cell)
+        mod = cell.modifier
+
+        ::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
+
+          # 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)
+        ::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)
+        ::Google::Apis::SheetsV4::UpdateCellsRequest.new(
+          fields: '*',
+          start: ::Google::Apis::SheetsV4::GridCoordinate.new(
+            column_index: @options.offset[1],
+            row_index: @options.offset[0]
+          ),
+          rows:
+        )
+      end
+
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::Google::Apis::SheetsV4::UpdateBordersRequest) }
+      def build_border(cell)
+        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)
+        ::Google::Apis::SheetsV4::Request.new(update_borders: build_border(cell))
+      end
+
+      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|
+          @position.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)
+        ::Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest.new.tap do |bu|
+          bu.requests = chunked_requests(rows)
+
+          @position.map_rows(rows) do |row|
+            row.cells.filter { |c| c.modifier.any_border? }
+               .each do |cell|
+                 bu.requests << build_update_borders_request(cell)
+               end
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/csv_plus_plus/writer/merger.rb

@@ -0,0 +1,31 @@
+# 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
+      # Our strategy for resolving differences between new changes and existing
+      def merge_cell_value(existing_value:, new_value:, options:)
+        # TODO: make an option that specifies if we override (take new data over old)
+        merged_value = new_value || existing_value
+
+        return merged_value if !options.verbose || merged_value == existing_value
+
+        warn("Overwriting existing value: \"#{existing_value}\" with \"#{new_value}\"")
+        merged_value
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/writer/open_document.rb

@@ -1,14 +1,33 @@
+# 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
+    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

@@ -1,50 +1,80 @@
+# 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 output_filename [Pathname, nil] 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
+      include ::CSVPlusPlus::Writer::Merger
+
+      RubyXLCell = ::T.type_alias { ::T.all(::RubyXL::Cell, ::RubyXL::CellConvenienceMethods) }
+      public_constant :RubyXLCell
+
+      RubyXLValue = ::T.type_alias { ::T.any(::String, ::Numeric, ::Date) }
+      public_constant :RubyXLValue
+
+      sig { returns(::T::Array[::CSVPlusPlus::Row]) }
+      attr_reader :rows
 
-      # @param input_filename [String] The file to write to
+      sig do
+        params(
+          options: ::CSVPlusPlus::Options::FileOptions,
+          position: ::CSVPlusPlus::Runtime::Position,
+          rows: ::T::Array[::CSVPlusPlus::Row]
+        ).void
+      end
+      # @param options [Options::FileOptions]
+      # @param position [Position] The current position
       # @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:)
+      def initialize(options:, position:, rows:)
+        @options = options
+        @position = position
         @rows = rows
-        @input_filename = input_filename
-        @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) }
       # Build a +RubyXL::Workbook+ with the given +@rows+ in +sheet_name+
       #
       # @return [RubyXL::Workbook]
       def build_workbook
-        open_workbook.tap { build_workbook! }
+        build_workbook!
+        @worksheet.workbook
       end
 
       private
 
+      sig { void }
       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)
-          end
+        @position.map_all_cells(@rows) do |cell|
+          build_cell(cell)
+          format_cell!(cell)
         end
       end
 
+      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?
@@ -59,29 +89,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
 
@@ -90,28 +147,69 @@ module CSVPlusPlus
         cell.change_contents(cell.value)
       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)
+      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
 
-      def open_workbook
-        if ::File.exist?(@input_filename)
-          ::RubyXL::Parser.parse(@input_filename).tap do |workbook|
-            @worksheet = workbook[@sheet_name] || workbook.add_worksheet(@sheet_name)
-          end
+      sig do
+        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 ::File.exist?(@options.output_filename)
+          workbook = ::RubyXL::Parser.parse(@options.output_filename)
+          workbook[@options.sheet_name] || workbook.add_worksheet(@options.sheet_name)
         else
-          ::RubyXL::Workbook.new.tap do |workbook|
-            @worksheet = workbook.worksheets[0].tap { |w| w.sheet_name = @sheet_name }
-          end
+          workbook = ::RubyXL::Workbook.new
+          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
 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

data/lib/csv_plus_plus/writer.rb

@@ -1,24 +1,93 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './writer/base_writer'
+require_relative './writer/merger'
+require_relative './writer/writer'
+
 require_relative './writer/csv'
 require_relative './writer/excel'
 require_relative './writer/google_sheets'
+require_relative './writer/google_sheets_builder'
 require_relative './writer/open_document'
+require_relative './writer/rubyxl_builder'
 
 module CSVPlusPlus
-  # Various strategies for writing to various formats (excel, google sheets, CSV, OpenDocument)
+  # Various strategies for writing to various formats (excel, google sheets, CSV & OpenDocument (not yet implemented))
   module Writer
+    extend ::T::Sig
+
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        position: ::CSVPlusPlus::Runtime::Position
+      ).returns(
+        ::T.any(
+          ::CSVPlusPlus::Writer::CSV,
+          ::CSVPlusPlus::Writer::Excel,
+          ::CSVPlusPlus::Writer::GoogleSheets,
+          ::CSVPlusPlus::Writer::OpenDocument
+        )
+      )
+    end
     # Return an instance of a writer depending on the given +options+
-    def self.writer(options)
-      return ::CSVPlusPlus::Writer::GoogleSheets.new(options) if options.google
-
-      case options.output_filename
-      when /\.csv$/ then ::CSVPlusPlus::Writer::CSV.new(options)
-      when /\.ods$/ then ::CSVPlusPlus::Writer::OpenDocument.new(options)
-      when /\.xl(sx|sm|tx|tm)$/ then ::CSVPlusPlus::Writer::Excel.new(options)
-      else raise(::CSVPlusPlus::Error, "Unsupported file extension: #{options.output_filename}")
+    #
+    # @param options [Options] The supplied options.
+    # @param position [Position] The current position.
+    #
+    # @return [Writer::CSV | Writer::Excel | Writer::GoogleSheets | Writer::OpenDocument]
+    def self.writer(options, position)
+      output_format = options.output_format
+      case output_format
+      when ::CSVPlusPlus::Options::OutputFormat::CSV then csv(options, position)
+      when ::CSVPlusPlus::Options::OutputFormat::Excel then excel(options, position)
+      when ::CSVPlusPlus::Options::OutputFormat::GoogleSheets then google_sheets(options, position)
+      when ::CSVPlusPlus::Options::OutputFormat::OpenDocument then open_document(options, position)
+      else ::T.absurd(output_format)
       end
     end
+
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        position: ::CSVPlusPlus::Runtime::Position
+      ).returns(::CSVPlusPlus::Writer::CSV)
+    end
+    # Instantiate a +CSV+ writer
+    def self.csv(options, position)
+      ::CSVPlusPlus::Writer::CSV.new(::T.cast(options, ::CSVPlusPlus::Options::FileOptions), position)
+    end
+
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        position: ::CSVPlusPlus::Runtime::Position
+      ).returns(::CSVPlusPlus::Writer::Excel)
+    end
+    # Instantiate a +Excel+ writer
+    def self.excel(options, position)
+      ::CSVPlusPlus::Writer::Excel.new(::T.cast(options, ::CSVPlusPlus::Options::FileOptions), position)
+    end
+
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        position: ::CSVPlusPlus::Runtime::Position
+      ).returns(::CSVPlusPlus::Writer::GoogleSheets)
+    end
+    # Instantiate a +GoogleSheets+ writer
+    def self.google_sheets(options, position)
+      ::CSVPlusPlus::Writer::GoogleSheets.new(::T.cast(options, ::CSVPlusPlus::Options::GoogleSheetsOptions), position)
+    end
+
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        position: ::CSVPlusPlus::Runtime::Position
+      ).returns(::CSVPlusPlus::Writer::OpenDocument)
+    end
+    # Instantiate an +OpenDocument+ writer
+    def self.open_document(options, position)
+      ::CSVPlusPlus::Writer::OpenDocument.new(::T.cast(options, ::CSVPlusPlus::Options::FileOptions), position)
+    end
   end
 end