tryouts 2.4.1 → 3.0.0.pre2

data/lib/tryouts/cli/formatters/verbose.rb

@@ -0,0 +1,344 @@
+# lib/tryouts/cli/formatters/verbose.rb
+
+class Tryouts
+  class CLI
+    # Detailed formatter with comprehensive output and clear visual hierarchy
+    class VerboseFormatter
+      include FormatterInterface
+
+      def initialize(options = {})
+        @line_width     = options.fetch(:line_width, 70)
+        @show_passed    = options.fetch(:show_passed, true)
+        @show_debug     = options.fetch(:debug, false)
+        @show_trace     = options.fetch(:trace, false)
+        @current_indent = 0
+      end
+
+      # Phase-level output
+      def phase_header(message, _file_count = nil, level = 0)
+        return if level.equal?(1)
+
+        separators = [
+          { char: '=', width: @line_width },      # Major phases
+          { char: '-', width: @line_width - 10 }, # Sub-phases
+          { char: '.', width: @line_width - 20 }, # Details
+          { char: '~', width: @line_width - 30 }, # Minor items
+        ]
+
+        config = separators[level] || separators.last
+
+        separator_line = config[:char] * config[:width]
+        header_line    = message.center(config[:width])
+
+        output = case level
+        when 0, 1
+          ['', separator_line, header_line, separator_line]
+        else
+          ['', header_line, separator_line]
+        end
+
+        with_indent(level) do
+          puts output.join("\n")
+        end
+        puts
+      end
+
+      # File-level operations
+      def file_start(file_path, _context_info = {})
+        puts file_header_visual(file_path)
+      end
+
+      def file_parsed(_file_path, _test_count, setup_present: false, teardown_present: false)
+        message = ''
+
+        extras   = []
+        extras << 'setup' if setup_present
+        extras << 'teardown' if teardown_present
+        message += " (#{extras.join(', ')})" unless extras.empty?
+
+        puts indent_text(message, 2)
+      end
+
+      def file_execution_start(_file_path, test_count, context_mode)
+        message = "Running #{test_count} tests with #{context_mode} context"
+        puts indent_text(message, 1)
+      end
+
+      def file_result(_file_path, total_tests, failed_count, error_count, elapsed_time)
+        issues_count = failed_count + error_count
+        details      = []
+
+        status = if issues_count > 0
+          details << "#{failed_count} failed" if failed_count > 0
+          details << "#{error_count} errors" if error_count > 0
+          details_str = details.join(', ')
+          Console.color(:red, "✗ #{issues_count}/#{total_tests} tests had issues (#{details_str})")
+        else
+          Console.color(:green, "✓ #{total_tests} tests passed")
+        end
+
+        puts indent_text(status, 2)
+        return unless elapsed_time
+
+        time_msg =
+          if elapsed_time < 2.0
+            "Completed in #{(elapsed_time * 1000).round}ms"
+          else
+            "Completed in #{elapsed_time.round(3)}s"
+          end
+        puts indent_text(Console.color(:dim, time_msg), 2)
+      end
+
+      # Test-level operations
+      def test_start(test_case, index, total)
+        desc    = test_case.description.to_s
+        desc    = 'Unnamed test' if desc.empty?
+        message = "Test #{index}/#{total}: #{desc}"
+        puts indent_text(Console.color(:dim, message), 2)
+      end
+
+      def test_result(test_case, result_status, actual_results = [], _elapsed_time = nil)
+        should_show = @show_passed || result_status != :passed
+
+        return unless should_show
+
+        status_line = case result_status
+                      when :passed
+          Console.color(:green, 'PASSED')
+                      when :failed
+          Console.color(:red, 'FAILED')
+                      when :error
+          Console.color(:red, 'ERROR')
+                      when :skipped
+          Console.color(:yellow, 'SKIPPED')
+        else
+          'UNKNOWN'
+                      end
+
+        location = "#{Console.pretty_path(test_case.path)}:#{test_case.line_range.first + 1}"
+        puts indent_text("#{status_line} #{test_case.description} @ #{location}", 2)
+
+        # Show source code for verbose mode
+        show_test_source_code(test_case)
+
+        # Show failure details for failed tests
+        if [:failed, :error].include?(result_status)
+          show_failure_details(test_case, actual_results)
+        end
+      end
+
+      def test_output(_test_case, output_text)
+        return if output_text.nil? || output_text.strip.empty?
+
+        puts indent_text('Test Output:', 3)
+        puts indent_text(Console.color(:dim, '--- BEGIN OUTPUT ---'), 3)
+
+        output_text.lines.each do |line|
+          puts indent_text(line.chomp, 4)
+        end
+
+        puts indent_text(Console.color(:dim, '--- END OUTPUT ---'), 3)
+        puts
+      end
+
+      # Setup/teardown operations
+      def setup_start(line_range)
+        message = "Executing global setup (lines #{line_range.first}..#{line_range.last})"
+        puts indent_text(Console.color(:cyan, message), 2)
+      end
+
+      def setup_output(output_text)
+        return if output_text.strip.empty?
+
+        output_text.lines.each do |line|
+          puts indent_text(line.chomp, 0)
+        end
+      end
+
+      def teardown_start(line_range)
+        message = "Executing teardown (lines #{line_range.first}..#{line_range.last})"
+        puts indent_text(Console.color(:cyan, message), 2)
+      end
+
+      def teardown_output(output_text)
+        return if output_text.strip.empty?
+
+        output_text.lines.each do |line|
+          puts indent_text(line.chomp, 0)
+        end
+      end
+
+      # Summary operations
+      def batch_summary(total_tests, failed_count, elapsed_time)
+        if failed_count > 0
+          passed  = total_tests - failed_count
+          message = "#{failed_count} failed, #{passed} passed"
+          color   = :red
+        else
+          message = "#{total_tests} tests passed"
+          color   = :green
+        end
+
+        time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
+        summary  = Console.color(color, "#{message}#{time_str}")
+        puts summary
+      end
+
+      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+        puts
+        puts '=' * @line_width
+        puts 'Grand Total:'
+
+        issues_count = failed_count + error_count
+        time_str =
+          if elapsed_time < 2.0
+            " (#{(elapsed_time * 1000).round}ms)"
+          else
+            " (#{elapsed_time.round(2)}s)"
+          end
+
+        if issues_count > 0
+          passed  = total_tests - issues_count
+          details = []
+          details << "#{failed_count} failed" if failed_count > 0
+          details << "#{error_count} errors" if error_count > 0
+          puts "#{details.join(', ')}, #{passed} passed#{time_str}"
+        else
+          puts "#{total_tests} tests passed#{time_str}"
+        end
+
+        puts "Files processed: #{successful_files} of #{total_files} successful"
+        puts '=' * @line_width
+      end
+
+      # Debug and diagnostic output
+      def debug_info(message, level = 0)
+        return unless @show_debug
+
+        prefix = Console.color(:cyan, 'INFO ')
+        puts indent_text("#{prefix} #{message}", level + 1)
+      end
+
+      def trace_info(message, level = 0)
+        return unless @show_trace
+
+        prefix = Console.color(:dim, 'TRACE')
+        puts indent_text("#{prefix} #{message}", level + 1)
+      end
+
+      def error_message(message, backtrace = nil)
+        error_msg = Console.color(:red, "ERROR: #{message}")
+        puts indent_text(error_msg, 1)
+
+        return unless backtrace && @show_debug
+
+        puts indent_text('Details:', 2)
+        # Show first 10 lines of backtrace to avoid overwhelming output
+        backtrace.first(10).each do |line|
+          puts indent_text(line, 3)
+        end
+        puts indent_text("... (#{backtrace.length - 10} more lines)", 3) if backtrace.length > 10
+      end
+
+      # Utility methods
+      def raw_output(text)
+        puts text
+      end
+
+      def separator(style = :light)
+        case style
+        when :heavy
+          puts '=' * @line_width
+        when :light
+          puts '-' * @line_width
+        when :dotted
+          puts '.' * @line_width
+        else # rubocop:disable Lint/DuplicateBranch
+          puts '-' * @line_width
+        end
+      end
+
+      private
+
+      def show_test_source_code(test_case)
+        puts indent_text('Source code:', 3)
+
+        # Use pre-captured source lines from parsing
+        start_line = test_case.line_range.first
+
+        test_case.source_lines.each_with_index do |line_content, index|
+          line_num     = start_line + index
+          line_display = format('%3d: %s', line_num + 1, line_content)
+
+          # Highlight expectation lines by checking if this line
+          # contains the expectation syntax
+          if line_content.match?(/^\s*#\s*=>\s*/)
+            line_display = Console.color(:yellow, line_display)
+          end
+
+          puts indent_text(line_display, 4)
+        end
+        puts
+      end
+
+      def show_failure_details(test_case, actual_results)
+        return if actual_results.empty?
+
+        puts indent_text('Expected vs Actual:', 3)
+
+        actual_results.each_with_index do |actual, idx|
+          expected_line = test_case.expectations[idx] if test_case.expectations
+
+          if expected_line
+            puts indent_text("Expected: #{Console.color(:green, expected_line)}", 4)
+            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
+          else
+            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
+          end
+
+          # Show difference if both are strings
+          if expected_line && actual.is_a?(String) && expected_line.is_a?(String)
+            show_string_diff(expected_line, actual)
+          end
+
+          puts
+        end
+      end
+
+      def show_string_diff(expected, actual)
+        return if expected == actual
+
+        puts indent_text('Difference:', 4)
+        puts indent_text("- #{Console.color(:red, actual)}", 5)
+        puts indent_text("+ #{Console.color(:green, expected)}", 5)
+      end
+
+      def file_header_visual(file_path)
+        pretty_path    = Console.pretty_path(file_path)
+        header_content = ">>>>>  #{pretty_path}  "
+        padding_length = [@line_width - header_content.length, 0].max
+        padding        = '<' * padding_length
+
+        [
+          '-' * @line_width,
+          header_content + padding,
+          '-' * @line_width,
+        ].join("\n")
+      end
+    end
+
+    # Verbose formatter that only shows failures and errors
+    class VerboseFailsFormatter < VerboseFormatter
+      def initialize(options = {})
+        super(options.merge(show_passed: false))
+      end
+
+      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
+        # Only show failed/error tests, but with full source code
+        return if result_status == :passed
+
+        super
+      end
+    end
+  end
+end

data/lib/tryouts/cli/formatters.rb

@@ -0,0 +1,6 @@
+# lib/tryouts/cli/formatters.rb
+
+require_relative 'formatters/base'
+require_relative 'formatters/compact'
+require_relative 'formatters/quiet'
+require_relative 'formatters/verbose'

data/lib/tryouts/cli/modes/generate.rb

@@ -0,0 +1,22 @@
+# lib/tryouts/cli/modes/generate.rb
+
+class Tryouts
+  class CLI
+    class GenerateMode
+      def initialize(file, testrun, options, output_manager, translator)
+        @file           = file
+        @testrun        = testrun
+        @options        = options
+        @output_manager = output_manager
+        @translator     = translator
+      end
+
+      def handle
+        @output_manager.raw("# Generated #{@options[:framework]} code for #{@file}")
+        @output_manager.raw("# Updated: #{Time.now}")
+        @output_manager.raw(@translator.generate_code(@testrun))
+        @output_manager.raw('')
+      end
+    end
+  end
+end

data/lib/tryouts/cli/modes/inspect.rb

@@ -0,0 +1,42 @@
+# lib/tryouts/cli/modes/inspect.rb
+
+class Tryouts
+  class CLI
+    class InspectMode
+      def initialize(file, testrun, options, output_manager, translator)
+        @file           = file
+        @testrun        = testrun
+        @options        = options
+        @output_manager = output_manager
+        @translator     = translator
+      end
+
+      def handle
+        @output_manager.raw("Inspecting: #{@file}")
+        @output_manager.separator(:heavy)
+        @output_manager.raw("Found #{@testrun.total_tests} test cases")
+        @output_manager.raw("Setup code: #{@testrun.setup.empty? ? 'None' : 'Present'}")
+        @output_manager.raw("Teardown code: #{@testrun.teardown.empty? ? 'None' : 'Present'}")
+        @output_manager.raw('')
+
+        @testrun.test_cases.each_with_index do |tc, i|
+          @output_manager.raw("Test #{i + 1}: #{tc.description}")
+          @output_manager.raw("  Code lines: #{tc.code.lines.count}")
+          @output_manager.raw("  Expectations: #{tc.expectations.size}")
+          @output_manager.raw("  Range: #{tc.line_range}")
+          @output_manager.raw('')
+        end
+
+        return unless @options[:framework] != :direct
+
+        @output_manager.raw("Testing #{@options[:framework]} translation...")
+        framework_klass    = TestRunner::FRAMEWORKS[@options[:framework]]
+        inspect_translator = framework_klass.new
+
+        translated_code = inspect_translator.generate_code(@testrun)
+        @output_manager.raw("#{@options[:framework].to_s.capitalize} code generated (#{translated_code.lines.count} lines)")
+        @output_manager.raw('')
+      end
+    end
+  end
+end

data/lib/tryouts/cli/opts.rb

@@ -0,0 +1,88 @@
+# lib/tryouts/cli/opts.rb
+
+class Tryouts
+  class CLI
+    HELP = <<~HELP
+
+      Framework Defaults:
+        Tryouts:    Shared context (state persists across tests)
+        RSpec:      Fresh context (each test isolated)
+        Minitest:   Fresh context (each test isolated)
+
+      Examples:
+        try test_try.rb                          # Tryouts test runner with shared context
+        try --rspec test_try.rb                  # RSpec with fresh context
+        try --direct --shared-context test_try.rb # Explicit shared context
+        try --generate-rspec test_try.rb         # Output RSpec code only
+        try --inspect test_try.rb                # Inspect file structure and validation
+
+      File Format:
+        ## Test description       # Test case marker
+        code_to_test             # Ruby code
+        #=> expected_result       # Expectation
+    HELP
+
+    class << self
+      def parse_args(args)
+        Tryouts.trace "Parsing arguments: #{args.inspect}"
+        options = {}
+
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: try [OPTIONS] FILE...\n\nModern Tryouts test runner with framework translation"
+
+          opts.separator "\nFramework Options:"
+          opts.on('--direct', 'Direct execution with TestBatch (default)') { options[:framework] = :direct }
+          opts.on('--rspec', 'Use RSpec framework') { options[:framework]                        = :rspec }
+          opts.on('--minitest', 'Use Minitest framework') { options[:framework]                  = :minitest }
+
+          opts.separator "\nGeneration Options:"
+          opts.on('--generate-rspec', 'Generate RSpec code only') do
+            options[:framework]     = :rspec
+            options[:generate_only] = true
+          end
+          opts.on('--generate-minitest', 'Generate Minitest code only') do
+            options[:framework]     = :minitest
+            options[:generate_only] = true
+          end
+          opts.on('--generate', 'Generate code only (use with --rspec/--minitest)') do
+            options[:generate_only] = true
+            options[:framework]   ||= :rspec
+          end
+
+          opts.separator "\nExecution Options:"
+          opts.on('--shared-context', 'Override default context mode') { options[:shared_context]       = true }
+          opts.on('--no-shared-context', 'Override default context mode') { options[:shared_context]    = false }
+          opts.on('-v', '--verbose', 'Show detailed test output with line numbers') { options[:verbose] = true }
+          opts.on('-f', '--fails', 'Show only failing tests (with --verbose)') { options[:fails_only]   = true }
+          opts.on('-q', '--quiet', 'Minimal output (dots and summary only)') { options[:quiet]          = true }
+          opts.on('-c', '--compact', 'Compact single-line output') { options[:compact]                  = true }
+
+          opts.separator "\nInspection Options:"
+          opts.on('-i', '--inspect', 'Inspect file structure without running tests') { options[:inspect] = true }
+
+          opts.separator "\nGeneral Options:"
+          opts.on('-V', '--version', 'Show version') { options[:version] = true }
+          opts.on('-D', '--debug', 'Enable debug mode') do
+            options[:debug] = true
+            Tryouts.debug   = true
+          end
+          opts.on('-h', '--help', 'Show this help') do
+            puts opts
+            exit 0
+          end
+
+          opts.separator HELP.freeze
+        end
+
+        files = parser.parse(args)
+        Tryouts.trace "Parsed files: #{files.inspect}, options: #{options.inspect}"
+        [files, options]
+      rescue OptionParser::InvalidOption => ex
+        Tryouts.info Console.color(:red, "Invalid option error: #{ex.message}")
+        warn "Error: #{ex.message}"
+        warn "Try 'try --help' for more information."
+        exit 1
+      end
+    end
+  end
+end

data/lib/tryouts/cli.rb

@@ -0,0 +1,54 @@
+# lib/tryouts/cli.rb
+
+require 'optparse'
+
+require_relative 'cli/opts'
+require_relative 'cli/formatters'
+require_relative 'test_runner'
+
+class Tryouts
+  class CLI
+    def initialize
+      @options = {
+        framework: :direct,
+        verbose: false,
+        inspect: false,
+      }
+    end
+
+    def run(files, **options)
+      @options.merge!(options)
+
+      output_manager = FormatterFactory.create_output_manager(@options)
+
+      handle_version_flag(@options, output_manager)
+      validate_files_exist(files, output_manager)
+
+      runner = TestRunner.new(
+        files: files,
+        options: @options,
+        output_manager: output_manager,
+      )
+
+      runner.run
+    end
+
+    private
+
+    def handle_version_flag(options, output_manager)
+      return unless options[:version]
+
+      output_manager.raw("Tryouts version #{Tryouts::VERSION}")
+      exit 0
+    end
+
+    def validate_files_exist(files, output_manager)
+      missing_files = files.reject { |file| File.exist?(file) }
+
+      unless missing_files.empty?
+        missing_files.each { |file| output_manager.error("File not found: #{file}") }
+        exit 1
+      end
+    end
+  end
+end

data/lib/tryouts/console.rb

@@ -1,4 +1,6 @@
-# frozen_string_literal: true
+# lib/tryouts/console.rb
+
+require 'pathname'
 
 class Tryouts
   module Console
@@ -12,7 +14,7 @@ class Tryouts
         blink: 5,
         reverse: 7,
         hidden: 8,
-        default: 0
+        default: 0,
       }.freeze
     end
 
