ripper_ruby_parser 1.1.1 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +19 -0
  3. data/Rakefile +2 -2
  4. data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +55 -4
  5. data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +20 -13
  6. data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb +27 -12
  7. data/lib/ripper_ruby_parser/sexp_handlers/hashes.rb +25 -12
  8. data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb +4 -2
  9. data/lib/ripper_ruby_parser/sexp_handlers/literals.rb +19 -15
  10. data/lib/ripper_ruby_parser/sexp_handlers/loops.rb +25 -11
  11. data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +12 -4
  12. data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +8 -4
  13. data/lib/ripper_ruby_parser/sexp_handlers/operators.rb +1 -5
  14. data/lib/ripper_ruby_parser/version.rb +1 -1
  15. data/lib/ripper_ruby_parser.rb +2 -2
  16. data/test/end_to_end/comments_test.rb +4 -4
  17. data/test/end_to_end/comparison_test.rb +15 -15
  18. data/test/end_to_end/error_conditions_test.rb +16 -16
  19. data/test/end_to_end/lib_comparison_test.rb +3 -3
  20. data/test/end_to_end/line_numbering_test.rb +4 -4
  21. data/test/end_to_end/samples_comparison_test.rb +4 -4
  22. data/test/end_to_end/test_comparison_test.rb +3 -3
  23. data/test/pt_testcase/pt_test.rb +4 -4
  24. data/test/test_helper.rb +1 -1
  25. data/test/unit/commenting_ripper_parser_test.rb +33 -33
  26. data/test/unit/parser_assignment_test.rb +30 -30
  27. data/test/unit/parser_blocks_test.rb +83 -65
  28. data/test/unit/parser_conditionals_test.rb +96 -64
  29. data/test/unit/parser_literals_test.rb +308 -212
  30. data/test/unit/parser_loops_test.rb +85 -15
  31. data/test/unit/parser_method_calls_test.rb +100 -41
  32. data/test/unit/parser_operators_test.rb +60 -28
  33. data/test/unit/parser_test.rb +435 -410
  34. data/test/unit/sexp_processor_test.rb +82 -82
  35. data/test/unit/version_test.rb +1 -1
  36. metadata +2 -2
data/test/unit/parser_loops_test.rb CHANGED
@@ -1,51 +1,121 @@
1
1
  require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
2
2
 
3
3
  describe RipperRubyParser::Parser do
4
- describe "#parse" do
5
- describe "for the while statement" do
6
- it "works in the single-line postfix case" do
7
- "foo while bar".
4
+ describe '#parse' do
5
+ describe 'for the while statement' do
6
+ it 'works with do' do
7
+ 'while foo do; bar; end'.
8
+ must_be_parsed_as s(:while,
9
+ s(:call, nil, :foo),
10
+ s(:call, nil, :bar), true)
11
+ end
12
+
13
+ it 'works without do' do
14
+ 'while foo; bar; end'.
15
+ must_be_parsed_as s(:while,
16
+ s(:call, nil, :foo),
17
+ s(:call, nil, :bar), true)
18
+ end
19
+
20
+ it 'works in the single-line postfix case' do
21
+ 'foo while bar'.
8
22
  must_be_parsed_as s(:while,
9
23
  s(:call, nil, :bar),
10
24
  s(:call, nil, :foo), true)
11
25
  end
12
26
 
13
- it "works in the block postfix case" do
14
- "begin; foo; end while bar".
27
+ it 'works in the block postfix case' do
28
+ 'begin; foo; end while bar'.
15
29
  must_be_parsed_as s(:while,
16
30
  s(:call, nil, :bar),
17
31
  s(:call, nil, :foo), false)
18
32
  end
19
33
 
20
- it "handles a negative condition" do
21
- "while not foo; bar; end".
34
+ it 'handles a negative condition' do
35
+ 'while not foo; bar; end'.
22
36
  must_be_parsed_as s(:while,
23
37
  s(:call, s(:call, nil, :foo), :!),
24
38
  s(:call, nil, :bar), true)
