tinygql 0.1.3 → 0.1.4

Sign up to get free protection for your applications and to get access to all the features.
Files changed (10) hide show
  1. checksums.yaml +4 -4
  2. data/lib/tinygql/nodes.rb +135 -15
  3. data/lib/tinygql/nodes.yml +34 -4
  4. data/lib/tinygql/parser.rb +53 -8
  5. data/lib/tinygql/version.rb +1 -1
  6. data/lib/tinygql/visitors.rb +261 -304
  7. data/lib/tinygql/visitors.rb.erb +8 -20
  8. data/test/parser_test.rb +51 -0
  9. data/test/schema-extensions.graphql +48 -0
  10. metadata +4 -2
data/lib/tinygql/visitors.rb CHANGED
@@ -1,508 +1,465 @@
1
1
  module TinyGQL
2
2
  module Visitors
3
3
  module Visitor
4
+
4
5
  def handle_document obj
5
- obj.definitions.each { |v| v.accept self }
6
+ obj.definitions.each { |v| v.accept self }
6
7
  end
8
+
7
9
  def handle_operation_definition obj
8
- if obj.variable_definitions
9
- obj.variable_definitions.each { |v| v.accept self }
10
- end
11
- if obj.directives
12
- obj.directives.each { |v| v.accept self }
13
- end
14
- obj.selection_set.each { |v| v.accept self }
10
+ obj.variable_definitions.each { |v| v.accept self } if obj.variable_definitions
11
+ obj.directives.each { |v| v.accept self } if obj.directives
12
+ obj.selection_set.each { |v| v.accept self }
15
13
  end
14
+
16
15
  def handle_variable obj
17
16
  end
17
+
18
18
  def handle_named_type obj
19
19
  end
20
+
20
21
  def handle_not_null_type obj
21
- obj.type.accept self
22
+ obj.type.accept(self)
22
23
  end
24
+
23
25
  def handle_list_type obj
24
- obj.type.accept self
26
+ obj.type.accept(self)
25
27
  end
28
+
26
29
  def handle_variable_definition obj
27
- obj.variable.accept self
28
- obj.type.accept self
29
- if obj.default_value
30
- obj.default_value.accept self
31
- end
30
+ obj.variable.accept(self)
31
+ obj.type.accept(self)
32
+ obj.default_value.accept(self) if obj.default_value
32
33
  end
34
+
33
35
  def handle_value obj
34
36
  end
37
+
35
38
  def handle_argument obj
36
- obj.value.accept self
39
+ obj.value.accept(self)
37
40
  end
41
+
38
42
  def handle_field obj
39
- if obj.arguments
40
- obj.arguments.each { |v| v.accept self }
41
- end
42
- if obj.directives
43
- obj.directives.each { |v| v.accept self }
44
- end
45
- if obj.selection_set
46
- obj.selection_set.each { |v| v.accept self }
47
- end
43
+ obj.arguments.each { |v| v.accept self } if obj.arguments
44
+ obj.directives.each { |v| v.accept self } if obj.directives
45
+ obj.selection_set.each { |v| v.accept self } if obj.selection_set
48
46
  end
47
+
49
48
  def handle_object_field obj
50
- obj.value.accept self
49
+ obj.value.accept(self)
51
50
  end
51
+
52
52
  def handle_int_value obj
53
53
  end
54
+
54
55
  def handle_float_value obj
55
56
  end
57
+
56
58
  def handle_string_value obj
57
59
  end
60
+
58
61
  def handle_boolean_value obj
59
62
  end
63
+
60
64
  def handle_null_value obj
61
65
  end
66
+
62
67
  def handle_enum_value obj
63
68
  end
69
+
64
70
  def handle_list_value obj
65
71
  end
72
+
66
73
  def handle_object_value obj
67
- obj.values.each { |v| v.accept self }
74
+ obj.values.each { |v| v.accept self }
68
75
  end
76
+
69
77
  def handle_directive obj
70
- obj.arguments.each { |v| v.accept self }
78
+ obj.arguments.each { |v| v.accept self } if obj.arguments
71
79
  end
