csvops 0.6.0.alpha → 0.8.0.alpha

data/test/csvtool/interface/cli/workflows/run_csv_split_workflow_test.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/workflows/run_csv_split_workflow"
+require "tmpdir"
+require "fileutils"
+
+class RunCsvSplitWorkflowTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_workflow_splits_into_chunk_files
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      input = [source_path, "", "", "10", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Split complete."
+      assert_includes out.string, "Chunk size: 10"
+      assert_includes out.string, "Chunks written: 3"
+      assert File.file?(File.join(dir, "people_part_001.csv"))
+      assert File.file?(File.join(dir, "people_part_002.csv"))
+      assert File.file?(File.join(dir, "people_part_003.csv"))
+    end
+  end
+
+  def test_workflow_supports_tsv_separator
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.tsv")
+      FileUtils.cp(fixture_path("sample_people.tsv"), source_path)
+      input = [source_path, "2", "", "2", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      chunk_path = File.join(dir, "people_part_001.tsv")
+      assert File.file?(chunk_path)
+      assert_includes File.read(chunk_path), "name\tcity"
+    end
+  end
+
+  def test_workflow_supports_headerless_mode
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("sample_people_no_headers.csv"), source_path)
+      input = [source_path, "", "n", "2", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      chunk_path = File.join(dir, "people_part_001.csv")
+      lines = File.read(chunk_path).lines.map(&:strip)
+      assert_equal "Alice,London", lines.first
+      assert_equal "Bob,Paris", lines.last
+    end
+  end
+
+  def test_workflow_supports_custom_separator
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.txt")
+      FileUtils.cp(fixture_path("sample_people_colon.txt"), source_path)
+      input = [source_path, "5", ":", "", "2", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      chunk_path = File.join(dir, "people_part_001.txt")
+      assert File.file?(chunk_path)
+      assert_includes File.read(chunk_path), "name:city"
+    end
+  end
+
+  def test_workflow_uses_custom_output_directory_and_prefix
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      output_dir = File.join(dir, "chunks")
+      Dir.mkdir(output_dir)
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      input = [source_path, "", "", "10", output_dir, "batch", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert File.file?(File.join(output_dir, "batch_part_001.csv"))
+      assert File.file?(File.join(output_dir, "batch_part_002.csv"))
+      assert File.file?(File.join(output_dir, "batch_part_003.csv"))
+    end
+  end
+
+  def test_workflow_does_not_overwrite_existing_file_without_confirmation
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      existing = File.join(dir, "people_part_001.csv")
+      File.write(existing, "sentinel\n")
+      input = [source_path, "", "", "10", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Output file already exists: #{existing}"
+      assert_equal "sentinel\n", File.read(existing)
+    end
+  end
+
+  def test_workflow_reports_missing_file
+    out = StringIO.new
+    input = ["/tmp/does-not-exist.csv", "", "", "10", "", "", "", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "File not found: /tmp/does-not-exist.csv"
+  end
+
+  def test_workflow_rejects_invalid_chunk_size
+    out = StringIO.new
+    input = [fixture_path("sample_people.csv"), "", "", "abc"].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Chunk size must be a positive integer."
+  end
+
+  def test_workflow_creates_output_directory_when_missing
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      output_dir = File.join(dir, "chunks")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      input = [source_path, "", "", "10", output_dir, "people", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert Dir.exist?(output_dir)
+      assert File.file?(File.join(output_dir, "people_part_001.csv"))
+    end
+  end
+
+  def test_workflow_can_write_manifest_when_enabled
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      manifest_path = File.join(dir, "manifest.csv")
+      input = [source_path, "", "", "10", "", "", "", "y", manifest_path].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert File.file?(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"
+      assert_includes out.string, "Manifest: #{manifest_path}"
+    end
+  end
+end

data/test/csvtool/interface/cli/workflows/run_csv_stats_workflow_test.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/workflows/run_csv_stats_workflow"
+require "tmpdir"
+
+class RunCsvStatsWorkflowTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_workflow_prints_core_stats_summary
+    out = StringIO.new
+    input = [fixture_path("sample_people.csv"), "", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "CSV Stats Summary"
+    assert_includes out.string, "Rows: 3"
+    assert_includes out.string, "Columns: 2"
+    assert_includes out.string, "Headers: name, city"
+    assert_includes out.string, "Column completeness:"
+    assert_includes out.string, "name: non_blank=3 blank=0"
+    assert_includes out.string, "city: non_blank=3 blank=0"
+  end
+
+  def test_workflow_supports_tsv_separator
+    out = StringIO.new
+    input = [fixture_path("sample_people.tsv"), "2", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Rows: 3"
+    assert_includes out.string, "Columns: 2"
+    assert_includes out.string, "Headers: name, city"
+  end
+
+  def test_workflow_supports_headerless_mode
+    out = StringIO.new
+    input = [fixture_path("sample_people_no_headers.csv"), "", "n"].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Rows: 3"
+    assert_includes out.string, "Columns: 2"
+    refute_includes out.string, "Headers:"
+    assert_includes out.string, "column_1: non_blank=3 blank=0"
+    assert_includes out.string, "column_2: non_blank=3 blank=0"
+  end
+
+  def test_workflow_supports_custom_separator
+    out = StringIO.new
+    input = [fixture_path("sample_people_colon.txt"), "5", ":", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Rows: 3"
+    assert_includes out.string, "Columns: 2"
+    assert_includes out.string, "Headers: name, city"
+  end
+
+  def test_workflow_prints_column_completeness_for_blank_values
+    out = StringIO.new
+    input = [fixture_path("sample_people_blanks.csv"), "", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "name: non_blank=3 blank=2"
+    assert_includes out.string, "city: non_blank=4 blank=1"
+  end
+
+  def test_workflow_reports_missing_file
+    out = StringIO.new
+    input = ["/tmp/does-not-exist.csv", "", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "File not found: /tmp/does-not-exist.csv"
+    refute_includes out.string, "Traceback"
+  end
+
+  def test_workflow_reports_parse_error
+    out = StringIO.new
+    input = [fixture_path("sample_people_bad_tail.csv"), "", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Could not parse CSV file."
+    refute_includes out.string, "Traceback"
+  end
+
+  def test_workflow_can_write_stats_to_file
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "stats.csv")
+      input = [fixture_path("sample_people.csv"), "", "", "2", output_path].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Wrote output to #{output_path}"
+      csv_text = File.read(output_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_workflow_reports_cannot_write_output_file
+    out = StringIO.new
+    output_path = "/tmp/does-not-exist-dir/stats.csv"
+    input = [fixture_path("sample_people.csv"), "", "", "2", output_path].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvStatsWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Cannot write output file: #{output_path} (Errno::ENOENT)"
+    refute_includes out.string, "Traceback"
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/build_session_step_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/build_session_step"
+
+class BuildSessionStepTest < Minitest::Test
+  class FakeBuilder
+    attr_reader :params
+
+    def call(**params)
+      @params = params
+      :session
+    end
+  end
+
+  def test_builds_session_from_context
+    builder = FakeBuilder.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::BuildSessionStep.new
+    context = {
+      session_builder: builder,
+      file_path: "/tmp/data.csv",
+      col_sep: ",",
+      headers_present: true,
+      chunk_size: 10,
+      output_directory: "/tmp/out",
+      file_prefix: "batch",
+      overwrite_existing: true,
+      write_manifest: true,
+      manifest_path: "/tmp/out/manifest.csv"
+    }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal :session, context[:session]
+    assert_equal "/tmp/data.csv", builder.params[:file_path]
+    assert_equal true, builder.params[:write_manifest]
+    assert_equal "/tmp/out/manifest.csv", builder.params[:manifest_path]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/collect_inputs_step_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_inputs_step"
+
+class CollectInputsStepTest < Minitest::Test
+  class FakePrompt
+    def initialize(value)
+      @value = value
+    end
+
+    def call(label: nil)
+      @value
+    end
+  end
+
+  class FakeErrors
+    attr_reader :invalid_chunk_size_calls
+
+    def initialize
+      @invalid_chunk_size_calls = 0
+    end
+
+    def invalid_chunk_size
+      @invalid_chunk_size_calls += 1
+    end
+  end
+
+  def test_collects_inputs_into_context
+    errors = FakeErrors.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectInputsStep.new(
+      file_path_prompt: FakePrompt.new("/tmp/data.csv"),
+      separator_prompt: FakePrompt.new(","),
+      headers_present_prompt: FakePrompt.new(true),
+      chunk_size_prompt: FakePrompt.new("10"),
+      errors: errors
+    )
+    context = {}
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp/data.csv", context[:file_path]
+    assert_equal ",", context[:col_sep]
+    assert_equal true, context[:headers_present]
+    assert_equal 10, context[:chunk_size]
+  end
+
+  def test_halts_on_invalid_chunk_size
+    errors = FakeErrors.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectInputsStep.new(
+      file_path_prompt: FakePrompt.new("/tmp/data.csv"),
+      separator_prompt: FakePrompt.new(","),
+      headers_present_prompt: FakePrompt.new(true),
+      chunk_size_prompt: FakePrompt.new("abc"),
+      errors: errors
+    )
+
+    result = step.call({})
+
+    assert_equal :halt, result
+    assert_equal 1, errors.invalid_chunk_size_calls
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/collect_manifest_step_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_manifest_step"
+
+class CollectManifestStepTest < Minitest::Test
+  class FakeSplitManifestPrompt
+    attr_reader :default_path
+
+    def call(default_path:)
+      @default_path = default_path
+      { write_manifest: true, manifest_path: "/tmp/out/custom_manifest.csv" }
+    end
+  end
+
+  def test_sets_manifest_values_in_context
+    prompt = FakeSplitManifestPrompt.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectManifestStep.new(
+      split_manifest_prompt: prompt
+    )
+    context = { output_directory: "/tmp/out", file_prefix: "batch" }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp/out/batch_manifest.csv", prompt.default_path
+    assert_equal true, context[:write_manifest]
+    assert_equal "/tmp/out/custom_manifest.csv", context[:manifest_path]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/collect_output_step_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_output_step"
+
+class CollectOutputStepTest < Minitest::Test
+  class FakeSplitOutputPrompt
+    attr_reader :received
+
+    def call(default_directory:, default_prefix:)
+      @received = { default_directory: default_directory, default_prefix: default_prefix }
+      { output_directory: "/tmp/out", file_prefix: "batch", overwrite_existing: true }
+    end
+  end
+
+  def test_sets_output_values_in_context
+    prompt = FakeSplitOutputPrompt.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectOutputStep.new(
+      split_output_prompt: prompt
+    )
+    context = { file_path: "/tmp/people.csv" }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp", prompt.received[:default_directory]
+    assert_equal "people", prompt.received[:default_prefix]
+    assert_equal "/tmp/out", context[:output_directory]
+    assert_equal "batch", context[:file_prefix]
+    assert_equal true, context[:overwrite_existing]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/execute_step_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/execute_step"
+
+class SplitExecuteStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    def initialize(headers_result:, run_result:)
+      @headers_result = headers_result
+      @run_result = run_result
+    end
+
+    def read_headers(file_path:, col_sep:, headers_present:)
+      @headers_called = [file_path, col_sep, headers_present]
+      @headers_result
+    end
+
+    def call(session:)
+      @session = session
+      @run_result
+    end
+
+    attr_reader :headers_called, :session
+  end
+
+  class FakePresenter
+    attr_reader :summary
+
+    def print_summary(data)
+      @summary = data
+    end
+  end
+
+  def test_handles_header_failure
+    headers_fail = Result.new(false, { path: "/tmp/missing.csv" })
+    use_case = FakeUseCase.new(headers_result: headers_fail, run_result: Result.new(true, {}))
+    handled = []
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::ExecuteStep.new
+
+    result = step.call(
+      file_path: "/tmp/missing.csv",
+      col_sep: ",",
+      headers_present: true,
+      chunk_size: 10,
+      use_case: use_case,
+      session: Object.new,
+      presenter: FakePresenter.new,
+      handle_error: ->(r) { handled << r }
+    )
+
+    assert_equal :halt, result
+    assert_equal [headers_fail], handled
+  end
+
+  def test_prints_summary_on_success
+    use_case = FakeUseCase.new(
+      headers_result: Result.new(true, { headers: %w[name city] }),
+      run_result: Result.new(true, { chunk_count: 3, chunk_paths: ["/tmp/a.csv"], data_rows: 25 })
+    )
+    presenter = FakePresenter.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::ExecuteStep.new
+
+    result = step.call(
+      file_path: "/tmp/people.csv",
+      col_sep: ",",
+      headers_present: true,
+      chunk_size: 10,
+      use_case: use_case,
+      session: :session,
+      presenter: presenter,
+      handle_error: ->(_r) { raise "unexpected" }
+    )
+
+    assert_nil result
+    assert_equal :session, use_case.session
+    assert_equal 10, presenter.summary[:chunk_size]
+    assert_equal 3, presenter.summary[:chunk_count]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_stats/build_session_step_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_stats/build_session_step"
+
+class CsvStatsBuildSessionStepTest < Minitest::Test
+  class FakeBuilder
+    attr_reader :params
+
+    def call(**params)
+      @params = params
+      :session
+    end
+  end
+
+  def test_builds_session_from_context
+    builder = FakeBuilder.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvStats::BuildSessionStep.new
+    context = {
+      session_builder: builder,
+      file_path: "/tmp/data.csv",
+      col_sep: "\t",
+      headers_present: true,
+      output_destination: :destination
+    }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal :session, context[:session]
+    assert_equal "/tmp/data.csv", builder.params[:file_path]
+    assert_equal "\t", builder.params[:col_sep]
+    assert_equal true, builder.params[:headers_present]
+    assert_equal :destination, builder.params[:destination]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_stats/collect_destination_step_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_stats/collect_destination_step"
+
+class CsvStatsCollectDestinationStepTest < Minitest::Test
+  class FakePrompt
+    def initialize(result)
+      @result = result
+    end
+
+    def call
+      @result
+    end
+  end
+
+  class FakeMapper
+    attr_reader :input
+
+    def call(input)
+      @input = input
+      :mapped_destination
+    end
+  end
+
+  def test_collects_and_maps_destination
+    mapper = FakeMapper.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvStats::CollectDestinationStep.new(
+      output_destination_prompt: FakePrompt.new({ mode: :file, path: "/tmp/out.csv" })
+    )
+    context = { output_destination_mapper: mapper }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal({ mode: :file, path: "/tmp/out.csv" }, mapper.input)
+    assert_equal :mapped_destination, context[:output_destination]
+  end
+
+  def test_halts_when_destination_prompt_returns_nil
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvStats::CollectDestinationStep.new(
+      output_destination_prompt: FakePrompt.new(nil)
+    )
+
+    result = step.call(output_destination_mapper: FakeMapper.new)
+
+    assert_equal :halt, result
+  end
+end