csvops 0.4.0.alpha → 0.5.0.alpha

data/lib/csvtool/interface/cli/workflows/steps/row_randomization/collect_inputs_step.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module RowRandomization
+            class CollectInputsStep
+              def initialize(file_path_prompt:, separator_prompt:, headers_present_prompt:, seed_prompt:)
+                @file_path_prompt = file_path_prompt
+                @separator_prompt = separator_prompt
+                @headers_present_prompt = headers_present_prompt
+                @seed_prompt = seed_prompt
+              end
+
+              def call(context)
+                file_path = @file_path_prompt.call
+                col_sep = @separator_prompt.call
+                return :halt if col_sep.nil?
+
+                headers_present = @headers_present_prompt.call
+                header_result = context.fetch(:use_case).read_headers(
+                  file_path: file_path,
+                  col_sep: col_sep,
+                  headers_present: headers_present
+                )
+                unless header_result.ok?
+                  context.fetch(:handle_error).call(header_result)
+                  return :halt
+                end
+
+                seed = @seed_prompt.call
+                return :halt if seed == Interface::CLI::Prompts::SeedPrompt::INVALID
+
+                context[:file_path] = file_path
+                context[:col_sep] = col_sep
+                context[:headers_present] = headers_present
+                context[:headers] = header_result.data[:headers]
+                context[:seed] = seed
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/row_randomization/execute_step.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module RowRandomization
+            class ExecuteStep
+              def call(context)
+                session = context.fetch(:session)
+                presenter = context.fetch(:presenter_factory).call(
+                  headers: context.fetch(:headers),
+                  col_sep: session.source.separator
+                )
+
+                presenter.print_console_start unless session.output_destination.file?
+                result = context.fetch(:use_case).randomize(
+                  session: session,
+                  headers: context.fetch(:headers),
+                  on_row: ->(fields) { presenter.print_row(fields) }
+                )
+                unless result.ok?
+                  context.fetch(:handle_error).call(result)
+                  return :halt
+                end
+
+                presenter.print_file_written(result.data[:output_path]) if session.output_destination.file?
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/workflow_step_pipeline.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          class WorkflowStepPipeline
+            def initialize(steps:)
+              @steps = steps
+            end
+
+            def call(context)
+              @steps.each do |step|
+                return false if step.call(context) == :halt
+              end
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/support/output_destination_mapper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "csvtool/domain/shared/output_destination"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Support
+          class OutputDestinationMapper
+            def call(output_destination)
+              if output_destination[:mode] == :file
+                Domain::Shared::OutputDestination.file(path: output_destination[:path])
+              else
+                Domain::Shared::OutputDestination.console
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/support/result_error_handler.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Support
+          class ResultErrorHandler
+            def initialize(errors:)
+              @errors = errors
+            end
+
+            def call(result, mapping)
+              action = mapping[result.error]
+              action&.call(result, @errors)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Csvtool
-  VERSION = "0.4.0.alpha"
+  VERSION = "0.5.0.alpha"
 end

