csvops 0.4.0.alpha → 0.5.0.alpha

data/lib/csvtool/application/use_cases/run_extraction.rb

@@ -1,64 +1,47 @@
 # frozen_string_literal: true
 
 require "csv"
-require "csvtool/interface/cli/errors/presenter"
-require "csvtool/interface/cli/prompts/file_path_prompt"
-require "csvtool/interface/cli/prompts/separator_prompt"
-require "csvtool/interface/cli/prompts/column_selector_prompt"
-require "csvtool/interface/cli/prompts/skip_blanks_prompt"
-require "csvtool/interface/cli/prompts/confirm_prompt"
-require "csvtool/interface/cli/prompts/output_destination_prompt"
 require "csvtool/infrastructure/csv/header_reader"
 require "csvtool/infrastructure/csv/value_streamer"
-require "csvtool/services/preview_builder"
-require "csvtool/infrastructure/output/console_writer"
 require "csvtool/infrastructure/output/csv_file_writer"
-require "csvtool/domain/column_session/separator"
-require "csvtool/domain/column_session/csv_source"
-require "csvtool/domain/column_session/column_selection"
-require "csvtool/domain/column_session/extraction_options"
-require "csvtool/domain/column_session/extraction_value"
-require "csvtool/domain/column_session/preview"
-require "csvtool/domain/column_session/column_session"
-require "csvtool/domain/shared/output_destination"
+require "csvtool/services/preview_builder"
 
 module Csvtool
   module Application
     module UseCases
       class RunExtraction
-        def initialize(stdin:, stdout:)
-          @stdin = stdin
-          @stdout = stdout
-          @errors = Interface::CLI::Errors::Presenter.new(stdout: stdout)
-          @header_reader = Infrastructure::CSV::HeaderReader.new
-          @value_streamer = Infrastructure::CSV::ValueStreamer.new
-          @preview_builder = Services::PreviewBuilder.new(value_streamer: @value_streamer)
+        Result = Struct.new(:ok, :error, :data, keyword_init: true) do
+          def ok?
+            ok
+          end
         end
 
-        def call
-          file_path = Interface::CLI::Prompts::FilePathPrompt.new(stdin: @stdin, stdout: @stdout).call
-          return @errors.file_not_found(file_path) unless File.file?(file_path)
-
-          col_sep = Interface::CLI::Prompts::SeparatorPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call
-          return if col_sep.nil?
-          separator = Domain::ColumnSession::Separator.new(col_sep)
+        def initialize(
+          header_reader: Infrastructure::CSV::HeaderReader.new,
+          value_streamer: Infrastructure::CSV::ValueStreamer.new,
+          preview_builder: nil,
+          csv_file_writer: nil
+        )
+          @header_reader = header_reader
+          @value_streamer = value_streamer
+          @preview_builder = preview_builder || Services::PreviewBuilder.new(value_streamer: value_streamer)
+          @csv_file_writer = csv_file_writer || Infrastructure::Output::CsvFileWriter.new(value_streamer: @value_streamer)
+        end
 
-          source = Domain::ColumnSession::CsvSource.new(path: file_path, separator: separator)
-          headers = @header_reader.call(file_path: source.path, col_sep: source.separator.value)
-          return @errors.no_headers if headers.empty?
+        def read_headers(file_path:, col_sep:)
+          return failure(:file_not_found, path: file_path) unless File.file?(file_path)
 
-          column_name = Interface::CLI::Prompts::ColumnSelectorPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call(headers)
-          return if column_name.nil?
-          column_selection = Domain::ColumnSession::ColumnSelection.new(name: column_name)
+          headers = @header_reader.call(file_path: file_path, col_sep: col_sep)
+          return failure(:no_headers) if headers.empty?
 
-          skip_blanks = Interface::CLI::Prompts::SkipBlanksPrompt.new(stdin: @stdin, stdout: @stdout).call
-          options = Domain::ColumnSession::ExtractionOptions.new(skip_blanks: skip_blanks, preview_limit: 10)
-          session = Domain::ColumnSession::ColumnSession.start(
-            source: source,
-            column_selection: column_selection,
-            options: options
-          )
+          success(headers: headers)
+        rescue CSV::MalformedCSVError
+          failure(:could_not_parse_csv)
+        rescue Errno::EACCES
+          failure(:cannot_read_file, path: file_path)
+        end
 