80
+
72
81
  def handle_type_condition obj
73
- obj.named_type.accept self
82
+ obj.named_type.accept(self)
74
83
  end
84
+
75
85
  def handle_inline_fragment obj
76
- if obj.type_condition
77
- obj.type_condition.accept self
78
- end
79
- if obj.directives
80
- obj.directives.each { |v| v.accept self }
81
- end
82
- obj.selection_set.each { |v| v.accept self }
86
+ obj.type_condition.accept(self) if obj.type_condition
87
+ obj.directives.each { |v| v.accept self } if obj.directives
88
+ obj.selection_set.each { |v| v.accept self }
83
89
  end
90
+
84
91
  def handle_fragment_spread obj
85
- obj.fragment_name.accept self
86
- if obj.directives
87
- obj.directives.each { |v| v.accept self }
88
- end
92
+ obj.directives.each { |v| v.accept self } if obj.directives
89
93
  end
94
+
90
95
  def handle_fragment_definition obj
91
- obj.fragment_name.accept self
92
- obj.type_condition.accept self
93
- if obj.directives
94
- obj.directives.each { |v| v.accept self }
95
- end
96
- obj.selection_set.each { |v| v.accept self }
96
+ obj.type_condition.accept(self)
97
+ obj.directives.each { |v| v.accept self } if obj.directives
98
+ obj.selection_set.each { |v| v.accept self }
97
99
  end
100
+
98
101
  def handle_root_operation_type_definition obj
99
- obj.operation_type.accept self
100
- obj.named_type.accept self
102
+ obj.named_type.accept(self)
101
103
  end
104
+
102
105
  def handle_schema_definition obj
103
- if obj.description
104
- obj.description.accept self
105
- end
106
- if obj.directives
107
- obj.directives.each { |v| v.accept self }
108
- end
109
- obj.root_operation_definitions.each { |v| v.accept self }
106
+ obj.description.accept(self) if obj.description
107
+ obj.directives.each { |v| v.accept self } if obj.directives
108
+ obj.root_operation_definitions.each { |v| v.accept self }
110
109
  end
110
+
111
111
  def handle_field_definition obj
112
- if obj.description
113
- obj.description.accept self
114
- end
115
- if obj.arguments_definition
116
- obj.arguments_definition.each { |v| v.accept self }
117
- end
118
- obj.type.accept self
119
- if obj.directives
120
- obj.directives.each { |v| v.accept self }
121
- end
112
+ obj.description.accept(self) if obj.description
113
+ obj.arguments_definition.each { |v| v.accept self } if obj.arguments_definition
114
+ obj.type.accept(self)
115
+ obj.directives.each { |v| v.accept self } if obj.directives
122
116
  end
117
+
123
118
  def handle_input_value_definition obj
124
- if obj.description
125
- obj.description.accept self
126
- end
127
- obj.type.accept self
128
- if obj.default_value
129
- obj.default_value.accept self
130
- end
131
- if obj.directives
132
- obj.directives.each { |v| v.accept self }
133
- end
119
+ obj.description.accept(self) if obj.description
120
+ obj.type.accept(self)
121
+ obj.default_value.accept(self) if obj.default_value
122
+ obj.directives.each { |v| v.accept self } if obj.directives
134
123
  end
124
+
135
125
  def handle_object_type_definition obj
136
- if obj.description
137
- obj.description.accept self
138
- end
139
- if obj.implements_interfaces
140
- obj.implements_interfaces.each { |v| v.accept self }
141
- end
142
- if obj.directives
143
- obj.directives.each { |v| v.accept self }
144
- end
145
- if obj.fields_definition
146
- obj.fields_definition.each { |v| v.accept self }
147
- end
126
+ obj.description.accept(self) if obj.description
127
+ obj.implements_interfaces.each { |v| v.accept self } if obj.implements_interfaces
128
+ obj.directives.each { |v| v.accept self } if obj.directives
129
+ obj.fields_definition.each { |v| v.accept self } if obj.fields_definition
148
130
  end
131
+
149
132
  def handle_interface_type_definition obj
