tryouts 3.0.0 → 3.1.1

data/lib/tryouts/testbatch.rb

@@ -1,314 +0,0 @@
-# lib/tryouts/testbatch.rb
-
-require 'stringio'
-
-class Tryouts
-  # Modern TestBatch using Ruby 3.4+ patterns and formatter system
-  class TestBatch
-    attr_reader :testrun, :failed_count, :container, :status, :results, :formatter, :output_manager
-
-    def initialize(testrun, **options)
-      @testrun        = testrun
-      @container      = Object.new
-      @options        = options
-      @formatter      = Tryouts::CLI::FormatterFactory.create_formatter(options)
-      @output_manager = options[:output_manager]
-      @global_tally   = options[:global_tally]
-      @failed_count   = 0
-      @status         = :pending
-      @results        = []
-      @start_time     = nil
-    end
-
-    # Main execution pipeline using functional composition
-    def run(before_test_hook = nil, &)
-      return false if empty?
-
-      @start_time = Time.now
-      @output_manager&.execution_phase(test_cases.size)
-      @output_manager&.info("Context: #{@options[:shared_context] ? 'shared' : 'fresh'}", 1)
-      @output_manager&.file_start(path, context: @options[:shared_context] ? :shared : :fresh)
-
-      if shared_context?
-        @output_manager&.info('Running global setup...', 2)
-        execute_global_setup
-      end
-
-      idx               = 0
-      execution_results = test_cases.map do |test_case|
-        @output_manager&.trace("Test #{idx + 1}/#{test_cases.size}: #{test_case.description}", 2)
-        idx                     += 1
-        result                   = execute_single_test(test_case, before_test_hook, &) # runs the test code
-        result
-      end
-
-      execute_global_teardown
-      finalize_results(execution_results)
-
-      @status = :completed
-      !failed?
-    end
-
-    def empty?
-      @testrun.empty?
-    end
-
-    def size
-      @testrun.total_tests
-    end
-
-    def test_cases
-      @testrun.test_cases
-    end
-
-    def path
-      @testrun.source_file
-    end
-
-    def failed?
-      @failed_count > 0
-    end
-
-    def completed?
-      @status == :completed
-    end
-
-    private
-
-    # Pattern matching for execution strategy selection
-    def execute_single_test(test_case, before_test_hook = nil)
-      before_test_hook&.call(test_case)
-
-      # Capture output during test execution
-      result          = nil
-      captured_output = capture_output do
-        result = case @options[:shared_context]
-                 when true
-                   execute_with_shared_context(test_case)
-                 when false, nil
-                   execute_with_fresh_context(test_case)
-                 else
-                   raise 'Invalid execution context configuration'
-                 end
-      end
-
-      # Add captured output to the result
-      result[:captured_output] = captured_output if captured_output && !captured_output.empty?
-
-      process_test_result(result)
-      yield(test_case) if block_given?
-      result
-    end
-
-    # Shared context execution - setup runs once, all tests share state
-    def execute_with_shared_context(test_case)
-      code  = test_case.code
-      path  = test_case.path
-      range = test_case.line_range
-
-      result_value        = @container.instance_eval(code, path, range.first + 1)
-      expectations_result = evaluate_expectations(test_case, result_value, @container)
-
-      build_test_result(test_case, result_value, expectations_result)
-    rescue StandardError => ex
-      build_error_result(test_case, ex.message, ex)
-    end
-
-    # Fresh context execution - setup runs per test, isolated state
-    def execute_with_fresh_context(test_case)
-      fresh_container = Object.new
-
-      # Execute setup in fresh context if present
-      setup = @testrun.setup
-      if setup && !setup.code.empty?
-        fresh_container.instance_eval(setup.code, setup.path, 1)
-      end
-
-      # Execute test in same fresh context
-      code  = test_case.code
-      path  = test_case.path
-      range = test_case.line_range
-
-      result_value        = fresh_container.instance_eval(code, path, range.first + 1)
-      expectations_result = evaluate_expectations(test_case, result_value, fresh_container)
-
-      build_test_result(test_case, result_value, expectations_result)
-    rescue StandardError => ex
-      build_error_result(test_case, ex.message, ex)
-    end
-
-    # Evaluate expectations using pattern matching for clean result handling
-    def evaluate_expectations(test_case, actual_result, context)
-      if test_case.expectations.empty?
-        { passed: true, actual_results: [], expected_results: [] }
-      else
-        evaluation_results = test_case.expectations.map do |expectation|
-          evaluate_single_expectation(expectation, actual_result, context, test_case)
-        end
-
-        {
-          passed: evaluation_results.all? { |r| r[:passed] },
-          actual_results: evaluation_results.map { |r| r[:actual] },
-          expected_results: evaluation_results.map { |r| r[:expected] },
-        }
-      end
-    end
-
-    def evaluate_single_expectation(expectation, actual_result, context, test_case)
-      path  = test_case.path
-      range = test_case.line_range
-
-      expected_value = context.instance_eval(expectation, path, range.first + 1)
-
-      {
-        passed: actual_result == expected_value,
-        actual: actual_result,
-        expected: expected_value,
-        expectation: expectation,
-      }
-    rescue StandardError => ex
-      {
-        passed: false,
-        actual: actual_result,
-        expected: "EXPECTED: #{ex.message}",
-        expectation: expectation,
-      }
-    end
-
-    # Build structured test results using pattern matching
-    def build_test_result(test_case, result_value, expectations_result)
-      if expectations_result[:passed]
-        {
-          test_case: test_case,
-          status: :passed,
-          result_value: result_value,
-          actual_results: expectations_result[:actual_results],
-          error: nil,
-        }
-      else
-        {
-          test_case: test_case,
-          status: :failed,
-          result_value: result_value,
-          actual_results: expectations_result[:actual_results],
-          error: nil,
-        }
-      end
-    end
-
-    def build_error_result(test_case, message, exception = nil)
-      {
-        test_case: test_case,
-        status: :error,
-        result_value: nil,
-        actual_results: ["ACTUAL: #{message}"],
-        error: exception,
-      }
-    end
-
-    # Process and display test results using formatter
-    def process_test_result(result)
-      @results << result
-
-      if [:failed, :error].include?(result[:status])
-        @failed_count += 1
-      end
-
-      show_test_result(result)
-
-      # Show captured output if any exists
-      if result[:captured_output] && !result[:captured_output].empty?
-        @output_manager&.test_output(result[:test_case], result[:captured_output])
-      end
-    end
-
-    # Global setup execution for shared context mode
-    def execute_global_setup
-      setup = @testrun.setup
-
-      if setup && !setup.code.empty? && @options[:shared_context]
-        @output_manager&.setup_start(setup.line_range)
-
-        # Capture setup output instead of letting it print directly
-        captured_output = capture_output do
-          @container.instance_eval(setup.code, setup.path, setup.line_range.first + 1)
-        end
-
-        @output_manager&.setup_output(captured_output) if captured_output && !captured_output.empty?
-      end
-    rescue StandardError => ex
-      @global_tally[:total_errors] += 1 if @global_tally
-      raise "Global setup failed: #{ex.message}"
-    end
-
-    # Global teardown execution
-    def execute_global_teardown
-      teardown = @testrun.teardown
-
-      if teardown && !teardown.code.empty?
-        @output_manager&.teardown_start(teardown.line_range)
-
-        # Capture teardown output instead of letting it print directly
-        captured_output = capture_output do
-          @container.instance_eval(teardown.code, teardown.path, teardown.line_range.first + 1)
-        end
-
-        @output_manager&.teardown_output(captured_output) if captured_output && !captured_output.empty?
-      end
-    rescue StandardError => ex
-      @global_tally[:total_errors] += 1 if @global_tally
-      @output_manager&.error("Teardown failed: #{ex.message}")
-    end
-
-    # Result finalization and summary display
-    def finalize_results(_execution_results)
-      @status      = :completed
-      elapsed_time = Time.now - @start_time
-      show_summary(elapsed_time)
-    end
-
-
-    def show_test_result(result)
-      test_case = result[:test_case]
-      status    = result[:status]
-      actuals   = result[:actual_results]
-
-      @output_manager&.test_result(test_case, status, actuals)
-    end
-
-    def show_summary(elapsed_time)
-      @output_manager&.batch_summary(size, @failed_count, elapsed_time)
-    end
-
-    # Helper methods using pattern matching
-
-    def shared_context?
-      @options[:shared_context] == true
-    end
-
-    def capture_output
-      old_stdout = $stdout
-      old_stderr = $stderr
-      $stdout    = StringIO.new
-      $stderr    = StringIO.new
-
-      yield
-
-      captured = $stdout.string + $stderr.string
-      captured.empty? ? nil : captured
-    ensure
-      $stdout = old_stdout
-      $stderr = old_stderr
-    end
-
-    def handle_batch_error(exception)
-      @status       = :error
-      @failed_count = 1
-
-      error_message = "Batch execution failed: #{exception.message}"
-      backtrace     = exception.respond_to?(:backtrace) ? exception.backtrace : nil
-
-      @output_manager&.error(error_message, backtrace)
-    end
-  end
-end