+        def preview(session:)
           preview_values = @preview_builder.call(
             file_path: session.source.path,
             column_name: session.column_selection.name,
@@ -66,58 +49,50 @@ module Csvtool
             skip_blanks: session.options.skip_blanks?,
             limit: session.options.preview_limit
           )
-          preview = Domain::ColumnSession::Preview.new(
-            values: preview_values.map { |value| Domain::ColumnSession::ExtractionValue.new(value) }
-          )
-          session = session.with_preview(preview)
-
-          confirmed = Interface::CLI::Prompts::ConfirmPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call(session.preview.to_strings)
-          return unless confirmed
-          session = session.confirm!
-
-          output_destination = Interface::CLI::Prompts::OutputDestinationPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call
-          return if output_destination.nil?
-          domain_destination =
-            if output_destination[:mode] == :file
-              Domain::Shared::OutputDestination.file(path: output_destination[:path])
-            else
-              Domain::Shared::OutputDestination.console
-            end
-          session = session.with_output_destination(domain_destination)
-
-          write_output(
-            session.output_destination,
-            file_path: session.source.path,
-            column_name: session.column_selection.name,
-            col_sep: session.source.separator.value,
-            skip_blanks: session.options.skip_blanks?
-          )
+          success(preview_values: preview_values)
         rescue CSV::MalformedCSVError
-          @errors.could_not_parse_csv
+          failure(:could_not_parse_csv)
         rescue Errno::EACCES
-          @errors.cannot_read_file(file_path)
+          failure(:cannot_read_file, path: session.source.path)
         end
 
-        private
-
-        def writer_for(output_destination)
-          if output_destination.file?
-            Infrastructure::Output::CsvFileWriter.new(stdout: @stdout, errors: @errors, value_streamer: @value_streamer)
+        def extract(session:, on_value: nil)
+          if session.output_destination.file?
+            @csv_file_writer.call(
+              output_path: session.output_destination.path,
+              file_path: session.source.path,
+              column_name: session.column_selection.name,
+              col_sep: session.source.separator.value,
+              skip_blanks: session.options.skip_blanks?
+            )
+            success(output_path: session.output_destination.path)
           else
-            Infrastructure::Output::ConsoleWriter.new(stdout: @stdout, value_streamer: @value_streamer)
+            @value_streamer.each(
+              file_path: session.source.path,
+              column_name: session.column_selection.name,
+              col_sep: session.source.separator.value,
+              skip_blanks: session.options.skip_blanks?
+            ) { |value| on_value.call(value) if on_value }
+            success({})
           end
+        rescue CSV::MalformedCSVError
+          failure(:could_not_parse_csv)
+        rescue Errno::EACCES, Errno::ENOENT => e
+          if session.output_destination.file?
+            failure(:cannot_write_output_file, path: session.output_destination.path, error_class: e.class)
+          else
+            failure(:cannot_read_file, path: session.source.path)
+          end
+        end
+
+        private
+
+        def success(data)
+          Result.new(ok: true, error: nil, data: data)
         end
 
-        def write_output(output_destination, file_path:, column_name:, col_sep:, skip_blanks:)
-          writer = writer_for(output_destination)
-          args = {
-            file_path: file_path,
-            column_name: column_name,
-            col_sep: col_sep,
-            skip_blanks: skip_blanks
-          }
-          args[:output_path] = output_destination.path if output_destination.file?
-          writer.call(**args)
+        def failure(code, data = {})
+          Result.new(ok: false, error: code, data: data)
         end
       end
     end

data/lib/csvtool/application/use_cases/run_row_extraction.rb

@@ -1,74 +1,46 @@
 # frozen_string_literal: true
 
 require "csv"
-require "csvtool/interface/cli/errors/presenter"
-require "csvtool/interface/cli/prompts/file_path_prompt"
-require "csvtool/interface/cli/prompts/separator_prompt"
-require "csvtool/interface/cli/prompts/output_destination_prompt"
 require "csvtool/infrastructure/csv/header_reader"
 require "csvtool/infrastructure/csv/row_streamer"
-require "csvtool/infrastructure/output/csv_row_console_writer"
 require "csvtool/infrastructure/output/csv_row_file_writer"
-require "csvtool/domain/row_session/row_range"
-require "csvtool/domain/row_session/row_source"
-require "csvtool/domain/row_session/row_session"
-require "csvtool/domain/shared/output_destination"
 
 module Csvtool
   module Application
     module UseCases
       class RunRowExtraction