150
- if obj.description
151
- obj.description.accept self
152
- end
153
- if obj.directives
154
- obj.directives.each { |v| v.accept self }
155
- end
156
- if obj.fields_definition
157
- obj.fields_definition.each { |v| v.accept self }
158
- end
133
+ obj.description.accept(self) if obj.description
134
+ obj.directives.each { |v| v.accept self } if obj.directives
135
+ obj.fields_definition.each { |v| v.accept self } if obj.fields_definition
159
136
  end
137
+
160
138
  def handle_union_type_definition obj
161
- if obj.description
162
- obj.description.accept self
163
- end
164
- if obj.directives
165
- obj.directives.each { |v| v.accept self }
166
- end
167
- if obj.union_member_types
168
- obj.union_member_types.each { |v| v.accept self }
169
- end
139
+ obj.description.accept(self) if obj.description
140
+ obj.directives.each { |v| v.accept self } if obj.directives
141
+ obj.union_member_types.each { |v| v.accept self } if obj.union_member_types
170
142
  end
143
+
171
144
  def handle_scalar_type_definition obj
172
- if obj.description
173
- obj.description.accept self
174
- end
175
- if obj.directives
176
- obj.directives.each { |v| v.accept self }
177
- end
145
+ obj.description.accept(self) if obj.description
146
+ obj.directives.each { |v| v.accept self } if obj.directives
178
147
  end
148
+
179
149
  def handle_enum_value_definition obj
180
- if obj.description
181
- obj.description.accept self
182
- end
183
- obj.enum_value.accept self
184
- if obj.directives
185
- obj.directives.each { |v| v.accept self }
186
- end
150
+ obj.description.accept(self) if obj.description
151
+ obj.enum_value.accept(self)
152
+ obj.directives.each { |v| v.accept self } if obj.directives
187
153
  end
154
+
188
155
  def handle_enum_type_definition obj
189
- if obj.description
190
- obj.description.accept self
191
- end
192
- if obj.directives
193
- obj.directives.each { |v| v.accept self }
194
- end
195
- if obj.enum_value_definition
196
- obj.enum_value_definition.each { |v| v.accept self }
197
- end
156
+ obj.description.accept(self) if obj.description
157
+ obj.directives.each { |v| v.accept self } if obj.directives
158
+ obj.enum_value_definition.each { |v| v.accept self } if obj.enum_value_definition
198
159
  end
160
+
199
161
  def handle_input_object_type_definition obj
200
- if obj.description
201
- obj.description.accept self
202
- end
203
- if obj.directives
204
- obj.directives.each { |v| v.accept self }
205
- end
206
- if obj.input_fields_definition
207
- obj.input_fields_definition.each { |v| v.accept self }
208
- end
162
+ obj.description.accept(self) if obj.description
163
+ obj.directives.each { |v| v.accept self } if obj.directives
164
+ obj.input_fields_definition.each { |v| v.accept self } if obj.input_fields_definition
209
165
  end
166
+
210
167
  def handle_object_type_extension obj
211
- if obj.implements_interfaces
212
- obj.implements_interfaces.each { |v| v.accept self }
213
- end
214
- if obj.directives
215
- obj.directives.each { |v| v.accept self }
216
- end
217
- if obj.fields_definition
218
- obj.fields_definition.each { |v| v.accept self }
219
- end
168
+ obj.implements_interfaces.each { |v| v.accept self } if obj.implements_interfaces
169
+ obj.directives.each { |v| v.accept self } if obj.directives
170
+ obj.fields_definition.each { |v| v.accept self } if obj.fields_definition
220
171
  end
172
+
221
173
  def handle_executable_directive_location obj
222
174
  end
175
+
223
176
  def handle_type_system_directive_location obj
224
177
  end
178
+
225
179
  def handle_directive_definition obj
