graphql-guard 1.3.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbde911695d5151407974b87a6ddd6ab4e02c726685ed35c1c59ad270a541a3c
-  data.tar.gz: 877dfa834f5b5880fe11f020567d55dfda0e8e012e3ea3d6c2a4e8acb9ed6ce7
+  metadata.gz: 7d5d87291a11cec745bf06b4b4ca13362123da9408167d788128393b3283c389
+  data.tar.gz: ad81005c01967b319d6439b36878497917a7bc48d573f4fe9cb3ba1c26e32d05
 SHA512:
-  metadata.gz: 5a485275f3e04a296a2fe0b5362aa8c15ee6002edab671f817758f4540ba05761675532d5b05b0ded05c78c05fd974e44c145085b8237aab59fb3df023e421a1
-  data.tar.gz: 52cade5337f95be53a0200663ecbe039a4026f63d21d54069b243676a65a23c594ada684defe85c194217caae0d1807ca487015196560a75a5fe2eab4adf786a
+  metadata.gz: '095a399709be67e31b09fc1bac0031a28323b173b8b2f4242aebf230fce6044a8bd321c85b0a6a6aa0119f889f7476720d259c6c4dad3904a251cb62dd13073d'
+  data.tar.gz: e573f57903edfe4b6ec5157eea5264423f81cf217d527d0cea73307cc3f95eabda9297295b570e2b6f4576e771340cc973269c2b3636d3f9548d053603ae887d

data/.gitignore

@@ -10,3 +10,4 @@
 
 # rspec failure tracking
 .rspec_status
+.ruby-version

data/.travis.yml

@@ -1,29 +1,11 @@
 sudo: false
 language: ruby
-before_install: gem install bundler -v 1.17.3
-matrix:
-  include:
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.3.8
-    - gemfile: graphql-latest.gemfile
-      env: GRAPHQL_RUBY_VERSION=LATEST CI=true
-      rvm: 2.3.8
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.4.5
-    - gemfile: graphql-latest.gemfile
-      env: GRAPHQL_RUBY_VERSION=LATEST CI=true
-      rvm: 2.4.5
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.5.7
-    - gemfile: graphql-latest.gemfile
-      env: GRAPHQL_RUBY_VERSION=LATEST CI=true
-      rvm: 2.5.7
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.6.5
-    - gemfile: graphql-latest.gemfile
-      env: GRAPHQL_RUBY_VERSION=LATEST CI=true
-      rvm: 2.6.5
+before_install: gem install bundler -v 2.1.4
+rvm:
+  - 2.3.8
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0
+env:
+  - CI=true

data/CHANGELOG.md

@@ -8,10 +8,68 @@ one of the following labels: `Added`, `Changed`, `Deprecated`,
 to manage the versions of this gem so
 that you can set version constraints properly.
 
-#### [Unreleased](https://github.com/exAspArk/graphql-guard/compare/v1.3.0...HEAD)
+#### [Unreleased](https://github.com/exAspArk/graphql-guard/compare/v2.0.0...HEAD)
 
 * WIP
 
