graphql-rb 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea68c93a7c58f20140405e57455f817f587a89f7
+  data.tar.gz: 1c70ce478b3283ed412d7d27c0c373d039907579
+SHA512:
+  metadata.gz: 226d8b3ec2ddfa287937c239caaaaa845a6e226fd821ac514d15de6ee0e12b40716286ef083b74f87f6302129abc2d0049fe1c5ab2cec231730ae296cb938060
+  data.tar.gz: 90420d7f666c395dfb827f27d24b6ead1ac7f8faaa5b342940b046cf9124485df6a8aac1f903ab22d307bec5cb48db01c0707c871d26c88c2e91638e508bf65b

data/Rakefile

@@ -0,0 +1,26 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'GraphQL'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test) do |test|
+  test.verbose      = false
+  test.rspec_opts   = %w[--color --format documentation]
+end
+
+task default: :test

data/lib/graphql/configuration/configurable.rb

@@ -0,0 +1,46 @@
+require_relative 'configuration'
+
+module GraphQL
+  module Configuration
+
+    class Configurable
+
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+
+      def method_missing(name, *args, &block)
+        if @configuration.respond_to?(name)
+          @configuration.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+
+      def self.new(*args, &block)
+        if args.size == 1 && !block_given? && args.first.is_a?(Base)
+          super args.first
+        else
+          configuration = self.configuration.new(*args, &block)
+          super(configuration)
+        end
+      end
+
+
+      def self.configuration
+        @configuration
+      end
+
+
+      def self.configure_with(configuration)
+        raise RuntimeError.new("Configuration should be descendant of #{Slots}.") unless configuration < Base
+        @configuration = configuration
+      end
+
+    end
+
+  end
+end

data/lib/graphql/configuration/configuration.rb

@@ -0,0 +1,92 @@
+require_relative 'slot'
+
+module GraphQL
+  module Configuration
+
+    class Base
+
+      def initialize(*args, &block)
+        options = args.last.instance_of?(Hash) ? args.pop : {}
+        slots.each { |key, slot| options[(slot.singular || slot.name).to_sym] = args.shift if args.size > 0 }
+        options.each { |key, value| public_send(key, value) }
+        instance_eval(&block) if block_given?
+      end
+
+      def slots
+        self.class.slots
+      end
+
+      class << self
+        def inherited(base)
+          base.instance_variable_set(:"@slots", @slots)
+        end
+
+        def slots
+          @slots ||= {}
+        end
+
+        def slot(*args, &block)
+          slot = Slot.new(*args, &block)
+          define_accessors(slot)
+          slots[slot.name] = slot
+        end
+
+        def coerce(slot, *args, &block)
+          if args.size == 1 && !block_given?
+            value = args.first
+            return value if value.is_a?(slot.effective_type)
+            value = slot.coerce.nil? ? value : slot.coerce.call(value)
+            return value if value.is_a?(slot.effective_type)
+            return value if value.is_a?(Proc)
+          end
+          slot.effective_type.new(*args, &block)
+        end
+
+        private
+
+        def define_accessors(slot)
+          instance_variable_name  = :"@#{slot.name}"
+          reader_name             = :"#{slot.name}"
+          writer_name             = :"#{slot.name}="
+
+          if slot.list?
+            list_instance_variable_name   = instance_variable_name
+            list_reader_name              = reader_name
+            instance_variable_name        = :"@#{slot.singular}"
+            reader_name                   = :"#{slot.singular}"
+            writer_name                   = :"#{slot.singular}="
+
+            define_method(list_reader_name) do |items = []|
+              instance_variable_set(list_instance_variable_name, []) if instance_variable_get(list_instance_variable_name).nil?
+              items.each do |item|
+                public_send(reader_name, item)
+              end
+              instance_variable_get(list_instance_variable_name)
+            end
+
+          end
+
+          define_method(writer_name) do |*args, &block|
+            if args.size > 0 || block_given?
+              value = self.class.coerce(slot, *args, &block)
+
+              raise RuntimeError.new "Cannot coerce." unless value.is_a?(slot.effective_type) || value.is_a?(Proc)
+
+              if slot.list?
+                public_send(:"#{slot.name}") << value
+              else
+                instance_variable_set(instance_variable_name, value)
+              end
+            end
+            slot.list? ? nil : instance_variable_get(instance_variable_name)
+          end
+
+          alias_method reader_name, writer_name
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/graphql/configuration/slot.rb

