tryouts 2.4.1 → 3.0.0.pre2

data/lib/tryouts/testbatch.rb

@@ -1,74 +1,314 @@
-# frozen_string_literal: true
-#
+# lib/tryouts/testbatch.rb
+
+require 'stringio'
+
 class Tryouts
-  class TestBatch < Array
-    class Container
-      def metaclass
-        class << self; end
-      end
+  # 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
-    attr_reader :path, :failed, :lines
-
-    def initialize(path, lines)
-      @path = path
-      @lines = lines
-      @container = Container.new.metaclass
-      @run = false
-      #super
-    end
-
-    def run(before_test, &after_test)
-      return if empty?
-      testcase_score = nil
-
-      setup
-      failed_tests = self.select do |tc|
-        before_test.call(tc) unless before_test.nil?
-        begin
-          testcase_score = tc.run  # returns -1 for failed, 0 for skipped, 1 for passed
-        rescue StandardError => e
-          testcase_score = -1
-          warn Console.color(:red, "Error in test: #{tc.inspect}")
-          warn Console.color(:red, e.message)
-          warn e.backtrace.join($/), $/
-        end
-        after_test.call(tc) # runs the tallying code
-        testcase_score.negative? # select failed tests
+
+    # 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
 
-      warn Console.color(:red, "Failed tests: #{failed_tests.size}") if Tryouts.debug?
-      @failed = failed_tests.size
-      @run = true
-      clean
+      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
 
-    rescue StandardError => e
-      @failed = 1 # so that failed? returns true
-      warn e.message, e.backtrace.join($/), $/
+    def test_cases
+      @testrun.test_cases
+    end
+
+    def path
+      @testrun.source_file
     end
 
     def failed?
-      !@failed.nil? && @failed.positive?
+      @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
 
-    def setup
-      return if empty?
+    # 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
 
-      start = first.desc.nil? ? first.test.first : first.desc.first - 1
-      Tryouts.eval lines[0..start - 1].join, path, 0 if start.positive?
+      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
 
-    def clean
-      return if empty?
+    # 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
 
-      last_line = last.exps.last + 1
-      return unless last_line < lines.size
+      # Execute test in same fresh context
+      code  = test_case.code
+      path  = test_case.path
+      range = test_case.line_range
 
-      Tryouts.eval lines[last_line..-1].join, path, last_line
+      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
 
-    def run?
-      @run
+    # 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,110 +1,51 @@
-# frozen_string_literal: true
+# lib/tryouts/testcase.rb
 
+# Modern data structures using Ruby 3.2+ Data classes
 class Tryouts
-  class TestCase
-    attr_reader :desc, :test, :exps, :path, :testrunner_output, :test_result, :console_output
-
-    def initialize(d, t, e)
-      @desc, @test, @exps, @path = d, t, e
-      @testrunner_output = []
-      @console_output = StringIO.new
+  # Core data structures
+  TestCase = Data.define(:description, :code, :expectations, :line_range, :path, :source_lines) do
+    def empty?
+      code.empty?
     end
 
-    def inspect
-      [@desc.inspect, @test.inspect, @exps.inspect].join
+    def expectations?
+      !expectations.empty?
     end
+  end
 
-    def to_s
-      [@desc.to_s, @test.to_s, @exps.to_s].join
+  Setup = Data.define(:code, :line_range, :path) do
+    def empty?
+      code.empty?
     end
+  end
 
-    def run
-      Tryouts.debug format('%s:%d', @test.path, @test.first)
-      Tryouts.debug inspect, $/
-
-      $stdout = @console_output
-      expectations = exps.collect do |exp, _idx|
-        exp =~ /\A\#?\s*=>\s*(.+)\Z/
-        ::Regexp.last_match(1) # this will be nil if the expectation is commented out
-      end
-
-      Tryouts.info 'Capturing STDOUT for tryout'
-      Tryouts.info 'vvvvvvvvvvvvvvvvvvv'
-      # Evaluate test block only if there are valid expectations
-      unless expectations.compact.empty?  # TODO: fast-fail if no expectations
-        test_value = Tryouts.eval @test.to_s, @test.path, @test.first
-        @has_run = true
-      end
-      Tryouts.info '^^^^^^^^^^^^^^^^^^^'
-
-      Tryouts.info "Capturing STDOUT for expectations"
-      Tryouts.info 'vvvvvvvvvvvvvvvvvvv'
-      expectations.each_with_index do |exp, idx|
-        if exp.nil?
-          @testrunner_output << '     [skipped]'
-          @test_result = 0
-        else
-          # Evaluate expectation
-
-          exp_value = Tryouts.eval(exp, @exps.path, @exps.first + idx)
-
-          test_passed = test_value.eql?(exp_value)
-          @test_result = test_passed ? 1 : -1
-          @testrunner_output << test_value.inspect
-        end
-      end
-      Tryouts.info '^^^^^^^^^^^^^^^^^^^'
-      $stdout = STDOUT # restore stdout
-
-      Tryouts.debug # extra newline
-      failed?
-
-      @test_result
-    rescue StandardError => e
-      Tryouts.debug "[testcaste.run] #{e.message}", e.backtrace.join($/), $/
-      # Continue raising the exception
-      raise e
-    ensure
-      $stdout = STDOUT # restore stdout
-      @test_result
+  Teardown = Data.define(:code, :line_range, :path) do
+    def empty?
+      code.empty?
     end