+#### [v2.0.0](https://github.com/exAspArk/graphql-guard/compare/v1.3.1...v2.0.0) – 2020-04-20
+
+* `Added`: support for `graphql` gem version `>= 1.10` with `Interpreter`. [#39](https://github.com/exAspArk/graphql-guard/pull/39)
+* `Removed`: support for previous `graphql` gem versions. [#39](https://github.com/exAspArk/graphql-guard/pull/39)
+
+**Breaking changes**:
+
+* Requires using `graphql` gem version `>= 1.10.0` with [Interpreter](https://graphql-ruby.org/queries/interpreter.html).
+
+Before:
+
+```rb
+class Schema < GraphQL::Schema
+  query QueryType
+  mutation MutationType
+
+  use GraphQL::Guard.new
+end
+```
+
+After:
+
+```rb
+class Schema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
+
+  query QueryType
+  mutation MutationType
+
+  use GraphQL::Guard.new
+end
+```
+
+
+* Use the actual type in the Policy object without `type.metadata[:type_class]`.
+
+Before (with `graphql` gem version `>= 1.8` and class-based type definitions):
+
+```rb
+class GraphqlPolicy
+  def self.guard(type, field)
+    RULES.dig(type.metadata[:type_class], field)
+  end
+end
+```
+
+After:
+
+```rb
+class GraphqlPolicy
+  def self.guard(type, field)
+    RULES.dig(type, field)
+  end
+end
+```
+
+
 #### [v1.3.1](https://github.com/exAspArk/graphql-guard/compare/v1.3.0...v1.3.1) – 2020-01-22
 
 * `Fixed`: compatibility with `graphql` gem version 1.10. [#36](https://github.com/exAspArk/graphql-guard/pull/36)

data/Gemfile

@@ -1,8 +1,9 @@
 source "https://rubygems.org"
 
-gem "pry"
-
 gem "graphql", "~> 1.10"
 
+gem "pry", require: false
+gem "coveralls", require: false
+
 # Specify your gem's dependencies in graphql-guard.gemspec
 gemspec

data/README.md

@@ -26,40 +26,37 @@ This gem provides a field-level authorization for [graphql-ruby](https://github.
 * [License](#license)
 * [Code of Conduct](#code-of-conduct)
 
-<a href="https://www.hyrestaff.com/" target="_blank" rel="noopener noreferrer">
-  <img src="images/hyre.png" height="39" width="137" alt="Sponsored by Hyre" style="max-width:100%;">
-</a>
-
 ## Usage
 
 Define a GraphQL schema:
 
 ```ruby
 # Define a type
-PostType = GraphQL::ObjectType.define do
-  name "Post"
-
-  field :id, !types.ID
-  field :title, types.String
+class PostType < GraphQL::Schema::Object
+  field :id, ID, null: false
+  field :title, String, null: true
 end
 
 # Define a query
-QueryType = GraphQL::ObjectType.define do
-  name "Query"
+class QueryType < GraphQL::Schema::Object
+  field :posts, [PostType], null: false do
+    argument :user_id, ID, required: true
+  end
 
-  field :posts, !types[!PostType] do
-    argument :user_id, !types.ID
-    resolve ->(obj, args, ctx) { Post.where(user_id: args[:user_id]) }
+  def posts(user_id:)
+    Post.where(user_id: user_id)
   end
 end
 
 # Define a schema
-Schema = GraphQL::Schema.define do
+class Schema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   query QueryType
 end
 
 # Execute query
-Schema.execute(query, variables: { user_id: 1 }, context: { current_user: current_user })
+Schema.execute(query, variables: { userId: 1 }, context: { current_user: current_user })
 ```
 
 ### Inline policies
@@ -67,7 +64,9 @@ Schema.execute(query, variables: { user_id: 1 }, context: { current_user: curren
 Add `GraphQL::Guard` to your schema:
 
 <pre>
-Schema = GraphQL::Schema.define do
+class Schema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   query QueryType
   <b>use GraphQL::Guard.new</b>
 end
@@ -76,22 +75,19 @@ end
 Now you can define `guard` for a field, which will check permissions before resolving the field:
 
 <pre>
-QueryType = GraphQL::ObjectType.define do
-  name "Query"
-
-  <b>field :posts</b>, !types[!PostType] do
-    argument :user_id, !types.ID
+class QueryType < GraphQL::Schema::Object
+  <b>field :posts</b>, [PostType], null: false do
+    argument :user_id, ID, required: true
     <b>guard ->(obj, args, ctx) {</b> args[:user_id] == ctx[:current_user].id <b>}</b>
-    ...
   end
+  ...
 end
 </pre>
 
 You can also define `guard`, which will be executed for every `*` field in the type:
 
 <pre>
-PostType = GraphQL::ObjectType.define do
-  name "Post"
+class PostType < GraphQL::Schema::Object
   <b>guard ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>
   ...
 end
@@ -120,27 +116,12 @@ class <b>GraphqlPolicy</b>
 end
 </pre>
 
-With `graphql-ruby` gem version >= 1.8 and class-based type definitions, use `camelCased` field names in the policy object.
-You'd also need to use `type.metadata` (related to [rmosolgo/graphql-ruby#1429](https://github.com/rmosolgo/graphql-ruby/issues/1429)) to get the type class:
-
-<pre>
-class GraphqlPolicy
-  RULES = {
-    MutationType => {
-      <b>createPost</b>: ->(obj, args, cts) { ctx[:current_user].admin? }
-    }
-  }
-
-  def self.guard(type, field)
-    RULES.dig(<b>type.metadata[:type_class]</b>, field)
-  end
-end
-</pre>
-
 Pass this object to `GraphQL::Guard`:
 
 <pre>
-Schema = GraphQL::Schema.define do
+class Schema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   query QueryType
   use GraphQL::Guard.new(<b>policy_object: GraphqlPolicy</b>)
 end
@@ -167,8 +148,8 @@ end
 class <b>GraphqlPolicy</b>
   RULES = {
     PostType => {
-      <b>'*': ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>,                           # <=== <b>4</b>
-      <b>title: ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>                          # <=== <b>2</b>
+      <b>'*': ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>,                                # <=== <b>4</b>
+      <b>title: ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>                               # <=== <b>2</b>
     }
   }
 
@@ -177,13 +158,14 @@ class <b>GraphqlPolicy</b>
   end
 end
 
-PostType = GraphQL::ObjectType.define do
-  name "Post"
-  <b>guard ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>                               # <=== <b>3</b>
-  <b>field :title</b>, !types.String, <b>guard: ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b> # <=== <b>1</b>
+class PostType < GraphQL::Schema::Object
+  <b>guard ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b>                                    # <=== <b>3</b>
+  field :title, String, null: true, <b>guard: ->(obj, args, ctx) {</b> ctx[:current_user].admin? <b>}</b> # <=== <b>1</b>
 end
 
-Schema = GraphQL::Schema.define do
+class Schema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   query QueryType
   use GraphQL::Guard.new(<b>policy_object: GraphqlPolicy</b>)
 end
@@ -211,8 +193,7 @@ class <b>Ability</b>
 end
 
 # Use the ability in your guard
-PostType = GraphQL::ObjectType.define do
-  name "Post"
+class PostType < GraphQL::Schema::Object
   guard ->(post, args, ctx) { <b>ctx[:current_ability].can?(:read, post)</b> }
   ...
 end
@@ -232,8 +213,7 @@ class <b>PostPolicy</b> < ApplicationPolicy
 end
 
 # Use the ability in your guard
-PostType = GraphQL::ObjectType.define do
-  name "Post"
+class PostType < GraphQL::Schema::Object
   guard ->(post, args, ctx) { <b>PostPolicy.new(ctx[:current_user], post).show?</b> }
   ...
 end
@@ -248,14 +228,20 @@ By default `GraphQL::Guard` raises a `GraphQL::Guard::NotAuthorizedError` except
 You can change this behavior, by passing custom `not_authorized` lambda. For example:
 
 <pre>
-SchemaWithErrors = GraphQL::Schema.define do
+class SchemaWithErrors < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   query QueryType
   use GraphQL::Guard.new(
     # By default it raises an error
-    # not_authorized: ->(type, field) { raise GraphQL::Guard::NotAuthorizedError.new("#{type}.#{field}") }
+    # not_authorized: ->(type, field) do
+    #   raise GraphQL::Guard::NotAuthorizedError.new("#{type}.#{field}")
+    # end
 
     # Returns an error in the response
-    <b>not_authorized: ->(type, field) { GraphQL::ExecutionError.new("Not authorized to access #{type}.#{field}") }</b>
+    <b>not_authorized: ->(type, field) do
+      GraphQL::ExecutionError.new("Not authorized to access #{type}.#{field}")
+    end</b>
   )
 end
 </pre>
@@ -300,7 +286,9 @@ class <b>GraphqlPolicy</b>
   end
 end
 
-Schema = GraphQL::Schema.define do
+class Schema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   query QueryType
   mutation MutationType
 
@@ -319,11 +307,9 @@ end
 It's possible to hide fields from being introspectable and accessible based on the context. For example:
 
 <pre>
-PostType = GraphQL::ObjectType.define do
-  name "Post"
-
-  field :id, !types.ID
-  field :title, types.String do
+class PostType < GraphQL::Schema::Object
+  field :id, ID, null: false
+  field :title, String, null: true do
     # The field "title" is accessible only for beta testers
     <b>mask ->(ctx) {</b> ctx[:current_user].beta_tester? <b>}</b>
   end
@@ -352,9 +338,8 @@ It's possible to test fields with `guard` in isolation:
 
 <pre>
 # Your type
-QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  <b>field :posts</b>, !types[!PostType], <b>guard ->(obj, args, ctx) {</b> ... <b>}</b>
+class QueryType < GraphQL::Schema::Object
+  field :posts, [PostType], null: false, <b>guard ->(obj, args, ctx) {</b> ... <b>}</b>
 end
 
 # Your test
@@ -370,9 +355,8 @@ If you would like to test your fields with policy objects:
 
 <pre>
 # Your type
-QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  <b>field :posts</b>, !types[!PostType]
+class QueryType < GraphQL::Schema::Object
+  field :posts, [PostType], null: false
 end
 
 # Your policy object

data/graphql-guard.gemspec

@@ -23,9 +23,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.1.0' # keyword args
 
-  spec.add_runtime_dependency "graphql", ">= 1.6.0", "< 2"
+  spec.add_runtime_dependency "graphql", ">= 1.10.0", "< 2"
 
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/graphql/guard.rb

@@ -5,10 +5,18 @@ require "graphql/guard/version"
 
 module GraphQL
   class Guard
+    NotAuthorizedError = Class.new(StandardError)
+
     ANY_FIELD_NAME = :'*'
-    DEFAULT_NOT_AUTHORIZED = ->(type, field) { raise NotAuthorizedError.new("Not authorized to access: #{type}.#{field}") }
 
-    NotAuthorizedError = Class.new(StandardError)
+    DEFAULT_NOT_AUTHORIZED = ->(type, field) do
+      raise NotAuthorizedError.new("Not authorized to access: #{type}.#{field}")
+    end
+
+    MASKING_FILTER = ->(schema_member, ctx) do
+      mask = schema_member.graphql_definition.metadata[:mask]
+      mask ? mask.call(ctx) : true
+    end
 
     attr_reader :policy_object, :not_authorized
 
@@ -18,75 +26,75 @@ module GraphQL
     end
 
     def use(schema_definition)
-      schema_definition.instrument(:field, self)
+      if schema_definition.interpreter?
+        schema_definition.tracer(self)
+      else
+        raise "Please use the graphql gem version >= 1.10 with GraphQL::Execution::Interpreter"
+      end
+
       add_schema_masking!(schema_definition)
     end
 
-    def instrument(type, field)
-      guard_proc = guard_proc(type, field)
-      return field unless guard_proc
-
-      old_resolve_proc = field.resolve_proc
-      new_resolve_proc = ->(object, arguments, context) do
-        authorized = guard_proc.call(object, arguments, context)
-
-        if authorized
-          old_resolve_proc.call(object, arguments, context)
-        else
-          not_authorized.call(type, field.name.to_sym)
-        end
+    def trace(event, trace_data)
+      if event == 'execute_field'
+        ensure_guarded(trace_data) { yield }
+      else
+        yield
       end
-
-      field.redefine { resolve(new_resolve_proc) }
     end
 
-    def guard_proc(type, field)
-      inline_field_guard(field) ||
-        policy_object_guard(type, field.name.to_sym) ||
-        inline_type_guard(type) ||
-        policy_object_guard(type, ANY_FIELD_NAME)
+    def find_guard_proc(type, field)
+      return unless type.respond_to?(:type_class)
+
+      inline_guard(field) ||
+        policy_object_guard(type.type_class, field.name.to_sym) ||
+        inline_guard(type) ||
+        policy_object_guard(type.type_class, ANY_FIELD_NAME)
     end
 
     private
 
     def add_schema_masking!(schema_definition)
-      default_filter_proc = Proc.new do
-        def default_filter
-          GraphQL::Filter.new(except: default_mask).merge(only: ->(schema_member, ctx) {
-            schema_member.metadata[:mask] ? schema_member.metadata[:mask].call(ctx) : true
-          })
+      schema_definition.class_eval do
+        def self.default_filter
+          GraphQL::Filter.new(except: default_mask).merge(only: MASKING_FILTER)
         end
       end
+    end
+
+    def ensure_guarded(trace_data)
+      field = trace_data[:field]
+      guard_proc = find_guard_proc(field.owner, field)
+      return yield unless guard_proc
 
-      if schema_definition.is_a?(Class) # GraphQL-Ruby version >= 1.10
-        schema_definition.class_eval(&default_filter_proc)
+      if guard_proc.call(trace_data[:object], args(trace_data), trace_data[:query].context)
+        yield
       else
-        schema_definition.target.instance_eval(&default_filter_proc)
+        not_authorized.call(field.owner.graphql_definition, field.name.to_sym)
       end
     end
 
-    def policy_object_guard(type, field_name)
-      policy_object && policy_object.guard(type, field_name)
+    def args(trace_data)
+      if trace_data[:arguments].key?(:input) && !trace_data[:arguments][:input].is_a?(Hash)
+        return trace_data[:arguments][:input] # Relay mutation input
+      end
+
+      trace_data[:arguments]
     end
 
-    def inline_field_guard(field)
-      field.metadata[:guard]
+    def policy_object_guard(type, field_name)
+      @policy_object && @policy_object.guard(type, field_name)
     end
 
-    def inline_type_guard(type)
-      type.metadata[:guard]
+    def inline_guard(type_or_field)
+      type_or_field.graphql_definition.metadata[:guard]
     end
   end
 end
 
-if GraphQL::ObjectType.respond_to?(:accepts_definitions) # GraphQL-Ruby version < 1.8
-  GraphQL::ObjectType.accepts_definitions(guard: GraphQL::Define.assign_metadata_key(:guard))
-  GraphQL::Field.accepts_definitions(guard: GraphQL::Define.assign_metadata_key(:guard))
-  GraphQL::Field.accepts_definitions(mask: GraphQL::Define.assign_metadata_key(:mask))
-end
-
-if defined?(GraphQL::Schema::Object) && GraphQL::Schema::Object.respond_to?(:accepts_definition) # GraphQL-Ruby version >= 1.8
-  GraphQL::Schema::Object.accepts_definition(:guard)
-  GraphQL::Schema::Field.accepts_definition(:guard)
-  GraphQL::Schema::Field.accepts_definition(:mask)
-end
+GraphQL::ObjectType.accepts_definitions(guard: GraphQL::Define.assign_metadata_key(:guard))
+GraphQL::Field.accepts_definitions(guard: GraphQL::Define.assign_metadata_key(:guard))
+GraphQL::Field.accepts_definitions(mask: GraphQL::Define.assign_metadata_key(:mask))
+GraphQL::Schema::Object.accepts_definition(:guard)
+GraphQL::Schema::Field.accepts_definition(:guard)
+GraphQL::Schema::Field.accepts_definition(:mask)

data/lib/graphql/guard/testing.rb

@@ -5,32 +5,18 @@ module GraphQL
     NoGuardError = Class.new(StandardError)
 
     def guard(*args)
-      raise NoGuardError.new("Get your field by calling: Type.field_with_guard('#{name}')") unless @__guard_type
-      guard_proc = @__guard_object.guard_proc(@__guard_type, self)
+      raise NoGuardError.new("Get your field by calling: Type.field_with_guard('#{name}')") unless @__guard_instance
+
+      guard_proc = @__guard_instance.find_guard_proc(@__guard_type, self)
       raise NoGuardError.new("Guard lambda does not exist for #{@__guard_type}.#{name}") unless guard_proc
 
       guard_proc.call(*args)
     end
 
-    def __policy_object=(policy_object)
+    def __set_guard_instance(policy_object, guard_type)
       @__policy_object = policy_object
-      @__guard_object = GraphQL::Guard.new(policy_object: policy_object)
-    end
-
-    def __guard_type=(guard_type)
       @__guard_type = guard_type
-    end
-  end
-
-  class ObjectType
-    def field_with_guard(field_name, policy_object = nil)
-      field = get_field(field_name)
-      return unless field
-
-      field.clone.tap do |f|
-        f.__policy_object = policy_object
-        f.__guard_type = self
-      end
+      @__guard_instance = GraphQL::Guard.new(policy_object: policy_object)
     end
   end
 
@@ -41,8 +27,7 @@ module GraphQL
         return unless field
 
         field.to_graphql.clone.tap do |f|
-          f.__policy_object = policy_object
-          f.__guard_type = self.to_graphql
+          f.__set_guard_instance(policy_object, self.to_graphql)
         end
       end
     end

data/lib/graphql/guard/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   class Guard
-    VERSION = "1.3.1"
+    VERSION = "2.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-guard
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.0
 platform: ruby
 authors:
 - exAspArk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-22 00:00:00.000000000 Z
+date: 2020-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 1.10.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 1.10.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -36,28 +36,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +81,6 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
-- ".ruby-version"
 - ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -91,9 +90,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- graphql-1.7.gemfile
 - graphql-guard.gemspec
-- graphql-latest.gemfile
 - lib/graphql/guard.rb
 - lib/graphql/guard/testing.rb
 - lib/graphql/guard/version.rb

data/.ruby-version

@@ -1 +0,0 @@
-2.6.5

data/graphql-1.7.gemfile

@@ -1,8 +0,0 @@
-source "https://rubygems.org"
-
-gem "pry"
-gem 'coveralls'
-
-gem "graphql", "~> 1.7.14"
-
-gemspec

data/graphql-latest.gemfile

@@ -1,8 +0,0 @@
-source "https://rubygems.org"
-
-gem "pry"
-gem 'coveralls'
-
-gem "graphql", "~> 1.10"
-
-gemspec