@@ -0,0 +1,124 @@
+module GraphQL
+  module Configuration
+
+    class Slot
+
+      def initialize(*args, &block)
+        define_methods
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options.keys.each { |key| options[key.to_sym] = options.delete(key) }
+        attributes.each { |name| options[name.to_sym] = args.shift if args.size > 0 }
+        options.each { |key, value| public_send(key, value) }
+        instance_eval(&block) if block_given?
+        validate!
+      end
+
+      def list?
+        type.is_a?(Array)
+      end
+
+      def effective_type
+        @effective_type ||= begin
+          t = list? ? type.first : type
+          t = t.call if t.is_a?(Proc)
+          t
+        end
+      end
+
+      def errors
+        @errors ||= {}
+      end
+
+      def valid?
+        errors.size == 0
+      end
+
+      def validate
+        @errors = {}
+        attributes.each { |name| send(:"validate_#{name}") }
+      end
+
+      private
+
+      def add_error(name, value)
+        (errors[name.to_sym] ||= []) << value
+      end
+
+      def validate!
+        validate
+        raise StandardError.new("#{self.class.name} validation error: #{errors.keys} #{errors.inspect}") unless valid?
+      end
+
+      def validate_name
+        add_error(:name, "missing") if @name.nil?
+        add_error(:name, "should be a String or Symbold, got #{name}") unless @name.is_a?(String) or @name.is_a?(Symbol)
+        add_error(:name, "cannot be empty") if @name.is_a?(String) && name.size == 0
+      end
+
+      def validate_type
+        add_error(:type, "missing") if @type.nil?
+
+        if type.instance_of?(Array)
+          add_type_error unless @type.size == 1
+          add_type_error unless type_valid?(@type.first)
+        else
+          add_type_error unless type_valid?(@type)
+        end
+      end
+
+      def type_valid?(type)
+        type.is_a?(Class) || type.is_a?(Module) || type.is_a?(Proc)
+      end
+
+      def add_type_error
+        add_error(:type, "should be a Class, Module or Array of one Class or Module, got #{@type}")
+      end
+
+      def validate_coerce
+        return if @coerce.nil?
+        add_error(:coerce, "should be a Proc, got #{@coerce}") unless @coerce.is_a?(Proc)
+      end
+
+      def validate_description
+        return if @description.nil?
+        add_error(:description, "should be a String, got #{@description}") unless @description.is_a?(String)
+      end
+
+      def validate_null
+        return if @null.nil?
+        add_error(:null, "should be true or false, got #{@null}") unless !!@null == @null
+      end
+
+      def validate_singular
+        @singular = :"#{@name}_item" if list? && @singular.nil?
+        return if @singular.nil?
+        add_error(:singular, "should be a String or Symbold, got #{@singular}") unless @singular.is_a?(String) or @singular.is_a?(Symbol)
+      end
+
+      def define_methods
+        attributes.each do |key|
+          instance_variable_name  = :"@#{key}"
+
+          define_singleton_method(:"#{key}") do |*args|
+            if args.size == 1
+              public_send(:"#{key}=", args.first)
+            else
+              instance_variable_get(instance_variable_name)
+            end
+          end unless methods.include?(:"#{key}")
+
+          define_singleton_method(:"#{key}=") do |value|
+            instance_variable_set(instance_variable_name, value)
+          end
+
+        end
+      end
+
+      def attributes
+        @attributes ||= [:name, :type, :coerce, :description, :null, :singular]
+      end
+
+    end
+
+  end
+end

data/lib/graphql/configuration.rb

