csvops 0.6.0.alpha → 0.8.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/run_csv_stats_workflow.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "csvtool/application/use_cases/run_csv_stats"
+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/output_destination_prompt"
+require "csvtool/interface/cli/workflows/builders/csv_stats_session_builder"
+require "csvtool/interface/cli/workflows/presenters/csv_stats_presenter"
+require "csvtool/interface/cli/workflows/support/result_error_handler"
+require "csvtool/interface/cli/workflows/support/output_destination_mapper"
+require "csvtool/interface/cli/workflows/steps/workflow_step_pipeline"
+require "csvtool/interface/cli/workflows/steps/csv_stats/collect_inputs_step"
+require "csvtool/interface/cli/workflows/steps/csv_stats/collect_destination_step"
+require "csvtool/interface/cli/workflows/steps/csv_stats/build_session_step"
+require "csvtool/interface/cli/workflows/steps/csv_stats/execute_step"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        class RunCsvStatsWorkflow
+          def initialize(stdin:, stdout:, use_case: Application::UseCases::RunCsvStats.new)
+            @stdin = stdin
+            @stdout = stdout
+            @use_case = use_case
+            @errors = Interface::CLI::Errors::Presenter.new(stdout: stdout)
+            @session_builder = Builders::CsvStatsSessionBuilder.new
+            @presenter = Presenters::CsvStatsPresenter.new(stdout: stdout)
+            @output_destination_mapper = Support::OutputDestinationMapper.new
+            @result_error_handler = Support::ResultErrorHandler.new(errors: @errors)
+          end
+
+          def call
+            context = {
+              use_case: @use_case,
+              session_builder: @session_builder,
+              output_destination_mapper: @output_destination_mapper,
+              presenter: @presenter,
+              handle_error: method(:handle_error)
+            }
+            pipeline = Steps::WorkflowStepPipeline.new(steps: [
+              Steps::CsvStats::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)
+              ),
+              Steps::CsvStats::CollectDestinationStep.new(
+                output_destination_prompt: Interface::CLI::Prompts::OutputDestinationPrompt.new(
+                  stdin: @stdin,
+                  stdout: @stdout,
+                  errors: @errors
+                )
+              ),
+              Steps::CsvStats::BuildSessionStep.new,
+              Steps::CsvStats::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]) },
+              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]) }
+            })
+          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/csv_stats/build_session_step.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvStats
+            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),
+                  destination: context.fetch(:output_destination)
+                )
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/workflows/steps/csv_stats/collect_destination_step.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvStats
+            class CollectDestinationStep
+              def initialize(output_destination_prompt:)
+                @output_destination_prompt = output_destination_prompt
+              end
+
+              def call(context)
+                output_destination = @output_destination_prompt.call
+                return :halt if output_destination.nil?
+
+                context[:output_destination] = context.fetch(:output_destination_mapper).call(output_destination)
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvStats
+            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[:file_path] = @file_path_prompt.call(label: "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/csv_stats/execute_step.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Steps
+          module CsvStats
+            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)
+                context.fetch(:presenter).print_file_written(result.data[:output_path]) if result.data[:output_path]
+                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.8.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