tryouts 3.4.0 → 3.5.1

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

@@ -19,12 +19,7 @@ class Tryouts
       def phase_header(message, file_count: nil)
         return if message.include?('EXECUTING') # Skip execution phase headers
 
-        header_line = message.center(@line_width)
-        separator_line = '=' * @line_width
-
-        puts(separator_line)
-        puts(header_line)
-        puts(separator_line)
+        puts("=== #{message} ===")
       end
 
       # File-level operations
@@ -40,12 +35,25 @@ class Tryouts
         extras << 'teardown' if teardown_present
         message += " (#{extras.join(', ')})" unless extras.empty?
 
-        puts(indent_text(message, 2))
+        puts(indent_text(message, 1))
+      end
+
+      def parser_warnings(file_path, warnings:)
+        return if warnings.empty? || !@options.fetch(:warnings, true)
+
+        puts
+        puts Console.color(:yellow, "Parser Warnings:")
+        warnings.each do |warning|
+          puts "  #{Console.color(:yellow, 'WARNING')}: #{warning.message} (line #{warning.line_number})"
+          puts "    #{Console.color(:dim, warning.context)}" unless warning.context.empty?
+          puts "    #{Console.color(:blue, warning.suggestion)}"
+        end
+        puts
       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))
+        puts(indent_text(message, 0))
       end
 
       # Summary operations - show detailed failure summary
@@ -53,9 +61,7 @@ class Tryouts
         return unless failure_collector.any_failures?
 
         puts
-        write '=' * 50
-        puts
-        puts Console.color(:red, 'Failed Tests:')
+        write '=== FAILURES ==='
 
         # Number failures sequentially across all files instead of per-file
         failure_number = 1
@@ -73,16 +79,14 @@ class Tryouts
             puts
             puts Console.color(:yellow, location)
             puts "  #{failure_number}) #{failure.description}"
-            puts "     #{Console.color(:red, 'Failure:')} #{failure.failure_reason}"
+            puts "     #{Console.color(:red, failure.failure_reason)}"
 
-            # Show source context in verbose mode
+            # Show source context in compact format
             if failure.source_context.any?
-              puts "     #{Console.color(:cyan, 'Source:')}"
               failure.source_context.each do |line|
                 puts "       #{line.strip}"
               end
             end
-            puts
             failure_number += 1
           end
         end
@@ -102,25 +106,27 @@ class Tryouts
 
           time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
           message = "✗ Out of #{total_tests} tests: #{details_str}#{time_str}"
-          puts indent_text(Console.color(color, message), 2)
+          puts indent_text(Console.color(color, message), 1)
         else
           message = "#{total_tests} tests passed"
           color = :green
-          puts indent_text(Console.color(color, "✓ #{message}"), 2)
+          puts indent_text(Console.color(color, "✓ #{message}"), 1)
         end
 
         return unless elapsed_time
 
         time_msg = "Completed in #{format_timing(elapsed_time).strip.tr('()', '')}"
-        puts indent_text(Console.color(:dim, time_msg), 2)
+        puts indent_text(Console.color(:dim, time_msg), 1)
       end
 
       # Test-level operations
       def test_start(test_case:, index:, total:)
+        return unless @show_passed
+
         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)
+        puts indent_text(Console.color(:dim, message), 1)
       end
 
       def test_result(result_packet)
@@ -143,7 +149,7 @@ class Tryouts
         test_case = result_packet.test_case
         location = "#{Console.pretty_path(test_case.path)}:#{test_case.first_expectation_line + 1}"
         puts
-        puts indent_text("#{status_line} @ #{location}", 2)
+        puts indent_text("#{status_line} @ #{location}", 1)
 
         # Show source code for verbose mode
         show_test_source_code(test_case)
@@ -160,21 +166,22 @@ class Tryouts
       def test_output(test_case:, output_text:, result_packet:)
         return if output_text.nil? || output_text.strip.empty?
 
-        puts indent_text('Test Output:', 3)
-        puts indent_text(Console.color(:dim, '--- BEGIN OUTPUT ---'), 3)
+        puts indent_text('Test Output:', 2)
+        puts indent_text(Console.color(:dim, '--- BEGIN OUTPUT ---'), 2)
 
         output_text.lines.each do |line|