226
- if obj.description
227
- obj.description.accept self
228
- end
229
- if obj.arguments_definition
230
- obj.arguments_definition.each { |v| v.accept self }
231
- end
232
- obj.directive_locations.each { |v| v.accept self }
180
+ obj.description.accept(self) if obj.description
181
+ obj.arguments_definition.each { |v| v.accept self } if obj.arguments_definition
182
+ obj.directive_locations.each { |v| v.accept self }
183
+ end
184
+
185
+ def handle_scalar_type_extension obj
186
+ obj.directives.each { |v| v.accept self } if obj.directives
187
+ end
188
+
189
+ def handle_interface_type_extension obj
190
+ obj.implements_interfaces.each { |v| v.accept self } if obj.implements_interfaces
191
+ obj.directives.each { |v| v.accept self } if obj.directives
192
+ obj.fields_definition.each { |v| v.accept self } if obj.fields_definition
193
+ end
194
+
195
+ def handle_union_type_extension obj
196
+ obj.directives.each { |v| v.accept self } if obj.directives
197
+ obj.union_member_types.each { |v| v.accept self } if obj.union_member_types
198
+ end
199
+
200
+ def handle_enum_type_extension obj
201
+ obj.directives.each { |v| v.accept self } if obj.directives
202
+ obj.enum_value_definition.each { |v| v.accept self } if obj.enum_value_definition
233
203
  end
204
+
205
+ def handle_input_object_type_extension obj
206
+ obj.directives.each { |v| v.accept self } if obj.directives
207
+ obj.input_fields_definition.each { |v| v.accept self } if obj.input_fields_definition
208
+ end
209
+
234
210
  end
235
211
 
236
212
  module Fold
213
+
237
214
  def handle_document obj, seed
238
- obj.definitions.each { |v| seed = v.fold(self, seed) }
215
+ obj.definitions.each { |v| seed = v.fold(self, seed) }
239
216
  seed
240
217
  end
218
+
241
219
  def handle_operation_definition obj, seed
242
- if obj.variable_definitions
243
- obj.variable_definitions.each { |v| seed = v.fold(self, seed) }
244
- end
245
- if obj.directives
246
- obj.directives.each { |v| seed = v.fold(self, seed) }
247
- end
248
- obj.selection_set.each { |v| seed = v.fold(self, seed) }
220
+ obj.variable_definitions.each { |v| seed = v.fold(self, seed) } if obj.variable_definitions
221
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
222
+ obj.selection_set.each { |v| seed = v.fold(self, seed) }
249
223
  seed
250
224
  end
225
+
251
226
  def handle_variable obj, seed
252
227
  seed
253
228
  end
229
+
254
230
  def handle_named_type obj, seed
255
231
  seed
256
232
  end
233
+
257
234
  def handle_not_null_type obj, seed
258
- seed = obj.type.fold self, seed
235
+ seed = obj.type.fold(self, seed)
259
236
  seed
260
237
  end
238
+
261
239
  def handle_list_type obj, seed
262
- seed = obj.type.fold self, seed
240
+ seed = obj.type.fold(self, seed)
263
241
  seed
264
242
  end
243
+
265
244
  def handle_variable_definition obj, seed
266
- seed = obj.variable.fold self, seed
267
- seed = obj.type.fold self, seed
268
- if obj.default_value
269
- seed = obj.default_value.fold self, seed
270
- end
245
+ seed = obj.variable.fold(self, seed)
246
+ seed = obj.type.fold(self, seed)
247
+ seed = obj.default_value.fold(self, seed) if obj.default_value
271
248
  seed
272
249
  end
250
+
273
251
  def handle_value obj, seed
274
252
  seed
275
253
  end
254
+
276
255
  def handle_argument obj, seed
277
- seed = obj.value.fold self, seed
256
+ seed = obj.value.fold(self, seed)
278
257
  seed
279
258
  end
259
+
280
260
  def handle_field obj, seed
281
- if obj.arguments
282
- obj.arguments.each { |v| seed = v.fold(self, seed) }
283
- end
284
- if obj.directives
285
- obj.directives.each { |v| seed = v.fold(self, seed) }
286
- end
287
- if obj.selection_set
288
- obj.selection_set.each { |v| seed = v.fold(self, seed) }
289
- end
261
+ obj.arguments.each { |v| seed = v.fold(self, seed) } if obj.arguments
262
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
263
+ obj.selection_set.each { |v| seed = v.fold(self, seed) } if obj.selection_set
290
264
  seed