25
39
  end
26
40
 
27
- it "handles a negative condition in the postfix case" do
28
- "foo while not bar".
41
+ it 'handles a negative condition in the postfix case' do
42
+ 'foo while not bar'.
29
43
  must_be_parsed_as s(:while,
30
44
  s(:call, s(:call, nil, :bar), :!),
31
45
  s(:call, nil, :foo), true)
32
46
  end
47
+
48
+ it 'converts a negated match condition to :until' do
49
+ 'while foo !~ bar; baz; end'.
50
+ must_be_parsed_as s(:until,
51
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
52
+ s(:call, nil, :baz), true)
53
+ end
54
+
55
+ it 'converts a negated match condition to :until in the postfix case' do
56
+ 'baz while foo !~ bar'.
57
+ must_be_parsed_as s(:until,
58
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
59
+ s(:call, nil, :baz), true)
60
+ end
33
61
  end
34
62
 
35
- describe "for the until statement" do
36
- it "handles a negative condition" do
37
- "until not foo; bar; end".
63
+ describe 'for the until statement' do
64
+ it 'works in the prefix block case with do' do
65
+ 'until foo do; bar; end'.
66
+ must_be_parsed_as s(:until,
67
+ s(:call, nil, :foo),
68
+ s(:call, nil, :bar), true)
69
+ end
70
+
71
+ it 'works in the prefix block case without do' do
72
+ 'until foo; bar; end'.
73
+ must_be_parsed_as s(:until,
74
+ s(:call, nil, :foo),
75
+ s(:call, nil, :bar), true)
76
+ end
77
+
78
+ it 'works in the single-line postfix case' do
79
+ 'foo until bar'.
80
+ must_be_parsed_as s(:until,
81
+ s(:call, nil, :bar),
82
+ s(:call, nil, :foo), true)
83
+ end
84
+
85
+ it 'works in the block postfix case' do
86
+ 'begin; foo; end until bar'.
87
+ must_be_parsed_as s(:until,
88
+ s(:call, nil, :bar),
89
+ s(:call, nil, :foo), false)
90
+ end
91
+
92
+ it 'handles a negative condition' do
93
+ 'until not foo; bar; end'.
38
94
  must_be_parsed_as s(:until,
39
95
  s(:call, s(:call, nil, :foo), :!),
40
96
  s(:call, nil, :bar), true)
41
97
  end
42
98
 
43
- it "handles a negative condition in the postfix case" do
44
- "foo until not bar".
99
+ it 'handles a negative condition in the postfix case' do
100
+ 'foo until not bar'.
45
101
  must_be_parsed_as s(:until,
46
102
  s(:call, s(:call, nil, :bar), :!),
47
103
  s(:call, nil, :foo), true)
48
104
  end
105
+
106
+ it 'converts a negated match condition to :while' do
107
+ 'until foo !~ bar; baz; end'.
108
+ must_be_parsed_as s(:while,
109
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
110
+ s(:call, nil, :baz), true)
111
+ end
112
+
113
+ it 'converts a negated match condition to :while in the postfix case' do
114
+ 'baz until foo !~ bar'.
115
+ must_be_parsed_as s(:while,
116
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
117
+ s(:call, nil, :baz), true)
118
+ end
49
119
  end
50
120
  end
51
121
  end
data/test/unit/parser_method_calls_test.rb CHANGED
@@ -1,45 +1,45 @@
1
1
  require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
2
2
 
3
3
  describe RipperRubyParser::Parser do
4
- describe "#parse" do
5
- describe "for method calls" do
6
- describe "without a receiver" do
7
- it "works without brackets" do
8
- "foo bar".
4
+ describe '#parse' do
5
+ describe 'for method calls' do
6
+ describe 'without a receiver' do
7
+ it 'works without brackets' do
8
+ 'foo bar'.
9
9
  must_be_parsed_as s(:call, nil, :foo,
10
10
  s(:call, nil, :bar))
11
11
  end
