tryouts 3.3.0 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7ef307bf73a8bd6c70f52c47337d550ae7715e0b64d15c7f708c9fd407f3df2
-  data.tar.gz: ccd166f03573bee1d31e3843ff95964cf5065ab4a1b2386e9769ec065a6958f5
+  metadata.gz: adb9f46213aee10ed4b9d2a1b9b8d5c9e385ea23f996445debc7458b43351512
+  data.tar.gz: 8d6abfed42e73bb340e13a62991b4855b8c0c18efa3092b4e3244a822a1612c1
 SHA512:
-  metadata.gz: 22b0d458cfadd632495c4df95f41cca3c06c6e6b3e219b18afb0fd21bfc14d1d9a872b165fcd2dd1c26052a9f57b84dad77c4a5a14c3efa08f62d74f0ab34467
-  data.tar.gz: 8cd6db263235736e26163b84568ad870de5835da3002e6f71226d961fc21e19d9eaef3cf2e02598a3907cb2701665e72a7e21ecea05b540f10ba37daa530a391
+  metadata.gz: 571410ed483879bd035b14c053a5c3496d51ad2248cff2534cf40fc06a72ece1aea13a7e61ae2c29b1e1f1768f19d3c5ede8c4e4a30a977c29aacb502c616988
+  data.tar.gz: 6b5186131242edf826ba44303daaee716ce1ec364683e521df5224818d796067209a9a0ae66cacc85d15796cfee92df2349372fc5df762ced52b8753e1196c0e

data/exe/try

@@ -17,7 +17,7 @@ if ENV['COVERAGE'] || ENV['SIMPLECOV']
     add_group 'Core', 'lib/tryouts.rb'
     add_group 'CLI', 'lib/tryouts/cli'
     add_group 'Formatters', 'lib/tryouts/cli/formatters'
-    add_group 'Parsers', 'lib/tryouts/prism_parser.rb'
+    add_group 'Parsers', 'lib/tryouts/parsers'
     add_group 'Data Structures', ['lib/tryouts/testcase.rb', 'lib/tryouts/testbatch.rb']
     add_group 'Translators', 'lib/tryouts/translators'
     add_group 'Execution', ['lib/tryouts/test_executor.rb', 'lib/tryouts/test_runner.rb', 'lib/tryouts/file_processor.rb']

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

@@ -57,6 +57,8 @@ class Tryouts
         puts Console.color(:red, 'Failed Tests:')
         puts
 
+        # Number failures sequentially across all files instead of per-file
+        failure_number = 1
         failure_collector.failures_by_file.each do |file_path, failures|
           failures.each do |failure|
             pretty_path = Console.pretty_path(file_path)
@@ -68,10 +70,11 @@ class Tryouts
               pretty_path
             end
 
-            puts "  #{location}"
+            puts "  #{failure_number}) #{location}"
             puts "    #{Console.color(:red, '✗')} #{failure.description}"
             puts "      #{failure.failure_reason}"
             puts
+            failure_number += 1
           end
         end
       end

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

@@ -56,8 +56,10 @@ class Tryouts
         puts
         puts Console.color(:red, 'Failed Tests:')
 
+        # Number failures sequentially across all files instead of per-file
+        failure_number = 1
         failure_collector.failures_by_file.each do |file_path, failures|
-          failures.each_with_index do |failure, index|
+          failures.each do |failure|
             pretty_path = Console.pretty_path(file_path)
 
             # Include line number with file path for easy copying/clicking
@@ -69,7 +71,7 @@ class Tryouts
 
             puts
             puts Console.color(:yellow, location)
-            puts "  #{index + 1}) #{failure.description}"
+            puts "  #{failure_number}) #{failure.description}"
             puts "     #{Console.color(:red, 'Failure:')} #{failure.failure_reason}"
 
             # Show source context in verbose mode
@@ -80,6 +82,7 @@ class Tryouts
               end
             end
             puts
+            failure_number += 1
           end
         end
       end

data/lib/tryouts/cli/opts.rb

@@ -67,8 +67,8 @@ class Tryouts
           opts.on('-l', '--live', 'Live status display') { options[:live_status]                          = true }
 
           opts.separator "\nParser Options:"