-        def initialize(stdin:, stdout:)
-          @stdin = stdin
-          @stdout = stdout
-          @errors = Interface::CLI::Errors::Presenter.new(stdout: stdout)
-          @header_reader = Infrastructure::CSV::HeaderReader.new
-          @row_streamer = Infrastructure::CSV::RowStreamer.new
+        Result = Struct.new(:ok, :error, :data, keyword_init: true) do
+          def ok?
+            ok
+          end
         end
 
-        def call
-          file_path = Interface::CLI::Prompts::FilePathPrompt.new(stdin: @stdin, stdout: @stdout).call
-          return @errors.file_not_found(file_path) unless File.file?(file_path)
-
-          col_sep = Interface::CLI::Prompts::SeparatorPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call
-          return if col_sep.nil?
-          source = Domain::RowSession::RowSource.new(path: file_path, separator: col_sep)
-
-          @stdout.print "Start row (1-based, inclusive): "
-          start_row_input = @stdin.gets&.strip.to_s
-          @stdout.print "End row (1-based, inclusive): "
-          end_row_input = @stdin.gets&.strip.to_s
+        def initialize(
+          header_reader: Infrastructure::CSV::HeaderReader.new,
+          row_streamer: Infrastructure::CSV::RowStreamer.new,
+          csv_row_file_writer: nil
+        )
+          @header_reader = header_reader
+          @row_streamer = row_streamer
+          @csv_row_file_writer = csv_row_file_writer || Infrastructure::Output::CsvRowFileWriter.new(row_streamer: @row_streamer)
+        end
 
-          headers = @header_reader.call(file_path: source.path, col_sep: source.separator)
-          return @errors.no_headers if headers.empty?
+        def read_headers(file_path:, col_sep:)
+          return failure(:file_not_found, path: file_path) unless File.file?(file_path)
 
-          row_range = Domain::RowSession::RowRange.from_inputs(
-            start_row_input: start_row_input,
-            end_row_input: end_row_input
-          )
-          session = Domain::RowSession::RowSession.start(source: source, row_range: row_range)
+          headers = @header_reader.call(file_path: file_path, col_sep: col_sep)
+          return failure(:no_headers) if headers.empty?
 
-          output_destination = Interface::CLI::Prompts::OutputDestinationPrompt.new(
-            stdin: @stdin,
-            stdout: @stdout,
-            errors: @errors
-          ).call
-          return if output_destination.nil?
-          destination =
-            if output_destination[:mode] == :file
-              Domain::Shared::OutputDestination.file(path: output_destination[:path])
-            else
-              Domain::Shared::OutputDestination.console
-            end
-          session = session.with_output_destination(destination)
+          success(headers: headers)
+        rescue CSV::MalformedCSVError
+          failure(:could_not_parse_csv)
+        rescue Errno::EACCES
+          failure(:cannot_read_file, path: file_path)
+        end
 
-          stats =
+        def extract(session:, headers:, on_row: nil)
           if session.output_destination.file?
