graphlyte 0.1.5 → 0.2.2

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: e9b09edacd482f9beb267eed78593bc26f5f0563648399f60fec47d1552052eb
4
- data.tar.gz: 39756650800195570dc38a7f7990e0b0efc001033045d6865f16b275749d3de5
3
+ metadata.gz: 25e9370260ac88d2a810c879bf663c4965340c6838e8e19b18f19309d81ffec1
4
+ data.tar.gz: dc7c5ba7909fb9f4615021e07e819771f66a0d73ba8cc5772928cb896808b2e8
5
5
  SHA512:
6
- metadata.gz: e084fd25d75112d2d97a994c63259d436a684e6880a8ea9ef47a56337012f78615bdeb89cb03a39603bdbb5dabd30c07e8b0167f46facae650a990f11dba4377
7
- data.tar.gz: 88cd8dd425fc74a8707b203683d76b5d168649b979708deffcec92f867c569a4f465ea0c30350ce9caa459c5b9ba667835f9e7ada7e9df4bee85b19bce7dda7b
6
+ metadata.gz: 77b742ef11daf4270c22e9ede3ae848dfb0d81a6ad4717c7a6a75ffa88ecf9f688630aa1348d7b8092d0096314596ccef9a34d95ef87486f2292481795763669
7
+ data.tar.gz: 53c19eab7a95e2ee2b4d5f2d9412560035c511c5be12bc8af443cad6f742aea36aa34ffffc5242cc58fe9ab685f0465f1e67344905f5baadd196a4b0552148d2
@@ -16,6 +16,7 @@ module Graphlyte
16
16
  values&.each do |key, value|
17
17
  if value.is_a?(Set)
18
18
  variables.concat extract_variables(value.values)
19
+ elsif value.is_a?(Array)
19
20
  elsif value.symbol?
20
21
  variables << value
21
22
  elsif value.formal?
@@ -60,12 +61,20 @@ module Graphlyte
60
61
  data.inject({}) do |memo, (k, v)|
61
62
  if v.is_a?(Array)
62
63
  memo[k] = v.map do |item|
63
- Value.new(item)
64
+ if item.is_a?(Value)
65
+ item
66
+ else
67
+ Value.new(item)
68
+ end
64
69
  end
65
70
  elsif v.is_a?(Hash)
66
71
  memo[k] = Set.new(v)
67
72
  else
68
- memo[k] = Value.new(v)
73
+ if v.is_a?(Value)
74
+ memo[k] = v
75
+ else
76
+ memo[k] = Value.new(v)
77
+ end
69
78
  end
70
79
  memo
71
80
  end
@@ -4,11 +4,17 @@ module Graphlyte
4
4
  class Value
5
5
  using Refinements::StringRefinement
6
6
 
7
- attr_reader :value
7
+ attr_reader :value, :default
8
8
 
9
- def initialize(value)
9
+ def initialize(value, default = nil)
10
10
  raise ArgumentError, "Hash not allowed in this context" if value.is_a? Hash
11
- @value = value
11
+ if value.is_a?(Value)
12
+ @value = value.value
13
+ @default = value.default
14
+ else
15
+ @value = value
16
+ @default = default
17
+ end
12
18
  end
13
19
 
14
20
  def symbol?
@@ -17,7 +17,7 @@ module Graphlyte
17
17
  end
18
18
 
19
19
  def method_missing(method, fieldset_or_hargs=nil, hargs={}, &block)
20
- # todo: camel case method
20
+ # todo: camel case method
21
21
 
22
22
  # hack for ruby bug in lower versions
23
23
  if [Fieldset, Fragment].include?(fieldset_or_hargs.class)
@@ -31,6 +31,10 @@ module Graphlyte
31
31
  field
32
32
  end
33
33
 
34
+ def respond_to_missing
35
+ true
36
+ end
37
+
34
38
  # for internal use only
35
39
  def >>
36
40
  @fields
@@ -1,25 +1,36 @@
1
1
  require_relative "./refinements/string_refinement"
2
+ require "json"
2
3
  module Graphlyte
3
4
  class Query < Fieldset
4
5
  using Refinements::StringRefinement
5
- attr_reader :name
6
+ attr_reader :name, :type
6
7
 
7
- def initialize(query_name=nil, **hargs)
8
- @name = query_name
8
+ def initialize(query_name=nil, type=:query, **hargs)
9
+ @name = query_name || "anonymousQuery"
10
+ @type = type
9
11
  super(**hargs)
