Class: GraphQL::InternalRepresentation::Scope

Inherits:
Object
  • Object
show all
Defined in:
lib/graphql/internal_representation/scope.rb

Overview

At a point in the AST, selections may apply to one or more types. Scope represents those types which selections may apply to.

Scopes can be defined by:

  • A single concrete or abstract type
  • An array of types
  • nil

The AST may be scoped to an array of types when two abstractly-typed fragments occur in inside one another.

Constant Summary

NO_TYPES = 
[].freeze

Instance Method Summary collapse

Constructor Details

#initialize(query, type_defn) ⇒ Scope

Returns a new instance of Scope

Parameters:



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/graphql/internal_representation/scope.rb', line 20

def initialize(query, type_defn)
  @query = query
  @type = type_defn
  @abstract_type = false
  @types = case type_defn
  when Array
    type_defn
  when GraphQL::BaseType
    @abstract_type = true
    nil
  when nil
    NO_TYPES
  else
    raise "Unexpected scope type: #{type_defn}"
  end
end

Instance Method Details

#each ⇒ Object

Call the block for each type in self. This uses the simplest possible expression of self, so if this scope is defined by an abstract type, it gets yielded.



69
70
71
72
73
74
75
 
# File 'lib/graphql/internal_representation/scope.rb', line 69

def each
  if @abstract_type
    yield(@type)
  else
    @types.each { |t| yield(t) }
  end
end

#enter(other_type_defn) ⇒ Scope

From a starting point of self, create a new scope by condition other_type_defn.

Parameters:

Returns:



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/graphql/internal_representation/scope.rb', line 40

def enter(other_type_defn)
  case other_type_defn
  when nil
    # The type wasn't found, who cares
    Scope.new(@query, nil)
  when @type
    # The condition is the same as current, so reuse self
    self
  when GraphQL::UnionType, GraphQL::InterfaceType
    # Make a new scope of the intersection between the previous & next conditions
    new_types = @query.possible_types(other_type_defn) & concrete_types
    Scope.new(@query, new_types)
  when GraphQL::BaseType
    # If this type is valid within the current scope,
    # return a new scope of _exactly_ this type.
    # Otherwise, this type is out-of-scope so the scope is null.
    if concrete_types.include?(other_type_defn)
      Scope.new(@query, other_type_defn)
    else
      Scope.new(@query, nil)
    end
  else
    raise "Unexpected scope: #{other_type_defn.inspect}"
  end
end