graphql-rb 0.0.2

data/lib/graphql/language/transform.rb

@@ -0,0 +1,101 @@
+require 'parslet'
+
+module GraphQL
+  module Language
+
+    class Transform < Parslet::Transform
+
+
+      rule(document: sequence(:a)) { Document.new(a) }
+
+
+      rule(operation_definition: {
+        type:                    simple(:a),
+        name:                    simple(:b),
+        variable_definitions:   subtree(:c),
+        directives:             subtree(:d),
+        selection_set:           simple(:e)
+      }) { OperationDefinition.new(a, b, c || [], d || [], e || []) }
+
+      rule(operation_definition: {
+        selection_set: simple(:a)
+      }) { OperationDefinition.new('query', '', [], [], a) }
+
+
+      rule(fragment_definition: {
+        name:              simple(:a),
+        type_condition:   subtree(:b),
+        directives:       subtree(:c),
+        selection_set:     simple(:d)
+      }) { FragmentDefinition.new(a, b, c || [], d || []) }
+
+
+      rule(fragment_spread: {
+        name:         simple(:a),
+        directives:   subtree(:b)
+      }) { FragmentSpread.new(a, b || []) }
+
+
+      rule(inline_fragment: {
+        type_condition:   subtree(:a),
+        directives:       subtree(:b),
+        selection_set:     simple(:c)
+      }) { InlineFragment.new(a, b || [], c || []) }
+
+
+      rule(field: {
+        alias:           simple(:a),
+        name:            simple(:b),
+        arguments:      subtree(:c),
+        directives:     subtree(:d),
+        selection_set:   simple(:e)
+      }) { Field.new(a, b, c || [], d || [], e || []) }
+
+
+      rule(directive: {
+        name:       simple(:a),
+        arguments:  subtree(:b)
+      }) { Directive.new(a, b || []) }
+
+
+      rule(argument: {
+        name:   simple(:a),
+        value:  simple(:b)
+      }) { Argument.new(a, b) }
+
+
+      rule(selection_set: {
+        selections: subtree(:a)
+      }) { SelectionSet.new(a || []) }
+
+
+      rule(variable_definition: {
+        variable:       simple(:a),
+        type:           simple(:b),
+        default_value:  simple(:c)
+      }) { VariableDefinition.new(a, b, c) }
+
+
+      rule(variable: simple(:a)) { Variable.new(a) }
+
+      rule(named_type:      simple(:a)) { NamedType.new(a)    }
+      rule(list_type:       simple(:a)) { ListType.new(a)     }
+      rule(non_null_type:   simple(:a)) { NonNullType.new(a)  }
+
+      rule(name: simple(:a)) { a.to_s }
+
+      rule(value: simple(:a)) { a }
+      rule(value: subtree(:a)) { Value.new(a[:kind], a[:value]) }
+
+      rule(string_value:    simple(:a)) { { value: a.to_s,      kind: :string   } }
+      rule(int_value:       simple(:a)) { { value: a.to_i,      kind: :int      } }
+      rule(float_value:     simple(:a)) { { value: a.to_f,      kind: :float    } }
+      rule(boolean_value:   simple(:a)) { { value: a == 'true', kind: :boolean  } }
+      rule(enum_value:      simple(:a)) { { value: a,           kind: :enum     } }
+      rule(list_value:    sequence(:a)) { { value: a,           kind: :list     } }
+      rule(object_value:   subtree(:a)) { { value: a,           kind: :object   } }
+
+    end
+
+  end
+end

data/lib/graphql/language/value.rb

@@ -0,0 +1,24 @@
+module GraphQL
+  module Language
+    Value = Struct.new('Value', :kind, :value) do
+
+
+      def materialize(type, variables)
+        case type
+        when GraphQLNonNull
+          materialize(type.of_type, variables)
+        when GraphQLList
+          value.map { |value| value.materialize(type.of_type, variables) }
+        when GraphQLInputObjectType
+          raise "Not. Implemented. Yet."
+        when GraphQLScalarType, GraphQLEnumType
+          type.parse_literal(self)
+        else
+          raise "Must be input type"
+        end
+      end
+
+
+    end
+  end
+end

