tinygql 0.1.2 → 0.1.4

Sign up to get free protection for your applications and to get access to all the features.
Files changed (15) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile +3 -0
  3. data/Rakefile +11 -0
  4. data/benchmark/fixtures/negotiate.gql +3643 -0
  5. data/bin/bench.rb +15 -4
  6. data/bin/profile.rb +5 -0
  7. data/lib/tinygql/nodes.rb +138 -17
  8. data/lib/tinygql/nodes.yml +45 -14
  9. data/lib/tinygql/parser.rb +76 -23
  10. data/lib/tinygql/version.rb +1 -1
  11. data/lib/tinygql/visitors.rb +261 -238
  12. data/lib/tinygql/visitors.rb.erb +8 -20
  13. data/test/parser_test.rb +77 -0
  14. data/test/schema-extensions.graphql +48 -0
  15. metadata +6 -2
data/lib/tinygql/visitors.rb CHANGED
@@ -1,442 +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.directives
104
- obj.directives.each { |v| v.accept self }
105
- end
106
- 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 }
107
109
  end
110
+
108
111
  def handle_field_definition obj
109
- if obj.arguments_definition
110
- obj.arguments_definition.each { |v| v.accept self }
111
- end
112
- obj.type.accept self
113
- if obj.directives
114
- obj.directives.each { |v| v.accept self }
115
- 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
116
116
  end
117
+
117
118
  def handle_input_value_definition obj
118
- obj.type.accept self
119
- if obj.default_value
120
- obj.default_value.accept self
121
- end
122
- if obj.directives
123
- obj.directives.each { |v| v.accept self }
124
- 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
125
123
  end
124
+
126
125
  def handle_object_type_definition obj
127
- if obj.implements_interfaces
128
- obj.implements_interfaces.each { |v| v.accept self }
129
- end
130
- if obj.directives
131
- obj.directives.each { |v| v.accept self }
132
- end
133
- if obj.fields_definition
134
- obj.fields_definition.each { |v| v.accept self }
135
- 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
136
130
  end
131
+
137
132
  def handle_interface_type_definition obj
138
- if obj.directives
139
- obj.directives.each { |v| v.accept self }
140
- end
141
- if obj.fields_definition
142
- obj.fields_definition.each { |v| v.accept self }
143
- 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
144
136
  end
137
+
145
138
  def handle_union_type_definition obj
146
- if obj.directives
147
- obj.directives.each { |v| v.accept self }
148
- end
149
- if obj.union_member_types
150
- obj.union_member_types.each { |v| v.accept self }
151
- 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
152
142
  end
143
+
153
144
  def handle_scalar_type_definition obj
154
- if obj.directives
155
- obj.directives.each { |v| v.accept self }
156
- end
145
+ obj.description.accept(self) if obj.description
146
+ obj.directives.each { |v| v.accept self } if obj.directives
157
147
  end
148
+
158
149
  def handle_enum_value_definition obj
159
- obj.enum_value.accept self
160
- if obj.directives
161
- obj.directives.each { |v| v.accept self }
162
- 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
163
153
  end
154
+
164
155
  def handle_enum_type_definition obj
165
- if obj.directives
166
- obj.directives.each { |v| v.accept self }
167
- end
168
- if obj.enum_value_definition
169
- obj.enum_value_definition.each { |v| v.accept self }
170
- 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
171
159
  end
160
+
172
161
  def handle_input_object_type_definition obj
173
- if obj.directives
174
- obj.directives.each { |v| v.accept self }
175
- end
176
- if obj.input_fields_definition
177
- obj.input_fields_definition.each { |v| v.accept self }
178
- 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
179
165
  end
166
+
180
167
  def handle_object_type_extension obj
181
- if obj.implements_interfaces
182
- obj.implements_interfaces.each { |v| v.accept self }
183
- end
184
- if obj.directives
185
- obj.directives.each { |v| v.accept self }
186
- end
187
- if obj.fields_definition
188
- obj.fields_definition.each { |v| v.accept self }
189
- 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
190
171
  end
172
+
191
173
  def handle_executable_directive_location obj
192
174
  end
175
+
193
176
  def handle_type_system_directive_location obj
194
177
  end
178
+
195
179
  def handle_directive_definition obj
196
- if obj.arguments_definition
197
- obj.arguments_definition.each { |v| v.accept self }
198
- end
199
- 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
200
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
+
201
210
  end
202
211
 
203
212
  module Fold
213
+
204
214
  def handle_document obj, seed
205
- obj.definitions.each { |v| seed = v.fold(self, seed) }
215
+ obj.definitions.each { |v| seed = v.fold(self, seed) }
206
216
  seed
