graphql-coverage 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0460ae052196100bcc288337d4c214628a6f083d318c28123b452132ac5e6d59
+  data.tar.gz: 884dc07d6864682bf2646e2302f13dff6bf132fe6cd8238746a1e8c684285f66
+SHA512:
+  metadata.gz: 80b3b3953f3a40e36efc205895a6337c128e80085255142352b2435b7fab245129c68528373199414ca686f0b0c47b3b1044d07c6abc045565837ff519c9a90e
+  data.tar.gz: 0c6d597a081d44bd34093c5a874ba7d8a30199ac941eb70474d9ad2e0fe5e4888f611e0abe558745d673d8d68b3cfe93999377ebb5550c6f477fa1f3ca8f20f2

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,19 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: enable
+
+Style:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Layout/FirstHashElementIndentation:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    - spec/exe/graphql-coverage_spec.rb

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# CHANGELOG
+
+## v0.1.0 - 2023-12-10
+
+* Initial release
+* Calculate coverage of GraphQL queries
+* Support multiple processes
+* Support `ignored_fields` option

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Masataka Pocke Kuwabara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# GraphQL::Coverage
+
+`GraphQL::Coverage` is a gem that calculates the coverage of GraphQL queries.
+
+## Motivation
+
+The motivation of this gem is to enforce the coverage of GraphQL queries in testing.
+
+In our projects, we have a rule that the test cases must cover all GraphQL fields. However, it is difficult to enforce this rule because we have no tools to check the coverage of GraphQL fields.
+
+You may think that we can check the coverage of GraphQL fields with ordinary coverage tools such as simplecov. However, it is not enough because GraphQL fields are often defined without method definition. For example:
+
+```ruby
+# without `def id`
+field :id, String, null: false
+```
+
+So I need to develop a tool that can check the coverage of GraphQL fields.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```console
+$ bundle add graphql-coverage --require false --group test
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```console
+$ gem install graphql-coverage
+```
+
+## Usage
+
+**This gem is not designed to be used in a production environment.**
+
+This gem is designed to be used in a test environment. Here is an example of using this gem with RSpec.
+
+### On a single process
+
+If your RSpec runs on a single process, add the following code to `spec_helper.rb`:
+
+```ruby
+RSpec.configure do |config|
+  config.before(:suite) do
+    require 'graphql/coverage'
+    # Pass a class that inherits `GraphQL::Schema`.
+    GraphQL::Coverage.enable(YourSchema)
+  end
+
+  config.after(:suite) do
+    GraphQL::Coverage.report!
+    # You can also use `GraphQL::Coverage.report` if you just want to display the report without failure.
+  end
+end
+```
+
+### On multiple processes
+
+You run RSpec on multiple processes in many cases. For example, you may use [parallel_tests](https://github.com/grosser/parallel_tests), [test-queue](https://github.com/tmm1/test-queue), or [CircleCI's parallelism](https://circleci.com/docs/parallelism-faster-jobs/).
+In such cases, you need to use `GraphQL::Coverage` in a different way to aggregate coverage results.
+
+The following code is an example of using `GraphQL::Coverage` with CircleCI's parallelism on a Rails application.
+
+```ruby
+# spec_helper.rb
+RSpec.configure do |config|
+  config.before(:suite) do
+    # Pass a class that inherits `GraphQL::Schema`.
+    GraphQL::Coverage.enable(YourSchema)
+  end
+
+  config.after(:suite) do
+    # Instead of `GraphQL::Coverage.report!`, use `GraphQL::Coverage.dump` to dump the coverage result to a file.
+    GraphQL::Coverage.dump(Rails.root.join("tmp/graphql-coverage-#{ENV['CIRCLE_NODE_INDEX']}.json"))
+  end
+end
+```
+
+After running RSpec, you can aggregate the coverage results and display the coverage with the following command:
+
+```console
+# It displays the same report as `GraphQL::Coverage.report!`.
+$ graphql-coverage --require ./config/environment.rb tmp/graphql-coverage-*.json
+```
+
+You must specify `--require` (or `-r`) option to load the schema. If you use Rails, you can specify `./config/environment.rb` as the argument of `--require` option.
+
+You can also use `--no-fail-on-uncovered` option to display the coverage without failure.
+
+### Configuration
+
+You can specify `ignored_fields` option to ignore some fields.
+
+```ruby
+# spec_helper.rb
+RSpec.configure do |config|
+  config.before(:suite) do
+    GraphQL::Coverage.enable(YourSchema)
+    GraphQL::Coverage.ignored_fields = [
+      # GraphQL::Coverage does not complain about the coverage of `Article`'s `title` field.
+      { type: 'Article', field: 'title' },
+      # You can use `*` as a wildcard.
+      { type: '*', field: 'id' },
+    ]
+  end
+end
+```
+
+I recommend specifying the following configuration in most cases to ignore fields for Relay Connection.
+
+```ruby
+GraphQL::Coverage.ignored_fields = [
+  { type: '*', field: 'edges' },
+  { type: '*', field: 'node' },
+  { type: '*', field: 'cursor' },
+]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pocke/graphql-coverage.

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task :steep do
+  sh 'steep', 'check'
+end
+
+task default: %i[rubocop steep spec]

