graphql 0.16.0 → 2.0.15

data/lib/graphql/define/type_definer.rb

@@ -1,30 +0,0 @@
-module GraphQL
-  module Define
-    # Some conveniences for definining return & argument types.
-    #
-    # Passed into initialization blocks, eg {ObjectType#initialize}, {Field#initialize}
-    class TypeDefiner
-      include Singleton
-      # rubocop:disable Style/MethodName
-      def Int;      GraphQL::INT_TYPE;      end
-      def String;   GraphQL::STRING_TYPE;   end
-      def Float;    GraphQL::FLOAT_TYPE;    end
-      def Boolean;  GraphQL::BOOLEAN_TYPE;  end
-      def ID;       GraphQL::ID_TYPE;       end
-      # rubocop:enable Style/MethodName
-
-      # Make a {ListType} which wraps the input type
-      #
-      # @example making a list type
-      #   list_of_strings = types[types.String]
-      #   list_of_strings.inspect
-      #   # => "[String]"
-      #
-      # @param type [Type] A type to be wrapped in a ListType
-      # @return [GraphQL::ListType] A ListType wrapping `type`
-      def [](type)
-        type.to_list_type
-      end
-    end
-  end
-end

data/lib/graphql/define.rb

@@ -1,8 +0,0 @@
-require "graphql/define/assign_argument"
-require "graphql/define/assign_enum_value"
-require "graphql/define/assign_object_field"
-require "graphql/define/assignment_dictionary"
-require "graphql/define/defined_object_proxy"
-require "graphql/define/instance_definable"
-require "graphql/define/non_null_with_bang"
-require "graphql/define/type_definer"

data/lib/graphql/directive/include_directive.rb

@@ -1,10 +0,0 @@
-GraphQL::Directive::IncludeDirective = GraphQL::Directive.define do
-  name "include"
-  description "Include this part of the query if `if` is true"
-  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
-  argument :if, !GraphQL::BOOLEAN_TYPE
-
-  include_proc -> (arguments) {
-    arguments["if"]
-  }
-end

data/lib/graphql/directive/skip_directive.rb

@@ -1,11 +0,0 @@
-GraphQL::Directive::SkipDirective = GraphQL::Directive.define do
-  name "skip"
-  description "Ignore this part of the query if `if` is true"
-  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
-
-  argument :if, !GraphQL::BOOLEAN_TYPE
-
-  include_proc -> (arguments) {
-    !arguments["if"]
-  }
-end

data/lib/graphql/directive.rb

@@ -1,49 +0,0 @@
-module GraphQL
-  class Directive
-    include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, :include_proc, argument: GraphQL::Define::AssignArgument
-
-    attr_accessor :locations, :arguments, :name, :description
-
-    LOCATIONS = [
-      QUERY =               :QUERY,
-      MUTATION =            :MUTATION,
-      SUBSCRIPTION =        :SUBSCRIPTION,
-      FIELD =               :FIELD,
-      FRAGMENT_DEFINITION = :FRAGMENT_DEFINITION,
-      FRAGMENT_SPREAD =     :FRAGMENT_SPREAD,
-      INLINE_FRAGMENT =     :INLINE_FRAGMENT,
-    ]
-
-    def initialize
-      @arguments = {}
-    end
-
-    def include?(arguments)
-      @include_proc.call(arguments)
-    end
-
-    def include_proc=(include_proc)
-      @include_proc = include_proc
-    end
-
-    def to_s
-      "<GraphQL::Directive #{name}>"
-    end
-
-    def on_field?
-      locations.include?(FIELD)
-    end
-
-    def on_fragment?
-      locations.include?(FRAGMENT_SPREAD) && locations.include?(INLINE_FRAGMENT)
-    end
-
-    def on_operation?
-      locations.include?(QUERY) && locations.include?(MUTATION) && locations.include?(SUBSCRIPTION)
-    end
-  end
-end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"

data/lib/graphql/enum_type.rb

@@ -1,95 +0,0 @@
-module GraphQL
-  # A finite set of possible values, represented in query strings with
-  # SCREAMING_CASE_NAMES
-  #
-  # @example An enum of programming languages
-  #
-  #   LanguageEnum = GraphQL::EnumType.define do
-  #     name "Languages"
-  #     description "Programming languages for Web projects"
-  #     value("PYTHON", "A dynamic, function-oriented language")
-  #     value("RUBY", "A very dynamic language aimed at programmer happiness")
-  #     value("JAVASCRIPT", "Accidental lingua franca of the web")
-  #   end
-  class EnumType < GraphQL::BaseType
-    accepts_definitions value: GraphQL::Define::AssignEnumValue
-
-    def initialize
-      @values_by_name = {}
-      @values_by_value = {}
-    end
-
-    def values=(values)
-      @values_by_name = {}
-      @values_by_value = {}
-      values.each { |enum_value| add_value(enum_value) }
-    end
-
-    def add_value(enum_value)
-      @values_by_name[enum_value.name] = enum_value
-      @values_by_value[enum_value.value] = enum_value
-    end
-
-    def values
-      @values_by_name
-    end
-
-    # Define a value within this enum
-    # @deprecated use {.define} API instead
-    # @param name [String] the string representation of this value
-    # @param description [String]
-    # @param deprecation_reason [String] if provided, `deprecated?` will be true
-    # @param value [Object] the underlying value for this enum value
-    def value(name, description=nil, deprecation_reason: nil, value: name)
-      values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
-    end
-
-    def kind
-      GraphQL::TypeKinds::ENUM
-    end
-
-    def validate_non_null_input(value_name)
-      result = GraphQL::Query::InputValidationResult.new
-
-      if !@values_by_name.key?(value_name)
-        result.add_problem("Expected #{JSON.dump(value_name)} to be one of: #{@values_by_name.keys.join(', ')}")
-      end
-
-      result
-    end
-
-    # Get the underlying value for this enum value
-    #
-    # @example get episode value from Enum
-    #   episode = EpisodeEnum.coerce("NEWHOPE")
-    #   episode # => 6
-    #
-    # @param value_name [String] the string representation of this enum value
-    # @return [Object] the underlying value for this enum value
-    def coerce_non_null_input(value_name)
-      return nil unless @values_by_name.key?(value_name)
-      @values_by_name.fetch(value_name).value
-    end
-
-    def coerce_result(value)
-      @values_by_value.fetch(value).name
-    end
-
-    def to_s
-      name
-    end
-
-    # A value within an {EnumType}
-    #
-    # Created with {EnumType#value}
-    class EnumValue
-      attr_accessor :name, :description, :deprecation_reason, :value
-      def initialize(name:, description:, deprecation_reason:, value:)
-        @name = name
-        @description = description
-        @deprecation_reason = deprecation_reason
-        @value = value
-      end
-    end
-  end
-end

data/lib/graphql/field.rb