-            Infrastructure::Output::CsvRowFileWriter.new(
-              stdout: @stdout,
-              errors: @errors,
-              row_streamer: @row_streamer
-            ).call(
+            stats = @csv_row_file_writer.call(
               output_path: session.output_destination.path,
               file_path: session.source.path,
               col_sep: session.source.separator,
@@ -76,35 +48,35 @@ module Csvtool
               start_row: session.row_range.start_row,
               end_row: session.row_range.end_row
             )
+            success(stats.merge(output_path: session.output_destination.path))
           else
-            Infrastructure::Output::CsvRowConsoleWriter.new(stdout: @stdout, row_streamer: @row_streamer).call(
+            stats = @row_streamer.each_in_range(
               file_path: session.source.path,
               col_sep: session.source.separator,
-              headers: headers,
               start_row: session.row_range.start_row,
               end_row: session.row_range.end_row
-            )
+            ) { |fields| on_row.call(fields) if on_row }
+            success(stats)
           end
-          return if stats.nil?
-
-          @errors.row_range_out_of_bounds(stats[:row_count]) unless stats[:matched]
-        rescue Domain::RowSession::InvalidStartRowError
-          @errors.invalid_start_row
-        rescue Domain::RowSession::InvalidEndRowError
-          @errors.invalid_end_row
-        rescue Domain::RowSession::InvalidRowRangeOrderError
-          @errors.invalid_row_range_order
-        rescue ArgumentError => e
-          return @errors.empty_output_path if e.message == "file output path cannot be empty"
-
-          raise e
         rescue CSV::MalformedCSVError
-          @errors.could_not_parse_csv
-        rescue Errno::EACCES
-          @errors.cannot_read_file(file_path)
+          failure(:could_not_parse_csv)
+        rescue Errno::EACCES, Errno::ENOENT => e
+          if session.output_destination.file?
+            failure(:cannot_write_output_file, path: session.output_destination.path, error_class: e.class)
+          else
+            failure(:cannot_read_file, path: session.source.path)
+          end
         end
-        
+
         private
+
+        def success(data)
+          Result.new(ok: true, error: nil, data: data)
+        end
+
+        def failure(code, data = {})
+          Result.new(ok: false, error: code, data: data)
+        end
       end
     end
   end

data/lib/csvtool/application/use_cases/run_row_randomization.rb

@@ -1,103 +1,86 @@
 # frozen_string_literal: true
 
 require "csv"
-require "csvtool/interface/cli/errors/presenter"
-require "csvtool/interface/cli/prompts/file_path_prompt"
-require "csvtool/interface/cli/prompts/separator_prompt"
-require "csvtool/interface/cli/prompts/headers_present_prompt"
-require "csvtool/interface/cli/prompts/seed_prompt"
-require "csvtool/interface/cli/prompts/output_destination_prompt"
 require "csvtool/infrastructure/csv/header_reader"
 require "csvtool/infrastructure/csv/row_randomizer"
-require "csvtool/domain/row_randomization_session/randomization_source"
-require "csvtool/domain/row_randomization_session/randomization_options"
-require "csvtool/domain/row_randomization_session/randomization_session"
-require "csvtool/domain/shared/output_destination"
+require "csvtool/infrastructure/output/csv_randomized_row_file_writer"
 
 module Csvtool
   module Application
     module UseCases
       class RunRowRandomization
-        def initialize(stdin:, stdout:)
-          @stdin = stdin
-          @stdout = stdout
-          @errors = Interface::CLI::Errors::Presenter.new(stdout: stdout)
-          @header_reader = Infrastructure::CSV::HeaderReader.new
-          @row_randomizer = Infrastructure::CSV::RowRandomizer.new
+        Result = Struct.new(:ok, :error, :data, keyword_init: true) do
+          def ok?
+            ok
+          end
         end
 
-        def call
-          file_path = Interface::CLI::Prompts::FilePathPrompt.new(stdin: @stdin, stdout: @stdout).call
-          return @errors.file_not_found(file_path) unless File.file?(file_path)
-
-          col_sep = Interface::CLI::Prompts::SeparatorPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call
-          return if col_sep.nil?
-
-          headers_present = Interface::CLI::Prompts::HeadersPresentPrompt.new(stdin: @stdin, stdout: @stdout).call
-          source = Domain::RowRandomizationSession::RandomizationSource.new(
-            path: file_path,
-            separator: col_sep,
-            headers_present: headers_present
+        def initialize(
+          header_reader: Infrastructure::CSV::HeaderReader.new,
+          row_randomizer: Infrastructure::CSV::RowRandomizer.new,
+          csv_randomized_row_file_writer: nil
+        )
+          @header_reader = header_reader
+          @row_randomizer = row_randomizer
+          @csv_randomized_row_file_writer = csv_randomized_row_file_writer || Infrastructure::Output::CsvRandomizedRowFileWriter.new(
+            row_randomizer: @row_randomizer
           )
-          headers = source.headers_present? ? @header_reader.call(file_path: source.path, col_sep: source.separator) : nil
-          return @errors.no_headers if source.headers_present? && headers.empty?
+        end
 
-          seed = Interface::CLI::Prompts::SeedPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors).call
-          return if seed == Interface::CLI::Prompts::SeedPrompt::INVALID
-          options = Domain::RowRandomizationSession::RandomizationOptions.new(seed: seed)
-          session = Domain::RowRandomizationSession::RandomizationSession.start(source: source, options: options)
+        def read_headers(file_path:, col_sep:, headers_present:)
+          return failure(:file_not_found, path: file_path) unless File.file?(file_path)
 
-          output_destination = Interface::CLI::Prompts::OutputDestinationPrompt.new(
-            stdin: @stdin,
-            stdout: @stdout,
-            errors: @errors
-          ).call
-          return if output_destination.nil?
-          destination =
-            if output_destination[:mode] == :file
-              Domain::Shared::OutputDestination.file(path: output_destination[:path])
-            else
-              Domain::Shared::OutputDestination.console
-            end
-          session = session.with_output_destination(destination)
+          headers = nil
+          if headers_present
+            headers = @header_reader.call(file_path: file_path, col_sep: col_sep)
+            return failure(:no_headers) if headers.empty?
+          end
 
-          randomized_rows = @row_randomizer.each(
-            file_path: session.source.path,
-            col_sep: session.source.separator,
-            headers: session.source.headers_present?,
-            seed: session.options.seed
-          )
+          success(headers: headers)
+        rescue CSV::MalformedCSVError
+          failure(:could_not_parse_csv)
+        rescue Errno::EACCES
+          failure(:cannot_read_file, path: file_path)
+        end
 
+        def randomize(session:, headers:, on_row: nil)
           if session.output_destination.file?
-            write_output_file(session.output_destination.path, headers, randomized_rows, col_sep: session.source.separator)
+            @csv_randomized_row_file_writer.call(
+              path: session.output_destination.path,
+              headers: headers,
+              file_path: session.source.path,
+              col_sep: session.source.separator,
+              headers_present: session.source.headers_present?,
+              seed: session.options.seed
+            )
+            success(output_path: session.output_destination.path)
           else
-            print_to_console(headers, randomized_rows, col_sep: session.source.separator)
+            @row_randomizer.each(
+              file_path: session.source.path,
+              col_sep: session.source.separator,
+              headers: session.source.headers_present?,
+              seed: session.options.seed
+            ) { |fields| on_row.call(fields) if on_row }
+            success({})
           end
         rescue CSV::MalformedCSVError
-          @errors.could_not_parse_csv
-        rescue ArgumentError => e
-          return @errors.empty_output_path if e.message == "file output path cannot be empty"
-
-          raise e
-        rescue Errno::EACCES
-          @errors.cannot_read_file(file_path)
+          failure(:could_not_parse_csv)
+        rescue Errno::EACCES, Errno::ENOENT => e
+          if session.output_destination.file?
+            failure(:cannot_write_output_file, path: session.output_destination.path, error_class: e.class)
+          else
+            failure(:cannot_read_file, path: session.source.path)
+          end
         end
 
         private
 
-        def print_to_console(headers, rows, col_sep:)
-          @stdout.puts
-          @stdout.puts ::CSV.generate_line(headers, row_sep: "", col_sep: col_sep).chomp if headers
-          rows.each { |fields| @stdout.puts ::CSV.generate_line(fields, row_sep: "", col_sep: col_sep).chomp }
+        def success(data)
+          Result.new(ok: true, error: nil, data: data)
         end
 
-        def write_output_file(path, headers, rows, col_sep:)
-          ::CSV.open(path, "w", write_headers: !headers.nil?, headers: headers, col_sep: col_sep) do |csv|
-            rows.each { |fields| csv << fields }
-          end
-          @stdout.puts "Wrote output to #{path}"
-        rescue Errno::EACCES, Errno::ENOENT => e
-          @errors.cannot_write_output_file(path, e.class)
+        def failure(code, data = {})
+          Result.new(ok: false, error: code, data: data)
         end
       end
     end

data/lib/csvtool/cli.rb

@@ -2,9 +2,9 @@
 
 require "csv"
 require "csvtool/interface/cli/menu_loop"
-require "csvtool/application/use_cases/run_extraction"
-require "csvtool/application/use_cases/run_row_extraction"
-require "csvtool/application/use_cases/run_row_randomization"
+require "csvtool/interface/cli/workflows/run_extraction_workflow"
+require "csvtool/interface/cli/workflows/run_row_extraction_workflow"
+require "csvtool/interface/cli/workflows/run_row_randomization_workflow"
 require "csvtool/interface/cli/workflows/run_cross_csv_dedupe_workflow"
 require "csvtool/interface/cli/errors/presenter"
 require "csvtool/infrastructure/csv/header_reader"
@@ -47,9 +47,9 @@ module Csvtool
     private
 
     def run_menu_loop
-      extract_column_action = -> { Application::UseCases::RunExtraction.new(stdin: @stdin, stdout: @stdout).call }
-      extract_rows_action = -> { Application::UseCases::RunRowExtraction.new(stdin: @stdin, stdout: @stdout).call }
-      randomize_rows_action = -> { Application::UseCases::RunRowRandomization.new(stdin: @stdin, stdout: @stdout).call }
+      extract_column_action = -> { Interface::CLI::Workflows::RunExtractionWorkflow.new(stdin: @stdin, stdout: @stdout).call }
+      extract_rows_action = -> { Interface::CLI::Workflows::RunRowExtractionWorkflow.new(stdin: @stdin, stdout: @stdout).call }
+      randomize_rows_action = -> { Interface::CLI::Workflows::RunRowRandomizationWorkflow.new(stdin: @stdin, stdout: @stdout).call }
       dedupe_action = -> { Interface::CLI::Workflows::RunCrossCsvDedupeWorkflow.new(stdin: @stdin, stdout: @stdout).call }
       Interface::CLI::MenuLoop.new(
         stdin: @stdin,

data/lib/csvtool/infrastructure/output/csv_cross_csv_dedupe_file_writer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Csvtool
+  module Infrastructure
+    module Output
+      class CsvCrossCsvDedupeFileWriter
+        def initialize(deduper:)
+          @deduper = deduper
+        end
+
+        def call(path:, headers:, col_sep:, dedupe_options:)
+          stats = nil
+          ::CSV.open(path, "w", write_headers: !headers.nil?, headers: headers, col_sep: col_sep) do |csv|
+            stats = @deduper.each_retained(**dedupe_options) { |fields| csv << fields }
+          end
+          stats
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/infrastructure/output/csv_file_writer.rb

@@ -6,9 +6,7 @@ module Csvtool
   module Infrastructure
     module Output
       class CsvFileWriter
-        def initialize(stdout:, errors:, value_streamer:)
-          @stdout = stdout
-          @errors = errors
+        def initialize(value_streamer:)
           @value_streamer = value_streamer
         end
 
@@ -19,10 +17,6 @@ module Csvtool
               csv << [value]
             end
           end
-
-          @stdout.puts "Wrote output to #{output_path}"
-        rescue Errno::EACCES, Errno::ENOENT => e
-          @errors.cannot_write_output_file(output_path, e.class)
         end
       end
     end

data/lib/csvtool/infrastructure/output/csv_randomized_row_file_writer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Csvtool
+  module Infrastructure
+    module Output
+      class CsvRandomizedRowFileWriter
+        def initialize(row_randomizer:)
+          @row_randomizer = row_randomizer
+        end
+
+        def call(path:, headers:, file_path:, col_sep:, headers_present:, seed:)
+          ::CSV.open(path, "w", write_headers: !headers.nil?, headers: headers, col_sep: col_sep) do |csv|
+            @row_randomizer.each(file_path: file_path, col_sep: col_sep, headers: headers_present, seed: seed) do |fields|
+              csv << fields
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/infrastructure/output/csv_row_file_writer.rb

@@ -6,9 +6,7 @@ module Csvtool
   module Infrastructure
     module Output
       class CsvRowFileWriter
-        def initialize(stdout:, errors:, row_streamer:)
-          @stdout = stdout
-          @errors = errors
+        def initialize(row_streamer:)
           @row_streamer = row_streamer
         end
 
@@ -30,12 +28,7 @@ module Csvtool
             csv << fields
           end
 
-          csv&.close
-          @stdout.puts "Wrote output to #{output_path}" if wrote_rows
-          stats
-        rescue Errno::EACCES, Errno::ENOENT => e
-          @errors.cannot_write_output_file(output_path, e.class)
-          nil
+          stats.merge(wrote_rows: wrote_rows)
         ensure
           csv&.close unless csv&.closed?
         end

data/lib/csvtool/interface/cli/prompts/dedupe_key_selector_prompt.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "csvtool/domain/cross_csv_dedupe_session/column_selector"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Prompts
+        class DedupeKeySelectorPrompt
+          def initialize(stdin:, stdout:)
+            @stdin = stdin
+            @stdout = stdout
+          end
+
+          def call(label:, headers_present:)
+            if headers_present
+              @stdout.print "#{label} key column name: "
+            else
+              @stdout.print "#{label} key column index (1-based): "
+            end
+            input = @stdin.gets&.strip.to_s
+            Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: headers_present, input: input)
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+    end
+  end
+end