+  end
 
-    def run?
-      @has_run.eql?(true)
+  Testrun = Data.define(:setup, :test_cases, :teardown, :source_file, :metadata) do
+    def total_tests
+      test_cases.size
     end
 
-    def skipped?
-      @test_result == 0
+    def empty?
+      test_cases.empty?
     end
+  end
 
-    def passed?
-      @test_result == 1
-    end
-    def failed?
-      @test_result == -1
-    end
+  # Enhanced error with context
+  class TryoutSyntaxError < StandardError
+    attr_reader :line_number, :context, :source_file
 
-    def color
-      case @test_result
-      when 1
-        :green
-      when 0
-        :white
-      else
-        :red
-      end
-    end
+    def initialize(message, line_number:, context:, source_file: nil)
+      @line_number = line_number
+      @context     = context
+      @source_file = source_file
 
-    def adjective
-      case @test_result
-      when 1
-        'PASSED'
-      when 0
-        'SKIPPED'
-      else
-        'FAILED'
-      end
+      location = source_file ? "#{source_file}:#{line_number}" : "line #{line_number}"
+      super("#{message} at #{location}: #{context}")
     end
-
   end
 end

data/lib/tryouts/translators/minitest_translator.rb

@@ -0,0 +1,106 @@
+# lib/tryouts/translators/minitest_translator.rb
+
+class Tryouts
+  module Translators
+    class MinitestTranslator
+      def initialize
+        require 'minitest/test'
+      rescue LoadError
+        raise 'Minitest gem is required for Minitest translation'
+      end
+
+      def translate(testrun)
+        file_basename = File.basename(testrun.source_file, '.rb')
+        class_name    = "Test#{file_basename.gsub(/[^A-Za-z0-9]/, '')}"
+
+        test_class = Class.new(Minitest::Test) do
+          # Setup method
+          if testrun.setup && !testrun.setup.empty?
+            define_method(:setup) do
+              instance_eval(testrun.setup.code)
+            end
+          end
+
+          # Generate test methods
+          testrun.test_cases.each_with_index do |test_case, index|
+            next if test_case.empty? || !test_case.expectations?
+
+            method_name = "test_#{index.to_s.rjust(3, '0')}_#{parameterize(test_case.description)}"
+            define_method(method_name) do
+              result = instance_eval(test_case.code) unless test_case.code.strip.empty?
+
+              test_case.expectations.each do |expectation|
+                expected_value = instance_eval(expectation)
+                assert_equal expected_value, result
+              end
+            end
+          end
+
+          # Teardown method
+          if testrun.teardown && !testrun.teardown.empty?
+            define_method(:teardown) do
+              instance_eval(testrun.teardown.code)
+            end
+          end
+        end
+
+        # Set the class name dynamically
+        Object.const_set(class_name, test_class) unless Object.const_defined?(class_name)
+        test_class
+      end
+
+      def generate_code(testrun)
+        file_basename = File.basename(testrun.source_file, '.rb')
+        class_name    = "Test#{file_basename.gsub(/[^A-Za-z0-9]/, '')}"
+        lines         = []
+
+        lines << ''
+        lines << "require 'minitest/test'"
+        lines << "require 'minitest/autorun'"
+        lines << ''
+        lines << "class #{class_name} < Minitest::Test"
+
+        if testrun.setup && !testrun.setup.empty?
+          lines << '  def setup'
+          testrun.setup.code.lines.each { |line| lines << "    #{line.chomp}" }
+          lines << '  end'
+          lines << ''
+        end
+
+        testrun.test_cases.each_with_index do |test_case, index|
+          next if test_case.empty? || !test_case.expectations?
+
+          method_name = "test_#{index.to_s.rjust(3, '0')}_#{parameterize(test_case.description)}"
+          lines << "  def #{method_name}"
+          unless test_case.code.strip.empty?
+            lines << '    result = begin'
+            test_case.code.lines.each { |line| lines << "      #{line.chomp}" }
+            lines << '    end'
+          end
+
+          test_case.expectations.each do |expectation|
+            lines << "    assert_equal #{expectation}, result"
+          end
+          lines << '  end'
+          lines << ''
+        end
+
+        if testrun.teardown && !testrun.teardown.empty?
+          lines << '  def teardown'
+          testrun.teardown.code.lines.each { |line| lines << "    #{line.chomp}" }
+          lines << '  end'
+        end
+
+        lines << 'end'
+        lines.join("\n")
+      end
+
+      private
+
+      # Simple string parameterization for method names
+      def parameterize(string)
+        string.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/^_|_$/, '')
+      end
+    end
+  end
+end