291
265
  end
266
+
292
267
  def handle_object_field obj, seed
293
- seed = obj.value.fold self, seed
268
+ seed = obj.value.fold(self, seed)
294
269
  seed
295
270
  end
271
+
296
272
  def handle_int_value obj, seed
297
273
  seed
298
274
  end
275
+
299
276
  def handle_float_value obj, seed
300
277
  seed
301
278
  end
279
+
302
280
  def handle_string_value obj, seed
303
281
  seed
304
282
  end
283
+
305
284
  def handle_boolean_value obj, seed
306
285
  seed
307
286
  end
287
+
308
288
  def handle_null_value obj, seed
309
289
  seed
310
290
  end
291
+
311
292
  def handle_enum_value obj, seed
312
293
  seed
313
294
  end
295
+
314
296
  def handle_list_value obj, seed
315
297
  seed
316
298
  end
299
+
317
300
  def handle_object_value obj, seed
318
- obj.values.each { |v| seed = v.fold(self, seed) }
301
+ obj.values.each { |v| seed = v.fold(self, seed) }
319
302
  seed
320
303
  end
304
+
321
305
  def handle_directive obj, seed
322
- obj.arguments.each { |v| seed = v.fold(self, seed) }
306
+ obj.arguments.each { |v| seed = v.fold(self, seed) } if obj.arguments
323
307
  seed
324
308
  end
309
+
325
310
  def handle_type_condition obj, seed
326
- seed = obj.named_type.fold self, seed
311
+ seed = obj.named_type.fold(self, seed)
327
312
  seed
328
313
  end
314
+
329
315
  def handle_inline_fragment obj, seed
330
- if obj.type_condition
331
- seed = obj.type_condition.fold self, seed
332
- end
333
- if obj.directives
334
- obj.directives.each { |v| seed = v.fold(self, seed) }
335
- end
336
- obj.selection_set.each { |v| seed = v.fold(self, seed) }
316
+ seed = obj.type_condition.fold(self, seed) if obj.type_condition
317
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
318
+ obj.selection_set.each { |v| seed = v.fold(self, seed) }
337
319
  seed
338
320
  end
321
+
339
322
  def handle_fragment_spread obj, seed
340
- seed = obj.fragment_name.fold self, seed
341
- if obj.directives
342
- obj.directives.each { |v| seed = v.fold(self, seed) }
343
- end
323
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
344
324
  seed
345
325
  end
326
+
346
327
  def handle_fragment_definition obj, seed
347
- seed = obj.fragment_name.fold self, seed
348
- seed = obj.type_condition.fold self, seed
349
- if obj.directives
350
- obj.directives.each { |v| seed = v.fold(self, seed) }
351
- end
352
- obj.selection_set.each { |v| seed = v.fold(self, seed) }
328
+ seed = obj.type_condition.fold(self, seed)
329
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
330
+ obj.selection_set.each { |v| seed = v.fold(self, seed) }
353
331
  seed
354
332
  end
333
+
355
334
  def handle_root_operation_type_definition obj, seed
356
- seed = obj.operation_type.fold self, seed
357
- seed = obj.named_type.fold self, seed
335
+ seed = obj.named_type.fold(self, seed)
358
336
  seed
359
337
  end
338
+
360
339
  def handle_schema_definition obj, seed
361
- if obj.description
362
- seed = obj.description.fold self, seed
363
- end
364
- if obj.directives
365
- obj.directives.each { |v| seed = v.fold(self, seed) }
366
- end
367
- obj.root_operation_definitions.each { |v| seed = v.fold(self, seed) }
340
+ seed = obj.description.fold(self, seed) if obj.description
341
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
342
+ obj.root_operation_definitions.each { |v| seed = v.fold(self, seed) }
368
343
  seed
369
344
  end
345
+
370
346
  def handle_field_definition obj, seed
