module GraphQL::Schema::Interface::DefinitionMethods

# File lib/graphql/schema/interface.rb, line 24
def definition_methods(&block)
  # Use an instance variable to tell whether it's been included previously or not;
  # You can't use constant detection because constants are brought into scope
  # by `include`, which has already happened at this point.
  if !defined?(@_definition_methods)
    defn_methods_module = Module.new
    @_definition_methods = defn_methods_module
    const_set(:DefinitionMethods, defn_methods_module)
    extend(defn_methods_module)
  end
  const_get(:DefinitionMethods).module_exec(&block)
end

# File lib/graphql/schema/interface.rb, line 75
def included(child_class)
  if !child_class.is_a?(Class)
    # In this case, it's been included into another interface.
    # This is how interface inheritance is implemented

    # We need this before we can call `own_interfaces`
    child_class.extend(Schema::Interface::DefinitionMethods)

    child_class.type_membership_class(self.type_membership_class)
    child_class.ancestors.reverse_each do |ancestor|
      if ancestor.const_defined?(:DefinitionMethods) && ancestor != child_class
        child_class.extend(ancestor.const_get(:DefinitionMethods))
      end
    end

    child_class.introspection(introspection)
    child_class.description(description)
    child_class.comment(nil)
    # If interfaces are mixed into each other, only define this class once
    if !child_class.const_defined?(:UnresolvedTypeError, false)
      add_unresolved_type_error(child_class)
    end
  elsif child_class < GraphQL::Schema::Object
    # This is being included into an object type, make sure it's using `implements(...)`
    locations = caller_locations(0, 10) #: as !nil
    backtrace_line = locations.find do |location|
      location_path = location.path #: as !nil
      location.base_label == "implements" &&
        location_path.end_with?("schema/member/has_interfaces.rb")
    end

    if !backtrace_line
      raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
    end

    child_class.ancestors.reverse_each do |ancestor|
      if ancestor != child_class && ancestor <= GraphQL::Schema::Interface && ancestor.const_defined?(:ResolverMethods, false)
        child_class.extend(ancestor.const_get(:ResolverMethods))
      end
    end
  end

  super
end

# File lib/graphql/schema/interface.rb, line 155
def kind
  GraphQL::TypeKinds::INTERFACE
end

# File lib/graphql/schema/interface.rb, line 135
def orphan_types(*types)
  if !types.empty?
    @orphan_types ||= []
    @orphan_types.concat(types)
  else
    if defined?(@orphan_types)
      all_orphan_types = @orphan_types.dup
      if defined?(super)
        all_orphan_types += super
        all_orphan_types.uniq!
      end
      all_orphan_types
    elsif defined?(super)
      super
    else
      EmptyObjects::EMPTY_ARRAY
    end
  end
end

# File lib/graphql/schema/interface.rb, line 51
def resolver_methods(&block)
  if !defined?(@_resolver_methods)
    resolver_methods_module = Module.new
    @_resolver_methods = resolver_methods_module
    const_set(:ResolverMethods, resolver_methods_module)
    extend(resolver_methods_module)
  end
  const_get(:ResolverMethods).module_exec(&block)
end

# File lib/graphql/schema/interface.rb, line 66
def type_membership_class(membership_class = nil)
  if membership_class
    @type_membership_class = membership_class
  else
    @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
  end
end

# File lib/graphql/schema/interface.rb, line 62
def visible?(context)
  true
end