tryouts 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95b7078a356f605ba8df53a52afcb2209d260c473787692c4b70c0d88e8c5620
-  data.tar.gz: f6d47e78b51ee13d754c03525329a1857a44767324abc6237a4896f81688ecc2
+  metadata.gz: a7ef307bf73a8bd6c70f52c47337d550ae7715e0b64d15c7f708c9fd407f3df2
+  data.tar.gz: ccd166f03573bee1d31e3843ff95964cf5065ab4a1b2386e9769ec065a6958f5
 SHA512:
-  metadata.gz: e49a47fd56ba73dc0a80deeb0d3559558b4dbefcc31904c21358a906e7f542d6a8caa7479b8d95e66af6e52f7ea4760d3df76e7e0b310f037f3a369adc9f3cbf
-  data.tar.gz: 8de293b074a3599af4c543b05b3d49d58508b154eb4cce396e55027343042fb5289020cbdd8277d03abf667303ec935d59d3ece8f3e50ec308e150b9541dbda8
+  metadata.gz: 22b0d458cfadd632495c4df95f41cca3c06c6e6b3e219b18afb0fd21bfc14d1d9a872b165fcd2dd1c26052a9f57b84dad77c4a5a14c3efa08f62d74f0ab34467
+  data.tar.gz: 8cd6db263235736e26163b84568ad870de5835da3002e6f71226d961fc21e19d9eaef3cf2e02598a3907cb2701665e72a7e21ecea05b540f10ba37daa530a391

data/README.md

@@ -134,7 +134,7 @@ try -D    # debug mode
 
 ### Core Components
 
-- **Prism Parser**: Native Ruby parsing with pattern matching for line classification
+- **Prism Parser**: Inhouse Ruby parsing with pattern matching for line classification
 - **Data Structures**: Immutable `Data.define` classes for test representation
 - **Framework Translators**: Convert tryouts to RSpec/Minitest format
 - **CLI**: Modern command-line interface with framework selection

data/exe/try

@@ -75,6 +75,6 @@ begin
   exit cli.run(files, **options)
 rescue StandardError => ex
   warn "Error: #{ex.message}"
-  warn ex.backtrace.join("\n") if options[:debug]
+  warn ex.backtrace.join("\n") if options&.dig(:debug)
   exit 1
 end

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

@@ -63,10 +63,10 @@ class Tryouts
 
             # Include line number with file path for easy copying/clicking
             location = if failure.line_number > 0
-              "#{pretty_path}:#{failure.line_number}"
+              "#{pretty_path}:#{failure.line_number + 1}"
             else
               pretty_path
-                       end
+            end
 
             puts "  #{location}"
             puts "    #{Console.color(:red, '✗')} #{failure.description}"

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

@@ -6,7 +6,7 @@ require_relative 'tty_status_display'
 class Tryouts
   class CLI
     # Centralized manager for live status display across all formatters
-    # Replaces the decorator pattern with native integration
+    # Replaces the decorator pattern with inhouse integration
     class LiveStatusManager
       def initialize(formatter, options = {})
         @formatter  = formatter
@@ -20,7 +20,7 @@ class Tryouts
         @display         = TTYStatusDisplay.new(@formatter.stdout, options)
         @status_reserved = false
 
-        debug_log('LiveStatusManager: Enabled with native integration')
+        debug_log('LiveStatusManager: Enabled with inhouse integration')
       end
 
       def enabled?

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

@@ -53,6 +53,7 @@ class Tryouts
 
         puts
         write '=' * 50
+        puts
         puts Console.color(:red, 'Failed Tests:')
 
         failure_collector.failures_by_file.each do |file_path, failures|
@@ -61,7 +62,7 @@ class Tryouts
 
             # Include line number with file path for easy copying/clicking
             if failure.line_number > 0
-              location = "#{pretty_path}:#{failure.line_number}"
+              location = "#{pretty_path}:#{failure.line_number + 1}"
             else
               location = pretty_path
             end

data/lib/tryouts/cli/opts.rb

@@ -66,6 +66,10 @@ class Tryouts
           opts.on('-c', '--compact', 'Compact single-line output') { options[:compact]                    = true }
           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.separator "\nInspection Options:"
           opts.on('-i', '--inspect', 'Inspect file structure without running tests') { options[:inspect] = true }
 
@@ -87,7 +91,6 @@ class Tryouts
         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

data/lib/tryouts/enhanced_parser.rb

