gql 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20b402e587fe168bb43d6b683c6f41d5d313d828
-  data.tar.gz: 5b5a28f87cce7e5e72df1ef7d366ae06689b269a
+  metadata.gz: c91705621b9dd8b0515c2d72859f30af612d5f24
+  data.tar.gz: d5f410d2acdc7c18f9832058db5c70fd720f7b08
 SHA512:
-  metadata.gz: 1ce7cd9bf3934dbc32adf6c6d1c69db6f1c8cbe78cdc8a0eb3aefcaa7a9f2511a385ffab599a2fe1bac156df59249fdcecaf73f40b2daf43ffd9e5fb5b5280ce
-  data.tar.gz: 910724d32eb06b282a067955789b2ff554dbe1034911a6e033e18720ab2b140126e85548e2d6c23e1b06fc1f48e77977d6384a712e8d70c0023f505de534f24e
+  metadata.gz: 73cb1ed1e7bb3cdbdb4cb6cbe9eea50c8eeec8aac68d708f9bac42e9feb887bc44a03ed477b2f51da659b370c1bea5a2192490730885eaa33d2d9cee10225e73
+  data.tar.gz: 2b41f407270151041915c441b9ff6ad790298d43ea925af074b4a7405d3b5475c27db40865c62e37d50d84e4d0fd373d6cd5cd5d26c82c86a9e126f32cb6adc6

data/README.md

@@ -1,6 +1,6 @@
 # gql
 
-An attempted implementation of Facebook's yet-to-be-released GraphQL specification, heavily inspired by [graphql-ruby](https://github.com/rmosolgo/graphql-ruby), but with other/more/less features/bugs.
+A Ruby implementation of Facebook's yet-to-be-released GraphQL specification, inspired by [graphql-ruby](https://github.com/rmosolgo/graphql-ruby), but with other/more/less features/bugs.
 
 Caution! This is pre-alpha software. Use at your own risk.
 

data/Rakefile

@@ -1,10 +1,6 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-Rake::TestTask.new :test => :compile do |t|
-  t.libs << 'test'
-end
-
 file 'lib/gql/tokenizer.rb' => 'lib/gql/tokenizer.rex' do |t|
   sh "bundle exec rex #{t.prerequisites.first} --output-file #{t.name}"
 end
@@ -19,4 +15,8 @@ end
 
 task :compile => ['lib/gql/tokenizer.rb', 'lib/gql/parser.rb']
 
+Rake::TestTask.new :test => :compile do |t|
+  t.libs << 'test'
+end
+
 task :default => :test

data/gql.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Martin Andert']
   spec.email         = ['mandert@gmail.com']
 
-  spec.summary       = 'An attempted Ruby implementation of Facebook\'s yet-to-be-released GraphQL specification.'
+  spec.summary       = 'A Ruby implementation of Facebook\'s yet-to-be-released GraphQL specification.'
   spec.homepage      = 'https://github.com/martinandert/gql'
   spec.license       = 'MIT'
 

data/lib/gql.rb

@@ -54,9 +54,9 @@ module GQL
     end
 
     def execute(input, context = {})
-      ast = parse(input)
+      query = parse(input)
 
-      executor = Executor.new(ast)
+      executor = Executor.new(query)
       executor.execute context
     end
 

data/lib/gql/array.rb

@@ -5,27 +5,19 @@ module GQL
     class_attribute :item_class, instance_accessor: false, instance_predicate: false
 
     class << self
-      def build_class(id, method, options = {})
+      def build_class(id, proc, options = {})
         item_class = options[:item_class] || self.item_class
 
-        if item_class.nil?
-          raise Errors::UndefinedNodeClass.new(self, 'item')
-        end
-
-        unless item_class <= Node
-          raise Errors::InvalidNodeClass.new(item_class, Node)
-        end
+        Node.validate_is_subclass! item_class, 'item'
 
         Class.new(self).tap do |field_class|
           field_class.id = id.to_s
-          field_class.method = method
+          field_class.proc = proc
           field_class.item_class = item_class
         end
       end
     end
 
-    call :size, Number, -> { target.size }
-
     def value
       target.map do |item|
         node = self.class.item_class.new(ast_node, item, variables, context)

data/lib/gql/call.rb

@@ -1,70 +1,37 @@
+require 'active_support/core_ext/class/attribute'
+
 module GQL
   class Call
-    class Method
-      attr_reader :target, :context
-
-      def initialize(target, context)
-        @target, @context = target, context
-      end
+    class_attribute :result_class, :proc, instance_accessor: false, instance_predicate: false
 
-      def execute(method, args)
-        instance_exec(*args, &method)
+    class << self
+      def returns(result_class)
+        self.result_class = result_class
       end
     end
 
-    class_attribute :id, :result_class, :method, instance_accessor: false, instance_predicate: false
-
-    class << self
-      def build_class(id, result_class, method)
-        if result_class.is_a? ::Array
-          if result_class.size == 1
-            result_class.unshift GQL.default_list_class || Connection
-          end
-
-          list_class, item_class = result_class
-
-          unless list_class <= Connection
-            raise Errors::InvalidNodeClass.new(list_class, Connection)
-          end
-
-          unless item_class <= Node
-            raise Errors::InvalidNodeClass.new(list_class, Node)
-          end
+    attr_reader :target, :context
 
