blob: 2d07cc3d48ccd402cf93b3dd271c8522b5972695 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
|
module BreakSpecs
class Driver
def initialize(ensures=false)
@ensures = ensures
end
def note(value)
ScratchPad << value
end
end
class Block < Driver
def break_nil
note :a
note yielding {
note :b
break
note :c
}
note :d
end
def break_value
note :a
note yielding {
note :b
break :break
note :c
}
note :d
end
def yielding
note :aa
note yield
note :bb
end
def create_block
note :za
b = capture_block do
note :zb
break :break
note :zc
end
note :zd
b
end
def capture_block(&b)
note :xa
b
end
def break_in_method_captured
note :a
create_block.call
note :b
end
def break_in_yield_captured
note :a
yielding(&create_block)
note :b
end
def break_in_method
note :a
b = capture_block {
note :b
break :break
note :c
}
note :d
note b.call
note :e
end
def call_method(b)
note :aa
note b.call
note :bb
end
def break_in_nested_method
note :a
b = capture_block {
note :b
break :break
note :c
}
note :cc
note call_method(b)
note :d
end
def break_in_yielding_method
note :a
b = capture_block {
note :b
break :break
note :c
}
note :cc
note yielding(&b)
note :d
end
def looped_break_in_captured_block
note :begin
looped_delegate_block do |i|
note :prebreak
break if i == 1
note :postbreak
end
note :end
end
def looped_delegate_block(&block)
note :preloop
2.times do |i|
note :predele
yield_value(i, &block)
note :postdele
end
note :postloop
end
private :looped_delegate_block
def yield_value(value)
note :preyield
yield value
note :postyield
end
private :yield_value
def method(v)
yield v
end
def invoke_yield_in_while
looping = true
while looping
note :aa
yield
note :bb
looping = false
end
note :should_not_reach_here
end
def break_in_block_in_while
invoke_yield_in_while do
note :break
break :value
note :c
end
end
end
class Lambda < Driver
# Cases for the invocation of the scope defining the lambda still active
# on the call stack when the lambda is invoked.
def break_in_defining_scope(value=true)
note :a
note lambda {
note :b
if value
break :break
else
break
end
note :c
}.call
note :d
end
def break_in_nested_scope
note :a
l = lambda do
note :b
break :break
note :c
end
note :d
invoke_lambda l
note :e
end
def invoke_lambda(l)
note :aa
note l.call
note :bb
end
def break_in_nested_scope_yield
note :a
l = lambda do
note :b
break :break
note :c
end
note :d
invoke_yield(&l)
note :e
end
def note_invoke_yield
note :aa
note yield
note :bb
end
def break_in_nested_scope_block
note :a
l = lambda do
note :b
break :break
note :c
end
note :d
invoke_lambda_block l
note :e
end
def invoke_yield
note :aaa
yield
note :bbb
end
def invoke_lambda_block(b)
note :aa
invoke_yield do
note :bb
note b.call
note :cc
end
note :dd
end
# Cases for the invocation of the scope defining the lambda NOT still
# active on the call stack when the lambda is invoked.
def create_lambda
note :la
l = lambda do
note :lb
break :break
note :lc
end
note :ld
l
end
def break_in_method
note :a
note create_lambda.call
note :b
end
def break_in_block_in_method
note :a
invoke_yield do
note :b
note create_lambda.call
note :c
end
note :d
end
def break_in_method_yield
note :a
invoke_yield(&create_lambda)
note :b
end
end
end
|