Method build_suite has 494 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def self.build_suite(&block)
        Class.new(Minitest::Test) do
          @@parse_fn = block

          def parse(query_string)

Method build_suite has 345 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def self.build_suite(execution_strategy)
        Class.new(Minitest::Test) do
          class << self
            attr_accessor :counter_schema, :specification_schema
          end

Class Schema has 88 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Schema
    extend Forwardable
    extend GraphQL::Schema::Member::AcceptsDefinition
    include GraphQL::Define::InstanceDefinable
    accepts_definitions \

File schema.rb has 719 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require "graphql/schema/base_64_encoder"
require "graphql/schema/catchall_middleware"
require "graphql/schema/default_parse_error"
require "graphql/schema/default_type_error"
require "graphql/schema/finder"

File member.rb has 664 lines of code (exceeds 250 allowed). Consider refactoring.

Open

begin
  require 'parser/current'
rescue LoadError
  raise LoadError, "GraphQL::Upgrader requires the 'parser' gem, please install it and/or add it to your Gemfile"
end

File schema_parser_specification.rb has 525 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module GraphQL
  module Compatibility
    # This asserts that a given parse function turns a string into
    # the proper tree of {{GraphQL::Language::Nodes}}.
    module SchemaParserSpecification

Method build_suite has 186 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def self.build_suite(execution_strategy)
        Class.new(Minitest::Test) do
          class << self
            attr_accessor :lazy_schema
          end

File nodes.rb has 431 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module GraphQL
  module Language
    module Nodes
      # {AbstractNode} is the base class for all nodes in a GraphQL AST.
      #

Method apply has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.

Open

      def apply(input_text)
        input_text.scan(/(?:input_field|field|return_field|connection|argument) .*$/).each do |field|
          matches = /(?<field_type>input_field|return_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)?(:?, +(?<return_type>([A-Za-z\[\]\.\!_0-9\(\)]|::|-> ?\{ ?| ?\})+))?(?<remainder>( |,|$).*)/.match(field)
          if matches
            name = matches[:name]

• Read up
  Read up

Method build has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.

Open

        def build(document, default_resolve: DefaultResolve)
          raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)

          if default_resolve.is_a?(Hash)
            default_resolve = ResolveMap.new(default_resolve)

• Read up
  Read up

Method resolve_with_support has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.

Open

      def resolve_with_support(**args)
        # First call the ready? hook which may raise
        ready_val = if args.any?
          ready?(**args)
        else

• Read up
  Read up

Method build has 123 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def self.build(execution_strategy)
          organization_type = nil

          timestamp_type = GraphQL::ScalarType.define do
            name "Timestamp"

Function sync has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.

Open

function sync(options) {
  if (!options) {
    options = {}
  }
  var logger = new Logger(options.quiet)

• Read up
  Read up

File execution_specification.rb has 355 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require "graphql/compatibility/execution_specification/counter_schema"
require "graphql/compatibility/execution_specification/specification_schema"

module GraphQL
  module Compatibility

Class Printer has 34 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Printer
      # Turn an arbitrary AST node back into a string.
      #
      # @example Turning a document into a query string
      #    document = GraphQL.parse(query_string)

Method visit has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.

Open

      def visit(schema, member, context_description)
        case member
        when GraphQL::Schema
          member.directives.each { |name, directive| visit(schema, directive, "Directive #{name}") }
          # Find the starting points, then visit them

• Read up
  Read up

Method from_arguments has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

      def self.from_arguments(ast_arguments, argument_owner, variables)
        context = variables ? variables.context : nil
        values_hash = {}
        defaults_used = Set.new

• Read up
  Read up

Method parse_type has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

        def parse_type(type_expr, null:)
          list_type = false

          return_type = case type_expr
          when String

• Read up
  Read up

Method build has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

        def self.build(execution_strategy)
          organization_type = nil

          timestamp_type = GraphQL::ScalarType.define do
            name "Timestamp"

• Read up
  Read up

Method resolve_value has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

        def resolve_value(value, field_type, field_ctx)
          field_defn = field_ctx.field

          if value.nil?
            if field_type.kind.non_null?

• Read up
  Read up