-          opts.on('--enhanced-parser', 'Use enhanced parser with inhouse comment extraction') { options[:parser] = :enhanced }
-          opts.on('--legacy-parser', 'Use legacy parser (current default)') { options[:parser] = :prism }
+          opts.on('--enhanced-parser', 'Use enhanced parser with inhouse comment extraction (default)') { options[:parser] = :enhanced }
+          opts.on('--legacy-parser', 'Use legacy prism parser') { options[:parser] = :prism }
 
           opts.separator "\nInspection Options:"
           opts.on('-i', '--inspect', 'Inspect file structure without running tests') { options[:inspect] = true }

data/lib/tryouts/expectation_evaluators/regex_match.rb

@@ -40,9 +40,17 @@ class Tryouts
         expectation_result = ExpectationResult.from_result(actual_result)
         pattern            = eval_expectation_content(@expectation.content, expectation_result)
 
-        # Convert actual_result to string for regex matching
-        string_result = actual_result.to_s
-        match_result  = string_result =~ pattern
+        # Auto-detect exceptions and use message for regex matching
+        # This allows #=~> /pattern/ to work naturally with exception messages
+        string_result = if actual_result.is_a?(Exception)
+                          # Make error available in context for manual access if needed
+                          @context.define_singleton_method(:error) { actual_result }
+                          actual_result.message  # Match against error message
+                        else
+                          actual_result.to_s     # Normal case: convert to string
+                        end
+
+        match_result = string_result =~ pattern
 
         build_result(
           passed: !match_result.nil?,

data/lib/tryouts/expectation_evaluators/result_type.rb

@@ -36,7 +36,15 @@ class Tryouts
 
       def evaluate(actual_result = nil)
         expectation_result = ExpectationResult.from_result(actual_result)
-        expected_class     = eval_expectation_content(@expectation.content, expectation_result)
+
+        # Try to evaluate in test context first, then fallback to global context for constants
+        begin
+          expected_class = eval_expectation_content(@expectation.content, expectation_result)
+        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.
+          expected_class = Object.const_get(@expectation.content.strip)
+        end
 
         build_result(
           passed: actual_result.is_a?(expected_class),

data/lib/tryouts/file_processor.rb

@@ -1,7 +1,7 @@
 # lib/tryouts/file_processor.rb
 
-require_relative 'prism_parser'
-require_relative 'enhanced_parser'
+require_relative 'parsers/prism_parser'
+require_relative 'parsers/enhanced_parser'
 require_relative 'test_executor'
 require_relative 'cli/modes/inspect'
 require_relative 'cli/modes/generate'
@@ -39,7 +39,7 @@ class Tryouts
     private
 
     def create_parser(file, options)
-      parser_type = options[:parser] || :prism  # default to legacy for safe rollout
+      parser_type = options[:parser] || :enhanced  # enhanced parser is now the default
 
       unless PARSER_TYPES.include?(parser_type)
         raise ArgumentError, "Unknown parser: #{parser_type}. Allowed types: #{PARSER_TYPES.join(', ')}"

data/lib/tryouts/parsers/base_parser.rb

@@ -0,0 +1,23 @@
+# lib/tryouts/parsers/base_parser.rb
+
+require 'prism'
+
+require_relative 'shared_methods'
+
+class Tryouts
+  # Fixed PrismParser with pattern matching for robust token filtering
+  module Parsers
+    class BaseParser
+      include Tryouts::Parsers::SharedMethods
+
+      def initialize(source_path)
+        @source_path  = source_path
+        @source       = File.read(source_path)
+        @lines        = @source.lines.map(&:chomp)
+        @prism_result = Prism.parse(@source)
+        @parsed_at    = Time.now
+      end
+
+    end
+  end
+end

data/lib/tryouts/parsers/enhanced_parser.rb

@@ -0,0 +1,113 @@
+# lib/tryouts/parsers/enhanced_parser.rb
+
+# Enhanced parser using Prism's inhouse comment extraction capabilities
+# Drop-in replacement for PrismParser that eliminates HEREDOC parsing issues
+
+require_relative '../test_case'
+require_relative 'base_parser'
+
+class Tryouts
+  # Enhanced parser that replaces manual line-by-line parsing with inhouse Prism APIs
+  # while maintaining full compatibility with the original parser's logic structure
+  class EnhancedParser < Tryouts::Parsers::BaseParser
+
+    def parse
+      return handle_syntax_errors if @prism_result.failure?
+
+      # Use inhouse comment extraction instead of line-by-line regex parsing
+      # This automatically excludes HEREDOC content!
+      tokens           = tokenize_content_with_inhouse_extraction
+      test_boundaries  = find_test_case_boundaries(tokens)
+      tokens           = classify_potential_descriptions_with_boundaries(tokens, test_boundaries)
+      test_blocks      = group_into_test_blocks(tokens)
+      process_test_blocks(test_blocks)
+    end
+
+    private
+
+    # Inhouse comment extraction - replaces the manual regex parsing
+    def tokenize_content_with_inhouse_extraction
+      tokens = []
+
+      # Get all comments using inhouse Prism extraction
+      comments        = Prism.parse_comments(@source)
+      comment_by_line = comments.group_by { |comment| comment.location.start_line }
+
+      # Process each line, handling multiple comments per line
+      @lines.each_with_index do |line, index|
+        line_number = index + 1
+
+        if (comments_for_line = comment_by_line[line_number]) && !comments_for_line.empty?
+          emitted_code = false
+          comments_for_line.sort_by! { |c| c.location.start_column }
+          comments_for_line.each do |comment|
+            comment_content = comment.slice.strip
+            if comment.location.start_column > 0
+              unless emitted_code
+                tokens << { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
+                emitted_code = true
+              end
+              # Inline comment may carry expectations; classify it too
+              tokens << classify_comment_inhousely(comment_content, line_number)
+            else
+              tokens << classify_comment_inhousely(comment_content, line_number)
+            end
+          end
+          next
+        end
+
+        # Handle non-comment lines (blank lines and code)
+        token = case line
+                when /^\s*$/
+                  { type: :blank, line: index }
+                else
+                  { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
+                end
+        tokens << token
+      end
+
+      tokens
+    end
+
+    # Inhouse comment classification - replaces complex regex patterns
+    def classify_comment_inhousely(content, line_number)
+      case content
+      when /^##\s*(.*)$/
+        { type: :description, content: $1.strip, line: line_number - 1 }
+      when /^#\s*TEST\s*\d*:\s*(.*)$/
+        { type: :description, content: $1.strip, line: line_number - 1 }
+      when /^#\s*=!>\s*(.*)$/
+        { type: :exception_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=<>\s*(.*)$/
+        { type: :intentional_failure_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*==>\s*(.*)$/
+        { type: :true_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when %r{^#\s*=/=>\s*(.*)$}
+        { type: :false_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=\|>\s*(.*)$/
+        { type: :boolean_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=:>\s*(.*)$/
+        { type: :result_type_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=~>\s*(.*)$/
+        { type: :regex_match_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=%>\s*(.*)$/
+        { type: :performance_time_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=(\d+)>\s*(.*)$/
+        { type: :output_expectation, content: $2.strip, pipe: $1.to_i, line: line_number - 1, ast: parse_expectation($2.strip) }
+      when /^#\s*=>\s*(.*)$/
+        { type: :expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^##\s*=>\s*(.*)$/
+        { type: :comment, content: '=>' + $1.strip, line: line_number - 1 }
+      when /^#\s*(.*)$/
+        { type: :potential_description, content: $1.strip, line: line_number - 1 }
+      else
+        { type: :comment, content: content.sub(/^#\s*/, ''), line: line_number - 1 }
+      end
+    end
+
+    # Parser type identification for metadata
+    def parser_type
+      :enhanced
+    end
+  end
+end

data/lib/tryouts/parsers/prism_parser.rb

@@ -0,0 +1,120 @@
+# lib/tryouts/parsers/prism_parser.rb
+
+require_relative '../test_case'
+require_relative 'base_parser'
+
+class Tryouts
+  # Fixed PrismParser with pattern matching for robust token filtering
+  class PrismParser < Tryouts::Parsers::BaseParser
+
+    def parse
+      return handle_syntax_errors if @prism_result.failure?
+
+      tokens           = tokenize_content
+      test_boundaries  = find_test_case_boundaries(tokens)
+      tokens           = classify_potential_descriptions_with_boundaries(tokens, test_boundaries)
+      test_blocks      = group_into_test_blocks(tokens)
+      process_test_blocks(test_blocks)
+    end
+
+    private
+
+    # Tokenize content using pattern matching for clean line classification
+    def tokenize_content
+      tokens = []
+
+      @lines.each_with_index do |line, index|
+        token = case line
+                in /^##\s*(.*)$/ # Test description format: ## description
+                  { type: :description, content: $1.strip, line: index }
+                in /^#\s*TEST\s*\d*:\s*(.*)$/  # rubocop:disable Lint/DuplicateBranch
+                  { type: :description, content: $1.strip, line: index }
+                in /^#\s*=!>\s*(.*)$/ # Exception expectation (updated for consistency)
+                  { type: :exception_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=<>\s*(.*)$/ # Intentional failure expectation
+                  { type: :intentional_failure_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*==>\s*(.*)$/ # Boolean true expectation
+                  { type: :true_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in %r{^#\s*=/=>\s*(.*)$} # Boolean false expectation
+                  { type: :false_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=\|>\s*(.*)$/ # Boolean (true or false) expectation
+                  { type: :boolean_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=:>\s*(.*)$/ # Result type expectation
+                  { type: :result_type_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=~>\s*(.*)$/ # Regex match expectation
+                  { type: :regex_match_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=%>\s*(.*)$/ # Performance time expectation
+                  { type: :performance_time_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=(\d+)>\s*(.*)$/ # Output expectation (stdout/stderr with pipe number)
+                  { type: :output_expectation, content: $2.strip, pipe: $1.to_i, line: index, ast: parse_expectation($2.strip) }
+                in /^#\s*=>\s*(.*)$/ # Regular expectation
+                  { type: :expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^##\s*=>\s*(.*)$/ # Commented out expectation (should be ignored)
+                  { type: :comment, content: '=>' + $1.strip, line: index }
+                in /^#\s*(.*)$/ # Single hash comment - potential description
+                  { type: :potential_description, content: $1.strip, line: index }
+                in /^\s*$/ # Blank line
+                  { type: :blank, line: index }
+                else # Ruby code
+                  { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
+                end
+
+        tokens << token
+      end
+
+      # Return tokens with potential_descriptions - they'll be classified later with test boundaries
+      tokens
+    end
+
+
+    # Convert potential_descriptions to descriptions or comments based on context
+    def classify_potential_descriptions(tokens)
+      tokens.map.with_index do |token, index|
+        if token[:type] == :potential_description
+          # Check if this looks like a test description based on content and context
+          content = token[:content].strip
+
+          # Skip if it's clearly just a regular comment (short, lowercase, etc.)
+          # Test descriptions are typically longer and more descriptive
+          looks_like_regular_comment = content.length < 20 &&
+                                       content.downcase == content &&
+                                       !content.match?(/test|example|demonstrate|show/i)
+
+          # Check if there's code immediately before this (suggesting it's mid-test)
+          prev_token      = index > 0 ? tokens[index - 1] : nil
+          has_code_before = prev_token && prev_token[:type] == :code
+
+          if looks_like_regular_comment || has_code_before
+            # Treat as regular comment
+            token.merge(type: :comment)
+          else
+            # Look ahead for test pattern: code + at least one expectation within reasonable distance
+            following_tokens = tokens[(index + 1)..]
+
+            # Skip blanks and comments to find meaningful content
+            meaningful_following = following_tokens.reject { |t| [:blank, :comment].include?(t[:type]) }
+
+            # Look for test pattern: at least one code token followed by at least one expectation
+            # within the next 10 meaningful tokens (to avoid matching setup/teardown)
+            test_window     = meaningful_following.first(10)
+            has_code        = test_window.any? { |t| t[:type] == :code }
+            has_expectation = test_window.any? { |t| is_expectation_type?(t[:type]) }
+
+            if has_code && has_expectation
+              token.merge(type: :description)
+            else
+              token.merge(type: :comment)
+            end
+          end
+        else
+          token
+        end
+      end
+    end
+
+    # Parser type identification for metadata
+    def parser_type
+      :prism_v2_fixed
+    end
+  end
+end