csvops 0.5.0.alpha → 0.7.0.alpha

data/lib/csvtool/domain/csv_parity_session/parity_options.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Domain
+    module CsvParitySession
+      class ParityOptions
+        attr_reader :separator
+
+        def initialize(separator:, headers_present:)
+          raise ArgumentError, "separator cannot be empty" if separator.to_s.empty?
+
+          @separator = separator
+          @headers_present = headers_present
+        end
+
+        def headers_present?
+          @headers_present
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/domain/csv_parity_session/parity_session.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Domain
+    module CsvParitySession
+      class ParitySession
+        attr_reader :source_pair, :options
+
+        def self.start(source_pair:, options:)
+          new(source_pair: source_pair, options: options)
+        end
+
+        def initialize(source_pair:, options:)
+          @source_pair = source_pair
+          @options = options
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/domain/csv_parity_session/source_pair.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Domain
+    module CsvParitySession
+      class SourcePair
+        attr_reader :left_path, :right_path
+
+        def initialize(left_path:, right_path:)
+          raise ArgumentError, "left_path cannot be empty" if left_path.to_s.empty?
+          raise ArgumentError, "right_path cannot be empty" if right_path.to_s.empty?
+
+          @left_path = left_path
+          @right_path = right_path
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/domain/csv_split_session/split_options.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Domain
+    module CsvSplitSession
+      class SplitOptions
+        attr_reader :chunk_size, :output_directory, :file_prefix, :overwrite_existing, :write_manifest, :manifest_path
+
+        def initialize(
+          chunk_size:,
+          output_directory: nil,
+          file_prefix: nil,
+          overwrite_existing: false,
+          write_manifest: false,
+          manifest_path: nil
+        )
+          @chunk_size = Integer(chunk_size)
+          @output_directory = output_directory
+          @file_prefix = file_prefix
+          @overwrite_existing = overwrite_existing
+          @write_manifest = write_manifest
+          @manifest_path = manifest_path
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/domain/csv_split_session/split_session.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Domain
+    module CsvSplitSession
+      class SplitSession
+        attr_reader :source, :options
+
+        def self.start(source:, options:)
+          new(source: source, options: options)
+        end
+
+        def initialize(source:, options:)
+          @source = source
+          @options = options
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/domain/csv_split_session/split_source.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Domain
+    module CsvSplitSession
+      class SplitSource
+        attr_reader :path, :separator, :headers_present
+
+        def initialize(path:, separator:, headers_present:)
+          @path = path
+          @separator = separator
+          @headers_present = headers_present
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/infrastructure/csv/csv_parity_comparator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Csvtool
+  module Infrastructure
+    module CSV
+      class CsvParityComparator
+        def call(left_path:, right_path:, col_sep:, headers_present:, sample_limit: 5)
+          deltas = Hash.new(0)
+          left_rows = stream_rows(path: left_path, col_sep: col_sep, headers_present: headers_present) do |key|
+            deltas[key] += 1
+          end
+          right_rows = stream_rows(path: right_path, col_sep: col_sep, headers_present: headers_present) do |key|
+            deltas[key] -= 1
+          end
+
+          left_only_count, right_only_count, left_only_examples, right_only_examples =
+            mismatch_totals_and_samples(deltas: deltas, sample_limit: sample_limit)
+
+          {
+            match: left_only_count.zero? && right_only_count.zero?,
+            left_rows: left_rows,
+            right_rows: right_rows,
+            left_only_count: left_only_count,
+            right_only_count: right_only_count,
+            left_only_examples: left_only_examples,
+            right_only_examples: right_only_examples
+          }
+        end
+
+        private
+
+        def stream_rows(path:, col_sep:, headers_present:)
+          rows = 0
+
+          ::CSV.foreach(path, headers: headers_present, col_sep: col_sep) do |row|
+            fields = headers_present ? row.fields : row
+            yield serialize(fields: fields, col_sep: col_sep)
+            rows += 1
+          end
+
+          rows
+        end
+
+        def mismatch_totals_and_samples(deltas:, sample_limit:)
+          left_only_count = 0
+          right_only_count = 0
+          left_only_examples = []
+          right_only_examples = []
+
+          deltas.each do |key, delta|
+            if delta.positive?
+              left_only_count += delta
+              left_only_examples << { row: key, count_delta: delta } if left_only_examples.length < sample_limit
+            elsif delta.negative?
+              right_only_count += -delta
+              right_only_examples << { row: key, count_delta: -delta } if right_only_examples.length < sample_limit
+            end
+          end
+
+          [left_only_count, right_only_count, left_only_examples, right_only_examples]
+        end
+
+        def serialize(fields:, col_sep:)
+          ::CSV.generate_line(fields, row_sep: "", col_sep: col_sep).chomp
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/infrastructure/csv/csv_splitter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Csvtool
+  module Infrastructure
+    module CSV
+      class CsvSplitter
+        class OutputFileExistsError < StandardError
+          attr_reader :path
+
+          def initialize(path)
+            super("output file exists: #{path}")
+            @path = path
+          end
+        end
+
+        def call(file_path:, col_sep:, headers_present:, chunk_size:, output_directory:, file_prefix:, overwrite_existing:)
+          ext = File.extname(file_path)
+          ext = ".csv" if ext.empty?
+          sequence = 0
+          data_rows = 0
+          chunk_paths = []
+          chunk_row_counts = []
+          rows_in_chunk = 0
+          current_csv = nil
+
+          write_mode_headers = nil
+          write_headers = headers_present
+
+          ::CSV.foreach(file_path, headers: headers_present, col_sep: col_sep) do |row|
+            if current_csv.nil? || rows_in_chunk >= chunk_size
+              current_csv&.close
+              sequence += 1
+              rows_in_chunk = 0
+              path = File.join(output_directory, format("%<prefix>s_part_%<num>03d%<ext>s", prefix: file_prefix, num: sequence, ext: ext))
+              raise OutputFileExistsError.new(path) if File.exist?(path) && !overwrite_existing
+
+              chunk_paths << path
+              chunk_row_counts << 0
+              write_mode_headers = headers_present ? row.headers : nil
+              current_csv = ::CSV.open(path, "w", write_headers: write_headers, headers: write_mode_headers, col_sep: col_sep)
+            end
+
+            fields = headers_present ? row.fields : row
+            current_csv << fields
+            rows_in_chunk += 1
+            chunk_row_counts[-1] += 1
+            data_rows += 1
+          end
+
+          {
+            chunk_paths: chunk_paths,
+            chunk_count: chunk_paths.length,
+            data_rows: data_rows,
+            chunk_row_counts: chunk_row_counts
+          }
+        ensure
+          current_csv&.close unless current_csv&.closed?
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/infrastructure/output/csv_split_manifest_writer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Csvtool
+  module Infrastructure
+    module Output
+      class CsvSplitManifestWriter
+        def call(path:, chunk_paths:, chunk_row_counts:)
+          ::CSV.open(path, "w") do |csv|
+            csv << %w[chunk_index chunk_path row_count]
+            chunk_paths.each_with_index do |chunk_path, index|
+              csv << [index + 1, chunk_path, chunk_row_counts[index]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csvtool/interface/cli/errors/presenter.rb

@@ -33,6 +33,10 @@ module Csvtool
             @stdout.puts "Cannot write output file: #{path} (#{error_class})"
           end
 
+          def output_file_exists(path)
+            @stdout.puts "Output file already exists: #{path}"
+          end
+
           def empty_output_path
             @stdout.puts "Output file path cannot be empty."
           end
@@ -53,6 +57,10 @@ module Csvtool
             @stdout.puts "Seed must be an integer."
           end
 
+          def invalid_chunk_size
+            @stdout.puts "Chunk size must be a positive integer."
+          end
+
           def canceled
             @stdout.puts "Canceled."
           end
@@ -72,6 +80,10 @@ module Csvtool
           def row_range_out_of_bounds(total_rows)
             @stdout.puts "Row range is out of bounds. File has #{total_rows} data rows."
           end
+
+          def header_mismatch
+            @stdout.puts "CSV headers do not match."
+          end
         end
       end
     end

data/lib/csvtool/interface/cli/menu_loop.rb

@@ -4,7 +4,7 @@ module Csvtool
   module Interface
     module CLI
       class MenuLoop
-        def initialize(stdin:, stdout:, menu_options:, extract_column_action:, extract_rows_action:, randomize_rows_action:, dedupe_action:)
+        def initialize(stdin:, stdout:, menu_options:, extract_column_action:, extract_rows_action:, randomize_rows_action:, dedupe_action:, parity_action:, split_action:)
           @stdin = stdin
           @stdout = stdout
           @menu_options = menu_options
@@ -12,6 +12,8 @@ module Csvtool
           @extract_rows_action = extract_rows_action
           @randomize_rows_action = randomize_rows_action
           @dedupe_action = dedupe_action
+          @parity_action = parity_action
+          @split_action = split_action
         end
 
         def run
@@ -31,9 +33,13 @@ module Csvtool
             when "4"
               @dedupe_action.call
             when "5"
+              @parity_action.call
+            when "6"
+              @split_action.call
+            when "7"
               return 0
             else
-              @stdout.puts "Please choose 1, 2, 3, 4, or 5."
+              @stdout.puts "Please choose 1, 2, 3, 4, 5, 6, or 7."
             end
           end
         end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Prompts
+        class ChunkSizePrompt
+          def initialize(stdin:, stdout:)
+            @stdin = stdin
+            @stdout = stdout
+          end
+
+          def call
+            @stdout.print "Rows per chunk: "
+            @stdin.gets&.strip.to_s
+          end
+        end
+      end
+    end
+  end
+end

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_parity_session_builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "csvtool/domain/csv_parity_session/source_pair"
+require "csvtool/domain/csv_parity_session/parity_options"
+require "csvtool/domain/csv_parity_session/parity_session"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Builders
+          class CsvParitySessionBuilder
+            def call(left_path:, right_path:, col_sep:, headers_present:)
+              source_pair = Domain::CsvParitySession::SourcePair.new(
+                left_path: left_path,
+                right_path: right_path
+              )
+              options = Domain::CsvParitySession::ParityOptions.new(
+                separator: col_sep,
+                headers_present: headers_present
+              )
+
+              Domain::CsvParitySession::ParitySession.start(
+                source_pair: source_pair,
+                options: options
+              )
+            end
+          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_parity_presenter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        module Presenters
+          class CsvParityPresenter
+            def initialize(stdout:)
+              @stdout = stdout
+            end
+
+            def print_summary(data)
+              @stdout.puts(data[:match] ? "MATCH" : "MISMATCH")
+              @stdout.puts "Summary: left_rows=#{data[:left_rows]} right_rows=#{data[:right_rows]} " \
+                           "left_only=#{data[:left_only_count]} right_only=#{data[:right_only_count]}"
+              return if data[:match]
+
+              print_examples("Left-only examples", data[:left_only_examples])
+              print_examples("Right-only examples", data[:right_only_examples])
+            end
+
+            private
+
+            def print_examples(label, examples)
+              return if examples.nil? || examples.empty?
+
+              @stdout.puts "#{label}:"
+              examples.each do |example|
+                @stdout.puts "  #{example[:row]} (count +#{example[:count_delta]})"
+              end
+            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_parity_workflow.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "csvtool/application/use_cases/run_csv_parity"
+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/workflows/builders/csv_parity_session_builder"
+require "csvtool/interface/cli/workflows/presenters/csv_parity_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/parity/collect_inputs_step"
+require "csvtool/interface/cli/workflows/steps/parity/build_session_step"
+require "csvtool/interface/cli/workflows/steps/parity/execute_step"
+
+module Csvtool
+  module Interface
+    module CLI
+      module Workflows
+        class RunCsvParityWorkflow
+          def initialize(stdin:, stdout:, use_case: Application::UseCases::RunCsvParity.new)
+            @stdin = stdin
+            @stdout = stdout
+            @use_case = use_case
+            @errors = Interface::CLI::Errors::Presenter.new(stdout: stdout)
+            @session_builder = Builders::CsvParitySessionBuilder.new
+            @presenter = Presenters::CsvParityPresenter.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::Parity::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::Parity::BuildSessionStep.new,
+              Steps::Parity::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]) },
+              no_headers: ->(_r, errors) { errors.no_headers },
+              header_mismatch: ->(_r, errors) { errors.header_mismatch }
+            })
+          end
+        end
+      end
+    end
+  end
+end