csvops 0.1.0.alpha → 0.3.0.alpha

data/test/csvtool/domain/{extraction_session → column_session}/extraction_value_test.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "../../../test_helper"
-require "csvtool/domain/extraction_session/extraction_value"
+require "csvtool/domain/column_session/extraction_value"
 
 class ExtractionValueTest < Minitest::Test
   def test_stringifies_value
-    value = Csvtool::Domain::ExtractionSession::ExtractionValue.new(123)
+    value = Csvtool::Domain::ColumnSession::ExtractionValue.new(123)
     assert_equal "123", value.value
   end
 end

data/test/csvtool/domain/{extraction_session → column_session}/output_destination_test.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 require_relative "../../../test_helper"
-require "csvtool/domain/extraction_session/output_destination"
+require "csvtool/domain/column_session/output_destination"
 
 class OutputDestinationTest < Minitest::Test
   def test_console_factory
-    destination = Csvtool::Domain::ExtractionSession::OutputDestination.console
+    destination = Csvtool::Domain::ColumnSession::OutputDestination.console
     assert_equal true, destination.console?
     assert_equal false, destination.file?
   end
 
   def test_file_factory
-    destination = Csvtool::Domain::ExtractionSession::OutputDestination.file(path: "/tmp/out.csv")
+    destination = Csvtool::Domain::ColumnSession::OutputDestination.file(path: "/tmp/out.csv")
     assert_equal true, destination.file?
     assert_equal "/tmp/out.csv", destination.path
   end

data/test/csvtool/domain/column_session/preview_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/column_session/preview"
+require "csvtool/domain/column_session/extraction_value"
+
+class PreviewTest < Minitest::Test
+  def test_exposes_size_and_string_values
+    values = [
+      Csvtool::Domain::ColumnSession::ExtractionValue.new("Alice"),
+      Csvtool::Domain::ColumnSession::ExtractionValue.new("Bob")
+    ]
+    preview = Csvtool::Domain::ColumnSession::Preview.new(values: values)
+
+    assert_equal 2, preview.size
+    assert_equal %w[Alice Bob], preview.to_strings
+  end
+end

data/test/csvtool/domain/{extraction_session → column_session}/separator_test.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 require_relative "../../../test_helper"
-require "csvtool/domain/extraction_session/separator"
+require "csvtool/domain/column_session/separator"
 
 class SeparatorTest < Minitest::Test
   def test_stores_value
-    separator = Csvtool::Domain::ExtractionSession::Separator.new(",")
+    separator = Csvtool::Domain::ColumnSession::Separator.new(",")
     assert_equal ",", separator.value
   end
 
   def test_empty_value_raises
-    assert_raises(ArgumentError) { Csvtool::Domain::ExtractionSession::Separator.new("") }
+    assert_raises(ArgumentError) { Csvtool::Domain::ColumnSession::Separator.new("") }
   end
 end

data/test/csvtool/domain/row_randomization_session/randomization_options_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_randomization_session/randomization_options"
+
+class RandomizationOptionsTest < Minitest::Test
+  def test_accepts_nil_or_integer_seed
+    with_seed = Csvtool::Domain::RowRandomizationSession::RandomizationOptions.new(seed: 42)
+    without_seed = Csvtool::Domain::RowRandomizationSession::RandomizationOptions.new(seed: nil)
+
+    assert_equal 42, with_seed.seed
+    assert_nil without_seed.seed
+  end
+
+  def test_rejects_non_integer_seed
+    assert_raises(ArgumentError) do
+      Csvtool::Domain::RowRandomizationSession::RandomizationOptions.new(seed: "abc")
+    end
+  end
+end

data/test/csvtool/domain/row_randomization_session/randomization_output_destination_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_randomization_session/randomization_output_destination"
+
+class RandomizationOutputDestinationTest < Minitest::Test
+  def test_console_and_file_modes
+    console = Csvtool::Domain::RowRandomizationSession::RandomizationOutputDestination.console
+    file = Csvtool::Domain::RowRandomizationSession::RandomizationOutputDestination.file(path: "/tmp/out.csv")
+
+    assert_equal false, console.file?
+    assert_equal true, file.file?
+    assert_equal "/tmp/out.csv", file.path
+  end
+
+  def test_rejects_empty_file_path
+    assert_raises(ArgumentError) do
+      Csvtool::Domain::RowRandomizationSession::RandomizationOutputDestination.file(path: "")
+    end
+  end
+end

