csvops 0.6.0.alpha → 0.7.0.alpha

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Prompts
+        class SplitManifestPrompt
+          def initialize(stdin:, stdout:, yes_no_prompt:)
+            @stdin = stdin
+            @stdout = stdout
+            @yes_no_prompt = yes_no_prompt
+          end
+
+          def call(default_path:)
+            write_manifest = @yes_no_prompt.call(
+              label: "Write manifest file? [y/N]: ",
+              default: false
+            )
+            return { write_manifest: false, manifest_path: nil } unless write_manifest
+
+            @stdout.print "Manifest file path [#{default_path}]: "
+            path = @stdin.gets&.strip.to_s
+            path = default_path if path.empty?
+            { write_manifest: true, manifest_path: path }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Prompts
+        class SplitOutputPrompt
+          def initialize(stdin:, stdout:, yes_no_prompt:)
+            @stdin = stdin
+            @stdout = stdout
+            @yes_no_prompt = yes_no_prompt
+          end
+
+          def call(default_directory:, default_prefix:)
+            @stdout.print "Output directory [#{default_directory}]: "
+            output_directory = @stdin.gets&.strip.to_s
+            output_directory = default_directory if output_directory.empty?
+
+            @stdout.print "Output file prefix [#{default_prefix}]: "
+            file_prefix = @stdin.gets&.strip.to_s
+            file_prefix = default_prefix if file_prefix.empty?
+
+            overwrite_existing = @yes_no_prompt.call(
+              label: "Overwrite existing chunk files? [y/N]: ",
+              default: false
+            )
+
+            {
+              output_directory: output_directory,
+              file_prefix: file_prefix,
+              overwrite_existing: overwrite_existing
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/builders/csv_split_session_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "csvtool/domain/csv_split_session/split_source"
+require "csvtool/domain/csv_split_session/split_options"
+require "csvtool/domain/csv_split_session/split_session"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Builders
+          class CsvSplitSessionBuilder
+            def call(
+              file_path:,
+              col_sep:,
+              headers_present:,
+              chunk_size:,
+              output_directory: nil,
+              file_prefix: nil,
+              overwrite_existing: false,
+              write_manifest: false,
+              manifest_path: nil
+            )
+              source = Domain::CsvSplitSession::SplitSource.new(
+                path: file_path,
+                separator: col_sep,
+                headers_present: headers_present
+              )
+              options = Domain::CsvSplitSession::SplitOptions.new(
+                chunk_size: chunk_size,
+                output_directory: output_directory,
+                file_prefix: file_prefix,
+                overwrite_existing: overwrite_existing,
+                write_manifest: write_manifest,
+                manifest_path: manifest_path
+              )
+              Domain::CsvSplitSession::SplitSession.start(source: source, options: options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/presenters/csv_split_presenter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Presenters
+          class CsvSplitPresenter
+            def initialize(stdout:)
+              @stdout = stdout
+            end
+
+            def print_summary(data)
+              @stdout.puts "Split complete."
+              @stdout.puts "Chunk size: #{data[:chunk_size]}"
+              @stdout.puts "Data rows: #{data[:data_rows]}"
+              @stdout.puts "Chunks written: #{data[:chunk_count]}"
+              @stdout.puts "Manifest: #{data[:manifest_path]}" if data[:manifest_path]
+              data[:chunk_paths].each { |path| @stdout.puts path }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Csvtool
-  VERSION = "0.6.0.alpha"
+  VERSION = "0.7.0.alpha"
 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