-          options = { list_class: list_class, item_class: item_class }
-          result_class = Connection.build_class(:result, nil, options)
-        elsif result_class && !(result_class <= Node)
-          raise Errors::InvalidNodeClass.new(result_class, Node)
-        end
-
-        Class.new(self).tap do |call_class|
-          call_class.id = id.to_s
-          call_class.method = method
-          call_class.result_class = result_class
-        end
-      end
+    def initialize(target, context)
+      @target, @context = target, context
     end
 
-    attr_reader :caller, :ast_node, :target, :variables, :context
-
-    def initialize(caller, ast_node, target, variables, context)
-      @caller, @ast_node, @target = caller, ast_node, target
-      @variables, @context = variables, context
+    def execute(*)
+      raise NotImplementedError, 'override in subclass'
     end
 
-    def execute
-      args = substitute_variables(ast_node.arguments)
+    def result_for(caller_class, ast_node, variables)
+      args = substitute_variables(ast_node.arguments, variables)
+      target = execute(*args)
 
-      method = Method.new(target, context)
-      target = method.execute(self.class.method, args)
-      result_class = self.class.result_class || caller.class
+      result_class = self.class.result_class || caller_class
 
       result = result_class.new(ast_node, target, variables, context)
       result.value
     end
 
     private
-      def substitute_variables(args)
+      def substitute_variables(args, variables)
         args.map { |arg| arg.is_a?(::Symbol) ? variables[arg] : arg }
       end
   end

data/lib/gql/config.rb

@@ -10,7 +10,7 @@ module GQL
       end
 
       if ENV['DEBUG']
-        value.call :_schema, Schema::Node, -> { context[:_schema_root] }
+        value.call :_schema, -> { context[:_schema_root] }, returns: Schema::Node
       end
 
       @@root_node_class = value

data/lib/gql/connection.rb

@@ -6,33 +6,18 @@ module GQL
     class_attribute :item_class, instance_accessor: false, instance_predicate: false
 
     class << self
-      def build_class(id, method, options = {})
+      def build_class(id, proc, options = {})
         list_class = options[:list_class] || self.list_class || GQL.default_list_class
         item_class = options[:item_class] || self.item_class
 
-        if list_class.nil?
-          raise Errors::UndefinedNodeClass.new(self, 'list')
-        end
-
-        unless list_class <= Connection
-          raise Errors::InvalidNodeClass.new(list_class, Connection)
-        end
-
-        if item_class.nil?
-          raise Errors::UndefinedNodeClass.new(self, 'item')
-        end
-
-        unless item_class <= Node
-          raise Errors::InvalidNodeClass.new(item_class, Node)
-        end
+        Connection.validate_is_subclass! list_class, 'list'
+        Node.validate_is_subclass! item_class, 'item'
 
         Class.new(list_class).tap do |field_class|
           field_class.id = id.to_s
-          field_class.method = method
+          field_class.proc = proc
 
-          field_class.array :edges, item_class: item_class do
-            target
-          end
+          field_class.array :edges, -> { target }, item_class: item_class
         end
       end
     end

data/lib/gql/executor.rb

@@ -1,10 +1,10 @@
 module GQL
   class Executor
-    attr_reader :ast_node, :variables
+    attr_reader :ast_root, :variables
 
-    def initialize(ast_root)
-      @ast_node   = ast_root.node
-      @variables  = ast_root.variables
+    def initialize(ast_query)
+      @ast_root   = ast_query.root
+      @variables  = ast_query.variables
     end
 
     def execute(context = {})
@@ -14,7 +14,7 @@ module GQL
 
       context[:_schema_root] = node_class if ENV['DEBUG']
 
-      node = node_class.new(ast_node, nil, variables, context)
+      node = node_class.new(ast_root, nil, variables, context)
       node.value
     end
   end

data/lib/gql/field.rb

@@ -2,25 +2,13 @@ require 'active_support/core_ext/class/attribute'
 
 module GQL
   class Field < Node
-    class Method
-      attr_reader :target, :context
-
-      def initialize(target, context)
-        @target, @context = target, context
-      end
-
-      def execute(method)
-        instance_exec(&method)
-      end
-    end
-
-    class_attribute :id, :method, instance_accessor: false, instance_predicate: false
+    class_attribute :id, :proc, instance_accessor: false, instance_predicate: false
 
     class << self
-      def build_class(id, method, options = {})
+      def build_class(id, proc, options = {})
         Class.new(self).tap do |field_class|
           field_class.id = id.to_s
-          field_class.method = method
+          field_class.proc = proc
         end
       end
     end

data/lib/gql/node.rb

@@ -1,57 +1,116 @@
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/object/try'
 
 module GQL
   class Node