data/Steepfile

@@ -0,0 +1,8 @@
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+  check "lib"
+
+  configure_code_diagnostics(D::Ruby.strict)
+end

data/exe/graphql-coverage

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(__dir__, "../lib")
+
+require 'graphql/coverage'
+require 'graphql/coverage/cli'
+
+exit GraphQL::Coverage::CLI.new(stdout: $stdout, stderr: $stderr).run(ARGV)

data/lib/graphql/coverage/call.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Coverage
+    # rubocop:disable Naming/ConstantName
+    # @api private
+    Call = _ = Struct.new(:type, :field, :result_type, keyword_init: true)
+    # rubocop:enable Naming/ConstantName
+    class Call
+      def self.from_graphql_object(field:, result_type:)
+        new(type: field.owner.graphql_name, field: field.graphql_name, result_type: result_type)
+      end
+    end
+  end
+end

data/lib/graphql/coverage/cli.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module GraphQL
+  module Coverage
+    class CLI
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run(argv)
+        # @type var params: params
+        params = {
+          'fail-on-uncovered': true,
+        }
+
+        args = OptionParser.new do |opts|
+          opts.banner = <<~TXT
+            Usage: graphql-coverage [options] [result file paths]
+
+            Display the coverage result from multiple result files.
+
+            Options:
+          TXT
+          opts.version = VERSION
+          opts.on('-r', '--require PATH', 'Require a file.') do |path|
+            require path
+          end
+
+          opts.on('--[no-]fail-on-uncovered', 'Fail when there are uncovered fields (default: true).')
+        end.parse(argv, into: _ = params)
+
+        Coverage.load(*args)
+
+        ok = Coverage.report(output: stdout)
+        if ok || !params[:'fail-on-uncovered']
+          return 0
+        else
+          1
+        end
+      end
+
+      private
+
+      attr_reader :stdout, :stderr
+    end
+  end
+end

data/lib/graphql/coverage/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Coverage
+    module Errors
+      class SchemaMismatch < StandardError
+        def initialize(expected:, got:)
+          super("Schema mismatch: expected #{expected}, got #{got}")
+        end
+      end
+
+      class UncoveredFields < StandardError
+      end
+    end
+  end
+end

