20560974963

Committed 28 Dec 2025 11:21PM UTC coverage: 79.076% (+1.7%) from 77.331%

Build # 20560974963

Build Type

push

github

Committed by

web-flow

Commit Message

refactor: migrate parser from regex to token-based parser combinator (#29)

* refactor: migrate parser from regex to token-based parser combinator

- Replace monolithic parser_combinator.rb (2833 lines) with modular architecture
- Add Scanner for tokenization with regex literal support
- Create IR::InterpolatedString for string interpolation parsing
- Fix type inference for interpolated strings (returns String)
- Add TRuby::ParseError for unified error handling
- Organize parsers into primitives/, combinators/, and token/ directories
- Each file contains exactly one class (snake_case filename matches PascalCase class)

* fix: enhance parser to support ternary, splat args, and statement expressions

- Add ternary operator (? :) parsing in ExpressionParser
- Support double splat (**opts) and single splat (*args) in method calls
- Support keyword arguments (name: value) in method calls
- Allow case/if/unless/begin as assignment right-hand side values
- Improve generic type compatibility (Array[untyped] with Array[T])

Fixes type inference errors in keyword_args samples.

* style: fix RuboCop violations and adjust metrics limits

* fix: require set for Ruby 3.1 compatibility

Run Details

1849 of 2098 new or added lines in 53 files covered. (88.13%)

6 existing lines in 2 files now uncovered.

6644 of 8402 relevant lines covered (79.08%)

908.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.88

/lib/t_ruby/parser_combinator/parser.rb

# frozen_string_literal: true

module TRuby
  module ParserCombinator
    # Base parser class for string-based parsing
    class Parser
      def parse(input, position = 0)
        raise NotImplementedError
      end

      # Combinators as methods

      # Sequence: run this parser, then the other
      def >>(other)
        Sequence.new(self, other)
      end

      # Alternative: try this parser, if it fails try the other
      def |(other)
        Alternative.new(self, other)
      end

      # Map: transform the result
      def map(&block)
        Map.new(self, block)
      end

      # FlatMap: transform with another parser
      def flat_map(&block)
        FlatMap.new(self, block)
      end

      # Many: zero or more repetitions
      def many
        Many.new(self)
      end

      # Many1: one or more repetitions
      def many1
        Many1.new(self)
      end

      # Optional: zero or one
      def optional
        Optional.new(self)
      end

      # Separated by: parse items separated by delimiter
      def sep_by(delimiter)
        SepBy.new(self, delimiter)
      end

      # Separated by 1: at least one item
      def sep_by1(delimiter)
        SepBy1.new(self, delimiter)
      end

      # Between: parse between left and right delimiters
      def between(left, right)
        (left >> self << right).map { |(_, val)| val }
      end

      # Skip right: parse both, keep left result
      def <<(other)
        SkipRight.new(self, other)
      end

      # Label: add a descriptive label for error messages
      def label(name)
        Label.new(self, name)
      end

      # Lookahead: check without consuming
      def lookahead
        Lookahead.new(self)
      end

      # Not: succeed only if parser fails
      def not_followed_by
        NotFollowedBy.new(self)
      end
    end
  end
end

1	# frozen_string_literal: true
2
3	module TRuby	1✔
4	module ParserCombinator	1✔
5	# Base parser class for string-based parsing
6	class Parser	1✔
7	def parse(input, position = 0)	1✔
NEW 8	raise NotImplementedError	×
9	end
10
11	# Combinators as methods
12
13	# Sequence: run this parser, then the other
14	def >>(other)	1✔
15	Sequence.new(self, other)	8,487✔
16	end
17
18	# Alternative: try this parser, if it fails try the other
19	def \|(other)	1✔
20	Alternative.new(self, other)	457✔
21	end
22
23	# Map: transform the result
24	def map(&block)	1✔
25	Map.new(self, block)	19,472✔
26	end
27
28	# FlatMap: transform with another parser
29	def flat_map(&block)	1✔
NEW 30	FlatMap.new(self, block)	×
31	end
32
33	# Many: zero or more repetitions
34	def many	1✔
35	Many.new(self)	10,687✔
36	end
37
38	# Many1: one or more repetitions
39	def many1	1✔
40	Many1.new(self)	7✔
41	end
42
43	# Optional: zero or one
44	def optional	1✔
45	Optional.new(self)	742✔
46	end
47
48	# Separated by: parse items separated by delimiter
49	def sep_by(delimiter)	1✔
50	SepBy.new(self, delimiter)	367✔
51	end
52
53	# Separated by 1: at least one item
54	def sep_by1(delimiter)	1✔
55	SepBy1.new(self, delimiter)	1,434✔
56	end
57
58	# Between: parse between left and right delimiters
59	def between(left, right)	1✔
60	(left >> self << right).map { \|(_, val)\| val }	2✔
61	end
62
63	# Skip right: parse both, keep left result
64	def <<(other)	1✔
65	SkipRight.new(self, other)	6,611✔
66	end
67
68	# Label: add a descriptive label for error messages
69	def label(name)	1✔
70	Label.new(self, name)	358✔
71	end
72
73	# Lookahead: check without consuming
74	def lookahead	1✔
NEW 75	Lookahead.new(self)	×
76	end
77
78	# Not: succeed only if parser fails
79	def not_followed_by	1✔
NEW 80	NotFollowedBy.new(self)	×
81	end
82	end
83	end
84	end

type-ruby / t-ruby / 20560974963

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous