graphql-rb 0.0.2

data/lib/graphql/language/argument.rb

@@ -0,0 +1,11 @@
+module GraphQL
+  module Language
+    Argument = Struct.new('Argument', :name, :value) do
+
+      def materialize(field_argument_type, values)
+        value.materialize(field_argument_type, values)
+      end
+
+    end
+  end
+end

data/lib/graphql/language/directive.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Language
+    Directive = Struct.new('Directive', :name, :arguments)
+  end
+end

data/lib/graphql/language/document.rb

@@ -0,0 +1,23 @@
+module GraphQL
+  module Language
+    Document = Struct.new('Document', :definitions) do
+
+      def operations
+        @operations ||= definitions.select { |definition| definition.is_a?(OperationDefinition) }
+      end
+
+      def operation(name)
+        operations.find { |operation| operation.name == name }
+      end
+
+      def fragments
+        @fragments ||= definitions.select { |definition| definition.is_a?(FragmentDefinition) }
+      end
+
+      def fragment(name)
+        fragments.find { |fragment| fragment.name == name }
+      end
+
+    end
+  end
+end

data/lib/graphql/language/field.rb

@@ -0,0 +1,55 @@
+module GraphQL
+  module Language
+    Field = Struct.new('Field', :alias, :name, :arguments, :directives, :selection_set) do
+
+      # GraphQL Specification
+      #   6.3 Evaluate selection sets
+      #     CollectFields
+      #       responseKey implementation
+      #
+      def key
+        self.alias || self.name
+      end
+
+      # GraphQL Specification
+      #   6.4.1 Field entries
+      #     ResolveFieldOnObject implementation
+      #       objectType, object, firstField = self
+      #         + context[document, schema, root]
+      #
+      # TODO: think of should or shouldn't we pass self as fourth parameter
+      #
+      def resolve(context, object_type, object)
+        arguments = [
+            object,
+            materialize_arguments(object_type, context[:variables]),
+            context
+        ]
+
+        resolve   = schema_field(object_type).resolve
+        arguments = arguments.slice(0, resolve.arity) if resolve.arity >= 0
+
+        resolve.call(*arguments)
+      end
+
+
+      def materialize_arguments(object_type, variables)
+        schema_field(object_type).args.reduce({}) do |memo, field_argument|
+          argument = arguments.find { |argument| argument.name == field_argument.name }
+          memo[argument.name.to_sym] = argument.materialize(field_argument.type, variables) unless argument.nil?
+          memo
+        end
+      end
+
+      def schema_field(object_type)
+        case
+        when GraphQL::Introspection.meta_field?(name)
+          GraphQL::Introspection.meta_field(name)
+        else
+          object_type.field(name)
+        end
+      end
+
+    end
+  end
+end

data/lib/graphql/language/fragment_definition.rb

@@ -0,0 +1,23 @@
+module GraphQL
+  module Language
+    FragmentDefinition = Struct.new('FragmentDefinition', :name, :type_condition, :directives, :selection_set) do
+
+      # GraphQL Specification
+      #   6.3 Evaluating selection sets
+      #     doesFragmentTypeApply implementation
+      #       objectType, fragmentType = self.type_condition => Schema.type
+      #         + context[schema, document]
+      #
+      def apply?(context, object_type)
+        type = context[:schema].type(type_condition.type)
+
+        return type == object_type if type.is_a?(GraphQLObjectType)
+
+        return type.possible_type?(object_type) if type.is_a?(GraphQLInterfaceType)
+
+        return type.possible_type?(object_type) if type.is_a?(GraphQLUnionType)
+      end
+
+    end
+  end
+end

data/lib/graphql/language/fragment_spread.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Language
+    FragmentSpread = Struct.new('FragmentSpread', :name, :directives)
+  end
+end

data/lib/graphql/language/inline_fragment.rb

@@ -0,0 +1,23 @@
+module GraphQL
+  module Language
+    InlineFragment = Struct.new('InlineFragment', :type_condition, :directives, :selection_set) do
+
+      # GraphQL Specification
+      #   6.3 Evaluating selection sets
+      #     doesFragmentTypeApply implementation
+      #       objectType, fragmentType = self.type_condition => Schema.type
+      #         + context[schema, document]
+      #
+      def apply?(context, object_type)
+        type = context[:schema].type(type_condition.type)
+
+        return type == object_type if type.is_a?(GraphQLObjectType)
+
+        return type.possible_type?(object_type) if type.is_a?(GraphQLInterfaceType)
+
+        return type.possible_type?(object_type) if type.is_a?(GraphQLUnionType)
+      end
+
+    end
+  end
+end

data/lib/graphql/language/list_type.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module Language
+    ListType = Struct.new('ListType', :type) do
+
+      def named_type
+        type.respond_to?(:named_type) ? type.named_type : type
+      end
+
+      def materialize(schema)
+        GraphQLList.new(type.materialize(schema))
+      end
+
+    end
+  end
+end