data/lib/tryouts/testcase.rb

@@ -1,51 +0,0 @@
-# lib/tryouts/testcase.rb
-
-# Modern data structures using Ruby 3.2+ Data classes
-class Tryouts
-  # Core data structures
-  TestCase = Data.define(:description, :code, :expectations, :line_range, :path, :source_lines) do
-    def empty?
-      code.empty?
-    end
-
-    def expectations?
-      !expectations.empty?
-    end
-  end
-
-  Setup = Data.define(:code, :line_range, :path) do
-    def empty?
-      code.empty?
-    end
-  end
-
-  Teardown = Data.define(:code, :line_range, :path) do
-    def empty?
-      code.empty?
-    end
-  end
-
-  Testrun = Data.define(:setup, :test_cases, :teardown, :source_file, :metadata) do
-    def total_tests
-      test_cases.size
-    end
-
-    def empty?
-      test_cases.empty?
-    end
-  end
-
-  # Enhanced error with context
-  class TryoutSyntaxError < StandardError
-    attr_reader :line_number, :context, :source_file
-
-    def initialize(message, line_number:, context:, source_file: nil)
-      @line_number = line_number
-      @context     = context
-      @source_file = source_file
-
-      location = source_file ? "#{source_file}:#{line_number}" : "line #{line_number}"
-      super("#{message} at #{location}: #{context}")
-    end
-  end
-end