12
12
 
13
- it "works with brackets" do
14
- "foo(bar)".
13
+ it 'works with brackets' do
14
+ 'foo(bar)'.
15
15
  must_be_parsed_as s(:call, nil, :foo,
16
16
  s(:call, nil, :bar))
17
17
  end
18
18
 
19
- it "works with an empty parameter list and no brackets" do
20
- "foo".
19
+ it 'works with an empty parameter list and no brackets' do
20
+ 'foo'.
21
21
  must_be_parsed_as s(:call, nil, :foo)
22
22
  end
23
23
 
24
- it "works with brackets around an empty parameter list" do
25
- "foo()".
24
+ it 'works with brackets around an empty parameter list' do
25
+ 'foo()'.
26
26
  must_be_parsed_as s(:call, nil, :foo)
27
27
  end
28
28
 
29
- it "works for methods ending in a question mark" do
30
- "foo?".
29
+ it 'works for methods ending in a question mark' do
30
+ 'foo?'.
31
31
  must_be_parsed_as s(:call, nil, :foo?)
32
32
  end
33
33
 
34
- it "works with nested calls without brackets" do
35
- "foo bar baz".
34
+ it 'works with nested calls without brackets' do
35
+ 'foo bar baz'.
36
36
  must_be_parsed_as s(:call, nil, :foo,
37
37
  s(:call, nil, :bar,
38
38
  s(:call, nil, :baz)))
39
39
  end
40
40
 
41
- it "works with a non-final splat argument" do
42
- "foo(bar, *baz, qux)".
41
+ it 'works with a non-final splat argument' do
42
+ 'foo(bar, *baz, qux)'.
43
43
  must_be_parsed_as s(:call,
44
44
  nil,
45
45
  :foo,
@@ -48,8 +48,8 @@ describe RipperRubyParser::Parser do
48
48
  s(:call, nil, :qux))
49
49
  end
50
50
 
51
- it "works with a splat argument followed by several regular arguments" do
52
- "foo(bar, *baz, qux, quuz)".
51
+ it 'works with a splat argument followed by several regular arguments' do
52
+ 'foo(bar, *baz, qux, quuz)'.
53
53
  must_be_parsed_as s(:call,
54
54
  nil,
55
55
  :foo,
@@ -58,27 +58,68 @@ describe RipperRubyParser::Parser do
58
58
  s(:call, nil, :qux),
59
59
  s(:call, nil, :quuz))
60
60
  end
61
+
62
+ it 'works with a named argument' do
63
+ 'foo(bar, baz: qux)'.
64
+ must_be_parsed_as s(:call,
65
+ nil,
66
+ :foo,
67
+ s(:call, nil, :bar),
68
+ s(:hash, s(:lit, :baz), s(:call, nil, :qux)))
69
+ end
70
+
71
+ it 'works with several named arguments' do
72
+ 'foo(bar, baz: qux, quux: quuz)'.
73
+ must_be_parsed_as s(:call,
74
+ nil,
75
+ :foo,
76
+ s(:call, nil, :bar),
77
+ s(:hash,
78
+ s(:lit, :baz), s(:call, nil, :qux),
79
+ s(:lit, :quux), s(:call, nil, :quuz)))
80
+ end
81
+
82
+ it 'works with a double splat argument' do
83
+ 'foo(bar, **baz)'.
84
+ must_be_parsed_as s(:call,
85
+ nil,
86
+ :foo,
87
+ s(:call, nil, :bar),
88
+ s(:hash,
89
+ s(:kwsplat, s(:call, nil, :baz))))
90
+ end
91
+
92
+ it 'works with a named argument followed by a double splat argument' do
93
+ 'foo(bar, baz: qux, **quuz)'.
94
+ must_be_parsed_as s(:call,
95
+ nil,
96
+ :foo,
97
+ s(:call, nil, :bar),
98
+ s(:hash,
99
+ s(:lit, :baz), s(:call, nil, :qux),
100
+ s(:kwsplat, s(:call, nil, :quuz))))
101
+ end
61
102
  end