@@ -0,0 +1,461 @@
+# Enhanced parser using Prism's inhouse comment extraction capabilities
+# Drop-in replacement for PrismParser that eliminates HEREDOC parsing issues
+
+require 'prism'
+require_relative 'test_case'
+
+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
+    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
+
+    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
+
+    # Copy the rest of the methods from PrismParser to maintain identical behavior
+
+    def find_test_case_boundaries(tokens)
+      boundaries = []
+
+      tokens.each_with_index do |token, index|
+        if token[:type] == :description
+          start_line = token[:line]
+          end_line   = find_test_case_end(tokens, index)
+          boundaries << { start: start_line, end: end_line } if end_line
+        end
+      end
+
+      boundaries
+    end
+
+    def find_test_case_end(tokens, start_index)
+      last_expectation_line = nil
+
+      (start_index + 1).upto(tokens.length - 1) do |i|
+        token = tokens[i]
+        break if token[:type] == :description
+
+        if is_expectation_type?(token[:type])
+          last_expectation_line = token[:line]
+        end
+      end
+
+      last_expectation_line
+    end
+
+    def classify_potential_descriptions_with_boundaries(tokens, test_boundaries)
+      tokens.map.with_index do |token, index|
+        if token[:type] == :potential_description
+          line_num         = token[:line]
+          within_test_case = test_boundaries.any? do |boundary|
+            line_num >= boundary[:start] && line_num <= boundary[:end]
+          end
+
+          if within_test_case
+            token.merge(type: :comment)
+          else
+            content = token[:content].strip
+
+            looks_like_test_description = content.match?(/test|example|demonstrate|show|should|when|given/i) &&
+                                          content.length > 10
+
+            prev_token      = index > 0 ? tokens[index - 1] : nil
+            has_code_before = prev_token && prev_token[:type] == :code
+
+            if has_code_before || !looks_like_test_description
+              token.merge(type: :comment)
+            else
+              following_tokens = tokens[(index + 1)..]
+              meaningful_following = following_tokens.reject { |t| [:blank, :comment].include?(t[:type]) }
+              test_window     = meaningful_following.first(5)
+              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 && looks_like_test_description
+                token.merge(type: :description)
+              else
+                token.merge(type: :comment)
+              end
+            end
+          end
+        else
+          token
+        end
+      end
+    end
+
+    def is_expectation_type?(type)
+      [
+        :expectation, :exception_expectation, :intentional_failure_expectation,
+        :true_expectation, :false_expectation, :boolean_expectation,
+        :result_type_expectation, :regex_match_expectation,
+        :performance_time_expectation, :output_expectation
+      ].include?(type)
+    end
+
+    def group_into_test_blocks(tokens)
+      blocks        = []
+      current_block = new_test_block
+
+      tokens.each do |token|
+        case [current_block, token]
+        in [_, { type: :description, content: String => desc, line: Integer => line_num }]
+          if !current_block[:description].empty? && current_block[:code].empty? && current_block[:expectations].empty?
+            current_block[:description] = [current_block[:description], desc].join(' ').strip
+          else
+            blocks << current_block if block_has_content?(current_block)
+            current_block = new_test_block.merge(description: desc, start_line: line_num)
+          end
+
+        in [{ expectations: [], start_line: nil }, { type: :code, content: String => code, line: Integer => line_num }]
+          current_block[:code] << token
+          current_block[:start_line] = line_num
+
+        in [{ expectations: [] }, { type: :code, content: String => code }]
+          current_block[:code] << token
+
+        in [{ expectations: Array => exps }, { type: :code }] if !exps.empty?
+          blocks << current_block
+          current_block = new_test_block.merge(code: [token], start_line: token[:line])
+
+        in [_, { type: :expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :exception_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :intentional_failure_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :true_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :false_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :boolean_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :result_type_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :regex_match_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :performance_time_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :output_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :comment | :blank }]
+          add_context_to_block(current_block, token)
+        end
+      end
+
+      blocks << current_block if block_has_content?(current_block)
+      classify_blocks(blocks)
+    end
+
+    def process_test_blocks(classified_blocks)
+      setup_blocks    = classified_blocks.filter { |block| block[:type] == :setup }
+      test_blocks     = classified_blocks.filter { |block| block[:type] == :test }
+      teardown_blocks = classified_blocks.filter { |block| block[:type] == :teardown }
+
+      Testrun.new(
+        setup: build_setup(setup_blocks),
+        test_cases: test_blocks.map { |block| build_test_case(block) },
+        teardown: build_teardown(teardown_blocks),
+        source_file: @source_path,
+        metadata: { parsed_at: @parsed_at, parser: :enhanced },
+      )
+    end
+
+    def build_setup(setup_blocks)
+      return Setup.new(code: '', line_range: 0..0, path: @source_path) if setup_blocks.empty?
+
+      Setup.new(
+        code: extract_pure_code_from_blocks(setup_blocks),
+        line_range: calculate_block_range(setup_blocks),
+        path: @source_path,
+      )
+    end
+
+    def build_teardown(teardown_blocks)
+      return Teardown.new(code: '', line_range: 0..0, path: @source_path) if teardown_blocks.empty?
+
+      Teardown.new(
+        code: extract_pure_code_from_blocks(teardown_blocks),
+        line_range: calculate_block_range(teardown_blocks),
+        path: @source_path,
+      )
+    end
+
+    def extract_pure_code_from_blocks(blocks)
+      blocks
+        .flat_map { |block| block[:code] }
+        .filter_map do |token|
+          case token
+          in { type: :code, content: String => content }
+            content
+          else
+            nil
+          end
+        end
+        .join("\n")
+    end
+
+    def calculate_block_range(blocks)
+      return 0..0 if blocks.empty?
+
+      valid_blocks = blocks.filter { |block| block[:start_line] && block[:end_line] }
+      return 0..0 if valid_blocks.empty?
+
+      line_ranges = valid_blocks.map { |block| block[:start_line]..block[:end_line] }
+      line_ranges.first.first..line_ranges.last.last
+    end
+
+    def extract_code_content(code_tokens)
+      code_tokens
+        .filter_map do |token|
+          case token
+          in { type: :code, content: String => content }
+            content
+          else
+            nil
+          end
+        end
+        .join("\n")
+    end
+
+    def parse_ruby_line(line)
+      return nil if line.strip.empty?
+
+      result = Prism.parse(line.strip)
+      case result
+      in { errors: [] => errors, value: { body: { body: [ast] } } }
+        ast
+      in { errors: Array => errors } if errors.any?
+        { type: :parse_error, errors: errors, raw: line }
+      else
+        nil
+      end
+    end
+
+    def parse_expectation(expr)
+      parse_ruby_line(expr)
+    end
+
+    def new_test_block
+      {
+        description: '',
+        code: [],
+        expectations: [],
+        comments: [],
+        start_line: nil,
+        end_line: nil,
+      }
+    end
+
+    def block_has_content?(block)
+      case block
+      in { description: String => desc, code: Array => code, expectations: Array => exps }
+        !desc.empty? || !code.empty? || !exps.empty?
+      else
+        false
+      end
+    end
+
+    def add_context_to_block(block, token)
+      case [block[:expectations].empty?, token]
+      in [true, { type: :comment | :blank }]
+        block[:code] << token
+      in [false, { type: :comment | :blank }]
+        block[:comments] << token
+      end
+    end
+
+    def classify_blocks(blocks)
+      blocks.map.with_index do |block, index|
+        block_type = case block
+                     in { expectations: [] } if index == 0
+                       :setup
+                     in { expectations: [] } if index == blocks.size - 1
+                       :teardown
+                     in { expectations: Array => exps } if !exps.empty?
+                       :test
+                     else
+                       :preamble
+                     end
+
+        block.merge(type: block_type, end_line: calculate_end_line(block))
+      end
+    end
+
+    def calculate_end_line(block)
+      content_tokens = [*block[:code], *block[:expectations]]
+      return block[:start_line] if content_tokens.empty?
+
+      content_tokens.map { |token| token[:line] }.max || block[:start_line]
+    end
+
+    def build_test_case(block)
+      case block
+      in {
+        type: :test,
+        description: String => desc,
+        code: Array => code_tokens,
+        expectations: Array => exp_tokens,
+        start_line: Integer => start_line,
+        end_line: Integer => end_line
+      }
+        source_lines = @lines[start_line..end_line]
+        first_expectation_line = exp_tokens.empty? ? start_line : exp_tokens.first[:line]
+
+        TestCase.new(
+          description: desc,
+          code: extract_code_content(code_tokens),
+          expectations: exp_tokens.map do |token|
+            type = case token[:type]
+                   when :exception_expectation then :exception
+                   when :intentional_failure_expectation then :intentional_failure
+                   when :true_expectation then :true # rubocop:disable Lint/BooleanSymbol
+                   when :false_expectation then :false # rubocop:disable Lint/BooleanSymbol
+                   when :boolean_expectation then :boolean
+                   when :result_type_expectation then :result_type
+                   when :regex_match_expectation then :regex_match
+                   when :performance_time_expectation then :performance_time
+                   when :output_expectation then :output
+                   else :regular
+                   end
+
+            if token[:type] == :output_expectation
+              OutputExpectation.new(content: token[:content], type: type, pipe: token[:pipe])
+            else
+              Expectation.new(content: token[:content], type: type)
+            end
+          end,
+          line_range: start_line..end_line,
+          path: @source_path,
+          source_lines: source_lines,
+          first_expectation_line: first_expectation_line,
+        )
+      else
+        raise "Invalid test block structure: #{block}"
+      end
+    end
+
+    def handle_syntax_errors
+      errors = @prism_result.errors.map do |error|
+        line_context = @lines[error.location.start_line - 1] || ''
+
+        TryoutSyntaxError.new(
+          error.message,
+          line_number: error.location.start_line,
+          context: line_context,
+          source_file: @source_path,
+        )
+      end
+
+      raise errors.first if errors.any?
+    end
+  end
+end