@@ -0,0 +1,3 @@
+require_relative 'configuration/slot'
+require_relative 'configuration/configurable'
+require_relative 'configuration/configuration'

data/lib/graphql/errors/error.rb

@@ -0,0 +1,3 @@
+module GraphQL
+  class GraphQLError < StandardError; end
+end

data/lib/graphql/errors.rb

@@ -0,0 +1 @@
+require_relative 'errors/error'

data/lib/graphql/executor.rb

@@ -0,0 +1,83 @@
+require 'celluloid/current'
+require 'singleton'
+
+module GraphQL
+  class Executor
+
+    class FutureCompleter
+      include Celluloid
+      include Singleton
+
+      def self.complete_value(context, field_type, resolved_object, selection_set)
+        completer = resolved_object.is_a?(Celluloid::Future) ? instance.future : instance
+        completer.complete_value(context, field_type, resolved_object, selection_set)
+      end
+
+      def complete_value(context, field_type, resolved_object, selection_set)
+        return nil if resolved_object.nil?
+
+        resolved_object = resolved_object.value if resolved_object.is_a?(Celluloid::Future)
+
+        case field_type
+        when GraphQLNonNull
+          completed_object = complete_value(context, field_type.of_type, resolved_object, selection_set)
+          raise "Field error: expecting non null value" if completed_object.nil?
+          completed_object
+        when GraphQLList
+          resolved_object.map do |item|
+            complete_value(context, field_type.of_type, item, selection_set)
+          end
+        when GraphQLScalarType, GraphQLEnumType
+          field_type.serialize(resolved_object)
+        when GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType
+          field_type = field_type.resolve_type(resolved_object) if field_type.is_a?(GraphQLAbstractType)
+          selection_set.evaluate(context, field_type, resolved_object)
+        end
+
+      end
+    end
+
+    attr_reader :document, :schema, :context
+
+    def initialize(document, schema)
+      @document = document
+      @schema   = schema
+      @context  = {
+        document:   document,
+        schema:     schema
+      }
+    end
+
+    def execute(root = {}, params = {}, operation_name = nil)
+      raise GraphQLError, "At least one operation should be defined." if document.operations.size == 0
+      raise GraphQLError, "Operation name should be defined for more than one operation." if document.operations.size > 1 && operation_name.nil?
+
+      operation_name  = document.operations.first.name if operation_name.nil?
+      operation       = document.operation(operation_name)
+
+      raise GraphQLError, "Operation named '#{operation_name}' not found in document." if operation.nil?
+
+      context[:root]    = root
+      context[:params]  = params
+
+      materialize(operation.evaluate(context))
+    end
+
+    def materialize(data)
+      case data
+      when Hash
+        data.each do |key, value|
+          data[key] = value.value if value.is_a?(Celluloid::Future)
+          materialize(data[key])
+        end
+      when Array
+        data.each_with_index do |value, i|
+          data[i] = value.value if value.is_a?(Celluloid::Future)
+          materialize(data[i])
+        end
+      end
+      data
+    end
+
+  end
+end

data/lib/graphql/introspection/meta_fields.rb

@@ -0,0 +1,54 @@
+module GraphQL
+  module Introspection
+
+    SchemaMetaField = GraphQLField.new do
+      name '__schema'
+      type ! Schema__
+
+      description 'Access the current type schema of this server.'
+
+      resolve -> (root, params, context) { context[:schema] }
+    end
+
+    TypeMetaField = GraphQLField.new do
+      name '__type'
+      type Type__
+
+      description 'Request the type information of a single type.'
+
+      arg :name, ! GraphQLString
+
+      resolve -> (root, params, context) { context[:schema].type(params[:name]) }
+    end
+
+    TypeNameMetaField = GraphQLField.new do
+      name '__typename'
+      type ! GraphQLString
+
+      description 'The name of the current Object type at runtime.'
+
+      resolve -> (root, params, context) { context[:parent_type].name }
+    end
+
+    def self.meta_field_map
+      [SchemaMetaField, TypeMetaField].reduce({}) { |memo, field| memo[field.name.to_sym] = field ; memo }
+    end
+
+    def self.meta_field_names
+      @meta_field_names ||= meta_field_map.keys
+    end
+
+    def self.meta_fields
+      @meta_fields ||= meta_field_map.values
+    end
+
+    def self.meta_field(name)
+      meta_field_map[name.to_sym]
+    end
+
+    def self.meta_field?(name)
+      !!meta_field(name)
+    end
+
+  end
+end

