graphql_cody 1.13.0

data/lib/graphql/define/defined_object_proxy.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Define
+    # This object delegates most methods to a dictionary of functions, {@dictionary}.
+    # {@target} is passed to the specified function, along with any arguments and block.
+    # This allows a method-based DSL without adding methods to the defined class.
+    class DefinedObjectProxy
+      extend GraphQL::Ruby2Keywords
+      # The object which will be defined by definition functions
+      attr_reader :target
+
+      def initialize(target)
+        @target = target
+        @dictionary = target.class.dictionary
+      end
+
+      # Provides shorthand access to GraphQL's built-in types
+      def types
+        GraphQL::Define::TypeDefiner.instance
+      end
+
+      # Allow `plugin` to perform complex initialization on the definition.
+      # Calls `plugin.use(defn, **kwargs)`.
+      # @param plugin [<#use(defn, **kwargs)>] A plugin object
+      # @param kwargs [Hash] Any options for the plugin
+      def use(plugin, **kwargs)
+        # https://bugs.ruby-lang.org/issues/10708
+        if kwargs == {}
+          plugin.use(self)
+        else
+          plugin.use(self, **kwargs)
+        end
+      end
+
+      # Lookup a function from the dictionary and call it if it's found.
+      def method_missing(name, *args, &block)
+        definition = @dictionary[name]
+        if definition
+          definition.call(@target, *args, &block)
+        else
+          msg = "#{@target.class.name} can't define '#{name}'"
+          raise NoDefinitionError, msg, caller
+        end
+      end
+      ruby2_keywords :method_missing
+
+      def respond_to_missing?(name, include_private = false)
+        @dictionary[name] || super
+      end
+    end
+  end
+end