data/test/csvtool/domain/row_randomization_session/randomization_session_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_randomization_session/randomization_session"
+require "csvtool/domain/row_randomization_session/randomization_source"
+require "csvtool/domain/row_randomization_session/randomization_options"
+require "csvtool/domain/row_randomization_session/randomization_output_destination"
+
+class RandomizationSessionTest < Minitest::Test
+  def test_with_output_destination_returns_updated_session
+    source = Csvtool::Domain::RowRandomizationSession::RandomizationSource.new(
+      path: "/tmp/in.csv",
+      separator: ",",
+      headers_present: true
+    )
+    options = Csvtool::Domain::RowRandomizationSession::RandomizationOptions.new(seed: 7)
+    session = Csvtool::Domain::RowRandomizationSession::RandomizationSession.start(source: source, options: options)
+    destination = Csvtool::Domain::RowRandomizationSession::RandomizationOutputDestination.console
+
+    updated = session.with_output_destination(destination)
+
+    assert_equal source, updated.source
+    assert_equal options, updated.options
+    assert_equal destination, updated.output_destination
+  end
+end

data/test/csvtool/domain/row_randomization_session/randomization_source_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_randomization_session/randomization_source"
+
+class RandomizationSourceTest < Minitest::Test
+  def test_holds_path_separator_and_headers_mode
+    source = Csvtool::Domain::RowRandomizationSession::RandomizationSource.new(
+      path: "/tmp/a.csv",
+      separator: ",",
+      headers_present: true
+    )
+
+    assert_equal "/tmp/a.csv", source.path
+    assert_equal ",", source.separator
+    assert_equal true, source.headers_present?
+  end
+
+  def test_rejects_empty_separator
+    assert_raises(ArgumentError) do
+      Csvtool::Domain::RowRandomizationSession::RandomizationSource.new(
+        path: "/tmp/a.csv",
+        separator: "",
+        headers_present: true
+      )
+    end
+  end
+end

data/test/csvtool/domain/row_session/row_output_destination_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_session/row_output_destination"
+
+class RowRangeOutputDestinationTest < Minitest::Test
+  def test_console_destination
+    destination = Csvtool::Domain::RowSession::RowOutputDestination.console
+    refute destination.file?
+  end
+
+  def test_file_destination
+    destination = Csvtool::Domain::RowSession::RowOutputDestination.file(path: "/tmp/out.csv")
+    assert destination.file?
+    assert_equal "/tmp/out.csv", destination.path
+  end
+
+  def test_rejects_empty_file_path
+    assert_raises(ArgumentError) do
+      Csvtool::Domain::RowSession::RowOutputDestination.file(path: "")
+    end
+  end
+end

data/test/csvtool/domain/row_session/row_range_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_session/row_range"
+
+class RowRangeTest < Minitest::Test
+  def test_builds_from_valid_inputs
+    row_range = Csvtool::Domain::RowSession::RowRange.from_inputs(start_row_input: "2", end_row_input: "4")
+    assert_equal 2, row_range.start_row
+    assert_equal 4, row_range.end_row
+  end
+
+  def test_rejects_invalid_start_row
+    assert_raises(Csvtool::Domain::RowSession::InvalidStartRowError) do
+      Csvtool::Domain::RowSession::RowRange.from_inputs(start_row_input: "0", end_row_input: "2")
+    end
+  end
+
+  def test_rejects_invalid_end_row
+    assert_raises(Csvtool::Domain::RowSession::InvalidEndRowError) do
+      Csvtool::Domain::RowSession::RowRange.from_inputs(start_row_input: "1", end_row_input: "abc")
+    end
+  end
+
+  def test_rejects_end_before_start
+    assert_raises(Csvtool::Domain::RowSession::InvalidRowRangeOrderError) do
+      Csvtool::Domain::RowSession::RowRange.from_inputs(start_row_input: "3", end_row_input: "2")
+    end
+  end
+end

data/test/csvtool/domain/row_session/row_session_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_session/row_session"
+require "csvtool/domain/row_session/row_source"
+require "csvtool/domain/row_session/row_range"
+require "csvtool/domain/row_session/row_output_destination"
+
+class RowSessionTest < Minitest::Test
+  def test_starts_and_sets_output_destination
+    source = Csvtool::Domain::RowSession::RowSource.new(path: "/tmp/a.csv", separator: ",")
+    row_range = Csvtool::Domain::RowSession::RowRange.new(start_row: 1, end_row: 2)
+
+    session = Csvtool::Domain::RowSession::RowSession.start(source: source, row_range: row_range)
+    destination = Csvtool::Domain::RowSession::RowOutputDestination.console
+    updated = session.with_output_destination(destination)
+
+    assert_equal source, updated.source
+    assert_equal row_range, updated.row_range
+    assert_equal destination, updated.output_destination
+  end
+end