data/lib/tryouts/failure_collector.rb

@@ -9,8 +9,8 @@ class Tryouts
     # Data structure for a single failure entry
     FailureEntry = Data.define(:file_path, :test_case, :result_packet) do
       def line_number
-        # Use last line of range (expectation line) for failure display
-        test_case.line_range&.last || test_case.first_expectation_line || 0
+        # Use first expectation line for consistency with main error display
+        test_case.first_expectation_line || test_case.line_range&.first || 0
       end
 
       def description

data/lib/tryouts/file_processor.rb

@@ -1,12 +1,15 @@
 # lib/tryouts/file_processor.rb
 
 require_relative 'prism_parser'
+require_relative 'enhanced_parser'
 require_relative 'test_executor'
 require_relative 'cli/modes/inspect'
 require_relative 'cli/modes/generate'
 
 class Tryouts
   class FileProcessor
+    # Supported parser types for validation and documentation
+    PARSER_TYPES = [:enhanced, :prism].freeze
     def initialize(file:, options:, output_manager:, translator:, global_tally:)
       @file           = file
       @options        = options
@@ -16,7 +19,7 @@ class Tryouts
     end
 
     def process
-      testrun                     = PrismParser.new(@file).parse
+      testrun                     = create_parser(@file, @options).parse
       @global_tally[:file_count] += 1
       @output_manager.file_parsed(@file, testrun.total_tests)
 