data/lib/graphql/define/instance_definable.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+module GraphQL
+  module Define
+    # @api deprecated
+    module InstanceDefinable
+      module DeprecatedDefine
+        def define(**kwargs, &block)
+          deprecated_caller = caller(1, 1).first
+          if deprecated_caller.include?("lib/graphql")
+            deprecated_caller = caller(2, 10).find { |c| !c.include?("lib/graphql") }
+          end
+
+          if deprecated_caller
+            GraphQL::Deprecation.warn <<-ERR
+#{self}.define will be removed in GraphQL-Ruby 2.0; use a class-based definition instead. See https://graphql-ruby.org/schema/class_based_api.html.
+  -> called from #{deprecated_caller}
+ERR
+          end
+          deprecated_define(**kwargs, &block)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.ensure_defined(:metadata)
+      end
+
+      # @api deprecated
+      def metadata
+        @metadata ||= {}
+      end
+
+      # @api deprecated
+      def deprecated_define(**kwargs, &block)
+        # make sure the previous definition_proc was executed:
+        ensure_defined
+        stash_dependent_methods
+        @pending_definition = Definition.new(kwargs, block)
+        nil
+      end
+
+      # @api deprecated
+      def define(**kwargs, &block)
+        deprecated_define(**kwargs, &block)
+      end
+
+      # @api deprecated
+      def redefine(**kwargs, &block)
+        ensure_defined
+        new_inst = self.dup
+        new_inst.deprecated_define(**kwargs, &block)
+        new_inst
+      end
+
+      def initialize_copy(other)
+        super
+        @metadata = other.metadata.dup
+      end
+
+      private
+
+      # Run the definition block if it hasn't been run yet.
+      # This can only be run once: the block is deleted after it's used.
+      # You have to call this before using any value which could
+      # come from the definition block.
+      # @return [void]
+      def ensure_defined
+        if @pending_definition
+          defn = @pending_definition
+          @pending_definition = nil
+
+          revive_dependent_methods
+
+          begin
+            defn_proxy = DefinedObjectProxy.new(self)
+            # Apply definition from `define(...)` kwargs
+            defn.define_keywords.each do |keyword, value|
+              # Don't splat string hashes, which blows up on Rubies before 2.7
+              if value.is_a?(Hash) && !value.empty? && value.each_key.all? { |k| k.is_a?(Symbol) }
+                defn_proxy.public_send(keyword, **value)
+              else
+                defn_proxy.public_send(keyword, value)
+              end
+            end
+            # and/or apply definition from `define { ... }` block
+            if defn.define_proc
+              defn_proxy.instance_eval(&defn.define_proc)
+            end
+          rescue StandardError
+            # The definition block failed to run, so make this object pending again:
+            stash_dependent_methods
+            @pending_definition = defn
+            raise
+          end
+        end
+        nil
+      end
+
+      # Take the pending methods and put them back on this object's singleton class.
+      # This reverts the process done by {#stash_dependent_methods}
+      # @return [void]
+      def revive_dependent_methods
+        pending_methods = @pending_methods
+        self.singleton_class.class_eval {
+          pending_methods.each do |method|
+            undef_method(method.name) if method_defined?(method.name)
+            define_method(method.name, method)
+          end
+        }
+        @pending_methods = nil
+      end
+
+      # Find the method names which were declared as definition-dependent,
+      # then grab the method definitions off of this object's class
+      # and store them for later.
+      #
+      # Then make a dummy method for each of those method names which:
+      #
+      # - Triggers the pending definition, if there is one
+      # - Calls the same method again.
+      #
+      # It's assumed that {#ensure_defined} will put the original method definitions
+      # back in place with {#revive_dependent_methods}.
+      # @return [void]
+      def stash_dependent_methods
+        method_names = self.class.ensure_defined_method_names
+        @pending_methods = method_names.map { |n| self.class.instance_method(n) }
+        self.singleton_class.class_eval do
+          method_names.each do |method_name|
+            undef_method(method_name) if method_defined?(method_name)
+            define_method(method_name) { |*args, &block|
+              ensure_defined
+              self.send(method_name, *args, &block)
+            }
+          end
+        end
+      end
+
+      class Definition
+        attr_reader :define_keywords, :define_proc
+        def initialize(define_keywords, define_proc)
+          @define_keywords = define_keywords
+          @define_proc = define_proc
+        end
+      end
+
+      module ClassMethods
+        # Create a new instance
+        # and prepare a definition using its {.definitions}.
+        # @api deprecated
+        # @param kwargs [Hash] Key-value pairs corresponding to defininitions from `accepts_definitions`
+        # @param block [Proc] Block which calls helper methods from `accepts_definitions`
+        def deprecated_define(**kwargs, &block)
+          instance = self.new
+          instance.deprecated_define(**kwargs, &block)
+          instance
+        end
+
+        # @api deprecated
+        def define(**kwargs, &block)
+          instance = self.new
+          instance.define(**kwargs, &block)
+          instance
+        end
+
+        # Attach definitions to this class.
+        # Each symbol in `accepts` will be assigned with `{key}=`.
+        # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
+        def accepts_definitions(*accepts)
+          new_assignments = if accepts.last.is_a?(Hash)
+            accepts.pop.dup
+          else
+            {}
+          end
+
+          accepts.each do |key|
+            new_assignments[key] = AssignAttribute.new(key)
+          end
+
+          @own_dictionary = own_dictionary.merge(new_assignments)
+        end
+
+        def ensure_defined(*method_names)
+          @ensure_defined_method_names ||= []
+          @ensure_defined_method_names.concat(method_names)
+          nil
+        end
+
+        def ensure_defined_method_names
+          own_method_names = @ensure_defined_method_names || []
+          if superclass.respond_to?(:ensure_defined_method_names)
+            superclass.ensure_defined_method_names + own_method_names
+          else
+            own_method_names
+          end
+        end
+
+        # @return [Hash] combined definitions for self and ancestors
+        def dictionary
+          if superclass.respond_to?(:dictionary)
+            own_dictionary.merge(superclass.dictionary)
+          else
+            own_dictionary
+          end
+        end
+
+        # @return [Hash] definitions for this class only
+        def own_dictionary
+          @own_dictionary ||= {}
+        end
+      end
+
+      class AssignMetadataKey
+        def initialize(key)
+          @key = key
+        end
+
+        def call(defn, value = true)
+          defn.metadata[@key] = value
+        end
+      end
+
+      class AssignAttribute
+        extend GraphQL::Ruby2Keywords
+
+        def initialize(attr_name)
+          @attr_assign_method = :"#{attr_name}="
+        end
+
+        # Even though we're just using the first value here,
+        # We have to add a splat here to use `ruby2_keywords`,
+        # so that it will accept a `[{}]` input from the caller.
+        def call(defn, *value)
+          defn.public_send(@attr_assign_method, value.first)
+        end
+        ruby2_keywords :call
+      end
+    end
+  end
+end