@@ -28,7 +30,7 @@ class Tryouts
         cyan: 36,
         white: 37,
         default: 39,
-        random: 30 + rand(10).to_i
+        random: 30 + rand(10).to_i,
       }.freeze
     end
 
@@ -44,7 +46,7 @@ class Tryouts
         cyan: 46,
         white: 47,
         default: 49,
-        random: 40 + rand(10).to_i
+        random: 40 + rand(10).to_i,
       }.freeze
     end
 
@@ -73,50 +75,63 @@ class Tryouts
         Console.bgcolor(col, self)
       end
     end
+    class << self
+      def bright(str)
+        str = [style(ATTRIBUTES[:bright]), str, default_style].join
+        str.extend Console::InstanceMethods
+        str
+      end
 
-    def self.bright(str)
-      str = [style(ATTRIBUTES[:bright]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
+      def underline(str)
+        str = [style(ATTRIBUTES[:underline]), str, default_style].join
+        str.extend Console::InstanceMethods
+        str
+      end
 
-    def self.underline(str)
-      str = [style(ATTRIBUTES[:underline]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
+      def reverse(str)
+        str = [style(ATTRIBUTES[:reverse]), str, default_style].join
+        str.extend Console::InstanceMethods
+        str
+      end
 
-    def self.reverse(str)
-      str = [style(ATTRIBUTES[:reverse]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
+      def color(col, str)
+        str = [style(COLOURS[col]), str, default_style].join
+        str.extend Console::InstanceMethods
+        str
+      end
 
-    def self.color(col, str)
-      str = [style(COLOURS[col]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
+      def att(name, str)
+        str = [style(ATTRIBUTES[name]), str, default_style].join
+        str.extend Console::InstanceMethods
+        str
+      end
 
-    def self.att(name, str)
-      str = [style(ATTRIBUTES[name]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
+      def bgcolor(col, str)
+        str = [style(ATTRIBUTES[col]), str, default_style].join
+        str.extend Console::InstanceMethods
+        str
+      end
 
-    def self.bgcolor(col, str)
-      str = [style(ATTRIBUTES[col]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
+      def style(*att)
+        # => \e[8;34;42m
+        "\e[%sm" % att.join(';')
+      end
 
-    def self.style(*att)
-      # => \e[8;34;42m
-      "\e[%sm" % att.join(';')
-    end
+      def default_style
+        style(ATTRIBUTES[:default], COLOURS[:default], BGCOLOURS[:default])
+      end
 
-    def self.default_style
-      style(ATTRIBUTES[:default], ATTRIBUTES[:COLOURS], ATTRIBUTES[:BGCOLOURS])
+      # Converts an absolute file path to a path relative to the current working
+      # directory. This simplifies logging and error reporting by showing
+      # only the relevant parts of file paths instead of lengthy absolute paths.
+      #
+      def pretty_path(file)
+        return nil if file.nil?
+
+        file     = File.expand_path(file) # be absolutely sure
+        basepath = Dir.pwd
+        Pathname.new(file).relative_path_from(basepath).to_s
+      end
     end
   end
 end