@@ -1,131 +0,0 @@
-module GraphQL
-  # {Field}s belong to {ObjectType}s and {InterfaceType}s.
-  #
-  # They're usually created with the `field` helper. If you create it by hand, make sure {#name} is a String.
-  #
-  # @example creating a field
-  #   GraphQL::ObjectType.define do
-  #     field :name, types.String, "The name of this thing "
-  #   end
-  #
-  # @example handling a circular reference
-  #   # If the field's type isn't defined yet, you have two options:
-  #
-  #   GraphQL::ObjectType.define do
-  #     # If you pass a Proc, it will be evaluated at schema build-time
-  #     field :city, -> { CityType }
-  #     # If you pass a String, it will be looked up in the global namespace at schema build-time
-  #     field :country, "CountryType"
-  #   end
-  #
-  # @example creating a field that accesses a different property on the object
-  #   GraphQL::ObjectType.define do
-  #     # use the `property` option:
-  #     field :firstName, types.String, property: :first_name
-  #   end
-  #
-  # @example defining a field, then attaching it to a type
-  #   name_field = GraphQL::Field.define do
-  #     name("Name")
-  #     type(!types.String)
-  #     description("The name of this thing")
-  #     resolve -> (object, arguments, context) { object.name }
-  #   end
-  #
-  #   NamedType = GraphQL::ObjectType.define do
-  #     # use the `field` option:
-  #     field :name, field: name_field
-  #   end
-  #
-  # @example Custom complexity values
-  #   # Complexity can be a number or a proc.
-  #
-  #   # Complexity can be defined with a keyword:
-  #   field :expensive_calculation, !types.Int, complexity: 10
-  #
-  #   # Or inside the block:
-  #   field :expensive_calculation_2, !types.Int do
-  #     complexity -> (ctx, args, child_complexity) { ctx[:current_user].staff? ? 0 : 10 }
-  #   end
-  #
-  # @example Calculating the complexity of a list field
-  #   field :items, types[ItemType] do
-  #     argument :limit, !types.Int
-  #     # Mulitply the child complexity by the possible items on the list
-  #     complexity -> (ctx, args, child_complexity) { child_complexity * args[:limit] }
-  #   end
-  #
-  class Field
-    include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :description, :resolve, :type, :property, :deprecation_reason, :complexity, argument: GraphQL::Define::AssignArgument
-
-    attr_accessor :deprecation_reason, :name, :description, :property
-
-    attr_reader :resolve_proc
-
-    # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
-    attr_reader :name
-
-    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-    attr_accessor :arguments
-
-    # @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `-> (query_ctx, args, child_complexity) { } # Numeric`
-    attr_accessor :complexity
-
-    def initialize
-      @complexity = 1
-      @arguments = {}
-      @resolve_proc = build_default_resolver
-    end
-
-    # Get a value for this field
-    # @example resolving a field value
-    #   field.resolve(obj, args, ctx)
-    #
-    # @param object [Object] The object this field belongs to
-    # @param arguments [Hash] Arguments declared in the query
-    # @param context [GraphQL::Query::Context]
-    def resolve(object, arguments, context)
-      @resolve_proc.call(object, arguments, context)
-    end
-
-    def resolve=(resolve_proc)
-      @resolve_proc = resolve_proc || build_default_resolver
-    end
-
-    def type=(new_return_type)
-      @clean_type = nil
-      @dirty_type = new_return_type
-    end
-
-    # Get the return type for this field.
-    def type
-      @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
-    end
-
-    # You can only set a field's name _once_ -- this to prevent
-    # passing the same {Field} to multiple `.field` calls.
-    #
-    # This is important because {#name} may be used by {#resolve}.
-    def name=(new_name)
-      if @name.nil?
-        @name = new_name
-      else
-        raise("Can't rename an already-named field. (Tried to rename \"#{@name}\" to \"#{new_name}\".) If you're passing a field with the `field:` argument, make sure it's an unused instance of GraphQL::Field.")
-      end
-    end
-
-    def to_s
-      "<Field: #{name || "not-named"}>"
-    end
-
-    private
-
-    def build_default_resolver
-      -> (obj, args, ctx) do
-        resolve_method = self.property || self.name
-        obj.public_send(resolve_method)
-      end
-    end
-  end
-end

data/lib/graphql/float_type.rb

@@ -1,5 +0,0 @@
-GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
-  name "Float"
-  coerce_input -> (value) { value.is_a?(Numeric) ? value.to_f : nil }
-  coerce_result -> (value) { value.to_f }
-end

data/lib/graphql/id_type.rb

@@ -1,12 +0,0 @@
-GraphQL::ID_TYPE = GraphQL::ScalarType.define do
-  name "ID"
-  coerce_result -> (value) { value.to_s }
-  coerce_input -> (value) {
-    case value
-    when String, Fixnum, Bignum
-      value.to_s
-    else
-      nil
-    end
-  }
-end

data/lib/graphql/input_object_type.rb

@@ -1,71 +0,0 @@
-module GraphQL
-  # A complex input type for a field argument.
-  #
-  # @example An input type with name and number
-  #   PlayerInput = GraphQL::InputObjectType.define do
-  #     name("Player")
-  #     input_field :name, !types.String
-  #     input_field :number, !types.Int
-  #   end
-  #
-  class InputObjectType < GraphQL::BaseType
-    accepts_definitions(
-      input_field: GraphQL::Define::AssignArgument,
-      argument: GraphQL::Define::AssignArgument
-    )
-
-    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-    attr_accessor :arguments
-
-    alias :input_fields :arguments
-
-    def initialize
-      @arguments = {}
-    end
-
-    def kind
-      GraphQL::TypeKinds::INPUT_OBJECT
-    end
-
-    def validate_non_null_input(input)
-      result = GraphQL::Query::InputValidationResult.new
-
-      # Items in the input that are unexpected
-      input.each do |name, value|
-        if arguments[name].nil?
-          result.add_problem("Field is not defined on #{self.name}", [name])
-        end
-      end
-
-      # Items in the input that are expected, but have invalid values
-      invalid_fields = arguments.map do |name, field|
-        field_result = field.type.validate_input(input[name])
-        if !field_result.valid?
-          result.merge_result!(name, field_result)
-        end
-      end
-
-      result
-    end
-
-    def coerce_non_null_input(value)
-      input_values = {}
-
-      arguments.each do |input_key, input_field_defn|
-        field_value = value[input_key]
-        field_value = input_field_defn.type.coerce_input(field_value)
-
-        # Try getting the default value
-        if field_value.nil?
-          field_value = input_field_defn.default_value
-        end
-
-        if !field_value.nil?
-          input_values[input_key] = field_value
-        end
-      end
-
-      GraphQL::Query::Arguments.new(input_values)
-    end
-  end
-end