data/lib/graphql/coverage/result.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Coverage
+    # @api private
+    class Result
+      def initialize(calls:, schema:, ignored_fields:)
+        @calls = calls.uniq
+        @schema = schema
+        @ignored_field_patterns = ignored_fields
+      end
+
+      def covered_fields
+        @calls
+      end
+
+      def uncovered_fields
+        @uncovered_fields ||= reject_ignored_fields(available_fields - @calls)
+      end
+
+      def ignored_fields
+        available_fields - uncovered_fields - @calls
+      end
+
+      def available_fields
+        # @type var target_types: Array[singleton(GraphQL::Schema::Object)]
+        target_types = _ = @schema.types.select { |name, klass| klass < GraphQL::Schema::Object && !name.start_with?('__') }.values
+
+        target_types.flat_map do |klass|
+          klass.fields.values.map do |field|
+            Call.from_graphql_object(field: field, result_type: nil)
+          end
+        end
+      end
+
+      def reject_ignored_fields(calls)
+        calls.reject do |call|
+          @ignored_field_patterns.any? do |ignored_field|
+            type = __skip__ = ignored_field[:type] || ignored_field['type']
+            field = __skip__ = ignored_field[:field] || ignored_field['field']
+            match_pattern?(type, call.type) && match_pattern?(field, call.field)
+          end
+        end
+      end
+
+      def match_pattern?(pat, str)
+        if pat == '*'
+          true
+        else
+          pat == str
+        end
+      end
+    end
+  end
+end

data/lib/graphql/coverage/store.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Coverage
+    # @api private
+    class Store
+      def self.current
+        @current
+      end
+
+      def self.reset!
+        @current = new
+      end
+
+      attr_reader :calls
+
+      def initialize
+        @calls = []
+      end
+
+      def append(call)
+        @calls << call
+      end
+
+      reset!
+    end
+  end
+end

data/lib/graphql/coverage/trace.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Coverage
+    # @api private
+    module Trace
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        result = super
+        # TODO: result type
+        Store.current.append(Call.from_graphql_object(field: field, result_type: nil))
+        result
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        result = super
+        # TODO: result type
+        Store.current.append(Call.from_graphql_object(field: field, result_type: nil))
+        result
+      end
+    end
+  end
+end

data/lib/graphql/coverage/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Coverage
+    VERSION = "0.1.0"
+  end
+end

data/lib/graphql/coverage.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'graphql'
+require 'json'
+
+require_relative "coverage/version"
+require_relative "coverage/trace"
+require_relative "coverage/store"
+require_relative "coverage/call"
+require_relative "coverage/errors"
+require_relative "coverage/result"
+
+module GraphQL
+  module Coverage
+    class << self
+      attr_accessor :ignored_fields
+    end
+
+    def self.enable(schema)
+      self.schema = schema
+      schema.trace_with(Trace)
+    end
+
+    def self.dump(file_path)
+      calls = Store.current.calls.map(&:to_h)
+      content = JSON.generate({ calls: calls, schema: @schema.name, ignored_fields: ignored_fields })
+      File.write(_ = file_path, content)
+    end
+
+    def self.load(*file_paths)
+      file_paths.each do |file_path|
+        content = JSON.parse(File.read(_ = file_path))
+        self.schema = Object.const_get(content['schema'])
+        self.ignored_fields = content['ignored_fields']
+
+        content['calls'].each do |call_hash|
+          call = Call.new(type: call_hash['type'], field: call_hash['field'], result_type: call_hash['result_type'])
+          Store.current.append(call)
+        end
+      end
+    end
+
+    def self.report(output: $stdout)
+      res = result
+
+      puts_rate = proc do
+        available_size = res.available_fields.size
+        covered_size = res.covered_fields.size
+        ignored_size = res.ignored_fields.size
+
+        cover_rate = sprintf("%.2f", covered_size.to_f / available_size * 100)
+        ignore_rate = sprintf("%.2f", ignored_size.to_f / available_size * 100)
+
+        output.puts "#{covered_size} / #{available_size} fields covered (#{cover_rate}%)"
+        output.puts "#{ignored_size} / #{available_size} fields ignored (#{ignore_rate}%)" if 0 < ignored_size
+      end
+
+      if res.uncovered_fields.empty?
+        output.puts "All fields are covered"
+        puts_rate.call
+        true
+      else
+        output.puts "There are uncovered fields"
+        puts_rate.call
+        output.puts "Missing fields:"
+        res.uncovered_fields.each do |call|
+          output.puts "  #{call.type}.#{call.field}"
+        end
+        false
+      end
+    end
+
+    def self.report!(output: $stdout)
+      report(output: output) or raise Errors::UncoveredFields
+    end
+
+    def self.result
+      Result.new(calls: Store.current.calls, schema: @schema, ignored_fields: ignored_fields)
+    end
+
+    # @api private
+    def self.reset!
+      __skip__ = @schema = nil
+      self.ignored_fields = []
+      Store.reset!
+    end
+
+    # @api private
+    private_class_method def self.schema=(schema)
+      if @schema && @schema != schema
+        raise Errors::SchemaMismatch.new(expected: @schema, got: schema)
+      end
+
+      @schema = schema
+    end
+
+    reset!
+  end
+end