-          puts indent_text(line.chomp, 4)
+          puts indent_text(line.chomp, 3)
         end
 
-        puts indent_text(Console.color(:dim, '--- END OUTPUT ---'), 3)
+        puts indent_text(Console.color(:dim, '--- END OUTPUT ---'), 2)
         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)
+        puts indent_text(Console.color(:cyan, message), 1)
+        puts
       end
 
       def setup_output(output_text)
@@ -187,8 +194,7 @@ class Tryouts
 
       def teardown_start(line_range:)
         message = "Executing teardown (lines #{line_range.first}..#{line_range.last})"
-        puts indent_text(Console.color(:cyan, message), 2)
-        puts
+        puts indent_text(Console.color(:cyan, message), 1)
       end
 
       def teardown_output(output_text)
@@ -201,8 +207,7 @@ class Tryouts
 
       def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
         puts
-        puts '=' * @line_width
-        puts 'Grand Total:'
+        puts '=== TOTAL ==='
 
         issues_count = failed_count + error_count
         time_str = if elapsed_time < 2.0
@@ -216,13 +221,12 @@ class Tryouts
           details = []
           details << "#{failed_count} failed" if failed_count > 0
           details << "#{error_count} errors" if error_count > 0
-          puts "#{details.join(', ')}, #{passed} passed#{time_str}"
+          printf("%-10s %s\n", "Testcases:", "#{details.join(', ')}, #{passed} passed#{time_str}")
         else
-          puts "#{total_tests} tests passed#{time_str}"
+          printf("%-10s %s\n", "Testcases:", "#{total_tests} tests passed#{time_str}")
         end
 
-        puts "Files: #{successful_files} of #{total_files} successful"
-        puts '=' * @line_width
+        printf("%-10s %s\n", "Files:", "#{successful_files} of #{total_files} passed")
       end
 
       # Debug and diagnostic output
@@ -243,16 +247,16 @@ class Tryouts
 
       def error_message(message, backtrace: nil)
         error_msg = Console.color(:red, "ERROR: #{message}")
-        puts indent_text(error_msg, 1)
+        puts indent_text(error_msg, 0)
 
         return unless backtrace && @show_stack_traces
 
-        puts indent_text('Details:', 2)
+        puts indent_text('Details:', 1)
         # Show first 10 lines of backtrace to avoid overwhelming output
         Console.pretty_backtrace(backtrace, limit: 10).each do |line|
-          puts indent_text(line, 3)
+          puts indent_text(line, 2)
         end
-        puts indent_text("... (#{backtrace.length - 10} more lines)", 3) if backtrace.length > 10
+        puts indent_text("... (#{backtrace.length - 10} more lines)", 2) if backtrace.length > 10
       end
 
       def live_status_capabilities
@@ -272,16 +276,16 @@ class Tryouts
       def show_exception_details(test_case, actual_results, expected_results = [])
         return if actual_results.empty?
 
-        puts indent_text('Exception Details:', 4)
+        puts indent_text('Exception Details:', 2)
 
         actual_results.each_with_index do |actual, idx|
           expected = expected_results[idx] if expected_results && idx < expected_results.length
           expectation = test_case.expectations[idx] if test_case.expectations
 
           if expectation&.type == :exception
-            puts indent_text("Caught: #{Console.color(:blue, actual.inspect)}", 5)
-            puts indent_text("Expectation: #{Console.color(:green, expectation.content)}", 5)
-            puts indent_text("Result: #{Console.color(:green, expected.inspect)}", 5) if expected
+            puts indent_text("Caught: #{Console.color(:blue, actual.inspect)}", 3)
+            puts indent_text("Expectation: #{Console.color(:green, expectation.content)}", 3)
+            puts indent_text("Result: #{Console.color(:green, expected.inspect)}", 3) if expected
           end
         end
         puts
@@ -300,7 +304,7 @@ class Tryouts
             line_display = Console.color(:yellow, line_display)
           end
 
-          puts indent_text(line_display, 4)
+          puts indent_text(line_display, 2)
         end
         puts
       end
@@ -314,15 +318,15 @@ class Tryouts
 
           if !expected.nil?
             # Use the evaluated expected value from the evaluator