+    class ExecutionContext
+      attr_reader :target, :context
+
+      def initialize(target, context)
+        @target, @context = target, context
+      end
+
+      def execute(method, args = [])
+        instance_exec(*args, &method)
+      end
+    end
+
     class_attribute :calls, :fields, instance_accessor: false, instance_predicate: false
 
     self.calls = {}
     self.fields = {}
 
     class << self
-      def call(id, result_class = nil, body = nil)
-        if body.nil? && result_class.is_a?(Proc)
-          body = result_class
-          result_class = nil
-        end
+      def call(id, *args)
+        if id.is_a? Hash
+          id.each do |id, call_class|
+            call id, call_class
+          end
+        else
+          options = args.extract_options!
 
-        body ||= lambda { |*args| target.public_send(id, *args) }
+          proc_or_class = args.shift || -> (*args) { target.public_send(id, *args) }
+          result_class = options[:returns] || proc_or_class.try(:result_class)
 
-        call_class = Call.build_class(id, result_class, body)
+          if result_class.is_a? ::Array
+            if result_class.size == 1
+              result_class.unshift GQL.default_list_class || Connection
+            end
 
-        self.const_set "#{id.to_s.camelize}Call", call_class
-        self.calls = calls.merge(id.to_sym => call_class)
-      end
+            options = {
+              list_class: result_class.first,
+              item_class: result_class.last
+            }
 
-      def field(*ids, &block)
-        options = ids.extract_options!
+            result_class = Connection.build_class(:result, nil, options)
+          elsif result_class
+            Node.validate_is_subclass! result_class, 'result'
+          end
 
-        ids.each do |id|
-          method = block || lambda { target.public_send(id) }
-          field_type = options.delete(:type) || Field
+          call_class =
+            if proc_or_class.is_a? Proc
+              Class.new(Call).tap do |call_class|
+                call_class.class_eval do
+                  self.proc = proc_or_class
 
-          unless field_type <= Field
-            raise Errors::InvalidNodeClass.new(field_type, Field)
-          end
+                  def execute(*args)
+                    instance_exec(*args, &self.class.proc)
+                  end
+                end
+
+                self.const_set "#{id.to_s.camelize}Call", call_class
+              end
+            else
+              proc_or_class
+            end
 
-          field_class = field_type.build_class(id, method, options)
+          call_class.result_class = result_class
 
+          self.calls = calls.merge(id.to_sym => call_class)
+        end
+      end
+
+      def field(id, *args)
+        options = args.extract_options!
+        proc    = args.shift || -> { target.public_send(id) }
+        type    = options.delete(:type) || Field
+
+        Field.validate_is_subclass! type, 'type'
+
+        type.build_class(id, proc, options).tap do |field_class|
           self.const_set "#{id.to_s.camelize}Field", field_class
           self.fields = fields.merge(id.to_sym => field_class)
         end
       end
 
-      def cursor(id = nil, &block)
-        body = id ? -> { target.public_send(id) } : block
-        field :cursor, { type: Simple }, &body
+      def cursor(id_or_proc)
+        id = id_or_proc.is_a?(Proc) ? nil : id_or_proc
+        proc = id ? -> { target.public_send(id) } : id_or_proc
+
+        field :cursor, proc, type: Simple
+      end
+
+      def validate_is_subclass!(subclass, name)
+        if subclass.nil?
+          raise Errors::UndefinedNodeClass.new(self, name)
+        end
+
+        unless subclass <= self
+          raise Errors::InvalidNodeClass.new(subclass, self)
+        end
+      end
+
+      def respond_to?(method, *args)
+        GQL.field_types.has_key?(method) || super
       end
 
-      def method_missing(method, *ids, &block)
-        if field_type = GQL.field_types[method]
-          options = ids.extract_options!
+      def method_missing(method, *args, &block)
+        if type = GQL.field_types[method]
+          options = args.extract_options!.merge(type: type)
 
-          field(*ids, options.merge(type: field_type), &block)
+          field(*args.push(options), &block)
         else
           super
         end
@@ -84,15 +143,15 @@ module GQL
         raise Errors::UndefinedCall.new(ast_call.id, self.class)
       end
 
-      call = call_class.new(self, ast_call, target, variables, context)
-      call.execute
+      call = call_class.new(target, context)
+      call.result_for self.class, ast_call, variables
     end
 
     def value_of_fields(ast_fields)
-      ast_fields.reduce({}) do |memo, ast_field|
+      ast_fields.reduce({}) do |result, ast_field|
         key = ast_field.alias_id || ast_field.id
 
-        memo.merge key => value_of_field(ast_field)
+        result.merge key => value_of_field(ast_field)
       end
     end
 
@@ -108,8 +167,8 @@ module GQL
           raise Errors::UndefinedField.new(ast_field.id, self.class)
         end
 
-        method = Field::Method.new(target, context)
-        target = method.execute(field_class.method)
+        method = ExecutionContext.new(target, context)
+        target = method.execute(field_class.proc)
 
         field = field_class.new(ast_field, target, variables, context)
         field.value