Class: GraphQL::Query::Arguments

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Dig
Defined in:
lib/graphql/query/arguments.rb

Overview

Read-only access to values, normalizing all keys to strings

Arguments recursively wraps the input in Arguments instances.

Defined Under Namespace

Classes: ArgumentValue

Constant Summary collapse

NoArguments = 
Class.new(self) do
  self.argument_definitions = []
end
NO_ARGS = 
NoArguments.new({}, context: nil, defaults_used: Set.new)

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Dig

#dig

Constructor Details

#initialize(values, context:, defaults_used:) ⇒ Arguments

Returns a new instance of Arguments.



43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/graphql/query/arguments.rb', line 43

def initialize(values, context:, defaults_used:)
  @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
    arg_name = inner_key.to_s
    arg_defn = self.class.argument_definitions[arg_name] || raise("Not found #{arg_name} among #{self.class.argument_definitions.keys}")
    arg_default_used = defaults_used.include?(arg_name)
    arg_value = wrap_value(inner_value, arg_defn.type, context)
    string_key = arg_defn.expose_as
    memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn, arg_default_used)
    memo
  end
end

Class Attribute Details

.argument_definitions ⇒ Object

Returns the value of attribute argument_definitions.



106
107
108
 
# File 'lib/graphql/query/arguments.rb', line 106

def argument_definitions
  @argument_definitions
end

.argument_owner ⇒ Object

Returns the value of attribute argument_owner.



106
107
108
 
# File 'lib/graphql/query/arguments.rb', line 106

def argument_owner
  @argument_owner
end

Instance Attribute Details

#argument_values ⇒ Object (readonly)

Returns the value of attribute argument_values.



41
42
43
 
# File 'lib/graphql/query/arguments.rb', line 41

def argument_values
  @argument_values
end

Class Method Details

.construct_arguments_class(argument_owner) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/graphql/query/arguments.rb', line 11

def self.construct_arguments_class(argument_owner)
  argument_definitions = argument_owner.arguments
  argument_owner.arguments_class = Class.new(self) do
    self.argument_owner = argument_owner
    self.argument_definitions = argument_definitions

    argument_definitions.each do |_arg_name, arg_definition|
      if arg_definition.method_access?
        expose_as = arg_definition.expose_as.to_s.freeze
        expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
        method_names = [expose_as, expose_as_underscored].uniq
        method_names.each do |method_name|
          # Don't define a helper method if it would override something.
          if method_defined?(method_name)
            GraphQL::Deprecation.warn(
              "Unable to define a helper for argument with name '#{method_name}' "\
              "as this is a reserved name. Add `method_access: false` to stop this warning."
            )
          else
            define_method(method_name) do
              # Always use `expose_as` here, since #[] doesn't accept underscored names
              self[expose_as]
            end
          end
        end
      end
    end
  end
end

Instance Method Details

#[](key) ⇒ Object

Returns the argument at that key.

Parameters:

  • key (String, Symbol) —

    name or index of value to access

Returns:

  • (Object) —

    the argument at that key



57
58
59
60
 
# File 'lib/graphql/query/arguments.rb', line 57

def [](key)
  key_s = key.is_a?(String) ? key : key.to_s
  @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).value
end

#default_used?(key) ⇒ Boolean

Returns true if the argument default was passed as the argument value to the resolver.

Parameters:

  • key (String, Symbol) —

    name of value to access

Returns:

  • (Boolean) —

    true if the argument default was passed as the argument value to the resolver



71
72
73
74
 
# File 'lib/graphql/query/arguments.rb', line 71

def default_used?(key)
  key_s = key.is_a?(String) ? key : key.to_s
  @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).default_used?
end

#each_value {|argument_value| ... } ⇒ Object

Access each key, value and type for the arguments in this set.

Yields:

Yield Parameters:



99
100
101
102
103
 
# File 'lib/graphql/query/arguments.rb', line 99

def each_value
  @argument_values.each_value do |argument_value|
    yield(argument_value)
  end
end

#key?(key) ⇒ Boolean

Returns true if the argument was present in this field.

Parameters:

  • key (String, Symbol) —

    name of value to access

Returns:

  • (Boolean) —

    true if the argument was present in this field



64
65
66
67
 
# File 'lib/graphql/query/arguments.rb', line 64

def key?(key)
  key_s = key.is_a?(String) ? key : key.to_s
  @argument_values.key?(key_s)
end

#prepare ⇒ Object 



92
93
94
 
# File 'lib/graphql/query/arguments.rb', line 92

def prepare
  self
end

#to_h ⇒ Hash

Get the hash of all values, with stringified keys

Returns:

  • (Hash) —

    the stringified hash



78
79
80
81
82
83
84
85
86
87
 
# File 'lib/graphql/query/arguments.rb', line 78

def to_h
  @to_h ||= begin
    h = {}
    each_value do |arg_value|
      arg_key = arg_value.definition.expose_as
      h[arg_key] = unwrap_value(arg_value.value)
    end
    h
  end
end

#to_kwargs ⇒ {Symbol=>Object} Also known as: to_hash

Convert this instance into valid Ruby keyword arguments

Returns:

  • ({Symbol=>Object}) 


117
118
119
120
121
122
123
124
125
 
# File 'lib/graphql/query/arguments.rb', line 117

def to_kwargs
  ruby_kwargs = {}

  keys.each do |key|
    ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = self[key]
  end

  ruby_kwargs
end