data/lib/graphql/language/variable.rb

@@ -0,0 +1,11 @@
+module GraphQL
+  module Language
+    Variable = Struct.new('Variable', :name) do
+
+      def materialize(type, variables)
+        variables[name.to_sym]
+      end
+
+    end
+  end
+end

data/lib/graphql/language/variable_definition.rb

@@ -0,0 +1,34 @@
+module GraphQL
+  module Language
+    VariableDefinition = Struct.new('VariableDefinition', :variable, :type, :default_value) do
+
+
+      def materialize(schema, param)
+        schema_type = type.materialize(schema)
+
+        if schema_type.nil? || !schema_type.is_a?(GraphQLInputType)
+          raise GraphQLError, "Variable '#{variable.name}' expected value " +
+            "of type '#{schema_type}' which cannot be used as input type."
+        end
+
+        if Validator.valid_value?(param, schema_type)
+          if !param && default_value
+            return default_value.materialize(schema_type)
+          end
+          return Validator.coerce_value(param, schema_type)
+        end
+
+        if param
+          raise GraphQLError, "Variable '#{variable.name}' expected value " +
+            "of type '#{schema_type}' but got '#{param}'."
+        else
+          raise GraphQLError, "Variable '#{variable.name}' " +
+            "of required type '#{type}' was not provided."
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/graphql/language.rb

@@ -0,0 +1,40 @@
+require_relative 'language/document'
+require_relative 'language/operation_definition'
+require_relative 'language/fragment_definition'
+require_relative 'language/fragment_spread'
+require_relative 'language/inline_fragment'
+require_relative 'language/selection_set'
+require_relative 'language/variable_definition'
+require_relative 'language/variable'
+require_relative 'language/named_type'
+require_relative 'language/list_type'
+require_relative 'language/non_null_type'
+require_relative 'language/name'
+require_relative 'language/value'
+require_relative 'language/field'
+require_relative 'language/argument'
+require_relative 'language/directive'
+
+require_relative 'language/parser'
+require_relative 'language/transform'
+
+
+module GraphQL
+  module Language
+
+    def self.parse(query)
+      transform.apply(parser.parse(query))
+    end
+
+  private
+
+    def self.parser
+      @parser ||= GraphQL::Language::Parser.new
+    end
+
+    def self.transform
+      @transform ||= GraphQL::Language::Transform.new
+    end
+
+  end
+end

data/lib/graphql/type/argument.rb

@@ -0,0 +1,16 @@
+module GraphQL
+
+  # GraphQLArgument
+  #
+  class GraphQLArgumentConfiguration < GraphQL::Configuration::Base
+    slot :name,           String, coerce: -> (v) { v.to_s }
+    slot :type,           GraphQLInputType
+    slot :default_value,  Object, null: true
+    slot :description,    String, null: true
+  end
+
+  class GraphQLArgument < GraphQL::Configuration::Configurable
+    configure_with GraphQLArgumentConfiguration
+  end
+
+end

data/lib/graphql/type/directive.rb

@@ -0,0 +1,37 @@
+module GraphQL
+
+  # GraphQLDirectiveConfiguration
+  #
+  class GraphQLDirectiveConfiguration < GraphQL::Configuration::Base
+    slot :name,           String, coerce: -> (v) { v.to_s }
+    slot :args,           [-> { GraphQLArgument }], singular: :arg
+    slot :description,    String, null: true
+    slot :on_operation,   Object, coerce: -> (v) { !!v }
+    slot :on_fragment,    Object, coerce: -> (v) { !!v }
+    slot :on_field,       Object, coerce: -> (v) { !!v }
+  end
+
+  class GraphQLDirective < GraphQL::Configuration::Configurable
+    configure_with GraphQLDirectiveConfiguration
+
+    def arg_map
+      @arg_map ||= @configuration.args.reduce({}) { |memo, arg| memo[arg.name.to_sym] = arg ; memo }
+    end
+
+    def arg_names
+      @arg_names ||= arg_map.keys
+    end
+
+    def args
+      @args ||= arg_map.values
+    end
+
+    def arg(name)
+      arg_map(name.to_sym)
+    end
+
+  end
+
+end
+
+require_relative 'directives'

