File field.rb has 514 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 49 (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

File nodes.rb has 476 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 463 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.

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

Open

        def build(document, default_resolve:, using: {}, interpreter: true, relay:)
          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 from_arguments has a Cognitive Complexity of 43 (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 add_type has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.

Open

      def add_type(type, owner:, late_types:, path:)
        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
          type_class = type.metadata[:type_class]
          if type_class.nil?
            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"

• Read up
  Read up

Function sync has 147 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function sync(options: SyncOptions) {
  var logger = new Logger(!!options.quiet)
  var verbose = !!options.verbose
  var url = options.url
  if (!url) {

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 initialize has a Cognitive Complexity of 34 (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: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, &definition_block)
        if name.nil?
          raise ArgumentError, "missing first `name` argument or keyword `name:`"
        end
        if !(field || function || resolver_class)

• Read up
  Read up

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

Open

      def update_type_owner(owner, type)
        case owner
        when Class
          if owner.kind.union?
            # It's a union with possible_types

• Read up
  Read up

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

Open

    def normalize_arguments(event_name, arg_owner, args)
      case arg_owner
      when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
        if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
          # it's a type, but not an input object

• 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

Function createAblyHandler has 111 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function createAblyHandler(options: AblyHandlerOptions) {
  const { ably, fetchOperation } = options

  const isAnonymousClient = () =>
    !ably.auth.clientId || ably.auth.clientId === "*"

Method continue_field has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.

Open

        def continue_field(path, value, field, type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
          case type.kind.name
          when "SCALAR", "ENUM"
            r = type.coerce_result(value, context)
            write_in_response(path, r)

• Read up
  Read up

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

Open

      def initialize(ctx, ast_variables, provided_variables)
        schema = ctx.schema
        @context = ctx

        @provided_variables = GraphQL::Argument.deep_stringify(provided_variables)

• Read up
  Read up

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 parse_type has a Cognitive Complexity of 29 (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 on_argument has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.

Open

      def on_argument(node, parent)
        # Check the child arguments first;
        # don't add a new error if one of them reports an error
        super

• Read up
  Read up