371
- if obj.description
372
- seed = obj.description.fold self, seed
373
- end
374
- if obj.arguments_definition
375
- obj.arguments_definition.each { |v| seed = v.fold(self, seed) }
376
- end
377
- seed = obj.type.fold self, seed
378
- if obj.directives
379
- obj.directives.each { |v| seed = v.fold(self, seed) }
380
- end
347
+ seed = obj.description.fold(self, seed) if obj.description
348
+ obj.arguments_definition.each { |v| seed = v.fold(self, seed) } if obj.arguments_definition
349
+ seed = obj.type.fold(self, seed)
350
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
381
351
  seed
382
352
  end
353
+
383
354
  def handle_input_value_definition obj, seed
384
- if obj.description
385
- seed = obj.description.fold self, seed
386
- end
387
- seed = obj.type.fold self, seed
388
- if obj.default_value
389
- seed = obj.default_value.fold self, seed
390
- end
391
- if obj.directives
392
- obj.directives.each { |v| seed = v.fold(self, seed) }
393
- end
355
+ seed = obj.description.fold(self, seed) if obj.description
356
+ seed = obj.type.fold(self, seed)
357
+ seed = obj.default_value.fold(self, seed) if obj.default_value
358
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
394
359
  seed
395
360
  end
361
+
396
362
  def handle_object_type_definition obj, seed
397
- if obj.description
398
- seed = obj.description.fold self, seed
399
- end
400
- if obj.implements_interfaces
401
- obj.implements_interfaces.each { |v| seed = v.fold(self, seed) }
402
- end
403
- if obj.directives
404
- obj.directives.each { |v| seed = v.fold(self, seed) }
405
- end
406
- if obj.fields_definition
407
- obj.fields_definition.each { |v| seed = v.fold(self, seed) }
408
- end
363
+ seed = obj.description.fold(self, seed) if obj.description
364
+ obj.implements_interfaces.each { |v| seed = v.fold(self, seed) } if obj.implements_interfaces
365
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
366
+ obj.fields_definition.each { |v| seed = v.fold(self, seed) } if obj.fields_definition
409
367
  seed
410
368
  end
369
+
411
370
  def handle_interface_type_definition obj, seed
412
- if obj.description
413
- seed = obj.description.fold self, seed
414
- end
415
- if obj.directives
416
- obj.directives.each { |v| seed = v.fold(self, seed) }
417
- end
418
- if obj.fields_definition
419
- obj.fields_definition.each { |v| seed = v.fold(self, seed) }
420
- end
371
+ seed = obj.description.fold(self, seed) if obj.description
372
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
373
+ obj.fields_definition.each { |v| seed = v.fold(self, seed) } if obj.fields_definition
421
374
  seed
422
375
  end
376
+
423
377
  def handle_union_type_definition obj, seed
424
- if obj.description
425
- seed = obj.description.fold self, seed
426
- end
427
- if obj.directives
428
- obj.directives.each { |v| seed = v.fold(self, seed) }
429
- end
430
- if obj.union_member_types
431
- obj.union_member_types.each { |v| seed = v.fold(self, seed) }
432
- end
378
+ seed = obj.description.fold(self, seed) if obj.description
379
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
380
+ obj.union_member_types.each { |v| seed = v.fold(self, seed) } if obj.union_member_types
433
381
  seed
434
382
  end
383
+
435
384
  def handle_scalar_type_definition obj, seed
436
- if obj.description
437
- seed = obj.description.fold self, seed
438
- end
439
- if obj.directives
440
- obj.directives.each { |v| seed = v.fold(self, seed) }
441
- end
385
+ seed = obj.description.fold(self, seed) if obj.description
386
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
442
387
  seed
443
388
  end
389
+
444
390
  def handle_enum_value_definition obj, seed
445
- if obj.description
446
- seed = obj.description.fold self, seed
447
- end
448
- seed = obj.enum_value.fold self, seed
449
- if obj.directives
450
- obj.directives.each { |v| seed = v.fold(self, seed) }
451
- end
391
+ seed = obj.description.fold(self, seed) if obj.description
392
+ seed = obj.enum_value.fold(self, seed)
393
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
452
394
  seed
