csvops 0.7.0.alpha → 0.8.0.alpha

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Presenters
+          class CsvStatsPresenter
+            def initialize(stdout:)
+              @stdout = stdout
+            end
+
+            def print_summary(data)
+              @stdout.puts "CSV Stats Summary"
+              @stdout.puts "Rows: #{data[:row_count]}"
+              @stdout.puts "Columns: #{data[:column_count]}"
+              @stdout.puts "Headers: #{data[:headers].join(', ')}" unless data[:headers].nil? || data[:headers].empty?
+              return if data[:column_stats].nil? || data[:column_stats].empty?
+
+              @stdout.puts "Column completeness:"
+              data[:column_stats].each do |stats|
+                @stdout.puts "  #{stats[:name]}: non_blank=#{stats[:non_blank_count]} blank=#{stats[:blank_count]}"
+              end
+            end
+
+            def print_file_written(path)
+              @stdout.puts "Wrote output to #{path}"
+            end
+          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_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.7.0.alpha"
+  VERSION = "0.8.0.alpha"
 end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/application/use_cases/run_csv_stats"
+require "csvtool/domain/csv_stats_session/stats_source"
+require "csvtool/domain/csv_stats_session/stats_options"
+require "csvtool/domain/csv_stats_session/stats_session"
+require "csvtool/domain/shared/output_destination"
+require "tmpdir"
+
+class RunCsvStatsTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_returns_core_stats_summary
+    source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+      path: fixture_path("sample_people.csv"),
+      separator: ",",
+      headers_present: true
+    )
+    session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+      source: source,
+      options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+    )
+
+    result = Csvtool::Application::UseCases::RunCsvStats.new.call(session: session)
+
+    assert result.ok?
+    assert_equal 3, result.data[:row_count]
+    assert_equal 2, result.data[:column_count]
+    assert_equal ["name", "city"], result.data[:headers]
+    assert_equal [
+      { name: "name", blank_count: 0, non_blank_count: 3 },
+      { name: "city", blank_count: 0, non_blank_count: 3 }
+    ], result.data[:column_stats]
+  end
+
+  def test_supports_tsv_separator
+    source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+      path: fixture_path("sample_people.tsv"),
+      separator: "\t",
+      headers_present: true
+    )
+    session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+      source: source,
+      options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+    )
+
+    result = Csvtool::Application::UseCases::RunCsvStats.new.call(session: session)
+
+    assert result.ok?
+    assert_equal 3, result.data[:row_count]
+    assert_equal 2, result.data[:column_count]
+    assert_equal ["name", "city"], result.data[:headers]
+  end
+
+  def test_supports_headerless_mode
+    source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+      path: fixture_path("sample_people_no_headers.csv"),
+      separator: ",",
+      headers_present: false
+    )
+    session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+      source: source,
+      options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+    )
+
+    result = Csvtool::Application::UseCases::RunCsvStats.new.call(session: session)
+
+    assert result.ok?
+    assert_equal 3, result.data[:row_count]
+    assert_equal 2, result.data[:column_count]
+    assert_nil result.data[:headers]
+    assert_equal [
+      { name: "column_1", blank_count: 0, non_blank_count: 3 },
+      { name: "column_2", blank_count: 0, non_blank_count: 3 }
+    ], result.data[:column_stats]
+  end
+
+  def test_supports_custom_separator
+    source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+      path: fixture_path("sample_people_colon.txt"),
+      separator: ":",
+      headers_present: true
+    )
+    session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+      source: source,
+      options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+    )
+
+    result = Csvtool::Application::UseCases::RunCsvStats.new.call(session: session)
+
+    assert result.ok?
+    assert_equal 3, result.data[:row_count]
+    assert_equal 2, result.data[:column_count]
+    assert_equal ["name", "city"], result.data[:headers]
+  end
+
+  def test_computes_blank_and_non_blank_counts
+    source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+      path: fixture_path("sample_people_blanks.csv"),
+      separator: ",",
+      headers_present: true
+    )
+    session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+      source: source,
+      options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+    )
+
+    result = Csvtool::Application::UseCases::RunCsvStats.new.call(session: session)
+
+    assert result.ok?
+    assert_equal [
+      { name: "name", blank_count: 2, non_blank_count: 3 },
+      { name: "city", blank_count: 1, non_blank_count: 4 }
+    ], result.data[:column_stats]
+  end
+
+  def test_writes_stats_to_file_when_file_output_selected
+    Dir.mktmpdir do |dir|
+      source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+        path: fixture_path("sample_people.csv"),
+        separator: ",",
+        headers_present: true
+      )
+      session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+        source: source,
+        options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+      ).with_output_destination(Csvtool::Domain::Shared::OutputDestination.file(path: File.join(dir, "stats.csv")))
+
+      result = Csvtool::Application::UseCases::RunCsvStats.new.call(session: session)
+
+      assert result.ok?
+      assert_equal session.output_destination.path, result.data[:output_path]
+      csv_text = File.read(session.output_destination.path)
+      assert_includes csv_text, "metric,value"
+      assert_includes csv_text, "row_count,3"
+      assert_includes csv_text, "column_count,2"
+    end
+  end
+
+  def test_returns_cannot_write_output_file_when_writer_fails
+    source = Csvtool::Domain::CsvStatsSession::StatsSource.new(
+      path: fixture_path("sample_people.csv"),
+      separator: ",",
+      headers_present: true
+    )
+    session = Csvtool::Domain::CsvStatsSession::StatsSession.start(
+      source: source,
+      options: Csvtool::Domain::CsvStatsSession::StatsOptions.new
+    ).with_output_destination(Csvtool::Domain::Shared::OutputDestination.file(path: "/tmp/out.csv"))
+    writer = Object.new
+    def writer.call(path:, data:)
+      raise Errno::EACCES, path
+    end
+
+    result = Csvtool::Application::UseCases::RunCsvStats.new(csv_stats_file_writer: writer).call(session: session)
+
+    refute result.ok?
+    assert_equal :cannot_write_output_file, result.error
+    assert_equal "/tmp/out.csv", result.data[:path]
+    assert_equal Errno::EACCES, result.data[:error_class]
+  end
+end