data/test/csvtool/domain/row_session/row_source_test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/row_session/row_source"
+
+class RowSourceTest < Minitest::Test
+  def test_holds_path_and_separator
+    source = Csvtool::Domain::RowSession::RowSource.new(path: "/tmp/a.csv", separator: "\t")
+    assert_equal "/tmp/a.csv", source.path
+    assert_equal "\t", source.separator
+  end
+end

data/test/csvtool/infrastructure/csv/row_randomizer_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/csv/row_randomizer"
+
+class InfrastructureRowRandomizerTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_randomizes_rows_and_preserves_membership
+    randomizer = Csvtool::Infrastructure::CSV::RowRandomizer.new
+
+    rows = randomizer.call(file_path: fixture_path("sample_people.csv"), col_sep: ",", headers: true, seed: 1234)
+
+    assert_equal 3, rows.length
+    assert_equal [%w[Alice London], %w[Bob Paris], %w[Cara Berlin]].sort, rows.sort
+  end
+
+  def test_same_seed_returns_same_order
+    randomizer = Csvtool::Infrastructure::CSV::RowRandomizer.new
+
+    one = randomizer.call(file_path: fixture_path("sample_people_many.csv"), col_sep: ",", headers: true, seed: 42)
+    two = randomizer.call(file_path: fixture_path("sample_people_many.csv"), col_sep: ",", headers: true, seed: 42)
+
+    assert_equal one, two
+  end
+
+  def test_different_seed_changes_order
+    randomizer = Csvtool::Infrastructure::CSV::RowRandomizer.new
+
+    one = randomizer.call(file_path: fixture_path("sample_people_many.csv"), col_sep: ",", headers: true, seed: 42)
+    two = randomizer.call(file_path: fixture_path("sample_people_many.csv"), col_sep: ",", headers: true, seed: 43)
+
+    refute_equal one, two
+  end
+end

data/test/csvtool/infrastructure/csv/row_streamer_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/csv/row_streamer"
+
+class InfrastructureRowStreamerTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_streams_only_requested_row_range
+    streamer = Csvtool::Infrastructure::CSV::RowStreamer.new
+    rows = []
+
+    stats = streamer.each_in_range(
+      file_path: fixture_path("sample_people.csv"),
+      col_sep: ",",
+      start_row: 2,
+      end_row: 3
+    ) { |fields| rows << fields }
+
+    assert_equal [["Bob", "Paris"], ["Cara", "Berlin"]], rows
+    assert_equal true, stats[:matched]
+    assert_equal 3, stats[:row_count]
+  end
+
+  def test_stops_before_malformed_tail_when_end_row_reached
+    streamer = Csvtool::Infrastructure::CSV::RowStreamer.new
+    rows = []
+
+    stats = streamer.each_in_range(
+      file_path: fixture_path("sample_people_bad_tail.csv"),
+      col_sep: ",",
+      start_row: 1,
+      end_row: 2
+    ) { |fields| rows << fields }
+
+    assert_equal [["Alice", "London"], ["Bob", "Paris"]], rows
+    assert_equal true, stats[:matched]
+  end
+end

data/test/csvtool/infrastructure/output/csv_row_console_writer_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/output/csv_row_console_writer"
+
+class InfrastructureCsvRowConsoleWriterTest < Minitest::Test
+  class FakeRowStreamer
+    def each_in_range(file_path:, col_sep:, start_row:, end_row:)
+      yield ["Bob", "Paris"]
+      yield ["Cara", "Berlin"]
+      { matched: true, row_count: 3 }
+    end
+  end
+
+  def test_writes_header_and_rows_to_stdout
+    out = StringIO.new
+    writer = Csvtool::Infrastructure::Output::CsvRowConsoleWriter.new(stdout: out, row_streamer: FakeRowStreamer.new)
+
+    stats = writer.call(file_path: "x.csv", col_sep: ",", headers: ["name", "city"], start_row: 2, end_row: 3)
+
+    assert_equal "name,city\nBob,Paris\nCara,Berlin\n", out.string
+    assert_equal true, stats[:matched]
+  end
+end

