File nodes.rb has 517 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.
      #

File runtime.rb has 504 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module GraphQL
  module Execution
    class Interpreter
      # I think it would be even better if we could somehow make
      # `continue_field` not recursive. "Trampolining" it somehow.

File field.rb has 474 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require "graphql/schema/field/connection_extension"
require "graphql/schema/field/scope_extension"

module GraphQL
  class Schema

Method evaluate_selections has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.

Open

        def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
          @interpreter_context[:current_object] = owner_object
          @interpreter_context[:current_path] = path
          selections_by_name = {}
          gather_selections(owner_object, owner_type, selections, selections_by_name)

• Read up
  Read up

Method on_argument has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.

Open

      def on_argument(node, parent)
        parent_defn = case parent
        when GraphQL::Language::Nodes::InputObject
          arg_defn = context.argument_definition
          if arg_defn.nil?

• 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 a Cognitive Complexity of 34 (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 has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.

Open

      def resolve(object, args, ctx)
        if @resolve_proc
          raise "Can't run resolve proc for #{path} when using GraphQL::Execution::Interpreter"
        end
        begin

• Read up
  Read up

Method initialize has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.

Open

      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, arguments: {}, &definition_block)
        if name.nil?
          raise ArgumentError, "missing first `name` argument or keyword `name:`"
        end
        if !(field || function || resolver_class)

• 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 resolve_value has a Cognitive Complexity of 28 (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

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

Open

        def gather_selections(owner_object, owner_type, selections, selections_by_name)
          selections.each do |node|
            # Skip gathering this if the directive says so
            if !directives_include?(node, owner_object, owner_type)
              next

• 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 evaluate_selections has 95 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
          @interpreter_context[:current_object] = owner_object
          @interpreter_context[:current_path] = path
          selections_by_name = {}
          gather_selections(owner_object, owner_type, selections, selections_by_name)

Method constantize has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.

Open

        def constantize(string)
          names = string.split('::')

          # Trigger a built-in NameError exception including the ill-formed constant in the message.
          Object.const_get(string) if names.empty?

• Read up
  Read up

Method define_type has 89 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def define_type(type, type_resolver)
          case type.fetch("kind")
          when "ENUM"
            EnumType.define(
              name: type["name"],