-            puts indent_text("Expected: #{Console.color(:green, expected.inspect)}", 4)
-            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
+            puts indent_text("Expected: #{Console.color(:green, expected.inspect)}", 2)
+            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 2)
           elsif expected_line && !expected_results.empty?
             # Only show raw expectation content if we have expected_results (non-error case)
-            puts indent_text("Expected: #{Console.color(:green, expected_line.content)}", 4)
-            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
+            puts indent_text("Expected: #{Console.color(:green, expected_line.content)}", 2)
+            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 2)
           else
             # For error cases (empty expected_results), just show the error
-            puts indent_text("Error:   #{Console.color(:red, actual.inspect)}", 4)
+            puts indent_text("Error:   #{Console.color(:red, actual.inspect)}", 2)
           end
 
           # Show difference if both are strings
@@ -337,21 +341,16 @@ class Tryouts
       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)
+        puts indent_text('Difference:', 2)
+        puts indent_text("- #{Console.color(:red, actual)}", 3)
+        puts indent_text("+ #{Console.color(:green, expected)}", 3)
       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
 
         [
-          indent_text('-' * @line_width, 1),
-          indent_text(header_content + padding, 1),
-          indent_text('-' * @line_width, 1),
+          indent_text("--- #{pretty_path} ---", 0)
         ].join("\n")
       end
     end
@@ -376,6 +375,20 @@ class Tryouts
         super
       end
 
+      # Suppress setup/teardown output in fails-only mode
+      def setup_start(line_range:)
+        # No output in fails mode
+      end
+
+      def teardown_start(line_range:)
+        # No output in fails mode
+      end
+
+      # Suppress file result summaries in fails-only mode
+      def file_result(_file_path, total_tests:, failed_count:, error_count:, elapsed_time: nil)
+        # No output in fails mode - let the batch_summary handle failures
+      end
+
       def live_status_capabilities
         {
           supports_coordination: true,     # Verbose can work with coordinated output

data/lib/tryouts/cli/line_spec_parser.rb

@@ -0,0 +1,109 @@
+# lib/tryouts/cli/line_spec_parser.rb
+
+class Tryouts
+  class CLI
+    class LineSpecParser
+      # Parse a file path with optional line specification
+      # Supports formats:
+      #   - file.rb:19        (single line)
+      #   - file.rb:19-45     (range)
+      #   - file.rb:L19       (GitHub-style single line)
+      #   - file.rb:L19-45    (GitHub-style range)
+      #   - file.rb:L19-L45   (GitHub-style range with L on both)
+      #
+      # Returns [filepath, line_spec] where line_spec is nil or a Range/Integer
+      def self.parse(path_with_spec)
+        return [path_with_spec, nil] unless path_with_spec.include?(':')
+
+        # Split on the last colon to handle paths with colons
+        parts = path_with_spec.rpartition(':')
+        filepath = parts[0]
+        line_spec_str = parts[2]
+
+        # If the filepath is empty, it means there was no colon or the input started with colon
+        return [path_with_spec, nil] if filepath.empty?
+
+        # If the "line spec" part looks like a Windows drive letter, this isn't a line spec
+        return [path_with_spec, nil] if line_spec_str =~ /\A[a-zA-Z]\z/
+
+        # Parse the line specification
+        line_spec = parse_line_spec(line_spec_str)
+
+        # If we couldn't parse it, treat the whole thing as a filepath
+        return [path_with_spec, nil] if line_spec.nil?
+
+        [filepath, line_spec]
+      end
+
+      private
+
+      def self.parse_line_spec(spec)
+        return nil if spec.nil? || spec.empty?
+
+        # Remove 'L' prefix if present (GitHub style)
+        spec = spec.gsub(/L/i, '')
+
+        # Handle range (e.g., "19-80")
+        if spec.include?('-')
+          parts = spec.split('-', 2)
+
+          # Validate that both parts are numeric
+          return nil unless parts[0] =~ /\A\d+\z/ && parts[1] =~ /\A\d+\z/
+
+          start_line = parts[0].to_i
+          end_line = parts[1].to_i
+
+          # Validate the numbers
+          return nil if start_line <= 0 || end_line <= 0
+          return nil if start_line > end_line
+
+          start_line..end_line
+        else
+          # Single line number - validate it's numeric
+          return nil unless spec =~ /\A\d+\z/
+
+          line = spec.to_i
+          return nil if line <= 0
+
+          line
+        end
+      end
+
+      # Check if a test case at the given line range matches the line specification
+      # Test case line ranges are 0-based, user line specs are 1-based
+      def self.matches?(test_case, line_spec)
+        return true if line_spec.nil?
+
+        # Convert user's 1-based line spec to 0-based for comparison
+        zero_based_spec = case line_spec
+        when Integer
+          line_spec - 1
+        when Range
+          (line_spec.begin - 1)..(line_spec.end - 1)
+        else
+          line_spec
+        end
+
+        # Test case line_range is already 0-based
+        test_range = test_case.line_range
+
+        case zero_based_spec
+        when Integer
+          # Single line - check if it falls within the test's range
+          test_range.cover?(zero_based_spec)
+        when Range
+          # Range - check if there's any overlap
+          spec_start = zero_based_spec.begin
+          spec_end = zero_based_spec.end
+          test_start = test_range.begin
+          test_end = test_range.end
+
+          # Check for overlap: ranges overlap if start of one is before end of other
+          !(test_end < spec_start || spec_end < test_start)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/tryouts/cli/opts.rb

@@ -123,6 +123,12 @@ class Tryouts
             options[:parallel_threads] = threads.to_i if threads && threads.to_i > 0
           end
 
+          opts.separator "\nParser Options:"
+          opts.on('--strict', 'Require explicit test descriptions (fail on unnamed tests)') { options[:strict] = true }
+          opts.on('--no-strict', 'Allow unnamed tests (legacy behavior)') { options[:strict] = false }
+          opts.on('-w', '--warnings', 'Show parser warnings (default: true)') { options[:warnings] = true }
+          opts.on('--no-warnings', 'Suppress parser warnings') { options[:warnings] = false }
+
           opts.separator "\nAgent-Optimized Output:"
           opts.on('-a', '--agent', 'Agent-optimized structured output for LLM context management') do
             options[:agent] = true

data/lib/tryouts/cli.rb

@@ -4,6 +4,7 @@ require 'optparse'
 
 require_relative 'cli/opts'
 require_relative 'cli/formatters'
+require_relative 'cli/line_spec_parser'
 require_relative 'test_runner'
 
 class Tryouts
@@ -13,6 +14,8 @@ class Tryouts
         framework: :direct,
         verbose: false,
         inspect: false,
+        strict: true,    # Default to strict mode for better UX
+        warnings: true,  # Default to showing warnings
       }
     end
 