data/lib/graphql/type/directives.rb

@@ -0,0 +1,25 @@
+module GraphQL
+
+  GraphQLIncludeDirective = GraphQLDirective.new do
+    name        :include
+    description 'Directs the executor to include this field or fragment only when the `if` argument is true.'
+
+    arg :if, ! GraphQLBoolean, description: 'Included when true'
+
+    on_operation  false
+    on_fragment   true
+    on_field      true
+  end
+
+  GraphQLSkipDirective = GraphQLDirective.new do
+    name        :skip
+    description 'Directs the executor to skip this field or fragment only when the `if` argument is true.'
+
+    arg :if, ! GraphQLBoolean, description: 'Skipped when true'
+
+    on_operation  false
+    on_fragment   true
+    on_field      true
+  end
+
+end

data/lib/graphql/type/enum_type.rb

@@ -0,0 +1,100 @@
+module GraphQL
+
+  #
+  # == GraphQLEnumType Definition
+  #
+  # Some leaf values of requests and input values are Enums. GraphQL serializes
+  # Enum values as strings, however internally Enums can be represented by any
+  # kind of type, often integers.
+  #
+  # Examples:
+  #
+  #   RGBAType = GraphQLEnum.new do
+  #     name  'RGBA'
+  #
+  #     value :RED,   0
+  #     value :GREEN, 1
+  #     value :BLUE,  2
+  #     value :ALPHA, description: 'Alpha channel'
+  #   end
+  #
+  # Note: If a value is not provided in a definition, the name of the enum value
+  # will be used as it's internal value.
+  #
+
+
+  # GraphQLEnumValueConfiguration
+  #
+  class GraphQLEnumValue < GraphQL::Configuration::Base
+    slot :name,                 String, coerce: -> (v) { v.to_s }
+    slot :value,                Object, null: true
+    slot :description,          String, null: true
+    slot :deprecation_reason,   String, null: true
+  end
+
+
+  # GraphQLEnumTypeConfiguration
+  #
+  class GraphQLEnumTypeConfiguration < GraphQL::Configuration::Base
+    slot :name,         String
+    slot :values,       [GraphQLEnumValue], singular: :value
+    slot :description,  String,             null: true
+  end
+
+
+  # GraphQLEnumType
+  #
+  class GraphQLEnumType < GraphQL::Configuration::Configurable
+
+    include GraphQLType
+    include GraphQLInputType
+    include GraphQLOutputType
+    include GraphQLLeafType
+    include GraphQLNullableType
+    include GraphQLNamedType
+
+    configure_with GraphQLEnumTypeConfiguration
+
+
+    def value_map
+      @value_map ||= @configuration.values.reduce({}) do |memo, value|
+        value.value = value.name if value.value.nil?
+        memo[value.name.to_sym] = value
+        memo
+      end
+    end
+
+    def value_map_by_values
+      @value_map_by_values ||= values.reduce({}) { |memo, value| memo[value.value.to_s] = value ; memo }
+    end
+
+    def value_names
+      @value_names ||= value_map.keys
+    end
+
+    def values
+      @values ||= value_map.values
+    end
+
+    def value(name)
+      value_map[name.to_sym]
+    end
+
+    def serialize(v)
+      value_map_by_values[v.to_s].name rescue nil
+    end
+
+    def parse_value(v)
+      value(v).value rescue nil
+    end
+
+    def parse_literal(ast)
+      value(ast[:value]).value rescue nil if ast[:kind] == :enum
+    end
+
+    def to_s
+      name
+    end
+
+  end
+end

