rails-graphql 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d610a5ff87d748320cba5705f819c0832146a28be41ffdfe9ebd8d13772b7326
-  data.tar.gz: 390b994294e6f7ee5f51feadb8dc0102d4d79816d90615b25ca46994bb62e66a
+  metadata.gz: 7ad5286d59309dafbc0ec0185c4b5c154bbccb7db15cfdb7831b78125212318c
+  data.tar.gz: 797b52a24b9f9a38167846cc08bc0e50a8728b5bc85041df5d2b81d6208f22f4
 SHA512:
-  metadata.gz: 738aab60ab153f08f180909a89577cc802c9171b1199763a540094aaf16ebe3169a0a75a49a5de0124383b555ab40d39448201031e71d0caa8ea52b1bc132229
-  data.tar.gz: 4f41e879a2501cbca1c1826c0c5e620e3506f156a4bcc4529d342dc9383109efdd33a25201b4959382967a73b6af29db29328db2ea30c31aa0d411c2c446c5c5
+  metadata.gz: de92336e813d1b4e12b4399475c6ae7d7bb7eec21a59d33a8f8a7701f82a657575df19113d239e502a2ea642dce90c664433d2f7020367d4c735129eac41ab61
+  data.tar.gz: 8739f94bf779f65df7db592641c31aad9493d6ed57ac104391341271af127a90c280de366857822fa73a1025b22bd6ddc8c98b2280baaa1e7832b86f622a93cc

data/ext/gql_parser.c