data/rbs_collection.lock.yaml

@@ -0,0 +1,24 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: graphql
+  version: '1.12'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 4b0d2f72e63b6c3e92dc54e19ce23dd24524f9a7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,17 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+path: .gem_rbs_collection
+
+gems:
+  - name: graphql-coverage
+    ignore: true
+  - name: graphql
+  - name: json
+  - name: pathname
+  - name: optparse

data/sig/graphql/coverage/call.rbs

@@ -0,0 +1,14 @@
+module GraphQL
+  module Coverage
+    # @api private
+    class Call
+      attr_accessor type: String
+      attr_accessor field: String
+      attr_accessor result_type: nil
+
+      def initialize: (type: String, field: String, result_type: nil) -> void
+
+      def self.from_graphql_object: (field: GraphQL::Schema::Field, result_type: untyped) -> instance
+    end
+  end
+end

data/sig/graphql/coverage/cli.rbs

@@ -0,0 +1,19 @@
+module GraphQL
+  module Coverage
+    # @api private
+    class CLI
+      type params = {
+        :'fail-on-uncovered' => bool,
+      }
+
+      def initialize: (stdout: IO, stderr: IO) -> void
+
+      def run: (Array[String] argv) -> Integer
+
+      private
+
+      attr_reader stdout: IO
+      attr_reader stderr: IO
+    end
+  end
+end

data/sig/graphql/coverage/errors.rbs

@@ -0,0 +1,14 @@
+module GraphQL
+  module Coverage
+    module Errors
+      # It occurs when the dumped files have different schemas.
+      class SchemaMismatch < StandardError
+        def initialize: (expected: untyped, got: untyped) -> void
+      end
+
+      # It occurs when the schema is not fully covered by the tests.
+      class UncoveredFields < StandardError
+      end
+    end
+  end
+end

data/sig/graphql/coverage/result.rbs

@@ -0,0 +1,27 @@
+module GraphQL
+  module Coverage
+    # @api private
+    class Result
+      @calls: Array[Call]
+      @schema: singleton(GraphQL::Schema)
+      @ignored_field_patterns: Array[ignored_field]
+      @uncovered_fields: Array[Call]
+
+      def initialize: (calls: Array[Call], schema: singleton(GraphQL::Schema), ignored_fields: Array[ignored_field]) -> void
+
+      def covered_fields: () -> Array[Call]
+
+      def uncovered_fields: () -> Array[Call]
+
+      def ignored_fields: () -> Array[Call]
+
+      def available_fields: () -> Array[Call]
+
+      private
+
+      def reject_ignored_fields: (Array[Call]) -> Array[Call]
+
+      def match_pattern?: (String, String) -> bool
+    end
+  end
+end

data/sig/graphql/coverage/store.rbs

@@ -0,0 +1,20 @@
+module GraphQL
+  module Coverage
+    # @api private
+    class Store
+      self.@current: untyped
+
+      @calls: untyped
+
+      def self.current: () -> untyped
+
+      def self.reset!: () -> untyped
+
+      attr_reader calls: untyped
+
+      def initialize: () -> void
+
+      def append: (untyped call) -> untyped
+    end
+  end
+end

data/sig/graphql/coverage/trace.rbs

@@ -0,0 +1,10 @@
+module GraphQL
+  module Coverage
+    # @api private
+    module Trace : GraphQL::Tracing::Trace
+      def execute_field: (field: GraphQL::Schema::Field, query: untyped, ast_node: untyped, arguments: untyped, object: untyped) -> untyped
+
+      alias execute_field_lazy execute_field
+    end
+  end
+end

