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
|
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 :c
note call_method(b)
note :d
end
def break_in_yielding_method
note :a
b = capture_block {
note :b
break :break
note :c
}
note :c
note yielding(&b)
note :d
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
note 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
|