data/lib/graphql/language/name.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Language
+    Name = Struct.new('Name', :value)
+  end
+end

data/lib/graphql/language/named_type.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module Language
+    NamedType = Struct.new('NamedType', :type) do
+
+      def named_type
+        type
+      end
+
+      def materialize(schema)
+        schema.type(type)
+      end
+
+    end
+  end
+end

data/lib/graphql/language/non_null_type.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module Language
+    NonNullType = Struct.new('NonNullType', :type) do
+
+      def named_type
+        type.respond_to?(:named_type) ? type.named_type : type
+      end
+
+      def materialize(schema)
+        GraphQLNonNull.new(type.materialize(schema))
+      end
+
+    end
+  end
+end

data/lib/graphql/language/operation_definition.rb

@@ -0,0 +1,33 @@
+module GraphQL
+  module Language
+    OperationDefinition = Struct.new('OperationDefinition', :type, :name, :variable_definitions, :directives, :selection_set) do
+
+
+      def evaluate(context)
+        context[:variables] = materialize_variables(context[:schema], context[:params])
+        type == 'mutation' ? execute_serially(context) : execute(context)
+      end
+
+
+      def execute(context)
+        selection_set.evaluate(context, context[:schema].query_type, context[:root])
+      end
+
+
+      def execute_serially(context)
+        raise "Not implemented. Yet."
+      end
+
+
+      def materialize_variables(schema, params)
+        variable_definitions.reduce({}) do |memo, variable_definition|
+          name = variable_definition.variable.name.to_sym
+          memo[name] = variable_definition.materialize(schema, params[name])
+          memo
+        end
+      end
+
+
+    end
+  end
+end

data/lib/graphql/language/parser.rb