data/lib/graphql/define/no_definition_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module GraphQL
+  module Define
+    class NoDefinitionError < GraphQL::Error
+    end
+  end
+end

data/lib/graphql/define/non_null_with_bang.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  module Define
+    # Wrap the object in NonNullType in response to `!`
+    # @example required Int type
+    #   !GraphQL::INT_TYPE
+    #
+    module NonNullWithBang
+      # Make the type non-null
+      # @return [GraphQL::NonNullType] a non-null type which wraps the original type
+      def !
+        to_non_null_type
+      end
+    end
+  end
+end

data/lib/graphql/define/type_definer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+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 Naming/MethodName
+      def Int;      GraphQL::DEPRECATED_INT_TYPE;      end
+      def String;   GraphQL::DEPRECATED_STRING_TYPE;   end
+      def Float;    GraphQL::DEPRECATED_FLOAT_TYPE;    end
+      def Boolean;  GraphQL::DEPRECATED_BOOLEAN_TYPE;  end
+      def ID;       GraphQL::DEPRECATED_ID_TYPE;       end
+      # rubocop:enable Naming/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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require "graphql/define/assign_argument"
+require "graphql/define/assign_connection"
+require "graphql/define/assign_enum_value"
+require "graphql/define/assign_global_id_field"
+require "graphql/define/assign_mutation_function"
+require "graphql/define/assign_object_field"
+require "graphql/define/defined_object_proxy"
+require "graphql/define/instance_definable"
+require "graphql/define/no_definition_error"
+require "graphql/define/non_null_with_bang"
+require "graphql/define/type_definer"
+
+module GraphQL
+  module Define
+    # A helper for definitions that store their value in `#metadata`.
+    #
+    # @example Storing application classes with GraphQL types
+    #   # Make a custom definition
+    #   GraphQL::ObjectType.accepts_definitions(resolves_to_class_names: GraphQL::Define.assign_metadata_key(:resolves_to_class_names))
+    #
+    #   # After definition, read the key from metadata
+    #   PostType.metadata[:resolves_to_class_names] # => [...]
+    #
+    # @param key [Object] the key to assign in metadata
+    # @return [#call(defn, value)] an assignment for `.accepts_definitions` which writes `key` to `#metadata`
+    def self.assign_metadata_key(key)
+      GraphQL::Define::InstanceDefinable::AssignMetadataKey.new(key)
+    end
+  end
+end

data/lib/graphql/deprecated_dsl.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module GraphQL
+  # There are two ways to apply the deprecated `!` DSL to class-style schema definitions:
+  #
+  # 1. Scoped by file (CRuby only), add to the top of the file:
+  #
+  #      using GraphQL::DeprecationDSL
+  #
+  #   (This is a "refinement", there are also other ways to scope it.)
+  #
+  # 2. Global application, add before schema definition:
+  #
+  #      GraphQL::DeprecationDSL.activate
+  #
+  module DeprecatedDSL
+    TYPE_CLASSES = [
+      GraphQL::Schema::Scalar,
+      GraphQL::Schema::Enum,
+      GraphQL::Schema::InputObject,
+      GraphQL::Schema::Union,
+      GraphQL::Schema::Interface,
+      GraphQL::Schema::Object,
+    ]
+
+    def self.activate
+      deprecated_caller = caller(1, 1).first
+      GraphQL::Deprecation.warn "DeprecatedDSL will be removed from GraphQL-Ruby 2.0, use `.to_non_null_type` instead of `!` and remove `.activate` from #{deprecated_caller}"
+      TYPE_CLASSES.each { |c| c.extend(Methods) }
+      GraphQL::Schema::List.include(Methods)
+      GraphQL::Schema::NonNull.include(Methods)
+    end
+
+    module Methods
+      def !
+        deprecated_caller = caller(1, 1).first
+        GraphQL::Deprecation.warn "DeprecatedDSL will be removed from GraphQL-Ruby 2.0, use `.to_non_null_type` instead of `!` at #{deprecated_caller}"
+        to_non_null_type
+      end
+    end
+
+    if defined?(::Refinement) && Refinement.private_method_defined?(:import_methods)
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          import_methods Methods
+        end
+      end
+    else
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          include Methods
+        end
+      end
+    end
+  end
+end