62
103
 
63
- describe "with a receiver" do
64
- it "works without brackets" do
65
- "foo.bar baz".
104
+ describe 'with a receiver' do
105
+ it 'works without brackets' do
106
+ 'foo.bar baz'.
66
107
  must_be_parsed_as s(:call,
67
108
  s(:call, nil, :foo),
68
109
  :bar,
69
110
  s(:call, nil, :baz))
70
111
  end
71
112
 
72
- it "works with brackets" do
73
- "foo.bar(baz)".
113
+ it 'works with brackets' do
114
+ 'foo.bar(baz)'.
74
115
  must_be_parsed_as s(:call,
75
116
  s(:call, nil, :foo),
76
117
  :bar,
77
118
  s(:call, nil, :baz))
78
119
  end
79
120
 
80
- it "works with brackets around a call with no brackets" do
81
- "foo.bar(baz qux)".
121
+ it 'works with brackets around a call with no brackets' do
122
+ 'foo.bar(baz qux)'.
82
123
  must_be_parsed_as s(:call,
83
124
  s(:call, nil, :foo),
84
125
  :bar,
@@ -86,8 +127,8 @@ describe RipperRubyParser::Parser do
86
127
  s(:call, nil, :qux)))
87
128
  end
88
129
 
89
- it "works with nested calls without brackets" do
90
- "foo.bar baz qux".
130
+ it 'works with nested calls without brackets' do
131
+ 'foo.bar baz qux'.
91
132
  must_be_parsed_as s(:call,
92
133
  s(:call, nil, :foo),
93
134
  :bar,
@@ -96,9 +137,27 @@ describe RipperRubyParser::Parser do
96
137
  end
97
138
  end
98
139
 
99
- describe "with blocks" do
100
- it "works for a do block" do
101
- "foo.bar do baz; end".
140
+ describe 'safe call' do
141
+ before do
142
+ skip 'This is not valid syntax below Ruby 2.3' if RUBY_VERSION < '2.3.0'
143
+ end
144
+
145
+ it 'works without arguments' do
146
+ 'foo&.bar'.must_be_parsed_as s(:safe_call, s(:call, nil, :foo), :bar)
147
+ end
148
+
149
+ it 'works with arguments' do
150
+ 'foo&.bar baz'.
151
+ must_be_parsed_as s(:safe_call,
152
+ s(:call, nil, :foo),
153
+ :bar,
154
+ s(:call, nil, :baz))
155
+ end
156
+ end
157
+
158
+ describe 'with blocks' do
159
+ it 'works for a do block' do
160
+ 'foo.bar do baz; end'.
102
161
  must_be_parsed_as s(:iter,
103
162
  s(:call,
104
163
  s(:call, nil, :foo),
@@ -107,8 +166,8 @@ describe RipperRubyParser::Parser do
107
166
  s(:call, nil, :baz))
108
167
  end
109
168
 
110
- it "works for a do block with several statements" do
111
- "foo.bar do baz; qux; end".
169
+ it 'works for a do block with several statements' do
170
+ 'foo.bar do baz; qux; end'.
112
171
  must_be_parsed_as s(:iter,
113
172
  s(:call,
114
173
  s(:call, nil, :foo),
@@ -121,25 +180,25 @@ describe RipperRubyParser::Parser do
121
180
  end
122
181
  end
123
182
 
124
- describe "for calls to super" do
125
- specify { "super".must_be_parsed_as s(:zsuper) }
183
+ describe 'for calls to super' do
184
+ specify { 'super'.must_be_parsed_as s(:zsuper) }
126
185
  specify do
127
- "super foo".must_be_parsed_as s(:super,
186
+ 'super foo'.must_be_parsed_as s(:super,
128
187
  s(:call, nil, :foo))
129
188
  end
130
189
  specify do
131
- "super foo, bar".must_be_parsed_as s(:super,
190
+ 'super foo, bar'.must_be_parsed_as s(:super,
132
191
  s(:call, nil, :foo),
133
192
  s(:call, nil, :bar))
134
193
  end
135
194
  specify do
136
- "super foo, *bar".must_be_parsed_as s(:super,
195
+ 'super foo, *bar'.must_be_parsed_as s(:super,
137
196
  s(:call, nil, :foo),
138
197
  s(:splat,
139
198
  s(:call, nil, :bar)))
140
199
  end
141
200
  specify do
142
- "super foo, *bar, &baz".
201
+ 'super foo, *bar, &baz'.
143
202
  must_be_parsed_as s(:super,
144
203
  s(:call, nil, :foo),
145
204
  s(:splat, s(:call, nil, :bar)),
@@ -147,8 +206,8 @@ describe RipperRubyParser::Parser do
147
206
  end
148
207
  end
149
208
 
150
- it "handles calling a proc" do
151
- "foo.()".
209
+ it 'handles calling a proc' do
210
+ 'foo.()'.
152
211
  must_be_parsed_as s(:call, s(:call, nil, :foo), :call)
153
212
  end
154
213
  end
data/test/unit/parser_operators_test.rb CHANGED
@@ -1,10 +1,10 @@
1
1
  require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
2
2
 
3
3
  describe RipperRubyParser::Parser do
4
- describe "#parse" do
5
- describe "for negated operators" do
4
+ describe '#parse' do
5
+ describe 'for negated operators' do
6
6
  specify do
7
- "foo !~ bar".must_be_parsed_as s(:not,
7
+ 'foo !~ bar'.must_be_parsed_as s(:not,
8
8
  s(:call,
9
9
  s(:call, nil, :foo),
10
10
  :=~,
@@ -12,16 +12,16 @@ describe RipperRubyParser::Parser do
12
12
  end
13
13
  end
14
14
 
15
- describe "for boolean operators" do
16
- it "handles :and" do
17
- "foo and bar".
15
+ describe 'for boolean operators' do
16
+ it 'handles :and' do
17
+ 'foo and bar'.
18
18
  must_be_parsed_as s(:and,
19
19
  s(:call, nil, :foo),
20
20
  s(:call, nil, :bar))
21
21
  end
22
22
 
23
- it "handles double :and" do
24
- "foo and bar and baz".
23
+ it 'handles double :and' do
24
+ 'foo and bar and baz'.
25
25
  must_be_parsed_as s(:and,
26
26
  s(:call, nil, :foo),
27
27
  s(:and,
@@ -29,15 +29,15 @@ describe RipperRubyParser::Parser do
29
29
  s(:call, nil, :baz)))
30
30
  end
31
31
 
32
- it "handles :or" do
33
- "foo or bar".
32
+ it 'handles :or' do
33
+ 'foo or bar'.
34
34
  must_be_parsed_as s(:or,
35
35
  s(:call, nil, :foo),
36
36
  s(:call, nil, :bar))
37
37
  end
38
38
 
39
- it "handles double :or" do
40
- "foo or bar or baz".
39
+ it 'handles double :or' do
40
+ 'foo or bar or baz'.
41
41
  must_be_parsed_as s(:or,
42
42
  s(:call, nil, :foo),
43
43
  s(:or,
@@ -45,8 +45,8 @@ describe RipperRubyParser::Parser do
45
45
  s(:call, nil, :baz)))
46
46
  end
47
47
 
48
- it "handles :or after :and" do
49
- "foo and bar or baz".
48
+ it 'handles :or after :and' do
49
+ 'foo and bar or baz'.
50
50
  must_be_parsed_as s(:or,
51
51
  s(:and,
52
52
  s(:call, nil, :foo),
@@ -54,8 +54,8 @@ describe RipperRubyParser::Parser do
54
54
  s(:call, nil, :baz))
55
55
  end
56
56
 
57
- it "handles :and after :or" do
58
- "foo or bar and baz".
57
+ it 'handles :and after :or' do
58
+ 'foo or bar and baz'.
59
59
  must_be_parsed_as s(:and,
60
60
  s(:or,
61
61
  s(:call, nil, :foo),
@@ -63,15 +63,15 @@ describe RipperRubyParser::Parser do
63
63
  s(:call, nil, :baz))
64
64
  end
65
65
 
66
- it "converts :&& to :and" do
67
- "foo && bar".
66
+ it 'converts :&& to :and' do
67
+ 'foo && bar'.
68
68
  must_be_parsed_as s(:and,
69
69
  s(:call, nil, :foo),
70
70
  s(:call, nil, :bar))
71
71
  end
72
72
 
73
- it "handles :|| after :&&" do
74
- "foo && bar || baz".
73
+ it 'handles :|| after :&&' do
74
+ 'foo && bar || baz'.
75
75
  must_be_parsed_as s(:or,
76
76
  s(:and,
77
77
  s(:call, nil, :foo),
@@ -79,8 +79,8 @@ describe RipperRubyParser::Parser do
79
79
  s(:call, nil, :baz))
80
80
  end
81
81
 
82
- it "handles :&& after :||" do
83
- "foo || bar && baz".
82
+ it 'handles :&& after :||' do
83
+ 'foo || bar && baz'.
84
84
  must_be_parsed_as s(:or,
85
85
  s(:call, nil, :foo),
86
86
  s(:and,
@@ -88,8 +88,8 @@ describe RipperRubyParser::Parser do
88
88
  s(:call, nil, :baz)))
89
89
  end
90
90
 
91
- it "handles bracketed :||" do
92
- "(foo || bar) || baz".
91
+ it 'handles bracketed :||' do
92
+ '(foo || bar) || baz'.
93
93
  must_be_parsed_as s(:or,
94
94
  s(:or,
95
95
  s(:call, nil, :foo),
@@ -97,15 +97,15 @@ describe RipperRubyParser::Parser do
97
97
  s(:call, nil, :baz))
98
98
  end
99
99
 
100
- it "converts :|| to :or" do
101
- "foo || bar".
100
+ it 'converts :|| to :or' do
101
+ 'foo || bar'.
102
102
  must_be_parsed_as s(:or,
103
103
  s(:call, nil, :foo),
104
104
  s(:call, nil, :bar))
105
105
  end
106
106
 
107
- it "handles triple :and" do
108
- "foo and bar and baz and qux".
107
+ it 'handles triple :and' do
108
+ 'foo and bar and baz and qux'.
109
109
  must_be_parsed_as s(:and,
110
110
  s(:call, nil, :foo),
111
111
  s(:and,
@@ -115,5 +115,37 @@ describe RipperRubyParser::Parser do
115
115
  s(:call, nil, :qux))))
116
116
  end
117
117
  end
118
+
119
+ describe 'for unary numerical operators' do
120
+ it 'handles unary minus with an integer literal' do
121
+ '- 1'.must_be_parsed_as s(:call, s(:lit, 1), :-@)
122
+ end
123
+
124
+ it 'handles unary minus with a float literal' do
125
+ '- 3.14'.must_be_parsed_as s(:call, s(:lit, 3.14), :-@)
126
+ end
127
+
128
+ it 'handles unary minus with a non-literal' do
129
+ '-foo'.
130
+ must_be_parsed_as s(:call,
131
+ s(:call, nil, :foo),
132
+ :-@)
133
+ end
134
+
135
+ it 'handles unary minus with a negative number literal' do
136
+ '- -1'.must_be_parsed_as s(:call, s(:lit, -1), :-@)
137
+ end
138
+
139
+ it 'handles unary plus with a number literal' do
140
+ '+ 1'.must_be_parsed_as s(:call, s(:lit, 1), :+@)
141
+ end
142
+
143
+ it 'handles unary plus with a non-literal' do
144
+ '+foo'.
145
+ must_be_parsed_as s(:call,
146
+ s(:call, nil, :foo),
147
+ :+@)
148
+ end
149
+ end
118
150
  end
119
151
  end