207
217
  end
218
+
208
219
  def handle_operation_definition obj, seed
209
- if obj.variable_definitions
210
- obj.variable_definitions.each { |v| seed = v.fold(self, seed) }
211
- end
212
- if obj.directives
213
- obj.directives.each { |v| seed = v.fold(self, seed) }
214
- end
215
- 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) }
216
223
  seed
217
224
  end
225
+
218
226
  def handle_variable obj, seed
219
227
  seed
220
228
  end
229
+
221
230
  def handle_named_type obj, seed
222
231
  seed
223
232
  end
233
+
224
234
  def handle_not_null_type obj, seed
225
- seed = obj.type.fold self, seed
235
+ seed = obj.type.fold(self, seed)
226
236
  seed
227
237
  end
238
+
228
239
  def handle_list_type obj, seed
229
- seed = obj.type.fold self, seed
240
+ seed = obj.type.fold(self, seed)
230
241
  seed
231
242
  end
243
+
232
244
  def handle_variable_definition obj, seed
233
- seed = obj.variable.fold self, seed
234
- seed = obj.type.fold self, seed
235
- if obj.default_value
236
- seed = obj.default_value.fold self, seed
237
- 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
238
248
  seed
239
249
  end
250
+
240
251
  def handle_value obj, seed
241
252
  seed
242
253
  end
254
+
243
255
  def handle_argument obj, seed
244
- seed = obj.value.fold self, seed
256
+ seed = obj.value.fold(self, seed)
245
257
  seed
246
258
  end
259
+
247
260
  def handle_field obj, seed
248
- if obj.arguments
249
- obj.arguments.each { |v| seed = v.fold(self, seed) }
250
- end
251
- if obj.directives
252
- obj.directives.each { |v| seed = v.fold(self, seed) }
253
- end
254
- if obj.selection_set
255
- obj.selection_set.each { |v| seed = v.fold(self, seed) }
256
- 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
257
264
  seed
258
265
  end
266
+
259
267
  def handle_object_field obj, seed
260
- seed = obj.value.fold self, seed
268
+ seed = obj.value.fold(self, seed)
261
269
  seed
262
270
  end
271
+
263
272
  def handle_int_value obj, seed
264
273
  seed
265
274
  end
275
+
266
276
  def handle_float_value obj, seed
267
277
  seed
268
278
  end
279
+
269
280
  def handle_string_value obj, seed
270
281
  seed
271
282
  end
283
+
272
284
  def handle_boolean_value obj, seed
273
285
  seed
274
286
  end
287
+
275
288
  def handle_null_value obj, seed
276
289
  seed
277
290
  end
291
+
278
292
  def handle_enum_value obj, seed
279
293
  seed
280
294
  end
295
+
281
296
  def handle_list_value obj, seed
282
297
  seed
283
298
  end
299
+
284
300
  def handle_object_value obj, seed
285
- obj.values.each { |v| seed = v.fold(self, seed) }
301
+ obj.values.each { |v| seed = v.fold(self, seed) }
286
302
  seed
287
303
  end
304
+
288
305
  def handle_directive obj, seed
289
- obj.arguments.each { |v| seed = v.fold(self, seed) }
306
+ obj.arguments.each { |v| seed = v.fold(self, seed) } if obj.arguments
290
307
  seed
291
308
  end
309
+
292
310
  def handle_type_condition obj, seed
293
- seed = obj.named_type.fold self, seed
311
+ seed = obj.named_type.fold(self, seed)
294
312
  seed
295
313
  end
314
+
296
315
  def handle_inline_fragment obj, seed
297
- if obj.type_condition
298
- seed = obj.type_condition.fold self, seed
299
- end
300
- if obj.directives
301
- obj.directives.each { |v| seed = v.fold(self, seed) }
302
- end
303
- 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) }
304
319
  seed
305
320
  end
321
+
306
322
  def handle_fragment_spread obj, seed
307
- seed = obj.fragment_name.fold self, seed
308
- if obj.directives
309
- obj.directives.each { |v| seed = v.fold(self, seed) }
310
- end
323
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
311
324
  seed
312
325
  end
326
+
313
327
  def handle_fragment_definition obj, seed
314
- seed = obj.fragment_name.fold self, seed
315
- seed = obj.type_condition.fold self, seed
316
- if obj.directives
317
- obj.directives.each { |v| seed = v.fold(self, seed) }
318
- end
319
- 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) }
320
331
  seed
321
332
  end
333
+
322
334
  def handle_root_operation_type_definition obj, seed