@@ -35,6 +38,21 @@ class Tryouts
 
     private
 
+    def create_parser(file, options)
+      parser_type = options[:parser] || :prism  # default to legacy for safe rollout
+
+      unless PARSER_TYPES.include?(parser_type)
+        raise ArgumentError, "Unknown parser: #{parser_type}. Allowed types: #{PARSER_TYPES.join(', ')}"
+      end
+
+      case parser_type
+      when :enhanced
+        EnhancedParser.new(file)
+      when :prism
+        PrismParser.new(file)
+      end
+    end
+
     def handle_inspect_mode(testrun)
       mode = Tryouts::CLI::InspectMode.new(@file, testrun, @options, @output_manager, @translator)
       mode.handle

data/lib/tryouts/prism_parser.rb

@@ -11,6 +11,7 @@ class Tryouts
       @source       = File.read(source_path)
       @lines        = @source.lines.map(&:chomp)
       @prism_result = Prism.parse(@source)
+      @parsed_at    = Time.now
     end
 
     def parse
@@ -308,7 +309,7 @@ class Tryouts
         test_cases: test_blocks.map { |block| build_test_case(block) },
         teardown: build_teardown(teardown_blocks),
         source_file: @source_path,
-        metadata: { parsed_at: Time.now, parser: :prism_v2_fixed },
+        metadata: { parsed_at: @parsed_at, parser: :prism_v2_fixed },
       )
     end
 

data/lib/tryouts/version.rb

@@ -1,5 +1,5 @@
 # lib/tryouts/version.rb
 
 class Tryouts
-  VERSION = '3.2.1'
+  VERSION = '3.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tryouts
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.0
 platform: ruby
 authors:
 - Delano Mandelbaum
@@ -137,6 +137,7 @@ files:
 - lib/tryouts/cli/opts.rb
 - lib/tryouts/cli/tty_detector.rb
 - lib/tryouts/console.rb
+- lib/tryouts/enhanced_parser.rb
 - lib/tryouts/expectation_evaluators/base.rb
 - lib/tryouts/expectation_evaluators/boolean.rb
 - lib/tryouts/expectation_evaluators/exception.rb