@@ -0,0 +1,331 @@
+require 'parslet'
+
+module GraphQL
+  module Language
+
+    class Parser < Parslet::Parser
+
+      rule(:root) { document }
+
+      # Source Character
+      #
+
+      rule(:source_character) { any }
+
+      # Ignored Tokens
+      #
+
+      rule(:ignored) { white_space | line_terminator | comment | comma }
+
+      rule(:ignored?) { ignored.repeat(0) }
+
+      rule(:ignored!) { ignored.repeat(1) }
+
+      rule(:white_space) { match('[\u0009\u000b\u000c\u0020\u00a0]') }
+
+      rule(:line_terminator) { match('[\u000a\u000d\u2028\u2029]') }
+
+      rule(:comment) { str('#') >> comment_char.repeat }
+
+      rule(:comment_char) { line_terminator.absent? >> source_character }
+
+      rule(:comma) { str(',') }
+
+      # Lexical Tokens
+      #
+
+      rule(:token) { punctuator | name | int_value | float_value | string_value }
+
+      rule(:punctuator) { match('[!$():=@[]{|}]') | str('...') }
+
+      rule(:integer_part) do
+        negative_sign.maybe >> str('0')                       |
+        negative_sign.maybe >> non_zero_digit >> digit.repeat
+      end
+
+      rule(:negative_sign) { str('-') }
+
+      rule(:digit) { match('[0-9]') }
+
+      rule(:non_zero_digit) { str('0').absent? >> digit }
+
+      rule(:fractional_part) { str('.') >> digit.repeat(1) }
+
+      rule(:exponent_part) { exponent_indicator >> sign.maybe >> digit.repeat(1) }
+
+      rule(:exponent_indicator) { match('[eE]') }
+
+      rule(:sign) { match('-+') }
+
+      rule(:string_character) do
+        (str('"') | str('\\') | line_terminator).absent? >> source_character  |
+        str('\\') >> escaped_unicode                                          |
+        str('\\') >> escaped_character
+      end
+
+      rule(:escaped_unicode) { str('u') >> match('[a-fA-F0-9]').repeat(4) }
+
+      rule(:escaped_character) { match('["\\/bfnrt]') }
+
+      rule(:name) do
+        (match('[_a-zA-Z]') >> match('[_a-zA-Z0-9]').repeat).as(:name)
+      end
+
+      rule(:string_value) do
+        str('"') >> string_character.repeat.as(:string_value) >> str('"')
+      end
+
+      rule(:int_value) do
+        integer_part.as(:int_value)
+      end
+
+      rule(:float_value) do
+        (
+          integer_part >> fractional_part >> exponent_part  |
+          integer_part >> fractional_part                   |
+          integer_part >> exponent_part
+        ).as(:float_value)
+      end
+
+      # Query Document
+      #
+
+      rule(:document) do
+        ignored? >> definition.repeat(1).as(:document) >> ignored?
+      end
+
+      rule(:definition) do
+        ignored? >> (operation_definition | fragment_definition) >> ignored?
+      end
+
+      rule(:operation_definition) do
+         ignored? >> (
+           selection_set.as(:selection_set)                       |
+           operation_type.as(:type)                               >>
+           name.as(:name)                                         >>
+           variable_definitions.maybe.as(:variable_definitions)   >>
+           directives.maybe.as(:directives)                       >>
+           selection_set.as(:selection_set)
+         ).as(:operation_definition) >> ignored?
+      end
+
+      rule(:operation_type) do
+        ignored? >> (str('query') | str('mutation')).as(:name) >> ignored?
+      end
+
+      rule(:selection_set) do
+        ignored? >> (str('{') >> selection.repeat(1).as(:selections) >> str('}')).as(:selection_set) >> ignored?
+      end
+
+      rule(:selection) do
+        ignored? >> (field | fragment_spread | inline_fragment) >> ignored?
+      end
+
+      rule(:field) do
+        ignored? >> (
+          field_alias.maybe.as(:alias)            >>
+          name.as(:name)                          >>
+          arguments.maybe.as(:arguments)          >>
+          directives.maybe.as(:directives)        >>
+          selection_set.maybe.as(:selection_set)
+        ).as(:field) >> ignored?
+      end
+
+      rule(:field_alias) do
+        ignored? >> name >> str(':') >> ignored?
+      end
+
+      rule(:arguments) do
+        ignored? >> (
+          str('(') >> argument.repeat(1) >> str(')')
+        ) >> ignored?
+      end
+
+      rule(:argument) do
+        ignored? >> (
+          name.as(:name)    >>
+          str(':')          >>
+          value.as(:value)
+        ).as(:argument) >> ignored?
+      end
+
+      rule(:fragment_spread) do
+        ignored? >> (
+          str('...')                        >>
+          fragment_name.as(:name)           >>
+          directives.maybe.as(:directives)
+        ).as(:fragment_spread) >> ignored?
+      end
+
+      rule(:inline_fragment) do
+        ignored? >> (
+          str('...')                          >>
+          ignored?                            >>
+          str('on')                           >>
+          ignored?                            >>
+          type_condition.as(:type_condition)  >>
+          directives.maybe.as(:directives)    >>
+          selection_set.as(:selection_set)
+        ).as(:inline_fragment) >> ignored?
+      end
+
+      rule(:fragment_definition) do
+        ignored? >> (
+          str('fragment')                     >>
+          fragment_name.as(:name)             >>
+          str('on')                           >>
+          type_condition.as(:type_condition)  >>
+          directives.maybe.as(:directives)    >>
+          selection_set.as(:selection_set)
+        ).as(:fragment_definition) >> ignored?
+      end
+
+      rule(:fragment_name) do
+        ignored? >> (str('on') >> ignored).absent? >> name.as(:name) >> ignored?
+      end
+
+      rule(:type_condition) do
+        ignored? >> named_type >> ignored?
+      end
+
+      rule(:value) do
+        ignored? >> (
+          variable          |
+          (
+            float_value     |
+            int_value       |
+            string_value    |
+            boolean_value   |
+            enum_value      |
+            list_value      |
+            object_value
+          ).as(:value)
+        ) >> ignored?
+      end
+
+      rule(:value_const) do
+        ignored? >> (
+          float_value         |
+          int_value           |
+          string_value        |
+          boolean_value       |
+          enum_value          |
+          list_value_const    |
+          object_value_const
+        ).as(:value) >> ignored?
+      end
+
+      rule(:boolean_value) do
+        ignored? >> (
+          str('true')   |
+          str('false')
+        ).as(:boolean_value) >> ignored?
+      end
+
+      rule(:enum_value) do
+        ignored? >> (
+          (
+            str('true')   |
+            str('false')  |
+            str('null')
+          ).absent? >> name
+        ).as(:enum_value) >> ignored?
+      end
+
+      rule(:list_value) do
+        ignored? >> (
+          str('[')      >>
+          value.repeat(1)  >>
+          str(']')
+        ).as(:list_value) >> ignored?
+      end
+
+      rule(:list_value_const) do
+        ignored? >> (
+          str('[')            >>
+          value_const.repeat(1)  >>
+          str(']')
+        ).as(:list_value) >> ignored?
+      end
+
+      rule(:object_value) do
+        ignored? >> (
+          str('{')              >>
+          object_field.repeat(1)   >>
+          str('}')
+        ).as(:object_value) >> ignored?
+      end
+
+      rule(:object_value_const) do
+        ignored? >> (
+          str('{')                    >>
+          object_field_const.repeat(1)   >>
+          str('}')
+        ).as(:object_value) >> ignored?
+      end
+
+      rule(:object_field) do
+        ignored? >> name.as(:name) >> str(':') >> value.as(:value) >> ignored?
+       end
+
+      rule(:object_field_const) do
+        ignored? >> name.as(:name) >> str(':') >> value_const.as(:value) >> ignored?
+      end
+
+      rule(:variable_definitions) do
+        ignored? >> str('(') >> variable_definition.repeat(1) >> str(')') >> ignored?
+      end
+
+      rule(:variable_definition) do
+        ignored? >> (
+          variable.as(:variable)                  >>
+          str(':')                                >>
+          type.as(:type)                          >>
+          default_value.maybe.as(:default_value)
+        ).as(:variable_definition) >> ignored?
+      end
+
+      rule(:variable) do
+        ignored? >> (
+          str('$') >> name
+        ).as(:variable) >> ignored?
+      end
+
+      rule(:default_value) do
+        ignored? >> str('=') >> value_const >> ignored?
+      end
+
+      rule(:type) do
+        ignored? >> (non_null_type | list_type | named_type) >> ignored?
+      end
+
+      rule(:named_type) do
+        ignored? >> name.as(:named_type) >> ignored?
+      end
+
+      rule(:list_type) do
+        ignored? >> (
+          str('[') >> type >> str(']')
+        ).as(:list_type) >> ignored?
+      end
+
+      rule(:non_null_type) do
+        ignored? >> (
+          list_type >> str('!') | named_type >> str('!')
+        ).as(:non_null_type) >> ignored?
+      end
+
+      rule(:directives) do
+        ignored? >> directive.repeat(1) >> ignored?
+      end
+
+      rule(:directive) do
+        ignored? >> (
+          str('@') >> name.as(:name) >> arguments.maybe.as(:arguments)
+        ).as(:directive) >> ignored?
+      end
+
+    end
+
+  end
+end