453
395
  end
396
+
454
397
  def handle_enum_type_definition obj, seed
455
- if obj.description
456
- seed = obj.description.fold self, seed
457
- end
458
- if obj.directives
459
- obj.directives.each { |v| seed = v.fold(self, seed) }
460
- end
461
- if obj.enum_value_definition
462
- obj.enum_value_definition.each { |v| seed = v.fold(self, seed) }
463
- end
398
+ seed = obj.description.fold(self, seed) if obj.description
399
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
400
+ obj.enum_value_definition.each { |v| seed = v.fold(self, seed) } if obj.enum_value_definition
464
401
  seed
465
402
  end
403
+
466
404
  def handle_input_object_type_definition obj, seed
467
- if obj.description
468
- seed = obj.description.fold self, seed
469
- end
470
- if obj.directives
471
- obj.directives.each { |v| seed = v.fold(self, seed) }
472
- end
473
- if obj.input_fields_definition
474
- obj.input_fields_definition.each { |v| seed = v.fold(self, seed) }
475
- end
405
+ seed = obj.description.fold(self, seed) if obj.description
406
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
407
+ obj.input_fields_definition.each { |v| seed = v.fold(self, seed) } if obj.input_fields_definition
476
408
  seed
477
409
  end
410
+
478
411
  def handle_object_type_extension obj, seed
479
- if obj.implements_interfaces
480
- obj.implements_interfaces.each { |v| seed = v.fold(self, seed) }
481
- end
482
- if obj.directives
483
- obj.directives.each { |v| seed = v.fold(self, seed) }
484
- end
485
- if obj.fields_definition
486
- obj.fields_definition.each { |v| seed = v.fold(self, seed) }
487
- end
412
+ obj.implements_interfaces.each { |v| seed = v.fold(self, seed) } if obj.implements_interfaces
413
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
414
+ obj.fields_definition.each { |v| seed = v.fold(self, seed) } if obj.fields_definition
488
415
  seed
489
416
  end
417
+
490
418
  def handle_executable_directive_location obj, seed
491
419
  seed
492
420
  end
421
+
493
422
  def handle_type_system_directive_location obj, seed
494
423
  seed
495
424
  end
425
+
496
426
  def handle_directive_definition obj, seed
497
- if obj.description
498
- seed = obj.description.fold self, seed
499
- end
500
- if obj.arguments_definition
501
- obj.arguments_definition.each { |v| seed = v.fold(self, seed) }
502
- end
503
- obj.directive_locations.each { |v| seed = v.fold(self, seed) }
427
+ seed = obj.description.fold(self, seed) if obj.description
428
+ obj.arguments_definition.each { |v| seed = v.fold(self, seed) } if obj.arguments_definition
429
+ obj.directive_locations.each { |v| seed = v.fold(self, seed) }
430
+ seed
431
+ end
432
+
433
+ def handle_scalar_type_extension obj, seed
434
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
504
435
  seed
505
436
  end
437
+
438
+ def handle_interface_type_extension obj, seed
439
+ obj.implements_interfaces.each { |v| seed = v.fold(self, seed) } if obj.implements_interfaces
440
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
441
+ obj.fields_definition.each { |v| seed = v.fold(self, seed) } if obj.fields_definition
442
+ seed
443
+ end
444
+
445
+ def handle_union_type_extension obj, seed
446
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
447
+ obj.union_member_types.each { |v| seed = v.fold(self, seed) } if obj.union_member_types
448
+ seed
449
+ end
450
+
451
+ def handle_enum_type_extension obj, seed
452
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
453
+ obj.enum_value_definition.each { |v| seed = v.fold(self, seed) } if obj.enum_value_definition
454
+ seed
455
+ end
456
+
457
+ def handle_input_object_type_extension obj, seed
458
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
459
+ obj.input_fields_definition.each { |v| seed = v.fold(self, seed) } if obj.input_fields_definition
460
+ seed
461
+ end
462
+
506
463
  end
507
464
  end
508
465
  end