csvops 0.5.0.alpha → 0.7.0.alpha

data/lib/csvtool/interface/cli/workflows/run_csv_split_workflow.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "csvtool/application/use_cases/run_csv_split"
+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/chunk_size_prompt"
+require "csvtool/interface/cli/prompts/yes_no_prompt"
+require "csvtool/interface/cli/prompts/split_output_prompt"
+require "csvtool/interface/cli/prompts/split_manifest_prompt"
+require "csvtool/interface/cli/workflows/builders/csv_split_session_builder"
+require "csvtool/interface/cli/workflows/presenters/csv_split_presenter"
+require "csvtool/interface/cli/workflows/support/result_error_handler"
+require "csvtool/interface/cli/workflows/steps/workflow_step_pipeline"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_inputs_step"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_output_step"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_manifest_step"
+require "csvtool/interface/cli/workflows/steps/csv_split/build_session_step"
+require "csvtool/interface/cli/workflows/steps/csv_split/execute_step"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        class RunCsvSplitWorkflow
+          def initialize(stdin:, stdout:, use_case: Application::UseCases::RunCsvSplit.new)
+            @stdin = stdin
+            @stdout = stdout
+            @use_case = use_case
+            @errors = Interface::CLI::Errors::Presenter.new(stdout: stdout)
+            @session_builder = Builders::CsvSplitSessionBuilder.new
+            @presenter = Presenters::CsvSplitPresenter.new(stdout: stdout)
+            @result_error_handler = Support::ResultErrorHandler.new(errors: @errors)
+          end
+
+          def call
+            context = {
+              use_case: @use_case,
+              session_builder: @session_builder,
+              presenter: @presenter,
+              handle_error: method(:handle_error)
+            }
+            pipeline = Steps::WorkflowStepPipeline.new(steps: [
+              Steps::CsvSplit::CollectInputsStep.new(
+                file_path_prompt: Interface::CLI::Prompts::FilePathPrompt.new(stdin: @stdin, stdout: @stdout),
+                separator_prompt: Interface::CLI::Prompts::SeparatorPrompt.new(stdin: @stdin, stdout: @stdout, errors: @errors),
+                headers_present_prompt: Interface::CLI::Prompts::HeadersPresentPrompt.new(stdin: @stdin, stdout: @stdout),
+                chunk_size_prompt: Interface::CLI::Prompts::ChunkSizePrompt.new(stdin: @stdin, stdout: @stdout),
+                errors: @errors
+              ),
+              Steps::CsvSplit::CollectOutputStep.new(
+                split_output_prompt: Interface::CLI::Prompts::SplitOutputPrompt.new(
+                  stdin: @stdin,
+                  stdout: @stdout,
+                  yes_no_prompt: Interface::CLI::Prompts::YesNoPrompt.new(stdin: @stdin, stdout: @stdout)
+                )
+              ),
+              Steps::CsvSplit::CollectManifestStep.new(
+                split_manifest_prompt: Interface::CLI::Prompts::SplitManifestPrompt.new(
+                  stdin: @stdin,
+                  stdout: @stdout,
+                  yes_no_prompt: Interface::CLI::Prompts::YesNoPrompt.new(stdin: @stdin, stdout: @stdout)
+                )
+              ),
+              Steps::CsvSplit::BuildSessionStep.new,
+              Steps::CsvSplit::ExecuteStep.new
+            ])
+            pipeline.call(context)
+            nil
+          end
+
+          private
+
+          def handle_error(result)
+            @result_error_handler.call(result, {
+              file_not_found: ->(r, errors) { errors.file_not_found(r.data[:path]) },
+              no_headers: ->(_r, errors) { errors.no_headers },
+              could_not_parse_csv: ->(_r, errors) { errors.could_not_parse_csv },
+              cannot_read_file: ->(r, errors) { errors.cannot_read_file(r.data[:path]) },
+              cannot_write_output_file: ->(r, errors) { errors.cannot_write_output_file(r.data[:path], r.data[:error_class]) },
+              output_file_exists: ->(r, errors) { errors.output_file_exists(r.data[:path]) }
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/csv_split/build_session_step.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvSplit
+            class BuildSessionStep
+              def call(context)
+                context[:session] = context.fetch(:session_builder).call(
+                  file_path: context.fetch(:file_path),
+                  col_sep: context.fetch(:col_sep),
+                  headers_present: context.fetch(:headers_present),
+                  chunk_size: context.fetch(:chunk_size),
+                  output_directory: context[:output_directory],
+                  file_prefix: context[:file_prefix],
+                  overwrite_existing: context.fetch(:overwrite_existing, false),
+                  write_manifest: context.fetch(:write_manifest, false),
+                  manifest_path: context[:manifest_path]
+                )
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvSplit
+            class CollectInputsStep
+              def initialize(file_path_prompt:, separator_prompt:, headers_present_prompt:, chunk_size_prompt:, errors:)
+                @file_path_prompt = file_path_prompt
+                @separator_prompt = separator_prompt
+                @headers_present_prompt = headers_present_prompt
+                @chunk_size_prompt = chunk_size_prompt
+                @errors = errors
+              end
+
+              def call(context)
+                context[:file_path] = @file_path_prompt.call(label: "Source CSV file path: ")
+                col_sep = @separator_prompt.call
+                return :halt if col_sep.nil?
+
+                context[:col_sep] = col_sep
+                context[:headers_present] = @headers_present_prompt.call
+                chunk_size = Integer(@chunk_size_prompt.call)
+                if chunk_size <= 0
+                  @errors.invalid_chunk_size
+                  return :halt
+                end
+
+                context[:chunk_size] = chunk_size
+                nil
+              rescue ArgumentError, TypeError
+                @errors.invalid_chunk_size
+                :halt
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/csv_split/collect_manifest_step.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvSplit
+            class CollectManifestStep
+              def initialize(split_manifest_prompt:)
+                @split_manifest_prompt = split_manifest_prompt
+              end
+
+              def call(context)
+                default_path = File.join(
+                  context.fetch(:output_directory),
+                  "#{context.fetch(:file_prefix)}_manifest.csv"
+                )
+                manifest = @split_manifest_prompt.call(default_path: default_path)
+                context[:write_manifest] = manifest[:write_manifest]
+                context[:manifest_path] = manifest[:manifest_path]
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/csv_split/collect_output_step.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvSplit
+            class CollectOutputStep
+              def initialize(split_output_prompt:)
+                @split_output_prompt = split_output_prompt
+              end
+
+              def call(context)
+                file_path = context.fetch(:file_path)
+                output = @split_output_prompt.call(
+                  default_directory: File.dirname(file_path),
+                  default_prefix: File.basename(file_path, ".*")
+                )
+                context[:output_directory] = output[:output_directory]
+                context[:file_prefix] = output[:file_prefix]
+                context[:overwrite_existing] = output[:overwrite_existing]
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvSplit
+            class ExecuteStep
+              def call(context)
+                headers_result = context.fetch(:use_case).read_headers(
+                  file_path: context.fetch(:file_path),
+                  col_sep: context.fetch(:col_sep),
+                  headers_present: context.fetch(:headers_present)
+                )
+                unless headers_result.ok?
+                  context.fetch(:handle_error).call(headers_result)
+                  return :halt
+                end
+
+                result = context.fetch(:use_case).call(session: context.fetch(:session))
+                unless result.ok?
+                  context.fetch(:handle_error).call(result)
+                  return :halt
+                end
+
+                context.fetch(:presenter).print_summary(result.data.merge(chunk_size: context.fetch(:chunk_size)))
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/parity/build_session_step.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module Parity
+            class BuildSessionStep
+              def call(context)
+                context[:session] = context.fetch(:session_builder).call(
+                  left_path: context.fetch(:left_path),
+                  right_path: context.fetch(:right_path),
+                  col_sep: context.fetch(:col_sep),
+                  headers_present: context.fetch(:headers_present)
+                )
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module Parity
+            class CollectInputsStep
+              def initialize(file_path_prompt:, separator_prompt:, headers_present_prompt:)
+                @file_path_prompt = file_path_prompt
+                @separator_prompt = separator_prompt
+                @headers_present_prompt = headers_present_prompt
+              end
+
+              def call(context)
+                context[:left_path] = @file_path_prompt.call(label: "Left CSV file path: ")
+                context[:right_path] = @file_path_prompt.call(label: "Right CSV file path: ")
+                col_sep = @separator_prompt.call
+                return :halt if col_sep.nil?
+
+                context[:col_sep] = col_sep
+                context[:headers_present] = @headers_present_prompt.call
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module Parity
+            class ExecuteStep
+              def call(context)
+                result = context.fetch(:use_case).call(session: context.fetch(:session))
+                unless result.ok?
+                  context.fetch(:handle_error).call(result)
+                  return :halt
+                end
+
+                context.fetch(:presenter).print_summary(result.data)
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/version.rb

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

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/application/use_cases/run_csv_parity"
+require "csvtool/domain/csv_parity_session/source_pair"
+require "csvtool/domain/csv_parity_session/parity_options"
+require "csvtool/domain/csv_parity_session/parity_session"
+
+class RunCsvParityTest < Minitest::Test
+  class EaccesComparator
+    def call(left_path:, right_path:, col_sep:, headers_present:, sample_limit: 5)
+      error = Errno::EACCES.new("/tmp/protected.csv")
+      def error.path
+        "/tmp/protected.csv"
+      end
+      raise error
+    end
+  end
+
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def build_session(left_path:, right_path:, separator: ",", headers_present: true)
+    source_pair = Csvtool::Domain::CsvParitySession::SourcePair.new(
+      left_path: left_path,
+      right_path: right_path
+    )
+    options = Csvtool::Domain::CsvParitySession::ParityOptions.new(
+      separator: separator,
+      headers_present: headers_present
+    )
+    Csvtool::Domain::CsvParitySession::ParitySession.start(
+      source_pair: source_pair,
+      options: options
+    )
+  end
+
+  def test_returns_match_for_equivalent_files
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("sample_people.csv"),
+        right_path: fixture_path("parity_people_reordered.csv")
+      )
+    )
+
+    assert_equal true, result.ok?
+    assert_equal true, result.data[:match]
+    assert_equal 0, result.data[:left_only_count]
+    assert_equal 0, result.data[:right_only_count]
+  end
+
+  def test_returns_mismatch_counts_for_non_equivalent_files
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("sample_people.csv"),
+        right_path: fixture_path("parity_people_mismatch.csv")
+      )
+    )
+
+    assert_equal true, result.ok?
+    assert_equal false, result.data[:match]
+    assert_equal 1, result.data[:left_only_count]
+    assert_equal 1, result.data[:right_only_count]
+  end
+
+  def test_duplicate_count_differences_are_detected
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("parity_duplicates_left.csv"),
+        right_path: fixture_path("parity_duplicates_right.csv")
+      )
+    )
+
+    assert_equal true, result.ok?
+    assert_equal false, result.data[:match]
+    assert_equal 1, result.data[:left_only_count]
+    assert_equal 0, result.data[:right_only_count]
+    assert_equal "1,Alice", result.data[:left_only_examples][0][:row]
+    assert_equal 1, result.data[:left_only_examples][0][:count_delta]
+  end
+
+  def test_headered_mode_fails_when_headers_do_not_match
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("sample_people.csv"),
+        right_path: fixture_path("parity_people_header_mismatch.csv")
+      )
+    )
+
+    assert_equal false, result.ok?
+    assert_equal :header_mismatch, result.error
+  end
+
+  def test_headerless_mode_compares_all_rows_as_data
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("sample_people_no_headers.csv"),
+        right_path: fixture_path("sample_people_no_headers.csv"),
+        headers_present: false
+      )
+    )
+
+    assert_equal true, result.ok?
+    assert_equal true, result.data[:match]
+  end
+
+  def test_returns_file_not_found_for_left_side
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: "/tmp/nope-left.csv",
+        right_path: fixture_path("sample_people.csv")
+      )
+    )
+
+    assert_equal false, result.ok?
+    assert_equal :file_not_found, result.error
+    assert_equal "/tmp/nope-left.csv", result.data[:path]
+  end
+
+  def test_returns_file_not_found_for_right_side
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("sample_people.csv"),
+        right_path: "/tmp/nope-right.csv"
+      )
+    )
+
+    assert_equal false, result.ok?
+    assert_equal :file_not_found, result.error
+    assert_equal "/tmp/nope-right.csv", result.data[:path]
+  end
+
+  def test_returns_parse_error_for_malformed_csv
+    result = Csvtool::Application::UseCases::RunCsvParity.new.call(
+      session: build_session(
+        left_path: fixture_path("sample_people.csv"),
+        right_path: fixture_path("sample_people_bad_tail.csv")
+      )
+    )
+
+    assert_equal false, result.ok?
+    assert_equal :could_not_parse_csv, result.error
+  end
+
+  def test_returns_cannot_read_file_when_eacces_is_raised
+    result = Csvtool::Application::UseCases::RunCsvParity.new(
+      comparator: EaccesComparator.new
+    ).call(
+      session: build_session(
+        left_path: fixture_path("sample_people.csv"),
+        right_path: fixture_path("sample_people.csv")
+      )
+    )
+
+    assert_equal false, result.ok?
+    assert_equal :cannot_read_file, result.error
+    assert_equal "/tmp/protected.csv", result.data[:path]
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/application/use_cases/run_csv_split"
+require "csvtool/domain/csv_split_session/split_source"
+require "csvtool/domain/csv_split_session/split_options"
+require "csvtool/domain/csv_split_session/split_session"
+require "tmpdir"
+require "fileutils"
+
+class RunCsvSplitTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_splits_25_rows_into_10_10_5_with_headers
+    use_case = Csvtool::Application::UseCases::RunCsvSplit.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+
+      source = Csvtool::Domain::CsvSplitSession::SplitSource.new(path: source_path, separator: ",", headers_present: true)
+      options = Csvtool::Domain::CsvSplitSession::SplitOptions.new(chunk_size: 10)
+      session = Csvtool::Domain::CsvSplitSession::SplitSession.start(source: source, options: options)
+
+      result = use_case.call(session: session)
+
+      assert result.ok?
+      assert_equal 3, result.data[:chunk_count]
+      assert_equal 25, result.data[:data_rows]
+      assert_equal 3, result.data[:chunk_paths].length
+
+      chunk_1 = File.read(result.data[:chunk_paths][0]).lines.map(&:strip)
+      chunk_2 = File.read(result.data[:chunk_paths][1]).lines.map(&:strip)
+      chunk_3 = File.read(result.data[:chunk_paths][2]).lines.map(&:strip)
+
+      assert_equal 11, chunk_1.length
+      assert_equal 11, chunk_2.length
+      assert_equal 6, chunk_3.length
+      assert_equal "name,city", chunk_1.first
+      assert_equal "name,city", chunk_2.first
+      assert_equal "name,city", chunk_3.first
+      assert_equal "Name01,City01", chunk_1[1]
+      assert_equal "Name10,City10", chunk_1[10]
+      assert_equal "Name11,City11", chunk_2[1]
+      assert_equal "Name20,City20", chunk_2[10]
+      assert_equal "Name21,City21", chunk_3[1]
+      assert_equal "Name25,City25", chunk_3[5]
+    end
+  end
+
+  def test_returns_output_file_exists_when_overwrite_is_disabled
+    use_case = Csvtool::Application::UseCases::RunCsvSplit.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      File.write(File.join(dir, "people_part_001.csv"), "sentinel\n")
+
+      source = Csvtool::Domain::CsvSplitSession::SplitSource.new(path: source_path, separator: ",", headers_present: true)
+      options = Csvtool::Domain::CsvSplitSession::SplitOptions.new(chunk_size: 10, overwrite_existing: false)
+      session = Csvtool::Domain::CsvSplitSession::SplitSession.start(source: source, options: options)
+
+      result = use_case.call(session: session)
+
+      refute result.ok?
+      assert_equal :output_file_exists, result.error
+      assert_equal File.join(dir, "people_part_001.csv"), result.data[:path]
+    end
+  end
+
+  def test_creates_output_directory_when_it_does_not_exist
+    use_case = Csvtool::Application::UseCases::RunCsvSplit.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      output_dir = File.join(dir, "new_chunks")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+
+      source = Csvtool::Domain::CsvSplitSession::SplitSource.new(path: source_path, separator: ",", headers_present: true)
+      options = Csvtool::Domain::CsvSplitSession::SplitOptions.new(
+        chunk_size: 10,
+        output_directory: output_dir,
+        file_prefix: "batch"
+      )
+      session = Csvtool::Domain::CsvSplitSession::SplitSession.start(source: source, options: options)
+
+      result = use_case.call(session: session)
+
+      assert result.ok?
+      assert Dir.exist?(output_dir)
+      assert File.file?(File.join(output_dir, "batch_part_001.csv"))
+    end
+  end
+
+  def test_writes_manifest_when_enabled
+    use_case = Csvtool::Application::UseCases::RunCsvSplit.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      manifest_path = File.join(dir, "manifest.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+
+      source = Csvtool::Domain::CsvSplitSession::SplitSource.new(path: source_path, separator: ",", headers_present: true)
+      options = Csvtool::Domain::CsvSplitSession::SplitOptions.new(
+        chunk_size: 10,
+        write_manifest: true,
+        manifest_path: manifest_path
+      )
+      session = Csvtool::Domain::CsvSplitSession::SplitSession.start(source: source, options: options)
+
+      result = use_case.call(session: session)
+
+      assert result.ok?
+      assert_equal manifest_path, result.data[:manifest_path]
+      lines = File.read(manifest_path).lines.map(&:strip)
+      assert_equal "chunk_index,chunk_path,row_count", lines.first
+      assert_includes lines[1], ",10"
+      assert_includes lines[2], ",10"
+      assert_includes lines[3], ",5"
+    end
+  end
+end