10
12
  end
11
13
 
12
14
  def placeholders
13
15
  flatten_variables(builder.>>).map do |value|
14
- ":#{value.value.placeholder} of #{value.value.name}"
16
+ unless value.formal?
17
+ str = ":#{value.value.to_sym.inspect} of unknown"
18
+ else
19
+ str = ":#{value.value.placeholder} of #{value.value.name}"
20
+ end
21
+
22
+ if value.default
23
+ str += " with default #{value.default.to_s}"
24
+ end
25
+ str
15
26
  end.join("\n")
16
27
  end
17
28
 
18
- def to_json(name="anonymousQuery", **hargs)
19
- variables = flatten_variables(builder.>>)
29
+ def to_json(query_name=name, **hargs)
30
+ variables = flatten_variables(builder.>>).uniq { |v| v.value }
20
31
  types = merge_variable_types(variables, hargs)
21
32
 
22
- str = "query #{name}"
33
+ str = "#{type} #{query_name}"
23
34
  unless types.empty?
24
35
  type_new = types.map do |type_arr|
25
36
  "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"
@@ -0,0 +1,520 @@
1
+ require "strscan"
2
+ require_relative "../fieldset"
3
+ require_relative "../query"
4
+ require_relative "../fragment"
5
+ require_relative "../schema_query"
6
+ require_relative "../types"
7
+
8
+ module Graphlyte
9
+ module Schema
10
+ module ParserHelpers
11
+ def parse_fields
12
+ fields = repeat(:parse_field)
13
+ fields
14
+ end
15
+
16
+ def parse_field
17
+ alias_field = expect(:ALIAS)
18
+ if token = expect(:FRAGMENT_REF)
19
+ raise "Can't find fragment #{token[0][1]}" unless fragments_dictionary[token[0][1]]
20
+ fragments_dictionary[token[0][1]]
21
+ elsif field = expect(:FIELD_NAME)
22
+ args = parse_args
23
+ if fieldset = parse_fieldset
24
+ need(:END_FIELD)
25
+ field = Field.new(field[0][1], fieldset, args)
26
+ else
27
+ field = Field.new(field[0][1], Fieldset.empty, args)
28
+ end
29
+
30
+ if alias_field
31
+ field.alias(alias_field[0][1])
32
+ end
33
+
34
+ field
35
+ end
36
+ end
37
+
38
+ def parse_fieldset
39
+ if expect(:START_FIELD)
40
+ fields = parse_fields
41
+ Fieldset.new(builder: Builder.new(fields))
42
+ end
43
+ end
44
+
45
+ def parse_args
46
+ if expect(:START_ARGS)
47
+ args = repeat(:parse_arg).inject(&:merge)
48
+ need(:END_ARGS)
49
+ args
50
+ end
51
+ end
52
+
53
+ def parse_default
54
+ if expect(:START_DEFAULT_VALUE)
55
+ value = parse_value
56
+ need(:END_DEFAULT_VALUE)
57
+ value
58
+ end
59
+ end
60
+
61
+ def parse_arg
62
+ if (token = expect(:ARG_KEY)) && (value = parse_value)
63
+ defaults = parse_default
64
+ key = token[0][1]
65
+ hash = {}
66
+ if [Array, Hash].include?(value.class)
67
+ hash[key] = value
68
+ else
69
+ hash[key] = Graphlyte::Arguments::Value.new(value, defaults)
70
+ end
71
+ hash
72
+ elsif (token = expect(:SPECIAL_ARG_KEY)) && (value = parse_value)
73
+ defaults = parse_default
74
+ @special_args ||= {}
75
+ arg = {}
76
+ if [Array, Hash].include?(value.class)
77
+ arg[token[0][1]] = value
78
+ else
79
+ arg[token[0][1]] = Graphlyte::Arguments::Value.new(value, defaults)
80
+ end
81
+ @special_args.merge!(arg)
82
+ arg
83
+ end
84
+ end
85
+
86
+ def parse_value
87
+ if token = expect(:ARG_NUM_VALUE) || expect(:ARG_STRING_VALUE) || expect(:ARG_BOOL_VALUE) || expect(:ARG_FLOAT_VALUE)
88
+ token[0][1]
89
+ elsif token = expect(:SPECIAL_ARG_REF)
90
+ ref = token[0][1]
91
+ raise "Can't find ref $#{ref}" unless @special_args[ref]
92
+ value = @special_args[ref]
93
+ Arguments::Value.new(Graphlyte::TYPES.send(value.value, ref.to_sym), value.default)
94
+ elsif token = expect(:SPECIAL_ARG_VAL)
95
+ token[0][1]
96
+ elsif token = expect(:ARG_HASH_START)
97
+ parse_arg_hash
98
+ elsif expect(:ARG_ARRAY_START)
99
+ parse_arg_array
100
+ end
101
+ end
102
+
103
+ def parse_arg_array
104
+ args = repeat(:parse_value)
105
+ need(:ARG_ARRAY_END)
106
+ args
107
+ end
108
+
109
+ def parse_arg_hash
110
+ if (key = expect(:ARG_KEY)) && (value = parse_value)
111
+ need(:ARG_HASH_END)
112
+ hash = {}
113
+ hash[key[0][1]] = value
114
+ hash
115
+ end
116
+ end
117
+
118
+ def repeat(method)
119
+ results = []
120
+
121
+ while result = send(method)
122
+ results << result
123
+ end
124
+
125
+ results
126
+ end
127
+
128
+ def expect(*expected_tokens)
129
+ upcoming = tokens[position, expected_tokens.size]
130
+ if upcoming.map(&:first) == expected_tokens
131
+ advance(expected_tokens.size)
132
+ upcoming
133
+ end
134
+ end
135
+
136
+ def need(*required_tokens)
137
+ upcoming = tokens[position, required_tokens.size]
138
+ expect(*required_tokens) or raise "Unexpected tokens. Expected #{required_tokens.inspect} but got #{upcoming.inspect}"
139
+ end
140
+
141
+ def advance(offset = 1)
142
+ @position += offset
143
+ end
144
+
145
+ def sort_fragments(sorted = [], fragments)
146
+ return sorted if !fragments || fragments.empty?
147
+ fragment_tokens = fragments.shift
148
+
149
+ current_ref = fragment_tokens.find do |token|
150
+ token[0] == :FRAGMENT_REF
151
+ end
152
+
153
+ if current_ref
154
+ exists = sorted.any? do |frags|
155
+ frags.find do |el|
156
+ el[0] == :START_FRAGMENT && el[1] == current_ref[1]
157
+ end
158
+ end
159
+ if exists
160
+ sorted << fragment_tokens
161
+ sort_fragments(sorted, fragments)
162
+ else
163
+ fragments.push fragment_tokens
164
+ sort_fragments(sorted, fragments)
165
+ end
166
+ else
167
+ sorted << fragment_tokens
168
+ sort_fragments(sorted, fragments)
169
+ end
170
+ end
171
+
172
+ def take_fragments
173
+ aggregate = @tokens.inject({taking: false, idx: 0, fragments: []}) do |memo, token_arr|
174
+ if token_arr[0] == :END_FRAGMENT
175
+ memo[:fragments][memo[:idx]] << token_arr
176
+ memo[:taking] = false
177
+ memo[:idx] += 1
178
+ elsif token_arr[0] === :START_FRAGMENT
179
+ memo[:fragments][memo[:idx]] = [token_arr]
180
+ memo[:taking] = true
181
+ elsif memo[:taking]
182
+ memo[:fragments][memo[:idx]] << token_arr
183
+ end
184
+ memo
185
+ end
186
+ aggregate[:fragments]
187
+ end
188
+ end
189
+
190
+ class FragmentParser
191
+ attr_reader :tokens, :position, :fragments_dictionary
192
+
193
+ include ParserHelpers
194
+
195
+ def initialize(tokens)
196
+ @tokens = tokens.flatten(1)
197
+ @position = 0
198
+ @fragments_dictionary = {}
199
+ end
200
+
201
+ def parse_fragments
202
+ repeat(:parse_fragment)
203
+ fragments_dictionary
204
+ end
205
+
206
+ def parse_fragment
207
+ if token = expect(:START_FRAGMENT)
208
+ parse_args
209
+ builder = Builder.new parse_fields
210
+ fragment = Fragment.new(token[0][1], token[0][2], builder: builder)
211
+ @fragments_dictionary[token[0][1]] = fragment
212
+ need(:END_FRAGMENT)
213
+ end
214
+ end
215
+ end
216
+
217
+ class Parser
218
+ attr_reader :tokens, :position, :fragments_dictionary
219
+
220
+ include ParserHelpers
221
+
222
+ def self.parse(gql)
223
+ obj = new Lexer.new(gql).tokenize
224
+ obj.parse
225
+ end
226
+
227
+ def initialize(tokens)
228
+ @tokens = tokens
229
+ @fragment_tokens = sort_fragments([], take_fragments)
230
+ @fragments_dictionary = {}
231
+ @fragments_dictionary = @fragment_tokens.any? ? FragmentParser.new(@fragment_tokens).parse_fragments : {}
232
+ @position = 0
233
+ end
234
+
235
+ def parse
236
+ if token = expect(:START_QUERY)
237
+ parse_query(token[0][1])
238
+ elsif token = expect(:START_MUTATION)
239
+ parse_mutation(token[0][1])
240
+ else
241
+ raise "INVALID"
242
+ end
243
+ end
244
+
245
+ def parse_query(name)
246
+ parse_args
247
+ builder = Builder.new parse_fields
248
+ query = Query.new(name, :query, builder: builder)
249
+ need(:END_QUERY)
250
+ query
251
+ end
252
+
253
+ def parse_mutation(name)
254
+ builder = Builder.new parse_fields
255
+ mutation = Query.new(name, :mutation, builder: builder)
256
+ need(:END_MUTATION)
257
+ mutation
258
+ end
259
+ end
260
+
261
+ class Lexer
262
+ attr_reader :stack, :scanner
263
+
264
+ def initialize(gql, scanner: StringScanner.new(gql))
265
+ @original_string = gql
266
+ @scanner = scanner
267
+ @tokens = []
268
+ end
269
+
270
+ SPECIAL_ARG_REGEX = /^\s*(?:(?<![\"\{]))([\w\!\[\]]+)(?:(?![\"\}]))/
271
+ SIMPLE_EXPRESSION = /(query|mutation|fragment)\s*\w+\s*on\w*.*\{\s*\n*[.|\w\s]*\}/
272
+ START_MAP = {
273
+ 'query' => :START_QUERY,
274
+ 'mutation' => :START_MUTATION,
275
+ 'fragment' => :START_FRAGMENT
276
+ }
277
+
278
+ def tokenize
279
+ until scanner.eos?
280
+ case state
281
+ when :default
282
+ if scanner.scan /^query (\w+)/
283
+ @tokens << [:START_QUERY, scanner[1]]
284
+ push_state :query
285
+ elsif scanner.scan /^mutation (\w+)/
286
+ @tokens << [:START_MUTATION, scanner[1]]
287
+ push_state :mutation
288
+ elsif scanner.scan /\s*fragment\s*(\w+)\s*on\s*(\w+)/
289
+ @tokens << [:START_FRAGMENT, scanner[1], scanner[2]]
290
+ push_state :fragment
291
+ elsif scanner.scan /\s*{\s*/
292
+ @tokens << [:START_FIELD]
293
+ push_state :field
294
+ elsif scanner.scan /\s*}\s*/
295
+ @tokens << [:END_EXPRESSION_SHOULDNT_GET_THIS]
296
+ else
297
+ advance
298
+ end
299
+ when :fragment
300
+ if scanner.scan /\s*\}\s*/
301
+ @tokens << [:END_FRAGMENT]
302
+ pop_state
303
+ pop_context
304
+ elsif scanner.check /^\s*\{\s*/
305
+ if get_context == :field
306
+ push_state :field
307
+ push_context :field
308
+ else
309
+ scanner.scan /^\s*\{\s*/
310
+ push_context :field
311
+ end
312
+ else
313
+ handle_field
314
+ end
315
+ when :mutation
316
+ if scanner.scan /\}/
317
+ @tokens << [:END_MUTATION]
318
+ pop_state
319
+ pop_context
320
+ elsif scanner.check /^\s*\{\s*$/
321
+ if get_context == :field
322
+ push_state :field
323
+ else
324
+ scanner.scan /^\s*\{\s*$/
325
+ push_context :field
326
+ end
327
+ else
328
+ handle_field
329
+ end
330
+ when :query
331
+ if scanner.scan /\s*\}\s*/
332
+ @tokens << [:END_QUERY]
333
+ pop_state
334
+ pop_context
335
+ elsif scanner.check /^\s*\{\s*/
336
+ if get_context == :field
337
+ push_state :field
338
+ push_context :field
339
+ else
340
+ scanner.scan /^\s*\{\s*/
341
+ push_context :field
342
+ end
343
+ else
344
+ handle_field
345
+ end
346
+ when :field
347
+ if scanner.check /\s*\}\s*/
348
+ if get_context == :field
349
+ scanner.scan /\s*\}\s*/
350
+ @tokens << [:END_FIELD]
351
+ pop_state
352
+ else
353
+ pop_state
354
+ end
355
+ else
356
+ handle_field
357
+ end
358
+ when :hash_arguments
359
+ handle_hash_arguments
360
+ when :array_arguments
361
+ handle_array_arguments
362
+ when :arguments
363
+ if scanner.scan /\s*\)\s*/
364
+ @tokens << [:END_ARGS]
365
+ pop_state
366
+ elsif scanner.scan /\=/
367
+ @tokens << [:START_DEFAULT_VALUE]
368
+ push_state :argument_defaults
369
+ elsif scanner.scan /,/
370
+ #
371
+ else
372
+ handle_shared_arguments
373
+ end
374
+ when :argument_defaults
375
+ if @stack.reverse.take(2).eql?([:argument_defaults, :argument_defaults])
376
+ @tokens << [:END_DEFAULT_VALUE]
377
+ pop_state
378
+ pop_state
379
+ else
380
+ push_state :argument_defaults
381
+ handle_shared_arguments
382
+ end
383
+ when :special_args
384
+ handle_special_args
385
+ end
386
+ end
387
+ @tokens
388
+ end
389
+
390
+ private
391
+
392
+ def handle_field
393
+ if scanner.scan /\s*\{\s*/
394
+ @context = :field
395
+ @tokens << [:START_FIELD]
396
+ push_state :field
397
+ elsif scanner.check /\.{3}(\w+)\s*\}/
398
+ scanner.scan /\.{3}(\w+)/
399
+ @tokens << [:FRAGMENT_REF, scanner[1]]
400
+ pop_context
401
+ # we need to pop state if we are nested in a field, and not in the query context
402
+ pop_state if get_context == :field
403
+ elsif scanner.scan /\.{3}(\w+)/
404
+ @tokens << [:FRAGMENT_REF, scanner[1]]
405
+ elsif scanner.scan /\s*(\w+):\s*/
406
+ @tokens << [:ALIAS, scanner[1]]
407
+ elsif scanner.check /\s*(\w+)\s*\}/
408
+ scanner.scan /\s*(\w+)\s*/
409
+ @tokens << [:FIELD_NAME, scanner[1]]
410
+ pop_context
411
+ # we need to pop state if we are nested in a field, and not in the query context
412
+ pop_state if get_context == :field
413
+ elsif scanner.scan /\s*(\w+)\s*/
414
+ @tokens << [:FIELD_NAME, scanner[1]]
415
+ elsif scanner.scan /^\s*\(/
416
+ @tokens << [:START_ARGS]
417
+ push_state :arguments
418
+ else
419
+ advance
420
+ end
421
+ end
422
+
423
+ def handle_shared_arguments
424
+ if scanner.scan /^(\w+):/
425
+ @tokens << [:ARG_KEY, scanner[1]]
426
+ elsif scanner.scan /^\s*\{\s*?/
427
+ @tokens << [:ARG_HASH_START]
428
+ push_state :hash_arguments
429
+ elsif scanner.scan /\s*\[\s*/
430
+ @tokens << [:ARG_ARRAY_START]
431
+ push_state :array_arguments
432
+ elsif scanner.scan /\s?\"([\w\s]+)\"/
433
+ @tokens << [:ARG_STRING_VALUE, scanner[1]]
434
+ elsif scanner.scan /\s?(\d+\.\d+)/
435
+ @tokens << [:ARG_FLOAT_VALUE, scanner[1].to_f]
436
+ elsif scanner.scan /\s?(\d+)/
437
+ @tokens << [:ARG_NUM_VALUE, scanner[1].to_i]
438
+ elsif scanner.scan /\s?(true|false)\s?/
439
+ bool = scanner[1] == "true"
440
+ @tokens << [:ARG_BOOL_VALUE, bool]
441
+ elsif scanner.scan /\$(\w+):/
442
+ @tokens << [:SPECIAL_ARG_KEY, scanner[1]]
443
+ push_state :special_args
444
+ elsif scanner.scan /\$(\w+)/
445
+ @tokens << [:SPECIAL_ARG_REF, scanner[1]]
446
+ else
447
+ advance
448
+ end
449
+ end
450
+
451
+ def handle_special_args
452
+ if scanner.check SPECIAL_ARG_REGEX
453
+ scanner.scan SPECIAL_ARG_REGEX
454
+ @tokens << [:SPECIAL_ARG_VAL, scanner[1]]
455
+ pop_state
456
+ else
457
+ pop_state
458
+ end
459
+ end
460
+
461
+ def handle_hash_arguments
462
+ if scanner.scan /\}/
463
+ @tokens << [:ARG_HASH_END]
464
+ pop_state
465
+ else
466
+ handle_shared_arguments
467
+ end
468
+ end
469
+
470
+ def handle_array_arguments
471
+ if scanner.scan /\s*\]\s*/
472
+ @tokens << [:ARG_ARRAY_END]
473
+ pop_state
474
+ else
475
+ handle_shared_arguments
476
+ end
477
+ end
478
+
479
+ def env
480
+ @ctx ||= []
481
+ end
482
+
483
+ def get_context
484
+ env.last || :default
485
+ end
486
+
487
+ def push_context(context)
488
+ env << context
489
+ end
490
+
491
+ def pop_context
492
+ env.pop
493
+ end
494
+
495
+ def rewind
496
+ scanner.pos = scanner.pos - 1
497
+ end
498
+
499
+ def advance
500
+ scanner.pos = scanner.pos + 1
501
+ end
502
+
503
+ def stack
504
+ @stack ||= []
505
+ end
506
+
507
+ def state
508
+ stack.last || :default
509
+ end
510
+
511
+ def push_state(state)
512
+ stack << state
513
+ end
514
+
515
+ def pop_state
516
+ stack.pop
517
+ end
518
+ end
519
+ end
520
+ end
data/lib/graphlyte.rb CHANGED
@@ -4,14 +4,23 @@ require_relative "./graphlyte/query"
4
4
  require_relative "./graphlyte/fragment"
5
5
  require_relative "./graphlyte/schema_query"
6
6
  require_relative "./graphlyte/types"
7
+ require_relative "./graphlyte/schema/parser"
7
8
 
8
9
  module Graphlyte
9
10
  extend SchemaQuery
10
11
 
11
12
  TYPES = Types.new
12
13
 
14
+ def self.parse(gql)
15
+ Graphlyte::Schema::Parser.parse(gql)
16
+ end
17
+
13
18
  def self.query(name = nil, &block)
14
- Query.new(name, builder: build(&block))
19
+ Query.new(name, :query, builder: build(&block))
20
+ end
21
+
22
+ def self.mutation(name = nil, &block)
23
+ Query.new(name, :mutation, builder: build(&block))
15
24
  end
16
25
 
17
26
  def self.fragment(fragment_name, model_name, &block)
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: graphlyte
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.5
4
+ version: 0.2.2
5
5
  platform: ruby
6
6
  authors:
7
7
  - Sean Gregory
8
- autorequire:
8
+ autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2021-08-14 00:00:00.000000000 Z
11
+ date: 2021-11-21 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rspec
@@ -53,6 +53,7 @@ files:
53
53
  - lib/graphlyte/fragment.rb
54
54
  - lib/graphlyte/query.rb
55
55
  - lib/graphlyte/refinements/string_refinement.rb
56
+ - lib/graphlyte/schema/parser.rb
56
57
  - lib/graphlyte/schema/types/base.rb
57
58
  - lib/graphlyte/schema_query.rb
58
59
  - lib/graphlyte/types.rb
@@ -60,8 +61,8 @@ homepage: https://rubygems.org/gems/graphlyte
60
61
  licenses:
61
62
  - MIT
62
63
  metadata:
63
- source_code_uri: https://github.com/skinnyjames/graphlyte
64
- post_install_message:
64
+ source_code_uri: https://gitlab.com/seanchristophergregory/graphlyte
65
+ post_install_message:
65
66
  rdoc_options: []
66
67
  require_paths:
67
68
  - lib
@@ -76,8 +77,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
76
77
  - !ruby/object:Gem::Version
77
78
  version: '0'
78
79
  requirements: []
79
- rubygems_version: 3.2.3
80
- signing_key:
80
+ rubygems_version: 3.2.31
81
+ signing_key:
81
82
  specification_version: 4
82
83
  summary: craft graphql queries with ruby
83
84
  test_files: []