data/lib/graphql/deprecation.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Deprecation
+    def self.warn(message)
+      Kernel.warn(message)
+    end
+  end
+end

data/lib/graphql/dig.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  module Dig
+    # implemented using the old activesupport #dig instead of the ruby built-in
+    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # to handle stringified/symbolized keys.
+    #
+    # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
+    # @return [Object]
+    def dig(own_key, *rest_keys)
+      val = self[own_key]
+      if val.nil? || rest_keys.empty?
+        val
+      else
+        val.dig(*rest_keys)
+      end
+    end
+  end
+end

data/lib/graphql/directive/deprecated_directive.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition

data/lib/graphql/directive/include_directive.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition

data/lib/graphql/directive/skip_directive.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition

data/lib/graphql/directive.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+module GraphQL
+  # Directives are server-defined hooks for modifying execution.
+  #
+  # Two directives are included out-of-the-box:
+  # - `@skip(if: ...)` Skips the tagged field if the value of `if` is true
+  # - `@include(if: ...)` Includes the tagged field _only_ if `if` is true
+  #
+  class Directive
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
+
+    attr_accessor :locations, :arguments, :name, :description, :arguments_class
+    attr_accessor :ast_node
+    # @api private
+    attr_writer :default_directive
+    ensure_defined(:locations, :arguments, :graphql_name, :name, :description, :default_directive?)
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_name :name
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
+    LOCATIONS = [
+      QUERY =                  :QUERY,
+      MUTATION =               :MUTATION,
+      SUBSCRIPTION =           :SUBSCRIPTION,
+      FIELD =                  :FIELD,
+      FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
+      FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
+      INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+      SCHEMA =                 :SCHEMA,
+      SCALAR =                 :SCALAR,
+      OBJECT =                 :OBJECT,
+      FIELD_DEFINITION =       :FIELD_DEFINITION,
+      ARGUMENT_DEFINITION =    :ARGUMENT_DEFINITION,
+      INTERFACE =              :INTERFACE,
+      UNION =                  :UNION,
+      ENUM =                   :ENUM,
+      ENUM_VALUE =             :ENUM_VALUE,
+      INPUT_OBJECT =           :INPUT_OBJECT,
+      INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
+    ]
+
+    LOCATION_DESCRIPTIONS = {
+      QUERY:                    'Location adjacent to a query operation.',
+      MUTATION:                 'Location adjacent to a mutation operation.',
+      SUBSCRIPTION:             'Location adjacent to a subscription operation.',
+      FIELD:                    'Location adjacent to a field.',
+      FRAGMENT_DEFINITION:      'Location adjacent to a fragment definition.',
+      FRAGMENT_SPREAD:          'Location adjacent to a fragment spread.',
+      INLINE_FRAGMENT:          'Location adjacent to an inline fragment.',
+      SCHEMA:                   'Location adjacent to a schema definition.',
+      SCALAR:                   'Location adjacent to a scalar definition.',
+      OBJECT:                   'Location adjacent to an object type definition.',
+      FIELD_DEFINITION:         'Location adjacent to a field definition.',
+      ARGUMENT_DEFINITION:      'Location adjacent to an argument definition.',
+      INTERFACE:                'Location adjacent to an interface definition.',
+      UNION:                    'Location adjacent to a union definition.',
+      ENUM:                     'Location adjacent to an enum definition.',
+      ENUM_VALUE:               'Location adjacent to an enum value definition.',
+      INPUT_OBJECT:             'Location adjacent to an input object type definition.',
+      INPUT_FIELD_DEFINITION:   'Location adjacent to an input object field definition.',
+    }
+
+    def initialize
+      @arguments = {}
+      @default_directive = false
+    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
+
+    # @return [Boolean] Is this directive supplied by default? (eg `@skip`)
+    def default_directive?
+      @default_directive
+    end
+
+    def inspect
+      "#<GraphQL::Directive #{name}>"
+    end
+
+    def type_class
+      metadata[:type_class]
+    end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+  end
+end