data/sig/graphql/coverage/version.rbs

@@ -0,0 +1,5 @@
+module GraphQL
+  module Coverage
+    VERSION: "0.1.0"
+  end
+end

data/sig/graphql/coverage.rbs

@@ -0,0 +1,39 @@
+module GraphQL
+  module Coverage
+    type ignored_field = { type: String, field: String }
+                       | { "type" => String, "field" => String }
+
+    # Specify fields to ignore in the coverage report.
+    # default: []
+    attr_accessor self.ignored_fields: Array[ignored_field]
+
+    self.@schema: singleton(GraphQL::Schema)
+
+    # Enable coverage tracking for the given schema.
+    def self.enable: (singleton(GraphQL::Schema) schema) -> void
+
+    # Dump the current coverage data to a file.
+    def self.dump: (String | Pathname file_path) -> void
+
+    # Load coverage data from specified files.
+    def self.load: (*String | Pathname file_paths) -> void
+
+    # Report coverage result to the `output`.
+    #
+    # It reports to the `STDOUT` by default.
+    # It returns `true` if the coverage is 100%.
+    def self.report: (?output: IO) -> bool
+
+    # Same as `report` but it raises an error if the coverage is not 100%.
+    def self.report!: (?output: IO) -> void
+
+    # @api private
+    def self.result: () -> Result
+
+    # @api private
+    def self.reset!: () -> untyped
+
+    # @api private
+    private def self.schema=: (untyped schema) -> untyped
+  end
+end

data/sig/shim.rbs

@@ -0,0 +1,39 @@
+module GraphQL
+  interface _GraphQLName
+    def graphql_name: () -> String
+  end
+
+  class Schema
+    def self.types: (?untyped context) -> Hash[String, Class]
+
+    def self.trace_with: (Module trace_mod, ?mode: Symbol | Array[Symbol], **untyped) -> void
+
+    class Field
+      attr_accessor owner: Class & _GraphQLName
+      attr_reader name: String
+
+      alias graphql_name name
+    end
+
+    class Member
+      module HashFields
+        module ObjectMethods
+          def fields: (?untyped context) -> Hash[String, Field]
+        end
+      end
+    end
+
+    class Object < Member
+      extend Member::HashFields
+      extend Member::HashFields::ObjectMethods
+    end
+  end
+
+  module Tracing
+    class Trace
+      def execute_field: (field: GraphQL::Schema::Field, query: untyped, ast_node: untyped, arguments: untyped, object: untyped) -> untyped
+
+      def execute_field_lazy: (field: GraphQL::Schema::Field, query: untyped, ast_node: untyped, arguments: untyped, object: untyped) -> untyped
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: graphql-coverage
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Masataka Pocke Kuwabara
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Coverage for GraphQL
+email:
+- kuwabara@pocke.me
+executables:
+- graphql-coverage
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- Steepfile
+- exe/graphql-coverage
+- lib/graphql/coverage.rb
+- lib/graphql/coverage/call.rb
+- lib/graphql/coverage/cli.rb
+- lib/graphql/coverage/errors.rb
+- lib/graphql/coverage/result.rb
+- lib/graphql/coverage/store.rb
+- lib/graphql/coverage/trace.rb
+- lib/graphql/coverage/version.rb
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
+- sig/graphql/coverage.rbs
+- sig/graphql/coverage/call.rbs
+- sig/graphql/coverage/cli.rbs
+- sig/graphql/coverage/errors.rbs
+- sig/graphql/coverage/result.rbs
+- sig/graphql/coverage/store.rbs
+- sig/graphql/coverage/trace.rbs
+- sig/graphql/coverage/version.rbs
+- sig/shim.rbs
+homepage: https://github.com/pocke/graphql-coverage
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/pocke/graphql-coverage
+  source_code_uri: https://github.com/pocke/graphql-coverage
+  changelog_uri: https://github.com/pocke/graphql-coverage/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.0.dev
+signing_key:
+specification_version: 4
+summary: Coverage for GraphQL
+test_files: []