data/test/csvtool/application/use_cases/io_boundary_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+
+class UseCaseIoBoundaryTest < Minitest::Test
+  USE_CASE_GLOB = File.expand_path("../../../../lib/csvtool/application/use_cases/*.rb", __dir__)
+  FORBIDDEN_PATTERNS = [
+    /CSV\.open/,
+    /File\.open\([^)]*,\s*["']w/,
+    /File\.write\(/,
+    /IO\.write\(/
+  ].freeze
+
+  def test_use_cases_do_not_perform_direct_file_writes
+    violations = []
+
+    Dir.glob(USE_CASE_GLOB).sort.each do |file_path|
+      content = File.read(file_path)
+      FORBIDDEN_PATTERNS.each do |pattern|
+        violations << "#{file_path}: #{pattern.inspect}" if content.match?(pattern)
+      end
+    end
+
+    assert_equal [], violations, "Found forbidden direct write APIs in use cases:\n#{violations.join("\n")}"
+  end
+end

data/test/csvtool/application/use_cases/run_cross_csv_dedupe_test.rb

@@ -11,6 +11,12 @@ require "csvtool/domain/shared/output_destination"
 require "tmpdir"
 
 class RunCrossCsvDedupeTest < Minitest::Test
+  class RaisingWriter
+    def call(**_kwargs)
+      raise Errno::ENOENT
+    end
+  end
+
   def fixture_path(name)
     File.expand_path("../../../fixtures/#{name}", __dir__)
   end
@@ -78,6 +84,28 @@ class RunCrossCsvDedupeTest < Minitest::Test
     assert_equal :column_not_found, result.error
   end
 
+  def test_returns_cannot_write_output_file_when_writer_fails
+    use_case = Csvtool::Application::UseCases::RunCrossCsvDedupe.new(
+      csv_cross_csv_dedupe_file_writer: RaisingWriter.new
+    )
+    output_path = "/tmp/deduped.csv"
+
+    result = use_case.call(
+      session: build_session(
+        source_path: fixture_path("dedupe_source.csv"),
+        reference_path: fixture_path("dedupe_reference.csv"),
+        source_selector_input: "customer_id",
+        reference_selector_input: "external_id",
+        output_destination: Csvtool::Domain::Shared::OutputDestination.file(path: output_path)
+      )
+    )
+
+    refute result.ok?
+    assert_equal :cannot_write_output_file, result.error
+    assert_equal output_path, result.data[:path]
+    assert_equal Errno::ENOENT, result.data[:error_class]
+  end
+
   private
 
   def build_session(source_path:, reference_path:, source_selector_input:, reference_selector_input:, output_destination:)

data/test/csvtool/application/use_cases/run_extraction_test.rb

@@ -2,30 +2,86 @@
 
 require_relative "../../../test_helper"
 require "csvtool/application/use_cases/run_extraction"
+require "csvtool/domain/column_session/column_session"
+require "csvtool/domain/column_session/csv_source"
+require "csvtool/domain/column_session/separator"
+require "csvtool/domain/column_session/column_selection"
+require "csvtool/domain/column_session/extraction_options"
+require "csvtool/domain/shared/output_destination"
+require "tmpdir"
 
 class RunExtractionTest < Minitest::Test
-  def test_missing_file_path_reports_error
-    out = StringIO.new
-    use_case = Csvtool::Application::UseCases::RunExtraction.new(
-      stdin: StringIO.new("/tmp/not-present.csv\n"),
-      stdout: out
+  class RaisingWriter
+    def call(**_kwargs)
+      raise Errno::ENOENT
+    end
+  end
+
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_read_headers_missing_file_returns_failure
+    result = Csvtool::Application::UseCases::RunExtraction.new.read_headers(
+      file_path: "/tmp/not-present.csv",
+      col_sep: ","
+    )
+
+    assert_equal false, result.ok?
+    assert_equal :file_not_found, result.error
+  end
+
+  def test_preview_returns_expected_values
+    use_case = Csvtool::Application::UseCases::RunExtraction.new
+
+    result = use_case.preview(
+      session: build_session(output_destination: Csvtool::Domain::Shared::OutputDestination.console)
     )
 
-    use_case.call
+    assert_equal true, result.ok?
+    assert_equal %w[Alice Bob Cara], result.data[:preview_values]
+  end
+
+  def test_extract_writes_values_to_file
+    use_case = Csvtool::Application::UseCases::RunExtraction.new
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "names.csv")
+      result = use_case.extract(
+        session: build_session(output_destination: Csvtool::Domain::Shared::OutputDestination.file(path: output_path))
+      )
 
-    assert_includes out.string, "File not found: /tmp/not-present.csv"
+      assert_equal true, result.ok?
+      assert_equal output_path, result.data[:output_path]
+      assert_equal "name\nAlice\nBob\nCara\n", File.read(output_path)
+    end
   end
 
-  def test_use_case_can_run_console_happy_path
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
-    input = ["#{fixture}", "1", "", "1", "", "y", ""].join("\n") + "\n"
+  def test_extract_returns_cannot_write_output_file_when_writer_fails
+    use_case = Csvtool::Application::UseCases::RunExtraction.new(csv_file_writer: RaisingWriter.new)
+
+    result = use_case.extract(
+      session: build_session(output_destination: Csvtool::Domain::Shared::OutputDestination.file(path: "/tmp/names.csv"))
+    )
 
-    use_case = Csvtool::Application::UseCases::RunExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
+    assert_equal false, result.ok?
+    assert_equal :cannot_write_output_file, result.error
+    assert_equal "/tmp/names.csv", result.data[:path]
+    assert_equal Errno::ENOENT, result.data[:error_class]
+  end
+
+  private
+
+  def build_session(output_destination:)
+    session = Csvtool::Domain::ColumnSession::ColumnSession.start(
+      source: Csvtool::Domain::ColumnSession::CsvSource.new(
+        path: fixture_path("sample_people.csv"),
+        separator: Csvtool::Domain::ColumnSession::Separator.new(",")
+      ),
+      column_selection: Csvtool::Domain::ColumnSession::ColumnSelection.new(name: "name"),
+      options: Csvtool::Domain::ColumnSession::ExtractionOptions.new(skip_blanks: true, preview_limit: 10)
+    )
 
-    assert_includes out.string, "Alice"
-    assert_includes out.string, "Bob"
-    assert_includes out.string, "Cara"
+    session.with_output_destination(output_destination)
   end
 end

data/test/csvtool/application/use_cases/run_row_extraction_test.rb

@@ -2,139 +2,119 @@
 
 require_relative "../../../test_helper"
 require "csvtool/application/use_cases/run_row_extraction"
+require "csvtool/domain/row_session/row_source"
+require "csvtool/domain/row_session/row_range"
+require "csvtool/domain/row_session/row_session"
+require "csvtool/domain/shared/output_destination"
 require "tmpdir"
 
 class RunRowExtractionTest < Minitest::Test
-  def test_use_case_prints_selected_row_range_with_header
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
-    input = [fixture, "", "2", "3", ""].join("\n") + "\n"
-
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
-
-    assert_includes out.string, "name,city"
-    assert_includes out.string, "Bob,Paris"
-    assert_includes out.string, "Cara,Berlin"
-    refute_includes out.string, "Alice,London"
+  class RaisingWriter
+    def call(**_kwargs)
+      raise Errno::ENOENT
+    end
   end
 
-  def test_rejects_non_numeric_start_row
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
-    input = [fixture, "", "abc", "3", ""].join("\n") + "\n"
-
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
-
-    assert_includes out.string, "Start row must be a positive integer."
-    refute_includes out.string, "name,city"
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
   end
 
-  def test_rejects_non_numeric_end_row
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
-    input = [fixture, "", "1", "xyz", ""].join("\n") + "\n"
-
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
-
-    assert_includes out.string, "End row must be a positive integer."
-    refute_includes out.string, "name,city"
-  end
-
-  def test_rejects_end_before_start
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
-    input = [fixture, "", "3", "2", ""].join("\n") + "\n"
-
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
-
-    assert_includes out.string, "End row must be greater than or equal to start row."
-    refute_includes out.string, "name,city"
+  def build_session(file_path:, separator: ",", start_row:, end_row:, output: :console, output_path: nil)
+    source = Csvtool::Domain::RowSession::RowSource.new(path: file_path, separator: separator)
+    row_range = Csvtool::Domain::RowSession::RowRange.new(start_row: start_row, end_row: end_row)
+    session = Csvtool::Domain::RowSession::RowSession.start(source: source, row_range: row_range)
+
+    session.with_output_destination(
+      if output == :file
+        Csvtool::Domain::Shared::OutputDestination.file(path: output_path)
+      else
+        Csvtool::Domain::Shared::OutputDestination.console
+      end
+    )
   end
 
-  def test_handles_out_of_bounds_start_row
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
-    input = [fixture, "", "10", "12", ""].join("\n") + "\n"
+  def test_read_headers_returns_headers_for_valid_file
+    use_case = Csvtool::Application::UseCases::RunRowExtraction.new
 
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
+    result = use_case.read_headers(file_path: fixture_path("sample_people.csv"), col_sep: ",")
 
-    assert_includes out.string, "Row range is out of bounds. File has 3 data rows."
-    refute_includes out.string, "name,city"
+    assert result.ok?
+    assert_equal ["name", "city"], result.data[:headers]
   end
 
-  def test_use_case_supports_tsv_separator
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.tsv", __dir__)
-    input = [fixture, "2", "2", "3", ""].join("\n") + "\n"
+  def test_read_headers_fails_when_file_is_missing
+    use_case = Csvtool::Application::UseCases::RunRowExtraction.new
 
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
+    result = use_case.read_headers(file_path: "/tmp/not-present.csv", col_sep: ",")
 
-    assert_includes out.string, "name,city"
-    assert_includes out.string, "Bob,Paris"
-    assert_includes out.string, "Cara,Berlin"
+    refute result.ok?
+    assert_equal :file_not_found, result.error
   end
 
-  def test_use_case_supports_custom_separator
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people_colon.txt", __dir__)
-    input = [fixture, "5", ":", "2", "3", ""].join("\n") + "\n"
+  def test_extract_streams_rows_for_console_mode
+    use_case = Csvtool::Application::UseCases::RunRowExtraction.new
+    session = build_session(file_path: fixture_path("sample_people.csv"), start_row: 2, end_row: 3)
+    headers = ["name", "city"]
+    rows = []
 
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
+    result = use_case.extract(session: session, headers: headers, on_row: ->(fields) { rows << fields })
 
-    assert_includes out.string, "name,city"
-    assert_includes out.string, "Bob,Paris"
-    assert_includes out.string, "Cara,Berlin"
+    assert result.ok?
+    assert_equal true, result.data[:matched]
+    assert_equal 3, result.data[:row_count]
+    assert_equal [["Bob", "Paris"], ["Cara", "Berlin"]], rows
   end
 
-  def test_use_case_can_write_selected_rows_to_file
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
+  def test_extract_writes_rows_to_file_mode
+    use_case = Csvtool::Application::UseCases::RunRowExtraction.new
+    headers = ["name", "city"]
 
     Dir.mktmpdir do |dir|
       output_path = File.join(dir, "rows.csv")
-      input = [fixture, "", "2", "3", "2", output_path].join("\n") + "\n"
-
-      use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-      use_case.call
-
+      session = build_session(
+        file_path: fixture_path("sample_people.csv"),
+        start_row: 2,
+        end_row: 3,
+        output: :file,
+        output_path: output_path
+      )
+
+      result = use_case.extract(session: session, headers: headers)
+
+      assert result.ok?
+      assert_equal true, result.data[:wrote_rows]
       assert_equal "name,city\nBob,Paris\nCara,Berlin\n", File.read(output_path)
-      assert_includes out.string, "Wrote output to #{output_path}"
     end
   end
 
-  def test_stops_parsing_after_end_row_for_console_output
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people_bad_tail.csv", __dir__)
-    input = [fixture, "", "1", "2", ""].join("\n") + "\n"
-
-    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-    use_case.call
-
-    assert_includes out.string, "name,city"
-    assert_includes out.string, "Alice,London"
-    assert_includes out.string, "Bob,Paris"
-    refute_includes out.string, "Could not parse CSV file."
+  def test_extract_returns_cannot_write_output_file_when_writer_fails
+    use_case = Csvtool::Application::UseCases::RunRowExtraction.new(csv_row_file_writer: RaisingWriter.new)
+    headers = ["name", "city"]
+    session = build_session(
+      file_path: fixture_path("sample_people.csv"),
+      start_row: 2,
+      end_row: 3,
+      output: :file,
+      output_path: "/tmp/rows.csv"
+    )
+
+    result = use_case.extract(session: session, headers: headers)
+
+    refute result.ok?
+    assert_equal :cannot_write_output_file, result.error
+    assert_equal "/tmp/rows.csv", result.data[:path]
+    assert_equal Errno::ENOENT, result.data[:error_class]
   end
 
-  def test_out_of_bounds_file_mode_reports_error
-    out = StringIO.new
-    fixture = File.expand_path("../../../fixtures/sample_people.csv", __dir__)
+  def test_extract_reports_out_of_bounds_via_stats
+    use_case = Csvtool::Application::UseCases::RunRowExtraction.new
+    session = build_session(file_path: fixture_path("sample_people.csv"), start_row: 10, end_row: 12)
+    headers = ["name", "city"]
 
-    Dir.mktmpdir do |dir|
-      output_path = File.join(dir, "rows.csv")
-      input = [fixture, "", "10", "12", "2", output_path].join("\n") + "\n"
-
-      use_case = Csvtool::Application::UseCases::RunRowExtraction.new(stdin: StringIO.new(input), stdout: out)
-      use_case.call
-    end
+    result = use_case.extract(session: session, headers: headers)
 
-    assert_includes out.string, "Row range is out of bounds. File has 3 data rows."
+    assert result.ok?
+    assert_equal false, result.data[:matched]
+    assert_equal 3, result.data[:row_count]
   end
 end