data/lib/graphql/introspection/query.rb

@@ -0,0 +1,81 @@
+module GraphQL
+  module Introspection
+
+    Query = %Q(
+      query IntrospectionQuery {
+        __schema {
+          queryType { name }
+          mutationType { name }
+          types {
+            ...FullType
+          }
+          directives {
+            name
+            description
+            args {
+              ...InputValue
+            }
+            onOperation
+            onFragment
+            onField
+          }
+        }
+      }
+      fragment FullType on __Type {
+        kind
+        name
+        description
+        fields {
+          name
+          description
+          args {
+            ...InputValue
+          }
+          type {
+            ...TypeRef
+          }
+          isDeprecated
+          deprecationReason
+        }
+        inputFields {
+          ...InputValue
+        }
+        interfaces {
+          ...TypeRef
+        }
+        enumValues {
+          name
+          description
+          isDeprecated
+          deprecationReason
+        }
+        possibleTypes {
+          ...TypeRef
+        }
+      }
+      fragment InputValue on __InputValue {
+        name
+        description
+        type { ...TypeRef }
+        defaultValue
+      }
+      fragment TypeRef on __Type {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+            }
+          }
+        }
+      }
+    )
+
+  end
+end

data/lib/graphql/introspection/schema.rb

@@ -0,0 +1,158 @@
+module GraphQL
+  module Introspection
+
+    Schema__ = GraphQLObjectType.new do
+
+      name '__Schema'
+
+      description  'A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types ' +
+        'and directives on the server, as well as the entry points for query and mutation operations.'
+
+      field :types, -> { ! + ! Type__ } do
+        description 'A list of all types supported by this server.'
+        resolve -> (schema) { schema.type_map.values }
+      end
+
+      field :queryType, -> { ! Type__ } do
+        description 'The type that query operations will be rooted at.'
+        resolve -> (schema) { schema.query_type }
+      end
+
+      field :mutationType, -> { ! Type__ } do
+        description 'If this server supports mutation, the type that mutation operations will be rooted at.'
+        resolve -> (schema) { schema.mutation_type }
+      end
+
+      field :directives, -> { ! + ! Type__ } do
+        description 'A list of all directives supported by this server.'
+      end
+
+    end
+
+    Directive__ = GraphQLObjectType.new do
+
+      name '__Directive'
+
+      field :name,          ! GraphQLString
+      field :description,     GraphQLString
+
+      field :args,          -> { ! + ! InputValue__ }
+
+      field :onOperation,   ! GraphQLBoolean,  resolve: -> (directive) { directive.on_operation }
+      field :onFragment,    ! GraphQLBoolean,  resolve: -> (directive) { directive.on_fragment }
+      field :onField,       ! GraphQLBoolean,  resolve: -> (directive) { directive.on_field }
+
+    end
+
+    Type__ = GraphQLObjectType.new do
+      name '__Type'
+
+      field :name,        GraphQLString, resolve: -> (type) { type.name rescue nil }
+      field :description, GraphQLString
+
+      field :kind, -> { ! TypeKind__ } do
+        resolve lambda { |type|
+          case type
+          when GraphQLScalarType      then :scalar
+          when GraphQLObjectType      then :object
+          when GraphQLInterfaceType   then :interface
+          when GraphQLUnionType       then :union
+          when GraphQLEnumType        then :enum
+          when GraphQLInputObjectType then :input_object
+          when GraphQLList            then :list
+          when GraphQLNonNull         then :non_null
+          else raise RuntimeError.new("Unknown kind of type: #{type}")
+          end
+        }
+      end
+
+      field :fields, -> { + ! Field__ } do
+        arg :includeDeprecated, GraphQLBoolean, default_value: false
+
+        resolve lambda { |type, params|
+          return nil unless type.is_a?(GraphQLObjectType) || type.is_a?(GraphQLInterfaceType)
+          fields = type.fields
+          fields = fields.select { |field| !field.deprecation_reason } unless params[:includeDeprecated]
+          fields
+        }
+      end
+
+      field :interfaces, -> { + ! Type__ } do
+        resolve lambda  { |type|
+          type.interfaces if type.is_a?(GraphQLObjectType)
+        }
+      end
+
+      field :possibleTypes, -> { + ! Type__ } do
+        resolve lambda { |type|
+          type.possible_types if type.is_a?(GraphQLInterfaceType) || type.is_a?(GraphQLUnionType)
+        }
+      end
+
+      field :enumValues, -> { + ! EnumValue__ } do
+
+        arg :includeDeprecated, GraphQLBoolean, default_value: false
+
+        resolve lambda { |type, params|
+          return nil unless type.is_a?(GraphQLEnumType)
+          values = type.values
+          values = values.select { |value| !value.deprecation_reason } unless params[:includeDeprecated]
+          values
+        }
+      end
+
+      field :inputFields, -> { + ! InputValue__ } do
+        resolve lambda { |type|
+          type.fields.values if type.is_a?(GraphQLInputObjectType)
+        }
+      end
+
+      field :ofType, -> { Type__ }, resolve: -> (type) { type.of_type rescue nil }
+
+    end
+
+    Field__ = GraphQLObjectType.new do
+      name '__Field'
+
+      field :name,              ! GraphQLString
+      field :description,         GraphQLString
+      field :args,                -> { ! + ! InputValue__ }
+      field :type,                -> { ! Type__ }
+      field :isDeprecated,      ! GraphQLBoolean,   resolve: -> (field) { !!field.deprecation_reason }
+      field :deprecationReason,   GraphQLString,    resolve: -> (field) { field.deprecation_reason }
+    end
+
+    InputValue__ = GraphQLObjectType.new do
+      name '__InputValue'
+
+      field :name,          ! GraphQLString
+      field :description,     GraphQLString
+      field :type,            -> { ! Type__ }
+      field :defaultValue,   GraphQLString, resolve: -> (value) { value.default_value }
+    end
+
+    EnumValue__ = GraphQLObjectType.new do
+      name '__EnumValue'
+
+      field :name,              ! GraphQLString
+      field :description,         GraphQLString
+      field :isDeprecated,      ! GraphQLBoolean, resolve: -> (value) { !!value.deprecation_reason }
+      field :deprecationReason,   GraphQLString,  resolve: -> (value) { value.deprecation_reason }
+    end
+
+    TypeKind__ = GraphQLEnumType.new do
+      name          '__TypeKind'
+      description   'An enum describing what kind of type a given __Type is'
+
+      value :SCALAR,        :scalar,        'Indicates this type is a scalar.'
+      value :OBJECT,        :object,        'Indicates this type is an object. `fields` and `interfaces` are valid fields.'
+      value :INTERFACE,     :interface,     'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'
+      value :UNION,         :union,         'Indicates this type is a union. `possibleTypes` is a valid field.'
+      value :ENUM,          :enum,          'Indicates this type is an enum. `values` is a valid field.'
+      value :INPUT_OBJECT,  :input_object,  'Indicates this type is an input object. `fields` is a valid field.'
+      value :LIST,          :list,          'Indicates this type is a list. `ofType` is a valid field.'
+      value :NON_NULL,      :non_null,      'Indicates this type is a non-null. `ofType` is a valid field.'
+    end
+
+  end
+end

data/lib/graphql/introspection.rb

@@ -0,0 +1,3 @@
+require_relative 'introspection/schema'
+require_relative 'introspection/meta_fields'
+require_relative 'introspection/query'