data/test/csvtool/infrastructure/output/csv_row_file_writer_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/output/csv_row_file_writer"
+require "csvtool/interface/cli/errors/presenter"
+require "tmpdir"
+
+class InfrastructureCsvRowFileWriterTest < Minitest::Test
+  class FakeRowStreamer
+    def each_in_range(file_path:, col_sep:, start_row:, end_row:)
+      yield ["Bob", "Paris"]
+      yield ["Cara", "Berlin"]
+      { matched: true, row_count: 3 }
+    end
+  end
+
+  def test_writes_header_and_rows_to_file
+    stdout = StringIO.new
+    writer = Csvtool::Infrastructure::Output::CsvRowFileWriter.new(
+      stdout: stdout,
+      errors: Csvtool::Interface::CLI::Errors::Presenter.new(stdout: stdout),
+      row_streamer: FakeRowStreamer.new
+    )
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "rows.csv")
+      stats = writer.call(
+        file_path: "x.csv",
+        col_sep: ",",
+        headers: ["name", "city"],
+        start_row: 2,
+        end_row: 3,
+        output_path: output_path
+      )
+
+      assert_equal "name,city\nBob,Paris\nCara,Berlin\n", File.read(output_path)
+      assert_equal true, stats[:matched]
+    end
+  end
+end

data/test/csvtool/interface/cli/errors/presenter_test.rb

@@ -18,7 +18,12 @@ class ErrorsPresenterTest < Minitest::Test
     presenter.invalid_output_destination
     presenter.empty_custom_separator
     presenter.invalid_separator_choice
+    presenter.invalid_seed
     presenter.canceled
+    presenter.invalid_start_row
+    presenter.invalid_end_row
+    presenter.invalid_row_range_order
+    presenter.row_range_out_of_bounds(3)
 
     text = out.string
     assert_includes text, "File not found: /tmp/x.csv"
@@ -31,6 +36,11 @@ class ErrorsPresenterTest < Minitest::Test
     assert_includes text, "Invalid output destination."
     assert_includes text, "Separator cannot be empty."
     assert_includes text, "Invalid separator choice."
+    assert_includes text, "Seed must be an integer."
     assert_includes text, "Canceled."
+    assert_includes text, "Start row must be a positive integer."
+    assert_includes text, "End row must be a positive integer."
+    assert_includes text, "End row must be greater than or equal to start row."
+    assert_includes text, "Row range is out of bounds. File has 3 data rows."
   end
 end

data/test/csvtool/interface/cli/menu_loop_test.rb

@@ -16,36 +16,92 @@ class MenuLoopTest < Minitest::Test
     end
   end
 
-  def test_routes_extract_then_exit
-    action = FakeAction.new
+  def test_routes_extract_column_then_exit
+    column_action = FakeAction.new
+    rows_action = FakeAction.new
+    randomize_rows_action = FakeAction.new
     stdout = StringIO.new
     menu = Csvtool::Interface::CLI::MenuLoop.new(
-      stdin: StringIO.new("1\n2\n"),
+      stdin: StringIO.new("1\n4\n"),
       stdout: stdout,
-      menu_options: ["Extract column", "Exit"],
-      extract_action: action
+      menu_options: ["Extract column", "Extract rows (range)", "Randomize rows", "Exit"],
+      extract_column_action: column_action,
+      extract_rows_action: rows_action,
+      randomize_rows_action: randomize_rows_action
     )
 
     status = menu.run
 
     assert_equal 0, status
-    assert_equal 1, action.runs
+    assert_equal 1, column_action.runs
+    assert_equal 0, rows_action.runs
+    assert_equal 0, randomize_rows_action.runs
     assert_includes stdout.string, "CSV Tool Menu"
   end
 