data/lib/graphql/int_type.rb

@@ -1,5 +0,0 @@
-GraphQL::INT_TYPE = GraphQL::ScalarType.define do
-  name "Int"
-  coerce_input -> (value) { value.is_a?(Numeric) ? value.to_i : nil }
-  coerce_result -> (value) { value.to_i }
-end

data/lib/graphql/interface_type.rb

@@ -1,38 +0,0 @@
-module GraphQL
-  # A collection of types which implement the same fields
-  #
-  # @example An interface with three required fields
-  #   DeviceInterface = GraphQL::InterfaceType.define do
-  #     name("Device")
-  #     description("Hardware devices for computing")
-  #
-  #     field :ram, types.String
-  #     field :processor, ProcessorType
-  #     field :release_year, types.Int
-  #   end
-  #
-  class InterfaceType < GraphQL::BaseType
-    include GraphQL::BaseType::HasPossibleTypes
-    accepts_definitions :resolve_type, field: GraphQL::Define::AssignObjectField
-
-    attr_accessor :fields
-
-    def initialize
-      @fields = {}
-    end
-
-    def kind
-      GraphQL::TypeKinds::INTERFACE
-    end
-
-    # @return [GraphQL::Field] The defined field for `field_name`
-    def get_field(field_name)
-      fields[field_name]
-    end
-
-    # @return [Array<GraphQL::Field>] All fields on this type
-    def all_fields
-      fields.values
-    end
-  end
-end

data/lib/graphql/internal_representation/node.rb

@@ -1,81 +0,0 @@
-require "set"
-
-module GraphQL
-  module InternalRepresentation
-    class Node
-      def initialize(ast_node:, return_type: nil, on_types: Set.new, name: nil, definition: nil, children: {}, spreads: [], directives: Set.new)
-        @ast_node = ast_node
-        @return_type = return_type
-        @on_types = on_types
-        @name = name
-        @definition = definition
-        @children = children
-        @spreads = spreads
-        @directives = directives
-      end
-
-      # Note: by the time this gets out of the Rewrite phase, this will be empty -- it's emptied out when fragments are merged back in
-      # @return [Array<GraphQL::Language::Nodes::FragmentSpreads>] Fragment names that were spread in this node
-      attr_reader :spreads
-
-      # These are the compiled directives from fragment spreads, inline fragments, and the field itself
-      # @return [Set<GraphQL::Language::Nodes::Directive>]
-      attr_reader :directives
-
-      # @return [GraphQL::Field, GraphQL::Directive] The definition to use to execute this node
-      attr_reader :definition
-
-      # @return [String] the name to use for the result in the response hash
-      attr_reader :name
-
-      # @return [GraphQL::Language::Nodes::AbstractNode] The AST node (or one of the nodes) where this was derived from
-      attr_reader :ast_node
-
-      # This may come from the previous field's return value or an explicitly-typed fragment
-      # @example On-type from previous return value
-      # {
-      #   person(id: 1) {
-      #     firstName # => on_type is person
-      #   }
-      # }
-      # @example On-type from explicit type condition
-      # {
-      #   node(id: $nodeId) {
-      #     ... on Nameable {
-      #       firstName # => on_type is Nameable
-      #     }
-      #   }
-      # }
-      # @return [Set<GraphQL::ObjectType, GraphQL::InterfaceType>] the types this field applies to
-      attr_reader :on_types
-
-      # @return [GraphQL::BaseType]
-      attr_reader :return_type
-
-      # @return [Array<GraphQL::Query::Node>]
-      attr_reader :children
-
-      def inspect(indent = 0)
-        own_indent = " " * indent
-        self_inspect = "#{own_indent}<Node #{name} (#{definition ? definition.name + ": " : ""}{#{on_types.to_a.join("|")}} -> #{return_type})>"
-        if children.any?
-          self_inspect << " {\n#{children.values.map { |n| n.inspect(indent + 2 )}.join("\n")}\n#{own_indent}}"
-        end
-        self_inspect
-      end
-
-      def dup
-        self.class.new({
-          ast_node: ast_node,
-          return_type: return_type,
-          on_types: on_types,
-          name: name,
-          definition: definition,
-          children: children,
-          spreads: spreads,
-          directives: directives,
-        })
-      end
-    end
-  end
-end