323
- seed = obj.operation_type.fold self, seed
324
- seed = obj.named_type.fold self, seed
335
+ seed = obj.named_type.fold(self, seed)
325
336
  seed
326
337
  end
338
+
327
339
  def handle_schema_definition obj, seed
328
- if obj.directives
329
- obj.directives.each { |v| seed = v.fold(self, seed) }
330
- end
331
- 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) }
332
343
  seed
333
344
  end
345
+
334
346
  def handle_field_definition obj, seed
335
- if obj.arguments_definition
336
- obj.arguments_definition.each { |v| seed = v.fold(self, seed) }
337
- end
338
- seed = obj.type.fold self, seed
339
- if obj.directives
340
- obj.directives.each { |v| seed = v.fold(self, seed) }
341
- 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
342
351
  seed
343
352
  end
353
+
344
354
  def handle_input_value_definition obj, seed
345
- seed = obj.type.fold self, seed
346
- if obj.default_value
347
- seed = obj.default_value.fold self, seed
348
- end
349
- if obj.directives
350
- obj.directives.each { |v| seed = v.fold(self, seed) }
351
- 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
352
359
  seed
353
360
  end
361
+
354
362
  def handle_object_type_definition obj, seed
355
- if obj.implements_interfaces
356
- obj.implements_interfaces.each { |v| seed = v.fold(self, seed) }
357
- end
358
- if obj.directives
359
- obj.directives.each { |v| seed = v.fold(self, seed) }
360
- end
361
- if obj.fields_definition
362
- obj.fields_definition.each { |v| seed = v.fold(self, seed) }
363
- 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
364
367
  seed
365
368
  end
369
+
366
370
  def handle_interface_type_definition obj, seed
367
- if obj.directives
368
- obj.directives.each { |v| seed = v.fold(self, seed) }
369
- end
370
- if obj.fields_definition
371
- obj.fields_definition.each { |v| seed = v.fold(self, seed) }
372
- 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
373
374
  seed
374
375
  end
376
+
375
377
  def handle_union_type_definition obj, seed
376
- if obj.directives
377
- obj.directives.each { |v| seed = v.fold(self, seed) }
378
- end
379
- if obj.union_member_types
380
- obj.union_member_types.each { |v| seed = v.fold(self, seed) }
381
- 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
382
381
  seed
383
382
  end
383
+
384
384
  def handle_scalar_type_definition obj, seed
385
- if obj.directives
386
- obj.directives.each { |v| seed = v.fold(self, seed) }
387
- end
385
+ seed = obj.description.fold(self, seed) if obj.description
386
+ obj.directives.each { |v| seed = v.fold(self, seed) } if obj.directives
388
387
  seed
389
388
  end
389
+
390
390
  def handle_enum_value_definition obj, seed
391
- seed = obj.enum_value.fold self, seed
392
- if obj.directives
393
- obj.directives.each { |v| seed = v.fold(self, seed) }
394
- 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
395
394
  seed
396
395
  end
396
+
397
397
  def handle_enum_type_definition obj, seed
398
- if obj.directives
399
- obj.directives.each { |v| seed = v.fold(self, seed) }
400
- end
401
- if obj.enum_value_definition
402
- obj.enum_value_definition.each { |v| seed = v.fold(self, seed) }
403
- 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
404
401
  seed
405
402
  end
403
+
406
404
  def handle_input_object_type_definition obj, seed
407
- if obj.directives
408
- obj.directives.each { |v| seed = v.fold(self, seed) }
409
- end
410
- if obj.input_fields_definition
411
- obj.input_fields_definition.each { |v| seed = v.fold(self, seed) }
412
- 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
413
408
  seed
414
409
  end
410
+
415
411
  def handle_object_type_extension obj, seed
416
- if obj.implements_interfaces
417
- obj.implements_interfaces.each { |v| seed = v.fold(self, seed) }
418
- end
419
- if obj.directives
420
- obj.directives.each { |v| seed = v.fold(self, seed) }
421
- end
422
- if obj.fields_definition
423
- obj.fields_definition.each { |v| seed = v.fold(self, seed) }
424
- 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
425
415
  seed
426
416
  end
417
+
427
418
  def handle_executable_directive_location obj, seed
428
419
  seed
429
420
  end
421
+
430
422
  def handle_type_system_directive_location obj, seed
431
423
  seed
432
424
  end
425
+
433
426
  def handle_directive_definition obj, seed
434
- if obj.arguments_definition
435
- obj.arguments_definition.each { |v| seed = v.fold(self, seed) }
436
- end
437
- 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
438
435
  seed
439
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
+
440
463
  end
441
464
  end
442
465
  end