@@ -22,11 +25,14 @@ class Tryouts
       output_manager = FormatterFactory.create_output_manager(@options)
 
       handle_version_flag(@options, output_manager)
-      validate_files_exist(files, output_manager)
+
+      # Parse line specs from file arguments
+      files_with_specs = parse_file_specs(files)
+      validate_files_exist(files_with_specs, output_manager)
 
       runner = TestRunner.new(
-        files: files,
-        options: @options,
+        files: files_with_specs.keys,
+        options: @options.merge(file_line_specs: files_with_specs),
         output_manager: output_manager,
       )
 
@@ -42,13 +48,24 @@ class Tryouts
       exit 0
     end
 
-    def validate_files_exist(files, output_manager)
-      missing_files = files.reject { |file| File.exist?(file) }
+    def validate_files_exist(files_with_specs, output_manager)
+      missing_files = files_with_specs.keys.reject { |file| File.exist?(file) }
 
       unless missing_files.empty?
         missing_files.each { |file| output_manager.error("File not found: #{file}") }
         exit 1
       end
     end
+
+    def parse_file_specs(files)
+      files_with_specs = {}
+
+      files.each do |file_arg|
+        filepath, line_spec = LineSpecParser.parse(file_arg)
+        files_with_specs[filepath] = line_spec
+      end
+
+      files_with_specs
+    end
   end
 end

data/lib/tryouts/expectation_evaluators/result_type.rb

@@ -40,6 +40,21 @@ class Tryouts
         # Try to evaluate in test context first, then fallback to global context for constants
         begin
           expected_class = eval_expectation_content(@expectation.content, expectation_result)