data/lib/graphql/type/field.rb

@@ -0,0 +1,50 @@
+module GraphQL
+
+  # GraphQLFieldConfiguration
+  #
+  class GraphQLFieldConfiguration < GraphQL::Configuration::Base
+    slot :name,                 String, coerce: -> (v) { v.to_s }
+    slot :type,                 -> { GraphQLOutputType }
+    slot :args,                 [ -> { GraphQLArgument } ], singular: :arg
+    slot :resolve,              Proc
+    slot :deprecation_reason,   String, null: true
+    slot :description,          String, null: true
+  end
+
+  # GraphQLField
+  #
+  class GraphQLField < GraphQL::Configuration::Configurable
+    configure_with GraphQLFieldConfiguration
+
+    DEFAULT_RESOLVE = lambda { |name|
+      lambda { |object|
+        object.public_send(name)
+      }
+    }
+
+    def type
+      @type ||= @configuration.type.is_a?(Proc) ? @configuration.type.call : @configuration.type
+    end
+
+    def arg_map
+      @arg_map ||= @configuration.args.reduce({}) { |memo, arg| memo[arg.name.to_sym] = arg ; memo }
+    end
+
+    def arg_names
+      @arg_names ||= arg_map.keys
+    end
+
+    def args
+      @args ||= arg_map.values
+    end
+
+    def arg(name)
+      arg_map(name.to_sym)
+    end
+
+    def resolve
+      @resolve ||= @configuration.resolve || DEFAULT_RESOLVE.call(name)
+    end
+  end
+
+end

data/lib/graphql/type/input_object_type.rb

@@ -0,0 +1,47 @@
+module GraphQL
+
+  class GraphQLInputObjectField < GraphQL::Configuration::Base
+    slot :name,           String
+    slot :type,           GraphQLInputType
+    slot :default_value,  Object,   null: true
+    slot :description,    String,   null: true
+  end
+
+  class GraphQLInputObjectTypeConfiguration < GraphQL::Configuration::Base
+    slot :name,           String
+    slot :fields,         [GraphQLInputObjectField], singular: :field
+    slot :description,    String,   null: true
+  end
+
+  class GraphQLInputObjectType < GraphQL::Configuration::Configurable
+
+    include GraphQLType
+    include GraphQLInputType
+    include GraphQLNullableType
+    include GraphQLNamedType
+
+    configure_with GraphQLInputObjectTypeConfiguration
+
+
+    def field_map
+      @field_map ||= @configuration.fields.reduce({}) { |memo, field| memo[field.name.to_sym] = field ; memo }
+    end
+
+    def field_names
+      @field_names ||= field_map.keys
+    end
+
+    def fields
+      @fields ||= field_map.values
+    end
+
+    def field(name)
+      field_map[name.to_sym]
+    end
+
+    def to_s
+      name
+    end
+  end
+
+end

data/lib/graphql/type/interface_type.rb

