trackler 2.1.0.3 → 2.1.0.4
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.
- checksums.yaml +4 -4
- data/common/exercises/clock/canonical-data.json +10 -5
- data/common/exercises/word-search/canonical-data.json +676 -0
- data/lib/trackler/version.rb +1 -1
- data/tracks/delphi/exercises/phone-number/uPhoneNumberExample.pas +26 -6
- data/tracks/delphi/exercises/phone-number/uPhoneNumberTests.pas +49 -16
- data/tracks/go/gen/gen.go +0 -4
- data/tracks/ruby/exercises/etl/.meta/.version +1 -0
- data/tracks/ruby/exercises/etl/etl_test.rb +82 -28
- data/tracks/ruby/exercises/etl/example.rb +4 -0
- data/tracks/ruby/lib/etl_cases.rb +28 -0
- data/tracks/ruby/lib/generator/exercise_cases.rb +2 -2
- data/tracks/swift/exercises/grade-school/Sources/GradeSchoolExample.swift +8 -9
- data/tracks/swift/exercises/grade-school/Tests/GradeSchoolTests/GradeSchoolTests.swift +14 -21
- metadata +5 -2
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 0f4a5eeade9a4606b722ee2797e1418b0246dbb8
|
|
4
|
+
data.tar.gz: 3dbb5988e94050dc9674eb5091f042ddae0e38f8
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 7330e08438242aab42d3104d5e23a7c735c69254ca1f3e77dfc090b0182f21e2700de2ec0ef288853c6d4738b4bf7cd2c9e2869820d931f7584690537f584d30
|
|
7
|
+
data.tar.gz: 021fe446632e0bf3a9a0511f8f082f166097821cea4fcdb09049c1332b458e651cfca1ea1d230c565c2be33fd8e50df36a88b07407bea66fef046fdebccb8cf9
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"exercise": "clock",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.1",
|
|
4
4
|
"comments": [
|
|
5
5
|
"Most languages require constructing a clock with initial values,",
|
|
6
6
|
"adding a positive or negative number of minutes, and testing equality",
|
|
@@ -10,7 +10,7 @@
|
|
|
10
10
|
],
|
|
11
11
|
"cases": [
|
|
12
12
|
{
|
|
13
|
-
"description": "
|
|
13
|
+
"description": "Create a new clock with an initial time",
|
|
14
14
|
"cases": [
|
|
15
15
|
{
|
|
16
16
|
"description": "on the hour",
|
|
@@ -148,7 +148,7 @@
|
|
|
148
148
|
]
|
|
149
149
|
},
|
|
150
150
|
{
|
|
151
|
-
"description": "
|
|
151
|
+
"description": "Add minutes",
|
|
152
152
|
"cases": [
|
|
153
153
|
{
|
|
154
154
|
"description": "add minutes",
|
|
@@ -213,7 +213,12 @@
|
|
|
213
213
|
"minute": 1,
|
|
214
214
|
"add": 3500,
|
|
215
215
|
"expected": "11:21"
|
|
216
|
-
}
|
|
216
|
+
}
|
|
217
|
+
]
|
|
218
|
+
},
|
|
219
|
+
{
|
|
220
|
+
"description": "Subtract minutes",
|
|
221
|
+
"cases": [
|
|
217
222
|
{
|
|
218
223
|
"description": "subtract minutes",
|
|
219
224
|
"property": "add",
|
|
@@ -281,7 +286,7 @@
|
|
|
281
286
|
]
|
|
282
287
|
},
|
|
283
288
|
{
|
|
284
|
-
"description": "
|
|
289
|
+
"description": "Compare two clocks for equality",
|
|
285
290
|
"cases": [
|
|
286
291
|
{
|
|
287
292
|
"description": "clocks with same time",
|
|
@@ -0,0 +1,676 @@
|
|
|
1
|
+
{
|
|
2
|
+
"exercise": "word-search",
|
|
3
|
+
"version": "1.0.0",
|
|
4
|
+
"comments": [
|
|
5
|
+
"Grid rows and columns are 1-indexed.",
|
|
6
|
+
"An expected value of -1 indicates that some sort of failure should occur."
|
|
7
|
+
],
|
|
8
|
+
"cases": [
|
|
9
|
+
{
|
|
10
|
+
"description": "Should locate words written left to right",
|
|
11
|
+
"property": "search",
|
|
12
|
+
"grid": [
|
|
13
|
+
"jefblpepre",
|
|
14
|
+
"camdcimgtc",
|
|
15
|
+
"oivokprjsm",
|
|
16
|
+
"pbwasqroua",
|
|
17
|
+
"rixilelhrs",
|
|
18
|
+
"wolcqlirpc",
|
|
19
|
+
"screeaumgr",
|
|
20
|
+
"alxhpburyi",
|
|
21
|
+
"jalaycalmp",
|
|
22
|
+
"clojurermt"
|
|
23
|
+
],
|
|
24
|
+
"wordsToSearchFor": [
|
|
25
|
+
"clojure"
|
|
26
|
+
],
|
|
27
|
+
"expected": {
|
|
28
|
+
"clojure": {
|
|
29
|
+
"start": {
|
|
30
|
+
"column": 1,
|
|
31
|
+
"row": 10
|
|
32
|
+
},
|
|
33
|
+
"end": {
|
|
34
|
+
"column": 7,
|
|
35
|
+
"row": 10
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
}
|
|
39
|
+
},
|
|
40
|
+
{
|
|
41
|
+
"description": "Should locate words written right to left",
|
|
42
|
+
"property": "search",
|
|
43
|
+
"grid": [
|
|
44
|
+
"jefblpepre",
|
|
45
|
+
"camdcimgtc",
|
|
46
|
+
"oivokprjsm",
|
|
47
|
+
"pbwasqroua",
|
|
48
|
+
"rixilelhrs",
|
|
49
|
+
"wolcqlirpc",
|
|
50
|
+
"screeaumgr",
|
|
51
|
+
"alxhpburyi",
|
|
52
|
+
"jalaycalmp",
|
|
53
|
+
"clojurermt"
|
|
54
|
+
],
|
|
55
|
+
"wordsToSearchFor": [
|
|
56
|
+
"clojure",
|
|
57
|
+
"elixir"
|
|
58
|
+
],
|
|
59
|
+
"expected": {
|
|
60
|
+
"clojure": {
|
|
61
|
+
"start": {
|
|
62
|
+
"column": 1,
|
|
63
|
+
"row": 10
|
|
64
|
+
},
|
|
65
|
+
"end": {
|
|
66
|
+
"column": 7,
|
|
67
|
+
"row": 10
|
|
68
|
+
}
|
|
69
|
+
},
|
|
70
|
+
"elixir": {
|
|
71
|
+
"start": {
|
|
72
|
+
"column": 6,
|
|
73
|
+
"row": 5
|
|
74
|
+
},
|
|
75
|
+
"end": {
|
|
76
|
+
"column": 1,
|
|
77
|
+
"row": 5
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
},
|
|
82
|
+
{
|
|
83
|
+
"description": "Should locate words written top to bottom",
|
|
84
|
+
"property": "search",
|
|
85
|
+
"grid": [
|
|
86
|
+
"jefblpepre",
|
|
87
|
+
"camdcimgtc",
|
|
88
|
+
"oivokprjsm",
|
|
89
|
+
"pbwasqroua",
|
|
90
|
+
"rixilelhrs",
|
|
91
|
+
"wolcqlirpc",
|
|
92
|
+
"screeaumgr",
|
|
93
|
+
"alxhpburyi",
|
|
94
|
+
"jalaycalmp",
|
|
95
|
+
"clojurermt"
|
|
96
|
+
],
|
|
97
|
+
"wordsToSearchFor": [
|
|
98
|
+
"clojure",
|
|
99
|
+
"elixir",
|
|
100
|
+
"ecmascript"
|
|
101
|
+
],
|
|
102
|
+
"expected": {
|
|
103
|
+
"clojure": {
|
|
104
|
+
"start": {
|
|
105
|
+
"column": 1,
|
|
106
|
+
"row": 10
|
|
107
|
+
},
|
|
108
|
+
"end": {
|
|
109
|
+
"column": 7,
|
|
110
|
+
"row": 10
|
|
111
|
+
}
|
|
112
|
+
},
|
|
113
|
+
"elixir": {
|
|
114
|
+
"start": {
|
|
115
|
+
"column": 6,
|
|
116
|
+
"row": 5
|
|
117
|
+
},
|
|
118
|
+
"end": {
|
|
119
|
+
"column": 1,
|
|
120
|
+
"row": 5
|
|
121
|
+
}
|
|
122
|
+
},
|
|
123
|
+
"ecmascript": {
|
|
124
|
+
"start": {
|
|
125
|
+
"column": 10,
|
|
126
|
+
"row": 1
|
|
127
|
+
},
|
|
128
|
+
"end": {
|
|
129
|
+
"column": 10,
|
|
130
|
+
"row": 10
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
},
|
|
135
|
+
{
|
|
136
|
+
"description": "Should locate words written bottom to top",
|
|
137
|
+
"property": "search",
|
|
138
|
+
"grid": [
|
|
139
|
+
"jefblpepre",
|
|
140
|
+
"camdcimgtc",
|
|
141
|
+
"oivokprjsm",
|
|
142
|
+
"pbwasqroua",
|
|
143
|
+
"rixilelhrs",
|
|
144
|
+
"wolcqlirpc",
|
|
145
|
+
"screeaumgr",
|
|
146
|
+
"alxhpburyi",
|
|
147
|
+
"jalaycalmp",
|
|
148
|
+
"clojurermt"
|
|
149
|
+
],
|
|
150
|
+
"wordsToSearchFor": [
|
|
151
|
+
"clojure",
|
|
152
|
+
"elixir",
|
|
153
|
+
"ecmascript",
|
|
154
|
+
"rust"
|
|
155
|
+
],
|
|
156
|
+
"expected": {
|
|
157
|
+
"clojure": {
|
|
158
|
+
"start": {
|
|
159
|
+
"column": 1,
|
|
160
|
+
"row": 10
|
|
161
|
+
},
|
|
162
|
+
"end": {
|
|
163
|
+
"column": 7,
|
|
164
|
+
"row": 10
|
|
165
|
+
}
|
|
166
|
+
},
|
|
167
|
+
"elixir": {
|
|
168
|
+
"start": {
|
|
169
|
+
"column": 6,
|
|
170
|
+
"row": 5
|
|
171
|
+
},
|
|
172
|
+
"end": {
|
|
173
|
+
"column": 1,
|
|
174
|
+
"row": 5
|
|
175
|
+
}
|
|
176
|
+
},
|
|
177
|
+
"ecmascript": {
|
|
178
|
+
"start": {
|
|
179
|
+
"column": 10,
|
|
180
|
+
"row": 1
|
|
181
|
+
},
|
|
182
|
+
"end": {
|
|
183
|
+
"column": 10,
|
|
184
|
+
"row": 10
|
|
185
|
+
}
|
|
186
|
+
},
|
|
187
|
+
"rust": {
|
|
188
|
+
"start": {
|
|
189
|
+
"column": 9,
|
|
190
|
+
"row": 5
|
|
191
|
+
},
|
|
192
|
+
"end": {
|
|
193
|
+
"column": 9,
|
|
194
|
+
"row": 2
|
|
195
|
+
}
|
|
196
|
+
}
|
|
197
|
+
}
|
|
198
|
+
},
|
|
199
|
+
{
|
|
200
|
+
"description": "Should locate words written top left to bottom right",
|
|
201
|
+
"property": "search",
|
|
202
|
+
"grid": [
|
|
203
|
+
"jefblpepre",
|
|
204
|
+
"camdcimgtc",
|
|
205
|
+
"oivokprjsm",
|
|
206
|
+
"pbwasqroua",
|
|
207
|
+
"rixilelhrs",
|
|
208
|
+
"wolcqlirpc",
|
|
209
|
+
"screeaumgr",
|
|
210
|
+
"alxhpburyi",
|
|
211
|
+
"jalaycalmp",
|
|
212
|
+
"clojurermt"
|
|
213
|
+
],
|
|
214
|
+
"wordsToSearchFor": [
|
|
215
|
+
"clojure",
|
|
216
|
+
"elixir",
|
|
217
|
+
"ecmascript",
|
|
218
|
+
"rust",
|
|
219
|
+
"java"
|
|
220
|
+
],
|
|
221
|
+
"expected": {
|
|
222
|
+
"clojure": {
|
|
223
|
+
"start": {
|
|
224
|
+
"column": 1,
|
|
225
|
+
"row": 10
|
|
226
|
+
},
|
|
227
|
+
"end": {
|
|
228
|
+
"column": 7,
|
|
229
|
+
"row": 10
|
|
230
|
+
}
|
|
231
|
+
},
|
|
232
|
+
"elixir": {
|
|
233
|
+
"start": {
|
|
234
|
+
"column": 6,
|
|
235
|
+
"row": 5
|
|
236
|
+
},
|
|
237
|
+
"end": {
|
|
238
|
+
"column": 1,
|
|
239
|
+
"row": 5
|
|
240
|
+
}
|
|
241
|
+
},
|
|
242
|
+
"ecmascript": {
|
|
243
|
+
"start": {
|
|
244
|
+
"column": 10,
|
|
245
|
+
"row": 1
|
|
246
|
+
},
|
|
247
|
+
"end": {
|
|
248
|
+
"column": 10,
|
|
249
|
+
"row": 10
|
|
250
|
+
}
|
|
251
|
+
},
|
|
252
|
+
"rust": {
|
|
253
|
+
"start": {
|
|
254
|
+
"column": 9,
|
|
255
|
+
"row": 5
|
|
256
|
+
},
|
|
257
|
+
"end": {
|
|
258
|
+
"column": 9,
|
|
259
|
+
"row": 2
|
|
260
|
+
}
|
|
261
|
+
},
|
|
262
|
+
"java": {
|
|
263
|
+
"start": {
|
|
264
|
+
"column": 1,
|
|
265
|
+
"row": 1
|
|
266
|
+
},
|
|
267
|
+
"end": {
|
|
268
|
+
"column": 4,
|
|
269
|
+
"row": 4
|
|
270
|
+
}
|
|
271
|
+
}
|
|
272
|
+
}
|
|
273
|
+
},
|
|
274
|
+
{
|
|
275
|
+
"description": "Should locate words written bottom right to top left",
|
|
276
|
+
"property": "search",
|
|
277
|
+
"grid": [
|
|
278
|
+
"jefblpepre",
|
|
279
|
+
"camdcimgtc",
|
|
280
|
+
"oivokprjsm",
|
|
281
|
+
"pbwasqroua",
|
|
282
|
+
"rixilelhrs",
|
|
283
|
+
"wolcqlirpc",
|
|
284
|
+
"screeaumgr",
|
|
285
|
+
"alxhpburyi",
|
|
286
|
+
"jalaycalmp",
|
|
287
|
+
"clojurermt"
|
|
288
|
+
],
|
|
289
|
+
"wordsToSearchFor": [
|
|
290
|
+
"clojure",
|
|
291
|
+
"elixir",
|
|
292
|
+
"ecmascript",
|
|
293
|
+
"rust",
|
|
294
|
+
"java",
|
|
295
|
+
"lua"
|
|
296
|
+
],
|
|
297
|
+
"expected": {
|
|
298
|
+
"clojure": {
|
|
299
|
+
"start": {
|
|
300
|
+
"column": 1,
|
|
301
|
+
"row": 10
|
|
302
|
+
},
|
|
303
|
+
"end": {
|
|
304
|
+
"column": 7,
|
|
305
|
+
"row": 10
|
|
306
|
+
}
|
|
307
|
+
},
|
|
308
|
+
"elixir": {
|
|
309
|
+
"start": {
|
|
310
|
+
"column": 6,
|
|
311
|
+
"row": 5
|
|
312
|
+
},
|
|
313
|
+
"end": {
|
|
314
|
+
"column": 1,
|
|
315
|
+
"row": 5
|
|
316
|
+
}
|
|
317
|
+
},
|
|
318
|
+
"ecmascript": {
|
|
319
|
+
"start": {
|
|
320
|
+
"column": 10,
|
|
321
|
+
"row": 1
|
|
322
|
+
},
|
|
323
|
+
"end": {
|
|
324
|
+
"column": 10,
|
|
325
|
+
"row": 10
|
|
326
|
+
}
|
|
327
|
+
},
|
|
328
|
+
"rust": {
|
|
329
|
+
"start": {
|
|
330
|
+
"column": 9,
|
|
331
|
+
"row": 5
|
|
332
|
+
},
|
|
333
|
+
"end": {
|
|
334
|
+
"column": 9,
|
|
335
|
+
"row": 2
|
|
336
|
+
}
|
|
337
|
+
},
|
|
338
|
+
"java": {
|
|
339
|
+
"start": {
|
|
340
|
+
"column": 1,
|
|
341
|
+
"row": 1
|
|
342
|
+
},
|
|
343
|
+
"end": {
|
|
344
|
+
"column": 4,
|
|
345
|
+
"row": 4
|
|
346
|
+
}
|
|
347
|
+
},
|
|
348
|
+
"lua": {
|
|
349
|
+
"start": {
|
|
350
|
+
"column": 8,
|
|
351
|
+
"row": 9
|
|
352
|
+
},
|
|
353
|
+
"end": {
|
|
354
|
+
"column": 6,
|
|
355
|
+
"row": 7
|
|
356
|
+
}
|
|
357
|
+
}
|
|
358
|
+
}
|
|
359
|
+
},
|
|
360
|
+
{
|
|
361
|
+
"description": "Should locate words written bottom left to top right",
|
|
362
|
+
"property": "search",
|
|
363
|
+
"grid": [
|
|
364
|
+
"jefblpepre",
|
|
365
|
+
"camdcimgtc",
|
|
366
|
+
"oivokprjsm",
|
|
367
|
+
"pbwasqroua",
|
|
368
|
+
"rixilelhrs",
|
|
369
|
+
"wolcqlirpc",
|
|
370
|
+
"screeaumgr",
|
|
371
|
+
"alxhpburyi",
|
|
372
|
+
"jalaycalmp",
|
|
373
|
+
"clojurermt"
|
|
374
|
+
],
|
|
375
|
+
"wordsToSearchFor": [
|
|
376
|
+
"clojure",
|
|
377
|
+
"elixir",
|
|
378
|
+
"ecmascript",
|
|
379
|
+
"rust",
|
|
380
|
+
"java",
|
|
381
|
+
"lua",
|
|
382
|
+
"lisp"
|
|
383
|
+
],
|
|
384
|
+
"expected": {
|
|
385
|
+
"clojure": {
|
|
386
|
+
"start": {
|
|
387
|
+
"column": 1,
|
|
388
|
+
"row": 10
|
|
389
|
+
},
|
|
390
|
+
"end": {
|
|
391
|
+
"column": 7,
|
|
392
|
+
"row": 10
|
|
393
|
+
}
|
|
394
|
+
},
|
|
395
|
+
"elixir": {
|
|
396
|
+
"start": {
|
|
397
|
+
"column": 6,
|
|
398
|
+
"row": 5
|
|
399
|
+
},
|
|
400
|
+
"end": {
|
|
401
|
+
"column": 1,
|
|
402
|
+
"row": 5
|
|
403
|
+
}
|
|
404
|
+
},
|
|
405
|
+
"ecmascript": {
|
|
406
|
+
"start": {
|
|
407
|
+
"column": 10,
|
|
408
|
+
"row": 1
|
|
409
|
+
},
|
|
410
|
+
"end": {
|
|
411
|
+
"column": 10,
|
|
412
|
+
"row": 10
|
|
413
|
+
}
|
|
414
|
+
},
|
|
415
|
+
"rust": {
|
|
416
|
+
"start": {
|
|
417
|
+
"column": 9,
|
|
418
|
+
"row": 5
|
|
419
|
+
},
|
|
420
|
+
"end": {
|
|
421
|
+
"column": 9,
|
|
422
|
+
"row": 2
|
|
423
|
+
}
|
|
424
|
+
},
|
|
425
|
+
"java": {
|
|
426
|
+
"start": {
|
|
427
|
+
"column": 1,
|
|
428
|
+
"row": 1
|
|
429
|
+
},
|
|
430
|
+
"end": {
|
|
431
|
+
"column": 4,
|
|
432
|
+
"row": 4
|
|
433
|
+
}
|
|
434
|
+
},
|
|
435
|
+
"lua": {
|
|
436
|
+
"start": {
|
|
437
|
+
"column": 8,
|
|
438
|
+
"row": 9
|
|
439
|
+
},
|
|
440
|
+
"end": {
|
|
441
|
+
"column": 6,
|
|
442
|
+
"row": 7
|
|
443
|
+
}
|
|
444
|
+
},
|
|
445
|
+
"lisp": {
|
|
446
|
+
"start": {
|
|
447
|
+
"column": 3,
|
|
448
|
+
"row": 6
|
|
449
|
+
},
|
|
450
|
+
"end": {
|
|
451
|
+
"column": 6,
|
|
452
|
+
"row": 3
|
|
453
|
+
}
|
|
454
|
+
}
|
|
455
|
+
}
|
|
456
|
+
},
|
|
457
|
+
{
|
|
458
|
+
"description": "Should locate words written top right to bottom left",
|
|
459
|
+
"property": "search",
|
|
460
|
+
"grid": [
|
|
461
|
+
"jefblpepre",
|
|
462
|
+
"camdcimgtc",
|
|
463
|
+
"oivokprjsm",
|
|
464
|
+
"pbwasqroua",
|
|
465
|
+
"rixilelhrs",
|
|
466
|
+
"wolcqlirpc",
|
|
467
|
+
"screeaumgr",
|
|
468
|
+
"alxhpburyi",
|
|
469
|
+
"jalaycalmp",
|
|
470
|
+
"clojurermt"
|
|
471
|
+
],
|
|
472
|
+
"wordsToSearchFor": [
|
|
473
|
+
"clojure",
|
|
474
|
+
"elixir",
|
|
475
|
+
"ecmascript",
|
|
476
|
+
"rust",
|
|
477
|
+
"java",
|
|
478
|
+
"lua",
|
|
479
|
+
"lisp",
|
|
480
|
+
"ruby"
|
|
481
|
+
],
|
|
482
|
+
"expected": {
|
|
483
|
+
"clojure": {
|
|
484
|
+
"start": {
|
|
485
|
+
"column": 1,
|
|
486
|
+
"row": 10
|
|
487
|
+
},
|
|
488
|
+
"end": {
|
|
489
|
+
"column": 7,
|
|
490
|
+
"row": 10
|
|
491
|
+
}
|
|
492
|
+
},
|
|
493
|
+
"elixir": {
|
|
494
|
+
"start": {
|
|
495
|
+
"column": 6,
|
|
496
|
+
"row": 5
|
|
497
|
+
},
|
|
498
|
+
"end": {
|
|
499
|
+
"column": 1,
|
|
500
|
+
"row": 5
|
|
501
|
+
}
|
|
502
|
+
},
|
|
503
|
+
"ecmascript": {
|
|
504
|
+
"start": {
|
|
505
|
+
"column": 10,
|
|
506
|
+
"row": 1
|
|
507
|
+
},
|
|
508
|
+
"end": {
|
|
509
|
+
"column": 10,
|
|
510
|
+
"row": 10
|
|
511
|
+
}
|
|
512
|
+
},
|
|
513
|
+
"rust": {
|
|
514
|
+
"start": {
|
|
515
|
+
"column": 9,
|
|
516
|
+
"row": 5
|
|
517
|
+
},
|
|
518
|
+
"end": {
|
|
519
|
+
"column": 9,
|
|
520
|
+
"row": 2
|
|
521
|
+
}
|
|
522
|
+
},
|
|
523
|
+
"java": {
|
|
524
|
+
"start": {
|
|
525
|
+
"column": 1,
|
|
526
|
+
"row": 1
|
|
527
|
+
},
|
|
528
|
+
"end": {
|
|
529
|
+
"column": 4,
|
|
530
|
+
"row": 4
|
|
531
|
+
}
|
|
532
|
+
},
|
|
533
|
+
"lua": {
|
|
534
|
+
"start": {
|
|
535
|
+
"column": 8,
|
|
536
|
+
"row": 9
|
|
537
|
+
},
|
|
538
|
+
"end": {
|
|
539
|
+
"column": 6,
|
|
540
|
+
"row": 7
|
|
541
|
+
}
|
|
542
|
+
},
|
|
543
|
+
"lisp": {
|
|
544
|
+
"start": {
|
|
545
|
+
"column": 3,
|
|
546
|
+
"row": 6
|
|
547
|
+
},
|
|
548
|
+
"end": {
|
|
549
|
+
"column": 6,
|
|
550
|
+
"row": 3
|
|
551
|
+
}
|
|
552
|
+
},
|
|
553
|
+
"ruby": {
|
|
554
|
+
"start": {
|
|
555
|
+
"column": 8,
|
|
556
|
+
"row": 6
|
|
557
|
+
},
|
|
558
|
+
"end": {
|
|
559
|
+
"column": 5,
|
|
560
|
+
"row": 9
|
|
561
|
+
}
|
|
562
|
+
}
|
|
563
|
+
}
|
|
564
|
+
},
|
|
565
|
+
{
|
|
566
|
+
"description": "Should fail to locate a word that is not in the puzzle",
|
|
567
|
+
"property": "search",
|
|
568
|
+
"grid": [
|
|
569
|
+
"jefblpepre",
|
|
570
|
+
"camdcimgtc",
|
|
571
|
+
"oivokprjsm",
|
|
572
|
+
"pbwasqroua",
|
|
573
|
+
"rixilelhrs",
|
|
574
|
+
"wolcqlirpc",
|
|
575
|
+
"screeaumgr",
|
|
576
|
+
"alxhpburyi",
|
|
577
|
+
"jalaycalmp",
|
|
578
|
+
"clojurermt"
|
|
579
|
+
],
|
|
580
|
+
"wordsToSearchFor": [
|
|
581
|
+
"clojure",
|
|
582
|
+
"elixir",
|
|
583
|
+
"ecmascript",
|
|
584
|
+
"rust",
|
|
585
|
+
"java",
|
|
586
|
+
"lua",
|
|
587
|
+
"lisp",
|
|
588
|
+
"ruby",
|
|
589
|
+
"haskell"
|
|
590
|
+
],
|
|
591
|
+
"expected": {
|
|
592
|
+
"clojure": {
|
|
593
|
+
"start": {
|
|
594
|
+
"column": 1,
|
|
595
|
+
"row": 10
|
|
596
|
+
},
|
|
597
|
+
"end": {
|
|
598
|
+
"column": 7,
|
|
599
|
+
"row": 10
|
|
600
|
+
}
|
|
601
|
+
},
|
|
602
|
+
"elixir": {
|
|
603
|
+
"start": {
|
|
604
|
+
"column": 6,
|
|
605
|
+
"row": 5
|
|
606
|
+
},
|
|
607
|
+
"end": {
|
|
608
|
+
"column": 1,
|
|
609
|
+
"row": 5
|
|
610
|
+
}
|
|
611
|
+
},
|
|
612
|
+
"ecmascript": {
|
|
613
|
+
"start": {
|
|
614
|
+
"column": 10,
|
|
615
|
+
"row": 1
|
|
616
|
+
},
|
|
617
|
+
"end": {
|
|
618
|
+
"column": 10,
|
|
619
|
+
"row": 10
|
|
620
|
+
}
|
|
621
|
+
},
|
|
622
|
+
"rust": {
|
|
623
|
+
"start": {
|
|
624
|
+
"column": 9,
|
|
625
|
+
"row": 5
|
|
626
|
+
},
|
|
627
|
+
"end": {
|
|
628
|
+
"column": 9,
|
|
629
|
+
"row": 2
|
|
630
|
+
}
|
|
631
|
+
},
|
|
632
|
+
"java": {
|
|
633
|
+
"start": {
|
|
634
|
+
"column": 1,
|
|
635
|
+
"row": 1
|
|
636
|
+
},
|
|
637
|
+
"end": {
|
|
638
|
+
"column": 4,
|
|
639
|
+
"row": 4
|
|
640
|
+
}
|
|
641
|
+
},
|
|
642
|
+
"lua": {
|
|
643
|
+
"start": {
|
|
644
|
+
"column": 8,
|
|
645
|
+
"row": 9
|
|
646
|
+
},
|
|
647
|
+
"end": {
|
|
648
|
+
"column": 6,
|
|
649
|
+
"row": 7
|
|
650
|
+
}
|
|
651
|
+
},
|
|
652
|
+
"lisp": {
|
|
653
|
+
"start": {
|
|
654
|
+
"column": 3,
|
|
655
|
+
"row": 6
|
|
656
|
+
},
|
|
657
|
+
"end": {
|
|
658
|
+
"column": 6,
|
|
659
|
+
"row": 3
|
|
660
|
+
}
|
|
661
|
+
},
|
|
662
|
+
"ruby": {
|
|
663
|
+
"start": {
|
|
664
|
+
"column": 8,
|
|
665
|
+
"row": 6
|
|
666
|
+
},
|
|
667
|
+
"end": {
|
|
668
|
+
"column": 5,
|
|
669
|
+
"row": 9
|
|
670
|
+
}
|
|
671
|
+
},
|
|
672
|
+
"haskell": null
|
|
673
|
+
}
|
|
674
|
+
}
|
|
675
|
+
]
|
|
676
|
+
}
|
data/lib/trackler/version.rb
CHANGED
|
@@ -7,9 +7,11 @@ type
|
|
|
7
7
|
['{2415B863-E2D7-4E13-BDEF-F7FE9B3E0788}']
|
|
8
8
|
function GetCleanNumber: string;
|
|
9
9
|
function GetAreaCode: string;
|
|
10
|
+
function GetExchangeCode: string;
|
|
10
11
|
function ToString: string;
|
|
11
12
|
property Clean: string read GetCleanNumber;
|
|
12
|
-
property
|
|
13
|
+
property Area: string read GetAreaCode;
|
|
14
|
+
property Exchange: string read GetExchangeCode;
|
|
13
15
|
end;
|
|
14
16
|
|
|
15
17
|
function NewPhoneNumber(aPhoneNumber: string): IPhoneNumber;
|
|
@@ -24,18 +26,22 @@ type
|
|
|
24
26
|
fContainsLetters: TRegex;
|
|
25
27
|
fNumber: string;
|
|
26
28
|
fAreaCode: string;
|
|
29
|
+
fExchangeCode: string;
|
|
27
30
|
function GetCleanNumber: string;
|
|
28
31
|
function GetAreaCode: string;
|
|
32
|
+
function GetExchangeCode: string;
|
|
29
33
|
function GetValidatedPhoneNumber(aPhoneNumber: string): string;
|
|
30
34
|
function StripOutNonNumerics(aValue: string): string;
|
|
31
35
|
function IsInvalidPhoneNumber(aPhoneNumber: string): Boolean;
|
|
32
36
|
function GetInvalidPhoneNumberReplacement(aPhoneNumber: string): string;
|
|
33
37
|
function IsPhoneNumberwithUSAreaCode(aValue: string): Boolean;
|
|
38
|
+
function IsValidCode(aCode: string): Boolean;
|
|
34
39
|
public
|
|
35
40
|
constructor Create(aPhoneNumber: string);
|
|
36
41
|
function ToString: string;
|
|
37
42
|
property Clean: string read GetCleanNumber;
|
|
38
|
-
property
|
|
43
|
+
property Area: string read GetAreaCode;
|
|
44
|
+
property Exchange: string read GetExchangeCode;
|
|
39
45
|
end;
|
|
40
46
|
|
|
41
47
|
function NewPhoneNumber(aPhoneNumber: string): IPhoneNumber;
|
|
@@ -48,17 +54,26 @@ begin
|
|
|
48
54
|
fDigitsOnly := TRegEx.Create('[^\d]');
|
|
49
55
|
fContainsLetters := TRegEx.Create('[a-zA-Z]');
|
|
50
56
|
fNumber := GetValidatedPhoneNumber(aPhoneNumber);
|
|
51
|
-
|
|
57
|
+
if not fNumber.IsEmpty then
|
|
58
|
+
begin
|
|
59
|
+
fAreaCode := fNumber.Substring(0, 3);
|
|
60
|
+
fExchangeCode := fNumber.Substring(3,3);
|
|
61
|
+
end;
|
|
52
62
|
end;
|
|
53
63
|
|
|
54
64
|
function TPhoneNumber.GetCleanNumber: string;
|
|
55
65
|
begin
|
|
56
|
-
result := fNumber;
|
|
66
|
+
result := ifthen(IsValidCode(fAreaCode) and IsValidCode(fExchangeCode),fNumber,'');
|
|
57
67
|
end;
|
|
58
68
|
|
|
59
69
|
function TPhoneNumber.GetAreaCode: string;
|
|
60
70
|
begin
|
|
61
|
-
result := fAreaCode;
|
|
71
|
+
result := ifthen(IsValidCode(fAreaCode),fAreaCode,'');
|
|
72
|
+
end;
|
|
73
|
+
|
|
74
|
+
function TPhoneNumber.GetExchangeCode: string;
|
|
75
|
+
begin
|
|
76
|
+
result := ifthen(IsValidCode(fExchangeCode),fExchangeCode,'');
|
|
62
77
|
end;
|
|
63
78
|
|
|
64
79
|
function TPhoneNumber.GetValidatedPhoneNumber(aPhoneNumber: string):string;
|
|
@@ -94,9 +109,14 @@ begin
|
|
|
94
109
|
result := (aValue.Length = 11) and aValue.StartsWith('1');
|
|
95
110
|
end;
|
|
96
111
|
|
|
112
|
+
function TPhoneNumber.IsValidCode(aCode: string): Boolean;
|
|
113
|
+
begin
|
|
114
|
+
result := (not aCode.IsEmpty) and (aCode[1] in ['2'..'9']);
|
|
115
|
+
end;
|
|
116
|
+
|
|
97
117
|
function TPhoneNumber.ToString: string;
|
|
98
118
|
begin
|
|
99
|
-
result := Format('(%s) %s-%s',[
|
|
119
|
+
result := Format('(%s) %s-%s',[Area, Exchange, Clean.Substring(6)]);
|
|
100
120
|
end;
|
|
101
121
|
|
|
102
122
|
end.
|
|
@@ -16,7 +16,7 @@ type
|
|
|
16
16
|
PhoneNumberTests = class(TObject)
|
|
17
17
|
public
|
|
18
18
|
[Test]
|
|
19
|
-
//
|
|
19
|
+
// [Ignore('Comment the "[Ignore]" statement to run the test')]
|
|
20
20
|
procedure Cleans_the_number;
|
|
21
21
|
|
|
22
22
|
[Test]
|
|
@@ -55,9 +55,21 @@ type
|
|
|
55
55
|
[Ignore]
|
|
56
56
|
procedure Invalid_with_right_number_of_digits_but_letters_mixed_in;
|
|
57
57
|
|
|
58
|
+
[Test]
|
|
59
|
+
[Ignore]
|
|
60
|
+
procedure Invalid_if_area_code_does_not_start_with_2_thru_9;
|
|
61
|
+
|
|
62
|
+
[Test]
|
|
63
|
+
[Ignore]
|
|
64
|
+
procedure Invalid_if_exchange_code_does_not_start_with_2_thru_9;
|
|
65
|
+
|
|
58
66
|
[Test]
|
|
59
67
|
[Ignore('This is a bonus test')]
|
|
60
|
-
procedure
|
|
68
|
+
procedure Extract_area_code;
|
|
69
|
+
|
|
70
|
+
[Test]
|
|
71
|
+
[Ignore('This is a bonus test')]
|
|
72
|
+
procedure Extract_exchange_code;
|
|
61
73
|
|
|
62
74
|
[Test]
|
|
63
75
|
[Ignore('This is a bonus test')]
|
|
@@ -70,35 +82,35 @@ uses uPhoneNumber;
|
|
|
70
82
|
procedure PhoneNumberTests.Cleans_the_number;
|
|
71
83
|
var phone: IPhoneNumber;
|
|
72
84
|
begin
|
|
73
|
-
phone := NewPhoneNumber('(
|
|
74
|
-
assert.AreEqual('
|
|
85
|
+
phone := NewPhoneNumber('(223) 456-7890');
|
|
86
|
+
assert.AreEqual('2234567890',phone.Clean);
|
|
75
87
|
end;
|
|
76
88
|
|
|
77
89
|
procedure PhoneNumberTests.Cleans_numbers_with_dots;
|
|
78
90
|
var phone: IPhoneNumber;
|
|
79
91
|
begin
|
|
80
|
-
phone := NewPhoneNumber('
|
|
81
|
-
assert.AreEqual('
|
|
92
|
+
phone := NewPhoneNumber('223.456.7890');
|
|
93
|
+
assert.AreEqual('2234567890',phone.Clean);
|
|
82
94
|
end;
|
|
83
95
|
|
|
84
96
|
procedure PhoneNumberTests.Cleans_numbers_with_multiple_spaces;
|
|
85
97
|
var phone: IPhoneNumber;
|
|
86
98
|
begin
|
|
87
|
-
phone := NewPhoneNumber('
|
|
88
|
-
assert.AreEqual('
|
|
99
|
+
phone := NewPhoneNumber('223 456 7890 ');
|
|
100
|
+
assert.AreEqual('2234567890',phone.Clean);
|
|
89
101
|
end;
|
|
90
102
|
|
|
91
103
|
procedure PhoneNumberTests.Valid_when_11_digits_and_starting_with_1;
|
|
92
104
|
var phone: IPhoneNumber;
|
|
93
105
|
begin
|
|
94
|
-
phone := NewPhoneNumber('
|
|
95
|
-
assert.AreEqual('
|
|
106
|
+
phone := NewPhoneNumber('12234567890');
|
|
107
|
+
assert.AreEqual('2234567890', phone.Clean);
|
|
96
108
|
end;
|
|
97
109
|
|
|
98
110
|
procedure PhoneNumberTests.Invalid_when_11_digits_does_not_start_with_a_1;
|
|
99
111
|
var phone: IPhoneNumber;
|
|
100
112
|
begin
|
|
101
|
-
phone := NewPhoneNumber('
|
|
113
|
+
phone := NewPhoneNumber('22234567890');
|
|
102
114
|
assert.AreEqual('', phone.Clean);
|
|
103
115
|
end;
|
|
104
116
|
|
|
@@ -137,18 +149,39 @@ begin
|
|
|
137
149
|
assert.AreEqual('', phone.Clean);
|
|
138
150
|
end;
|
|
139
151
|
|
|
140
|
-
procedure PhoneNumberTests.
|
|
152
|
+
procedure PhoneNumberTests.Invalid_if_area_code_does_not_start_with_2_thru_9;
|
|
153
|
+
var phone: IPhoneNumber;
|
|
154
|
+
begin
|
|
155
|
+
phone := NewPhoneNumber('(123) 456-7890');
|
|
156
|
+
assert.AreEqual('', phone.Clean);
|
|
157
|
+
end;
|
|
158
|
+
|
|
159
|
+
procedure PhoneNumberTests.Invalid_if_exchange_code_does_not_start_with_2_thru_9;
|
|
160
|
+
var phone: IPhoneNumber;
|
|
161
|
+
begin
|
|
162
|
+
phone := NewPhoneNumber('(223) 056-7890');
|
|
163
|
+
assert.AreEqual('', phone.Clean);
|
|
164
|
+
end;
|
|
165
|
+
|
|
166
|
+
procedure PhoneNumberTests.Extract_area_code;
|
|
167
|
+
var phone: IPhoneNumber;
|
|
168
|
+
begin
|
|
169
|
+
phone := NewPhoneNumber('(223) 456-7890');
|
|
170
|
+
assert.AreEqual('223', phone.Area);
|
|
171
|
+
end;
|
|
172
|
+
|
|
173
|
+
procedure PhoneNumberTests.Extract_exchange_code;
|
|
141
174
|
var phone: IPhoneNumber;
|
|
142
175
|
begin
|
|
143
|
-
phone := NewPhoneNumber('
|
|
144
|
-
assert.AreEqual('
|
|
176
|
+
phone := NewPhoneNumber('223.456.7890');
|
|
177
|
+
assert.AreEqual('456', phone.Exchange);
|
|
145
178
|
end;
|
|
146
179
|
|
|
147
180
|
procedure PhoneNumberTests.Formats_a_number;
|
|
148
181
|
var phone: IPhoneNumber;
|
|
149
182
|
begin
|
|
150
|
-
phone := NewPhoneNumber('
|
|
151
|
-
assert.AreEqual('(
|
|
183
|
+
phone := NewPhoneNumber('2234567890');
|
|
184
|
+
assert.AreEqual('(223) 456-7890', phone.ToString);
|
|
152
185
|
end;
|
|
153
186
|
|
|
154
187
|
initialization
|
data/tracks/go/gen/gen.go
CHANGED
|
@@ -49,9 +49,6 @@ const (
|
|
|
49
49
|
// Header tells how the test data was generated, for display in the header of
|
|
50
50
|
// cases_test.go
|
|
51
51
|
type Header struct {
|
|
52
|
-
// Ori is a deprecated short name for Origin.
|
|
53
|
-
// TODO: Remove Ori once everything switches to Origin.
|
|
54
|
-
Ori string
|
|
55
52
|
Origin string
|
|
56
53
|
Commit string
|
|
57
54
|
Version string
|
|
@@ -126,7 +123,6 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
|
|
|
126
123
|
Header
|
|
127
124
|
J interface{}
|
|
128
125
|
}{Header{
|
|
129
|
-
Ori: jOrigin,
|
|
130
126
|
Origin: jOrigin,
|
|
131
127
|
Commit: jCommit,
|
|
132
128
|
Version: commonMetadata.Version,
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
1
|
|
@@ -3,56 +3,110 @@ gem 'minitest', '>= 5.0.0'
|
|
|
3
3
|
require 'minitest/autorun'
|
|
4
4
|
require_relative 'etl'
|
|
5
5
|
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
6
|
+
# Common test data version: ca9ed58
|
|
7
|
+
class EtlTest < Minitest::Test
|
|
8
|
+
def test_a_single_letter
|
|
9
|
+
# skip
|
|
10
|
+
old = {
|
|
11
|
+
1 => ["A"]
|
|
12
|
+
}
|
|
13
|
+
expected = {
|
|
14
|
+
'a' => 1
|
|
15
|
+
}
|
|
11
16
|
assert_equal expected, ETL.transform(old)
|
|
12
17
|
end
|
|
13
18
|
|
|
14
|
-
def
|
|
19
|
+
def test_single_score_with_multiple_letters
|
|
15
20
|
skip
|
|
16
|
-
old = {
|
|
17
|
-
|
|
18
|
-
|
|
21
|
+
old = {
|
|
22
|
+
1 => ["A", "E", "I", "O", "U"]
|
|
23
|
+
}
|
|
24
|
+
expected = {
|
|
25
|
+
'a' => 1,
|
|
26
|
+
'e' => 1,
|
|
27
|
+
'i' => 1,
|
|
28
|
+
'o' => 1,
|
|
29
|
+
'u' => 1
|
|
30
|
+
}
|
|
19
31
|
assert_equal expected, ETL.transform(old)
|
|
20
32
|
end
|
|
21
33
|
|
|
22
|
-
def
|
|
34
|
+
def test_multiple_scores_with_multiple_letters
|
|
23
35
|
skip
|
|
24
|
-
old = {
|
|
36
|
+
old = {
|
|
37
|
+
1 => ["A", "E"],
|
|
38
|
+
2 => ["D", "G"]
|
|
39
|
+
}
|
|
25
40
|
expected = {
|
|
26
41
|
'a' => 1,
|
|
27
|
-
'e' => 1,
|
|
28
42
|
'd' => 2,
|
|
43
|
+
'e' => 1,
|
|
29
44
|
'g' => 2
|
|
30
45
|
}
|
|
31
|
-
|
|
32
46
|
assert_equal expected, ETL.transform(old)
|
|
33
47
|
end
|
|
34
48
|
|
|
35
|
-
def
|
|
49
|
+
def test_multiple_scores_with_differing_numbers_of_letters
|
|
36
50
|
skip
|
|
37
51
|
old = {
|
|
38
|
-
1 =>
|
|
39
|
-
2 =>
|
|
40
|
-
3 =>
|
|
41
|
-
4 =>
|
|
42
|
-
5 =>
|
|
43
|
-
8 =>
|
|
44
|
-
10 =>
|
|
52
|
+
1 => ["A", "E", "I", "O", "U", "L", "N", "R", "S", "T"],
|
|
53
|
+
2 => ["D", "G"],
|
|
54
|
+
3 => ["B", "C", "M", "P"],
|
|
55
|
+
4 => ["F", "H", "V", "W", "Y"],
|
|
56
|
+
5 => ["K"],
|
|
57
|
+
8 => ["J", "X"],
|
|
58
|
+
10 => ["Q", "Z"]
|
|
45
59
|
}
|
|
46
|
-
|
|
47
60
|
expected = {
|
|
48
|
-
'a' => 1,
|
|
49
|
-
'
|
|
50
|
-
'
|
|
51
|
-
'
|
|
52
|
-
'
|
|
61
|
+
'a' => 1,
|
|
62
|
+
'b' => 3,
|
|
63
|
+
'c' => 3,
|
|
64
|
+
'd' => 2,
|
|
65
|
+
'e' => 1,
|
|
66
|
+
'f' => 4,
|
|
67
|
+
'g' => 2,
|
|
68
|
+
'h' => 4,
|
|
69
|
+
'i' => 1,
|
|
70
|
+
'j' => 8,
|
|
71
|
+
'k' => 5,
|
|
72
|
+
'l' => 1,
|
|
73
|
+
'm' => 3,
|
|
74
|
+
'n' => 1,
|
|
75
|
+
'o' => 1,
|
|
76
|
+
'p' => 3,
|
|
77
|
+
'q' => 10,
|
|
78
|
+
'r' => 1,
|
|
79
|
+
's' => 1,
|
|
80
|
+
't' => 1,
|
|
81
|
+
'u' => 1,
|
|
82
|
+
'v' => 4,
|
|
83
|
+
'w' => 4,
|
|
84
|
+
'x' => 8,
|
|
85
|
+
'y' => 4,
|
|
53
86
|
'z' => 10
|
|
54
87
|
}
|
|
55
|
-
|
|
56
88
|
assert_equal expected, ETL.transform(old)
|
|
57
89
|
end
|
|
90
|
+
|
|
91
|
+
# Problems in exercism evolve over time, as we find better ways to ask
|
|
92
|
+
# questions.
|
|
93
|
+
# The version number refers to the version of the problem you solved,
|
|
94
|
+
# not your solution.
|
|
95
|
+
#
|
|
96
|
+
# Define a constant named VERSION inside of the top level BookKeeping
|
|
97
|
+
# module, which may be placed near the end of your file.
|
|
98
|
+
#
|
|
99
|
+
# In your file, it will look like this:
|
|
100
|
+
#
|
|
101
|
+
# module BookKeeping
|
|
102
|
+
# VERSION = 1 # Where the version number matches the one in the test.
|
|
103
|
+
# end
|
|
104
|
+
#
|
|
105
|
+
# If you are curious, read more about constants on RubyDoc:
|
|
106
|
+
# http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
|
|
107
|
+
|
|
108
|
+
def test_bookkeeping
|
|
109
|
+
skip
|
|
110
|
+
assert_equal 1, BookKeeping::VERSION
|
|
111
|
+
end
|
|
58
112
|
end
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
require 'generator/exercise_cases'
|
|
2
|
+
|
|
3
|
+
class EtlCase < ExerciseCase
|
|
4
|
+
def workload
|
|
5
|
+
indent_lines([
|
|
6
|
+
"old = {\n #{format(input)}\n }",
|
|
7
|
+
"expected = {\n #{format(expected)}\n }",
|
|
8
|
+
"assert_equal expected, ETL.transform(old)"
|
|
9
|
+
], 4)
|
|
10
|
+
end
|
|
11
|
+
|
|
12
|
+
private
|
|
13
|
+
|
|
14
|
+
def format(obj)
|
|
15
|
+
case
|
|
16
|
+
when obj.respond_to?(:each_pair)
|
|
17
|
+
indent_lines(
|
|
18
|
+
obj.each_with_object([]) {|(k, v), string| string << "#{format(k)} => #{format(v)}" },
|
|
19
|
+
6,
|
|
20
|
+
",\n"
|
|
21
|
+
)
|
|
22
|
+
when obj.respond_to?(:each) then obj
|
|
23
|
+
when obj.to_s =~ /\d+/ then obj.to_i
|
|
24
|
+
else %Q('#{obj}')
|
|
25
|
+
end
|
|
26
|
+
end
|
|
27
|
+
|
|
28
|
+
end
|
|
@@ -21,8 +21,8 @@ class ExerciseCase < OpenStruct
|
|
|
21
21
|
# "#{assert} Isogram.is_isogram?(string)"
|
|
22
22
|
# ], 4
|
|
23
23
|
# )
|
|
24
|
-
def indent_lines(code, depth)
|
|
25
|
-
code.join(
|
|
24
|
+
def indent_lines(code, depth, separator = "\n")
|
|
25
|
+
code.join(separator + ' ' * depth)
|
|
26
26
|
end
|
|
27
27
|
|
|
28
28
|
# used in workload, for example, as
|
|
@@ -1,25 +1,24 @@
|
|
|
1
1
|
struct GradeSchool {
|
|
2
|
-
var roster = [Int:
|
|
2
|
+
var roster = [Int: [String]]()
|
|
3
3
|
|
|
4
4
|
mutating func addStudent(_ name: String, grade: Int) {
|
|
5
5
|
if let students = roster[grade] {
|
|
6
6
|
var students = students
|
|
7
|
-
students.
|
|
7
|
+
students.append(name)
|
|
8
8
|
roster[grade] = students
|
|
9
9
|
} else {
|
|
10
|
-
roster[grade] =
|
|
10
|
+
roster[grade] = [name]
|
|
11
11
|
}
|
|
12
12
|
}
|
|
13
13
|
|
|
14
|
-
func studentsInGrade(_ grade: Int) ->
|
|
15
|
-
return roster[grade] ??
|
|
14
|
+
func studentsInGrade(_ grade: Int) -> [String] {
|
|
15
|
+
return roster[grade] ?? [String]()
|
|
16
16
|
}
|
|
17
17
|
|
|
18
|
-
var sortedRoster: [Int:
|
|
19
|
-
var sortedRoster = [Int:
|
|
18
|
+
var sortedRoster: [Int: [String]] {
|
|
19
|
+
var sortedRoster = [Int: [String]](minimumCapacity: roster.count)
|
|
20
20
|
for (grade, students) in roster {
|
|
21
|
-
sortedRoster[grade] =
|
|
22
|
-
|
|
21
|
+
sortedRoster[grade] = students.sorted()
|
|
23
22
|
}
|
|
24
23
|
return sortedRoster
|
|
25
24
|
}
|
|
@@ -3,27 +3,19 @@ import XCTest
|
|
|
3
3
|
|
|
4
4
|
class GradeSchoolTests: XCTestCase {
|
|
5
5
|
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
for (index, student) in result.enumerated() {
|
|
10
|
-
guard index < expected.count && expected.contains(student) else { return false }
|
|
11
|
-
}
|
|
12
|
-
return true
|
|
13
|
-
}
|
|
14
|
-
private func similar<C: Collection>(_ result: C, _ expected: [String]) -> Bool {
|
|
15
|
-
return result.count.toIntMax() == IntMax(expected.count)
|
|
6
|
+
func sameArray(_ result: [String]?, _ expected: [String]? ) -> Bool {
|
|
7
|
+
guard let result = result, let expected = expected else { return false }
|
|
8
|
+
return result == expected
|
|
16
9
|
}
|
|
17
10
|
|
|
18
|
-
func
|
|
19
|
-
|
|
11
|
+
func XCTAssertEqualArray (_ result: [String]?, _ expected: [String]? ) {
|
|
12
|
+
XCTAssertTrue(sameArray(expected, result))
|
|
20
13
|
}
|
|
21
14
|
|
|
22
15
|
func testAnEmptySchool() {
|
|
23
16
|
let school = GradeSchool()
|
|
24
17
|
let result = school.roster
|
|
25
18
|
XCTAssertTrue(result.isEmpty)
|
|
26
|
-
|
|
27
19
|
}
|
|
28
20
|
|
|
29
21
|
func testAddStudent() {
|
|
@@ -32,7 +24,7 @@ class GradeSchoolTests: XCTestCase {
|
|
|
32
24
|
let result = school.roster
|
|
33
25
|
let expected: Dictionary = [2: ["Aimee"]]
|
|
34
26
|
XCTAssertEqual(Array(result.keys), Array(expected.keys))
|
|
35
|
-
|
|
27
|
+
XCTAssertEqualArray(result[2], expected[2])
|
|
36
28
|
}
|
|
37
29
|
|
|
38
30
|
func testAddMoreStudentsInSameClass() {
|
|
@@ -43,7 +35,7 @@ class GradeSchoolTests: XCTestCase {
|
|
|
43
35
|
let result = school.roster
|
|
44
36
|
let expected = [2: ["Fred", "James", "Paul"]]
|
|
45
37
|
XCTAssertEqual(Array(result.keys), Array(expected.keys))
|
|
46
|
-
|
|
38
|
+
XCTAssertEqualArray(result[2], expected[2])
|
|
47
39
|
}
|
|
48
40
|
|
|
49
41
|
func testAddStudentsToDifferentGrades() {
|
|
@@ -54,7 +46,7 @@ class GradeSchoolTests: XCTestCase {
|
|
|
54
46
|
let expected = [3: ["Chelsea"], 7: ["Logan"]]
|
|
55
47
|
XCTAssertEqual(Array(result.keys).sorted(by: >), Array(expected.keys).sorted(by: >))
|
|
56
48
|
|
|
57
|
-
|
|
49
|
+
XCTAssertEqualArray(result[3], expected[3])
|
|
58
50
|
}
|
|
59
51
|
|
|
60
52
|
func testGetStudentsInAGrade() {
|
|
@@ -64,7 +56,7 @@ class GradeSchoolTests: XCTestCase {
|
|
|
64
56
|
school.addStudent("Jeff", grade: 1)
|
|
65
57
|
let result = school.studentsInGrade(5)
|
|
66
58
|
let expected = ["Franklin", "Bradley"]
|
|
67
|
-
|
|
59
|
+
XCTAssertEqual(result, expected)
|
|
68
60
|
}
|
|
69
61
|
|
|
70
62
|
func testGetStudentsInANonExistantGrade() {
|
|
@@ -72,7 +64,7 @@ class GradeSchoolTests: XCTestCase {
|
|
|
72
64
|
let result = school.studentsInGrade(1)
|
|
73
65
|
|
|
74
66
|
let expected = [String]()
|
|
75
|
-
|
|
67
|
+
XCTAssertEqual(result, expected)
|
|
76
68
|
}
|
|
77
69
|
|
|
78
70
|
func testSortSchool() {
|
|
@@ -88,11 +80,12 @@ class GradeSchoolTests: XCTestCase {
|
|
|
88
80
|
4: ["Christopher", "Jennifer"],
|
|
89
81
|
6: ["Kareem"]
|
|
90
82
|
]
|
|
83
|
+
|
|
91
84
|
XCTAssertEqual(Array(result.keys).sorted(by: >), Array(expected.keys).sorted(by: >))
|
|
92
85
|
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
86
|
+
XCTAssertEqualArray(result[3], expected[3])
|
|
87
|
+
XCTAssertEqualArray(result[4], expected[4])
|
|
88
|
+
XCTAssertEqualArray(result[6], expected[6])
|
|
96
89
|
}
|
|
97
90
|
|
|
98
91
|
static var allTests: [(String, (GradeSchoolTests) -> () throws -> Void)] {
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: trackler
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 2.1.0.
|
|
4
|
+
version: 2.1.0.4
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Katrina Owen
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2017-04-
|
|
11
|
+
date: 2017-04-29 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: rubyzip
|
|
@@ -414,6 +414,7 @@ files:
|
|
|
414
414
|
- common/exercises/word-count/canonical-data.json
|
|
415
415
|
- common/exercises/word-count/description.md
|
|
416
416
|
- common/exercises/word-count/metadata.yml
|
|
417
|
+
- common/exercises/word-search/canonical-data.json
|
|
417
418
|
- common/exercises/word-search/description.md
|
|
418
419
|
- common/exercises/word-search/metadata.yml
|
|
419
420
|
- common/exercises/wordy/canonical-data.json
|
|
@@ -7227,6 +7228,7 @@ files:
|
|
|
7227
7228
|
- tracks/ruby/exercises/dominoes/dominoes_test.rb
|
|
7228
7229
|
- tracks/ruby/exercises/dominoes/example.rb
|
|
7229
7230
|
- tracks/ruby/exercises/dominoes/example.tt
|
|
7231
|
+
- tracks/ruby/exercises/etl/.meta/.version
|
|
7230
7232
|
- tracks/ruby/exercises/etl/etl_test.rb
|
|
7231
7233
|
- tracks/ruby/exercises/etl/example.rb
|
|
7232
7234
|
- tracks/ruby/exercises/flatten-array/example.rb
|
|
@@ -7405,6 +7407,7 @@ files:
|
|
|
7405
7407
|
- tracks/ruby/lib/difference_of_squares_cases.rb
|
|
7406
7408
|
- tracks/ruby/lib/disable_skip.rb
|
|
7407
7409
|
- tracks/ruby/lib/dominoes_cases.rb
|
|
7410
|
+
- tracks/ruby/lib/etl_cases.rb
|
|
7408
7411
|
- tracks/ruby/lib/generator.rb
|
|
7409
7412
|
- tracks/ruby/lib/generator/case_values.rb
|
|
7410
7413
|
- tracks/ruby/lib/generator/command_line.rb
|