+  def test_routes_extract_rows_then_exit
+    column_action = FakeAction.new
+    rows_action = FakeAction.new
+    randomize_rows_action = FakeAction.new
+    stdout = StringIO.new
+    menu = Csvtool::Interface::CLI::MenuLoop.new(
+      stdin: StringIO.new("2\n4\n"),
+      stdout: stdout,
+      menu_options: ["Extract column", "Extract rows (range)", "Randomize rows", "Exit"],
+      extract_column_action: column_action,
+      extract_rows_action: rows_action,
+      randomize_rows_action: randomize_rows_action
+    )
+
+    status = menu.run
+
+    assert_equal 0, status
+    assert_equal 0, column_action.runs
+    assert_equal 1, rows_action.runs
+    assert_equal 0, randomize_rows_action.runs
+  end
+
+  def test_routes_randomize_rows_then_exit
+    column_action = FakeAction.new
+    rows_action = FakeAction.new
+    randomize_rows_action = FakeAction.new
+    stdout = StringIO.new
+    menu = Csvtool::Interface::CLI::MenuLoop.new(
+      stdin: StringIO.new("3\n4\n"),
+      stdout: stdout,
+      menu_options: ["Extract column", "Extract rows (range)", "Randomize rows", "Exit"],
+      extract_column_action: column_action,
+      extract_rows_action: rows_action,
+      randomize_rows_action: randomize_rows_action
+    )
+
+    status = menu.run
+
+    assert_equal 0, status
+    assert_equal 0, column_action.runs
+    assert_equal 0, rows_action.runs
+    assert_equal 1, randomize_rows_action.runs
+  end
+
   def test_invalid_choice_shows_prompt
-    action = FakeAction.new
+    column_action = FakeAction.new
+    rows_action = FakeAction.new
+    randomize_rows_action = FakeAction.new
     stdout = StringIO.new
     menu = Csvtool::Interface::CLI::MenuLoop.new(
-      stdin: StringIO.new("x\n2\n"),
+      stdin: StringIO.new("x\n4\n"),
       stdout: stdout,
-      menu_options: ["Extract column", "Exit"],
-      extract_action: action
+      menu_options: ["Extract column", "Extract rows (range)", "Randomize rows", "Exit"],
+      extract_column_action: column_action,
+      extract_rows_action: rows_action,
+      randomize_rows_action: randomize_rows_action
     )
 
     menu.run
 
-    assert_includes stdout.string, "Please choose 1 or 2."
-    assert_equal 0, action.runs
+    assert_includes stdout.string, "Please choose 1, 2, 3, or 4."
+    assert_equal 0, column_action.runs
+    assert_equal 0, rows_action.runs
+    assert_equal 0, randomize_rows_action.runs
   end
 end

data/test/csvtool/interface/cli/prompts/headers_present_prompt_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/prompts/headers_present_prompt"
+
+class HeadersPresentPromptTest < Minitest::Test
+  def test_defaults_to_true_and_accepts_negative_inputs
+    yes_prompt = Csvtool::Interface::CLI::Prompts::HeadersPresentPrompt.new(stdin: StringIO.new("\n"), stdout: StringIO.new)
+    no_prompt = Csvtool::Interface::CLI::Prompts::HeadersPresentPrompt.new(stdin: StringIO.new("n\n"), stdout: StringIO.new)
+
+    assert_equal true, yes_prompt.call
+    assert_equal false, no_prompt.call
+  end
+end

data/test/csvtool/interface/cli/prompts/seed_prompt_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/prompts/seed_prompt"
+
+class SeedPromptTest < Minitest::Test
+  class FakeErrors
+    attr_reader :calls
+
+    def initialize
+      @calls = []
+    end
+
+    def invalid_seed
+      @calls << :invalid_seed
+    end
+  end
+
+  def test_blank_returns_nil
+    errors = FakeErrors.new
+    prompt = Csvtool::Interface::CLI::Prompts::SeedPrompt.new(stdin: StringIO.new("\n"), stdout: StringIO.new, errors: errors)
+    assert_nil prompt.call
+    assert_empty errors.calls
+  end
+
+  def test_integer_returns_seed
+    errors = FakeErrors.new
+    prompt = Csvtool::Interface::CLI::Prompts::SeedPrompt.new(stdin: StringIO.new("42\n"), stdout: StringIO.new, errors: errors)
+    assert_equal 42, prompt.call
+    assert_empty errors.calls
+  end
+
+  def test_invalid_reports_error
+    errors = FakeErrors.new
+    prompt = Csvtool::Interface::CLI::Prompts::SeedPrompt.new(stdin: StringIO.new("abc\n"), stdout: StringIO.new, errors: errors)
+    assert_equal Csvtool::Interface::CLI::Prompts::SeedPrompt::INVALID, prompt.call
+    assert_includes errors.calls, :invalid_seed
+  end
+end

data/test/fixtures/sample_people_bad_tail.csv

@@ -0,0 +1,5 @@
+name,city
+Alice,London
+Bob,Paris
+Cara,Berlin
+"broken

data/test/fixtures/sample_people_no_headers.csv

@@ -0,0 +1,3 @@
+Alice,London
+Bob,Paris
+Cara,Berlin