data/lib/graphql/language/selection_set.rb

@@ -0,0 +1,107 @@
+module GraphQL
+  module Language
+    SelectionSet = Struct.new("SelectionSet", :selections) do
+
+      def empty?
+        selections.empty?
+      end
+
+      # GraphQL Specification
+      #   6.4.1 Field entries
+      #     GetFieldEntry implementation
+      #       objectType, object, - fields
+      #         + context[schema, document]
+      #
+      # TODO: think of way to have error accessor at this point. Executor?
+      #
+      def evaluate(context, object_type, object)
+        grouped_fields = collect_fields(context, object_type)
+
+        #
+        # TODO: Merge equal fields
+        #
+
+        grouped_fields.reduce({}) do |memo, (key, fields)|
+          field             = fields.first
+          field_definition  = case
+          when GraphQL::Introspection.meta_field?(field.name)
+            GraphQL::Introspection.meta_field(field.name)
+          else
+            object_type.field(field.name)
+          end
+
+          unless field_definition.nil?
+            resolve_context = context.merge({ parent_type: object_type })
+
+            resolved_object   = field.resolve(context, object_type, object)
+            selection_set     = merge_selection_sets(fields)
+            memo[key.to_sym]  = Executor::FutureCompleter.complete_value(context, field_definition.type, resolved_object, selection_set)
+          end
+
+          memo
+        end
+      end
+
+      # GraphQL Specification
+      #   6.3 Evaluate selection sets
+      #     CollectFields implementation
+      #       objectType, selectionSet = self, visitedFragments = []
+      #         + context[schema, document]
+      #
+      def collect_fields(context, object_type, visited_fragments = [])
+        memo = {}
+
+        selections.each do |selection|
+
+          case selection
+
+          when Field
+            # TODO: Directives
+            (memo[selection.key] ||= []) << selection
+
+          when FragmentSpread
+            next if visited_fragments.include?(selection.name)
+
+            visited_fragments << selection.name
+
+            fragment = context[:document].fragment(selection.name)
+
+            next if fragment.nil?
+
+            next unless fragment.apply?(context, object_type)
+
+            fragment.selection_set.collect_fields(context, object_type).each do |key, fields|
+              memo[key] = (memo[key] ||= []).concat(fields)
+            end
+
+          when InlineFragment
+            next unless selection.apply?(context, object_type)
+
+            selection.selection_set.collect_fields(context, object_type).each do |key, fields|
+              memo[key] = (memo[key] ||= []).concat(fields)
+            end
+
+          end
+
+        end
+
+        memo
+      end
+
+      # GraphQL Specification
+      #   6.4.1 Field entries
+      #     MergeSelectionSets implementations
+      #       fields
+      #
+      def merge_selection_sets(fields)
+        selections = fields.reduce([]) do |memo, field|
+          memo.concat field.selection_set.selections unless field.selection_set.nil? || field.selection_set.empty?
+          memo
+        end
+
+        SelectionSet.new(selections)
+      end
+
+    end
+  end
+end