@@ -83,7 +83,7 @@ VALUE gql_parse_execution(VALUE self, VALUE document)
   {
     // Try to upgrade if the token is a name
     if (scanner.lexeme == gql_i_name)
-      scanner.lexeme = gql_name_to_keyword(&scanner, GQL_EXECUTION_KEYWORDS);
+      scanner.lexeme = GQL_SAFE_NAME_TO_KEYWORD(&scanner, GQL_EXECUTION_KEYWORDS);
 
     // It can contain either operations or fragments, anything else is unknown and an error
     if (QGL_I_OPERATION(scanner.lexeme) || scanner.lexeme == gql_is_op_curly)
@@ -157,14 +157,14 @@ VALUE gql_parse_fragment(struct gql_scanner *scanner)
   gql_next_lexeme_no_comments(scanner);
   if (scanner->lexeme != gql_i_name)
     return gql_nil_and_unknown(scanner);
-  else if (gql_name_to_keyword(scanner, GQL_EXECUTION_KEYWORDS) == gql_ie_on)
+  else if (GQL_SAFE_NAME_TO_KEYWORD(scanner, GQL_EXECUTION_KEYWORDS) == gql_ie_on)
     return gql_nil_and_unknown(scanner);
 
   // Save the name of the fragment
   GQL_ASSIGN_TOKEN_AND_NEXT(pieces[0], scanner);
 
   // If we don't have an "on" next, we have a problem
-  if (gql_name_to_keyword(scanner, GQL_EXECUTION_KEYWORDS) != gql_ie_on)
+  if (GQL_SAFE_NAME_TO_KEYWORD(scanner, GQL_EXECUTION_KEYWORDS) != gql_ie_on)
     return gql_nil_and_unknown(scanner);
 
   // Skip the on and ensure that next is a name
@@ -481,7 +481,7 @@ VALUE gql_parse_spread(struct gql_scanner *scanner)
   if (scanner->lexeme == gql_i_name)
   {
     // Upgrade the name because it will decide if it is an inline spread or not
-    scanner->lexeme = gql_name_to_keyword(scanner, GQL_EXECUTION_KEYWORDS);
+    scanner->lexeme = GQL_SAFE_NAME_TO_KEYWORD(scanner, GQL_EXECUTION_KEYWORDS);
 
     // If we are at "on" then we have an inline spread, otherwise a fragment referenced by name
     if (scanner->lexeme == gql_ie_on)

data/ext/shared.c

@@ -65,16 +65,17 @@ enum gql_lexeme gql_upgrade_basis(const char *upgrade_from[])
 }
 
 // This checks if the identifier in the scanner should be upgraded to a keyword
-enum gql_lexeme gql_name_to_keyword(struct gql_scanner *scanner, const char *upgrade_from[])
+enum gql_lexeme gql_name_to_keyword(struct gql_scanner *scanner, const char *keywords[], unsigned int size)
 {
   unsigned long pos, len = GQL_SCAN_SIZE(scanner);
-  unsigned int valid = 0, i = 0;
+  unsigned int valid = 0;
   const char *keyword;
 
   // Check until it finds the end of the array
-  while ((keyword = upgrade_from[i]) != 0)
+  for (size_t i = 0; i < size; ++i)
   {
     // Move ot the next item and check the current for different size
+    keyword = keywords[i];
     if(strlen(keyword) == len)
     {
       // We cannot use the normal strcomp because we are comparing a mid part of the string
@@ -85,11 +86,8 @@ enum gql_lexeme gql_name_to_keyword(struct gql_scanner *scanner, const char *upg
       }
 
       // Only return if valid was kept as true
-      if (valid == 1) return gql_upgrade_basis(upgrade_from) + i;
+      if (valid == 1) return gql_upgrade_basis(keywords) + i;
     }
-
-    // Move to the next index
-    i++;
   }
 
   // Return name if was not able to upgrade to a keyword
@@ -438,7 +436,7 @@ VALUE gql_value_to_rb(struct gql_scanner *scanner, int accept_var)
   // If it's a name, then it can be a keyword or a enum value
   if (scanner->lexeme == gql_i_name)
   {
-    scanner->lexeme = gql_name_to_keyword(scanner, GQL_VALUE_KEYWORDS);
+    scanner->lexeme = GQL_SAFE_NAME_TO_KEYWORD(scanner, GQL_VALUE_KEYWORDS);
     if (scanner->lexeme == gql_iv_true)
       return Qtrue;
     else if (scanner->lexeme == gql_iv_false)

data/ext/shared.h

@@ -70,6 +70,10 @@
   rb_ary_push(source, value);           \
 })
 
+#define GQL_SAFE_NAME_TO_KEYWORD(scanner, source) ({                        \
+  gql_name_to_keyword(scanner, source, (sizeof(source) / sizeof(char *))); \
+})
+
 enum gql_lexeme
 {
   // Basic identifiers
@@ -153,7 +157,7 @@ void gql_debug_print(const char *message);
 struct gql_scanner gql_new_scanner(VALUE source);
 
 enum gql_lexeme gql_upgrade_basis(const char *upgrade_from[]);
-enum gql_lexeme gql_name_to_keyword(struct gql_scanner *scanner, const char *upgrade_from[]);
+enum gql_lexeme gql_name_to_keyword(struct gql_scanner *scanner, const char *keywords[], unsigned int size);
 
 enum gql_lexeme gql_read_name(struct gql_scanner *scanner);
 enum gql_lexeme gql_read_comment(struct gql_scanner *scanner);

data/lib/rails/graphql/alternative/field_set.rb

@@ -12,7 +12,7 @@ module Rails
 
         include Helpers::Instantiable
 
-        self.field_type = Field::OutputField
+        self.field_type = GraphQL::Field::OutputField
         self.valid_field_types = Type::Object.valid_field_types
 
         def self.i18n_scope
@@ -33,7 +33,7 @@ module Rails
       #
       # Same as a +FieldSet+ but for mutation fields
       MutationSet = Class.new(FieldSet)
-      MutationSet.field_type = Field::MutationField
+      MutationSet.field_type = GraphQL::Field::MutationField
       MutationSet.redefine_singleton_method(:i18n_scope) { :mutation }
 
 
@@ -41,7 +41,7 @@ module Rails
       #
       # Same as a +FieldSet+ but for subscription fields
       SubscriptionSet = Class.new(FieldSet)
-      SubscriptionSet.field_type = Field::SubscriptionField
+      SubscriptionSet.field_type = GraphQL::Field::SubscriptionField
       SubscriptionSet.redefine_singleton_method(:i18n_scope) { :subscription }
     end
   end

data/lib/rails/graphql/alternative/query.rb

@@ -52,7 +52,7 @@ module Rails
           def define_field(field_name = nil, type = :any, **xargs, &block)
             field_name ||= anonymous? ? '_anonymous' : begin
               type_module = type_field_class.to_s.classify.pluralize
-              user_name = name.split(+"#{type_module}::")[1]
+              user_name = name.split(+"#{type_module}::")&.at(1)
               user_name ||= name.delete_prefix('GraphQL::')
               user_name.tr(':', '')
             end

data/lib/rails/graphql/alternative.rb

@@ -16,6 +16,7 @@ module Rails
 
       autoload_at "#{__dir__}/alternative/field_set" do
         autoload :FieldSet
+        autoload :QuerySet
         autoload :MutationSet
         autoload :SubscriptionSet
       end

data/lib/rails/graphql/helpers/with_fields.rb

@@ -137,19 +137,19 @@ module Rails
         def import(source)
           # Import an alternative declaration of a field
           if source.is_a?(Module) && source <= Alternative::Query
-            return proxy_field(type, source.field)
+            return proxy_field(source.field)
           end
 
           case source
           when Array
             # Import a list of fields
-            source.each { |field| proxy_field(type, field) }
+            source.each { |field| proxy_field(field) }
           when Hash, Concurrent::Map
             # Import a keyed list of fields
-            source.each_value { |field| proxy_field(type, field) }
+            source.each_value { |field| proxy_field(field) }
           when Helpers::WithFields
             # Import a set of fields
-            source.fields.each_value { |field| proxy_field(type, field) }
+            source.fields.each_value { |field| proxy_field(field) }
           else
             return if GraphQL.config.silence_import_warnings
             GraphQL.logger.warn(+"Unable to import #{source.inspect} into #{self.name}.")

data/lib/rails/graphql/railtie.rb

@@ -29,13 +29,9 @@ module Rails
       # Ensure a valid logger
       initializer 'graphql.logger' do |app|
         ActiveSupport.on_load(:graphql) do
-          return if config.logger.present?
-
-          logger = ::Rails.logger
-          if logger.respond_to?(:tagged)
-            config.logger = logger
-          else
-            config.logger = ActiveSupport::TaggedLogging.new(logger)
+          config.logger ||= begin
+            logger = ::Rails.logger
+            logger.respond_to?(:tagged) ? logger : ActiveSupport::TaggedLogging.new(logger)
           end
         end
       end

data/lib/rails/graphql/version.rb

@@ -14,7 +14,7 @@ module Rails
     module VERSION
       MAJOR = 1
       MINOR = 0
-      TINY  = 1
+      TINY  = 3
       PRE   = nil
 
       STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/test/assets/alternative.gql

@@ -0,0 +1,323 @@
+schema {
+  query: _Query
+  mutation: _Mutation
+}
+
+"The Boolean scalar type represents true or false."
+scalar Boolean
+
+"The Float scalar type represents signed double-precision fractional values."
+scalar Float
+
+"""
+The ID scalar type represents a unique identifier and it is serialized in the same
+way as a String but it accepts both numeric and string based values as input.
+"""
+scalar ID
+
+"The Int scalar type represents a signed 32-bit numeric non-fractional value."
+scalar Int
+
+"""
+The String scalar type represents textual data, represented as UTF-8 character
+sequences.
+"""
+scalar String
+
+"The valid locations that a directive may be placed."
+enum __DirectiveLocation {
+  "Mark as a executable directive usable on query objects."
+  QUERY
+  
+  "Mark as a executable directive usable on mutation objects."
+  MUTATION
+  
+  "Mark as a executable directive usable on subscription objects."
+  SUBSCRIPTION
+  
+  "Mark as a executable directive usable on field objects."
+  FIELD
+  
+  "Mark as a executable directive usable on fragment definition objects."
+  FRAGMENT_DEFINITION
+  
+  "Mark as a executable directive usable on fragment spread objects."
+  FRAGMENT_SPREAD
+  
+  "Mark as a executable directive usable on inline fragment objects."
+  INLINE_FRAGMENT
+  
+  "Mark as a type system directive usable on schema definitions."
+  SCHEMA
+  
+  "Mark as a type system directive usable on scalar definitions."
+  SCALAR
+  
+  "Mark as a type system directive usable on object definitions."
+  OBJECT
+  
+  "Mark as a type system directive usable on field definitions."
+  FIELD_DEFINITION
+  
+  "Mark as a type system directive usable on argument definitions."
+  ARGUMENT_DEFINITION
+  
+  "Mark as a type system directive usable on interface definitions."
+  INTERFACE
+  
+  "Mark as a type system directive usable on union definitions."
+  UNION
+  
+  "Mark as a type system directive usable on enum definitions."
+  ENUM
+  
+  "Mark as a type system directive usable on enum value definitions."
+  ENUM_VALUE
+  
+  "Mark as a type system directive usable on input object definitions."
+  INPUT_OBJECT
+  
+  "Mark as a type system directive usable on input field definitions."
+  INPUT_FIELD_DEFINITION
+}
+
+"""
+The fundamental unit of any GraphQL Schema is the type.
+This enum enlist all the valid base types.
+"""
+enum __TypeKind {
+  "Scalar types represent primitive leaf values in a GraphQL type system.\n"
+  SCALAR
+  
+  "Objects represent a list of named fields, each of which yield a value of a\nspecific type.\n"
+  OBJECT
+  
+  "Interfaces represent a list of named fields and their types.\n"
+  INTERFACE
+  
+  "Unions represent an object that could be one of a list of GraphQL Object types.\n"
+  UNION
+  
+  "Enum types, like scalar types, also represent leaf values in a GraphQL\ntype system. However Enum types describe the set of possible values.\n"
+  ENUM
+  
+  "Objects represent a list of named fields, each of which yield a value of\na specific type.\n"
+  INPUT_OBJECT
+  
+  "A GraphQL list is a special collection type which declares the type of\neach item in the List (referred to as the item type of the list).\n"
+  LIST
+  
+  "This type wraps an underlying type, and this type acts identically to that wrapped\ntype, with the exception that null is not a valid response for the wrapping type.\n"
+  NON_NULL
+}
+
+type Sample {
+  sample: String
+}
+
+type _Mutation {
+  sampleMutation: String
+  
+  sampleMutationA: String
+  
+  sampleMutationB: String
+}
+
+type _Query {
+  __schema: __Schema!
+  
+  __type(name: String!): __Type
+  
+  sampleObject: Sample
+  
+  sampleQuery: String
+  
+  sampleQueryA: String
+  
+  sampleQueryB: String
+}
+
+"""
+Directives provide a way to describe alternate runtime execution
+and type validation behavior in a GraphQL document.
+
+In some cases, you need to provide options to alter GraphQL's execution
+behavior in ways field arguments will not suffice, such as conditionally
+including or skipping a field. Directives provide this by describing
+additional information to the executor.
+"""
+# Assigned to Rails::GraphQL::Directive class
+type __Directive {
+  args: [__InputValue!]!
+  
+  description: String
+  
+  isRepeatable: Boolean!
+  
+  locations: [__DirectiveLocation!]!
+  
+  name: String!
+}
+
+"""
+One of the values of an Enum object. It is unique within the Enum set
+of values. It's a string representation, not a numeric representation,
+of a value kept as all caps (ie. ONE_VALUE).
+"""
+type __EnumValue {
+  deprecationReason: String
+  
+  description: String
+  
+  isDeprecated: Boolean!
+  
+  name: String!
+}
+
+"""
+Fields are the elements that compose both Objects and Interfaces. Each
+field in these other objects may contain arguments and always yields
+a value of a specific type.
+"""
+# Assigned to Rails::GraphQL::Field class
+type __Field {
+  args: [__InputValue!]!
+  
+  deprecationReason: String
+  
+  description: String
+  
+  isDeprecated: Boolean!
+  
+  name: String!
+  
+  type: __Type!
+}
+
+"""
+Arguments provided to Fields or Directives and the input fields of an
+InputObject are represented as Input Values which describe their type
+and optionally a default value.
+"""
+# Assigned to Rails::GraphQL::Field::InputField class
+type __InputValue {
+  defaultValue: String
+  
+  description: String
+  
+  name: String!
+  
+  type: __Type!
+}
+
+"""
+A GraphQL service's collective type system capabilities are referred
+to as that service's "schema". A schema is defined in terms of the
+types and directives it supports as well as the root operation types
+for each kind of operation: query, mutation, and subscription; this
+determines the place in the type system where those operations begin.
+"""
+# Assigned to Rails::GraphQL::Schema class
+type __Schema {
+  directives: [__Directive!]!
+  
+  mutationType: __Type
+  
+  queryType: __Type!
+  
+  subscriptionType: __Type
+  
+  types: [__Type!]!
+}
+
+"""
+The fundamental unit of any GraphQL Schema is the type. There are six
+kinds of named type definitions in GraphQL, and two wrapping types.
+
+The most basic type is a +Scalar+. A scalar represents a primitive value,
+like a string or an integer.
+
++Scalars+ and +Enums+ form the leaves in response trees; the intermediate
+levels are +Object+ types, which define a set of fields.
+
+An +Interface+ defines a list of fields; +Object+ types that implement
+that interface are guaranteed to implement those fields.
+
+A +Union+ defines a list of possible types; similar to interfaces,
+whenever the type system claims a union will be returned, one of the
+possible types will be returned.
+
+Finally, oftentimes it is useful to provide complex structs as inputs
+to GraphQL field arguments or variables; the +Input Object+ type allows
+the schema to define exactly what data is expected.
+"""
+# Assigned to Rails::GraphQL::Type class
+type __Type {
+  description: String
+  
+  "ENUM only"
+  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+  
+  "OBJECT and INTERFACE only"
+  fields(includeDeprecated: Boolean = false): [__Field!]
+  
+  "INPUT_OBJECT only"
+  inputFields: [__InputValue!]
+  
+  "OBJECT only"
+  interfaces: [__Type!]
+  
+  kind: __TypeKind!
+  
+  name: String
+  
+  "NON_NULL and LIST only"
+  ofType: __Type
+  
+  "INTERFACE and UNION only"
+  possibleTypes: [__Type!]
+  
+  specifiedByURL: String
+}
+
+"""
+Indicate deprecated portions of a GraphQL service's schema, such as deprecated
+fields on a type or deprecated enum values.
+"""
+directive @deprecated(
+
+  """
+  Explain why the underlying element was marked as deprecated. If possible,
+indicate what element should be used instead. This description is formatted
+using Markdown syntax (as specified by [CommonMark](http://commonmark.org/)).
+  """
+  reason: String
+  
+) on FIELD_DEFINITION | ENUM_VALUE
+
+"Allows for conditional inclusion during execution as described by the if argument."
+directive @include(
+
+  "When false, the underlying element will be automatically marked as null."
+  if: Boolean!
+  
+) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+"Allows for conditional exclusion during execution as described by the if argument."
+directive @skip(
+
+  "When true, the underlying element will be automatically marked as null."
+  if: Boolean!
+  
+) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+"""
+A built-in directive used within the type system definition language to provide
+a scalar specification URL for specifying the behavior of custom scalar types.
+"""
+directive @specifiedBy(
+
+  "Point to a human-readable specification of the data format."
+  url: String!
+  
+) on SCALAR

data/test/integration/alternative_test.rb

@@ -0,0 +1,145 @@
+require 'integration/config'
+
+class Integration_AlternativeTest < GraphQL::IntegrationTestCase
+  module Alternatives
+    # A regular field that is imported into an object
+    class SampleField < GraphQL::Field
+      define_field :sample, :string
+
+      def resolve
+        "#{current[:sample]} Resolved"
+      end
+    end
+
+    # A simple query field that can called directly
+    class SampleQuery < GraphQL::Query
+      define_field :sample_query, :string
+
+      def resolve
+        'Sample Query'
+      end
+    end
+
+    # A simple mutation field that can called directly
+    class SampleMutation < GraphQL::Mutation
+      define_field :sample_mutation, :string
+
+      def perform
+        request.extensions['mutation'] = 'Ok!'
+      end
+
+      def resolve
+        'Sample Mutation'
+      end
+    end
+
+    # A set of query fields
+    class SampleQuerySet < GraphQL::QuerySet
+      field :sample_query_a, :string
+      field :sample_query_b, :string
+
+      def sample_query_a
+        'Sample Query A'
+      end
+
+      def sample_query_b
+        'Sample Query B'
+      end
+    end
+
+    # A set of mutation fields
+    class SampleMutationSet < GraphQL::MutationSet
+      field :sample_mutation_a, :string
+      field :sample_mutation_b, :string
+
+      def sample_mutation_a!
+        request.extensions['mutationA'] = 'Ok!'
+      end
+
+      def sample_mutation_a
+        'Sample Mutation A'
+      end
+
+      def sample_mutation_b!
+        request.extensions['mutationB'] = 'Ok!'
+      end
+
+      def sample_mutation_b
+        'Sample Mutation B'
+      end
+    end
+  end
+
+  class SCHEMA < GraphQL::Schema
+    namespace :alternatives
+
+    configure do |config|
+      config.enable_string_collector = false
+      config.default_response_format = :json
+    end
+
+    object 'Sample' do
+      import Alternatives::SampleField
+    end
+
+    query_fields do
+      import Alternatives::SampleQuery
+      import Alternatives::SampleQuerySet
+      field :sample_object, 'Sample'
+    end
+
+    mutation_fields do
+      import Alternatives::SampleMutation
+      import Alternatives::SampleMutationSet
+    end
+
+    def sample_object
+      { sample: 'Sample Field' }
+    end
+  end
+
+  def test_query_object
+    result = { data: { sampleObject: { sample: 'Sample Field Resolved' } } }
+    assert_result(result, '{ sampleObject { sample } }')
+  end
+
+  def test_query_field
+    assert_result({ data: { sampleQuery: 'Sample Query' } }, '{ sampleQuery }')
+  end
+
+  def test_query_field_set
+    assert_result({ data: { sampleQueryA: 'Sample Query A' } }, '{ sampleQueryA }')
+    assert_result({ data: { sampleQueryB: 'Sample Query B' } }, '{ sampleQueryB }')
+
+    result = { data: { sampleQueryA: 'Sample Query A', sampleQueryB: 'Sample Query B' } }
+    assert_result(result, '{ sampleQueryA sampleQueryB }')
+  end
+
+  def test_mutation_field
+    result = { data: { sampleMutation: 'Sample Mutation' }, extensions: { mutation: 'Ok!' } }
+    assert_result(result, 'mutation { sampleMutation }')
+  end
+
+  def test_mutation_field_set
+    result = { data: { sampleMutationA: 'Sample Mutation A' }, extensions: { mutationA: 'Ok!' } }
+    assert_result(result, 'mutation { sampleMutationA }')
+
+    result = { data: { sampleMutationB: 'Sample Mutation B' }, extensions: { mutationB: 'Ok!' } }
+    assert_result(result, 'mutation { sampleMutationB }')
+
+    result = {
+      data: { sampleMutationA: 'Sample Mutation A', sampleMutationB: 'Sample Mutation B' },
+      extensions: { mutationA: 'Ok!', mutationB: 'Ok!' },
+    }
+
+    assert_result(result, 'mutation { sampleMutationA sampleMutationB }')
+  end
+
+  def test_gql_introspection
+    result = SCHEMA.to_gql
+    expected = gql_file('alternative').split('').sort.join.squish
+
+    # File.write('test/assets/alternative.gql', result)
+    assert_equal(expected, result.split('').sort.join.squish)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-graphql
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Carlos Silva
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-04 00:00:00.000000000 Z
+date: 2024-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -339,6 +339,7 @@ files:
 - lib/rails/graphql/type_map.rb
 - lib/rails/graphql/uri.rb
 - lib/rails/graphql/version.rb
+- test/assets/alternative.gql
 - test/assets/en.yml
 - test/assets/introspection-db.json
 - test/assets/introspection-mem.txt
@@ -375,6 +376,7 @@ files:
 - test/graphql/type_map_test.rb
 - test/graphql/type_test.rb
 - test/graphql_test.rb
+- test/integration/alternative_test.rb
 - test/integration/authorization_test.rb
 - test/integration/config.rb
 - test/integration/customization_test.rb
@@ -402,7 +404,7 @@ metadata:
   source_code_uri: https://github.com/virtualshield/rails-graphql
   bug_tracker_uri: https://github.com/virtualshield/rails-graphql/issues
   changelog_uri: https://github.com/virtualshield/rails-graphql/blob/master/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options:
 - "--title"
 - GraphQL server for Rails
@@ -420,10 +422,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.26
-signing_key:
+signing_key: 
 specification_version: 4
 summary: GraphQL meets RoR with the most Ruby-like DSL
 test_files:
+- test/assets/alternative.gql
 - test/assets/en.yml
 - test/assets/introspection-db.json
 - test/assets/introspection-mem.txt
@@ -460,6 +463,7 @@ test_files:
 - test/graphql/type_map_test.rb
 - test/graphql/type_test.rb
 - test/graphql_test.rb
+- test/integration/alternative_test.rb
 - test/integration/authorization_test.rb
 - test/integration/config.rb
 - test/integration/customization_test.rb