+
+          # If the evaluated result is not a class/module (e.g., shadowed constant),
+          # fall back to global context resolution
+          unless expected_class.is_a?(Class) || expected_class.is_a?(Module)
+            # Attempt to get the constant from global context
+            # This handles cases where a local variable/method shadows a class constant
+            constant_name = @expectation.content.strip
+            # Ensure the constant name is valid before attempting const_get
+            if constant_name =~ /\A[A-Z][\w:]*\z/
+              expected_class = Object.const_get(constant_name)
+            else
+              # If it's not a valid constant name, the evaluation failed
+              raise TypeError, "Expected a Class or Module, got #{expected_class.class}"
+            end
+          end
         rescue NameError => e
           # If we can't find the constant in test context, try global context
           # This is common for exception classes like ArgumentError, StandardError, etc.

data/lib/tryouts/file_processor.rb

@@ -20,8 +20,15 @@ class Tryouts
 
     def process
       testrun                     = create_parser(@file, @options).parse
+
+      # Apply line spec filtering before reporting test counts
+      if @options[:line_spec]
+        testrun = filter_testrun_by_line_spec(testrun)
+      end
+
       @global_tally[:aggregator].increment_total_files
       @output_manager.file_parsed(@file, testrun.total_tests)
+      @output_manager.parser_warnings(@file, warnings: testrun.warnings)
 
       if @options[:inspect]
         handle_inspect_mode(testrun)
@@ -38,6 +45,34 @@ class Tryouts
 
     private
 
+    def filter_testrun_by_line_spec(testrun)
+      require_relative 'cli/line_spec_parser'
+
+      line_spec = @options[:line_spec]
+
+      # Filter test cases to only those that match the line spec
+      filtered_cases = testrun.test_cases.select do |test_case|
+        Tryouts::CLI::LineSpecParser.matches?(test_case, line_spec)
+      end
+
+      # Check if any tests matched the line specification
+      if filtered_cases.empty?
+        @output_manager.file_failure(@file, "No test cases found matching line specification: #{line_spec}")
+        return testrun  # Return original testrun to avoid breaking the pipeline
+      end
+
+      # Create a new testrun with filtered cases
+      # We need to preserve the setup and teardown but only include matching tests
+      testrun.class.new(
+        setup: testrun.setup,
+        test_cases: filtered_cases,
+        teardown: testrun.teardown,
+        source_file: testrun.source_file,
+        metadata: testrun.metadata,
+        warnings: testrun.warnings
+      )
+    end
+
     def create_parser(file, options)
       parser_type = options[:parser] || :enhanced  # enhanced parser is now the default
 
@@ -47,9 +82,9 @@ class Tryouts
 
       case parser_type
       when :enhanced
-        EnhancedParser.new(file)
+        EnhancedParser.new(file, options)
       when :prism
-        PrismParser.new(file)
+        PrismParser.new(file, options)
       end
     end
 

data/lib/tryouts/parser_warning.rb

@@ -0,0 +1,26 @@
+# lib/tryouts/parser_warning.rb
+
+class Tryouts
+  # Data structure for parser warnings
+  ParserWarning = Data.define(:type, :message, :line_number, :context, :suggestion) do
+    def self.unnamed_test(line_number:, context:)
+      new(
+        type: :unnamed_test,
+        message: "Test case without explicit description",
+        line_number: line_number,
+        context: context,
+        suggestion: "Add a test description using '## Description' prefix"
+      )
+    end
+
+    def self.ambiguous_test_boundary(line_number:, context:)
+      new(
+        type: :ambiguous_boundary,
+        message: "Ambiguous test case boundary detected",
+        line_number: line_number,
+        context: context,
+        suggestion: "Use explicit '## Description' to clarify test structure"
+      )
+    end
+  end
+end

data/lib/tryouts/parsers/base_parser.rb

@@ -3,6 +3,7 @@
 require 'prism'
 
 require_relative 'shared_methods'
+require_relative '../parser_warning'
 
 class Tryouts
   # Fixed PrismParser with pattern matching for robust token filtering
@@ -10,12 +11,14 @@ class Tryouts
     class BaseParser
       include Tryouts::Parsers::SharedMethods
 
-      def initialize(source_path)
+      def initialize(source_path, options = {})
         @source_path  = source_path
         @source       = File.read(source_path)
         @lines        = @source.lines.map(&:chomp)
         @prism_result = Prism.parse(@source)
         @parsed_at    = Time.now
+        @options      = options
+        @warnings     = []
       end
 
     end