@@ -0,0 +1,64 @@
+module GraphQL
+
+  class GraphQLInterfaceTypeConfiguration < GraphQL::Configuration::Base
+    slot :name,           String
+    slot :fields,         [-> { GraphQLField }], singular: :field
+    slot :resolve_type,   Proc,     null: true
+    slot :description,    String,   null: true
+  end
+
+  class GraphQLInterfaceType < GraphQL::Configuration::Configurable
+
+    include GraphQLType
+    include GraphQLOutputType
+    include GraphQLCompositeType
+    include GraphQLAbstractType
+    include GraphQLNullableType
+    include GraphQLNamedType
+
+    configure_with GraphQLInterfaceTypeConfiguration
+
+    def initialize(configuration)
+      super
+      @implementations = []
+    end
+
+    def implement!(type)
+      raise RuntimeError.new("#{self} can implement instances of GraphQLType. Got #{type.class}.") unless type.is_a?(GraphQLType)
+      @implementations << type unless possible_type?(type)
+    end
+
+    def field_map
+      @field_map ||= @configuration.fields.reduce({}) { |memo, field| memo[field.name.to_sym] = field ; memo}
+    end
+
+    def field_names
+      @field_names ||= field_map.keys
+    end
+
+    def fields
+      @fields ||= field_map.values
+    end
+
+    def field(name)
+      field_map(name.to_sym)
+    end
+
+    def possible_types
+      @implementations
+    end
+
+    def possible_type?(type)
+      possible_types.include?(type)
+    end
+
+    def resolve_type(type)
+      @configuration.resolve_type.nil? ? type_of(type) : @configuration.resolve_type.call(type)
+    end
+
+    def to_s
+      name
+    end
+  end
+
+end

data/lib/graphql/type/list.rb

@@ -0,0 +1,23 @@
+module GraphQL
+
+  class GraphQLList
+
+    include GraphQLType
+    include GraphQLInputType
+    include GraphQLOutputType
+    include GraphQLNullableType
+
+    attr_reader :of_type
+
+    def initialize(of_type)
+      raise "Expecting #{GraphQLType}, got #{of_type.class}." unless of_type.is_a?(GraphQLType)
+      @of_type = of_type
+    end
+
+    def to_s
+      '[' + of_type.to_s + ']'
+    end
+
+  end
+
+end

data/lib/graphql/type/non_null.rb

@@ -0,0 +1,25 @@
+module GraphQL
+
+  class GraphQLNonNull
+
+    include GraphQLType
+    include GraphQLInputType
+    include GraphQLOutputType
+
+    NESTING_ERROR = 'Cannot nest NonNull inside NonNull'
+
+    attr_reader :of_type
+
+    def initialize(of_type)
+      raise "Expecting #{GraphQLType}, got #{of_type.class}." unless of_type.is_a?(GraphQLType)
+      raise NESTING_ERROR if of_type.is_a?(GraphQLNonNull)
+      @of_type = of_type
+    end
+
+    def to_s
+      of_type.to_s + '!'
+    end
+
+  end
+
+end

data/lib/graphql/type/object_type.rb

@@ -0,0 +1,57 @@
+module GraphQL
+
+  class GraphQLObjectTypeConfiguration < GraphQL::Configuration::Base
+    slot :name,         String
+    slot :interfaces,   [-> { GraphQLInterfaceType }],  null: true, singular: :interface
+    slot :fields,       [-> { GraphQLField }],                      singular: :field
+    slot :type_of?,     Proc,                           null: true
+    slot :description,  String,                         null: true
+  end
+
+
+  class GraphQLObjectType < GraphQL::Configuration::Configurable
+
+    include GraphQLType
+    include GraphQLOutputType
+    include GraphQLCompositeType
+    include GraphQLNullableType
+    include GraphQLNamedType
+
+    configure_with GraphQLObjectTypeConfiguration
+
+    def initialize(configuration)
+      super
+      interfaces.each { |interface| interface.implement!(self) }
+    end
+
+
+    def field_map
+      @field_map ||= @configuration.fields.reduce({}) { |memo, field| memo[field.name.to_sym] = field ; memo}
+    end
+
+    def field_names
+      @field_names ||= field_map.keys
+    end
+
+    def fields
+      @fields ||= field_map.values
+    end
+
+    def field(name)
+      field_map[name.to_sym]
+    end
+
+    def interfaces
+      @configuration.interfaces
+    end
+
+    def type_of?(type)
+      @configuration.type_of?.nil? ? false : @configuration.type_of?.call(type)
+    end
+
+    def to_s
+      name
+    end
+  end
+
+end