gql 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 770f58471faa9640c902c42c9d89329b3af9a458
-  data.tar.gz: d95c3150739cbd190256a55adcec0a65c7a059b2
+  metadata.gz: 84b1f6dbe8ad680fd457f4f14dbd0183b4b18d46
+  data.tar.gz: 192058fde95f568491e87c6edd719b9a4c85b1c1
 SHA512:
-  metadata.gz: bc67c88490eac0c385ae5cf53558249342552d8e1a97c6ba719adc4f0495be148529f928bd400236eca5aeeac5eb8377d94cb965bb5d5025ca1f9c32260d2c23
-  data.tar.gz: 0927523dd03114407ffecb1797997a5620ab4dfc10efa7f0d84571945e47c24625a3a412deb9bdecf25e383ea18df4467db27f4d42c951b1f391caf732f54cd7
+  metadata.gz: dee4291ac7f769adf121c145b8f2a2a93bd0a3417aba29e218120cc2106045f2e4f19cbcd2491b778aff4531f6c04d88acb39500bae1d24763be054131cfe29a
+  data.tar.gz: ae67282c3aa9cf8b48155429c7f6714f16562ba3ff77fdf9f4a9edcfabc8fae59d02b7472490599f3959b36a2af82971ad8ff36754be8f3b8b61cf71d757ff64

data/lib/gql.rb

@@ -1,5 +1,7 @@
 require 'active_support/dependencies/autoload'
+
 require 'gql/version'
+require 'gql/errors'
 
 module GQL
   extend ActiveSupport::Autoload
@@ -9,33 +11,17 @@ module GQL
   autoload :Call
   autoload :Config
   autoload :Connection
-  autoload :Error, 'gql/errors'
   autoload :Executor
   autoload :Field
+  autoload :Lazy
   autoload :Number
   autoload :Object
   autoload :Parser
+  autoload :Registry
   autoload :Scalar
   autoload :String
-  autoload :TestCase
   autoload :Tokenizer
 
-  module Errors
-    extend ActiveSupport::Autoload
-
-    autoload_at 'gql/errors' do
-      autoload :CallNotFound
-      autoload :FieldClassNotSet
-      autoload :FieldNotFound
-      autoload :InvalidFieldClass
-      autoload :NoMethodError
-      autoload :RootClassNotSet
-      autoload :ScanError
-      autoload :SyntaxError
-      autoload :VariableNotFound
-    end
-  end
-
   module Schema
     extend ActiveSupport::Autoload
 
@@ -55,8 +41,8 @@ module GQL
       Thread.current[:gql_config] = value
     end
 
-    %w(root_field_class root_target_proc field_types
-       default_list_field_class default_field_proc
+    %w(root_class root_target_proc field_types
+       default_list_class default_field_proc
        default_call_proc debug).each do |method|
       module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
         def #{method}

data/lib/gql/array.rb

@@ -2,32 +2,26 @@ require 'active_support/core_ext/class/attribute'
 
 module GQL
   class Array < Field
-    class_attribute :item_field_class, instance_accessor: false, instance_predicate: false
+    class_attribute :item_class, instance_accessor: false, instance_predicate: false
 
     class << self
       def build_class(id, proc, options = {})
-        item_field_class = options.delete(:item_field_class) || self.item_field_class
-
-        if item_field_class.is_a?(Hash)
-          item_field_class.values.each do |ifc|
-            Field.validate_is_subclass! ifc, 'item_field_class'
-          end
-        else
-          Field.validate_is_subclass! item_field_class, 'item_field_class'
-          item_field_class = Hash.new(item_field_class)
-        end
+        item_class = options.delete(:item_class) || self.item_class
+        item_class = ::Hash.new(item_class) unless item_class.is_a?(::Hash)
 
         Class.new(self).tap do |field_class|
-          field_class.id = id.to_s
+          field_class.id = id
           field_class.proc = proc
-          field_class.item_field_class = item_field_class
+          field_class.item_class = item_class
         end
       end
     end
 
     def value
       target.map do |item|
-        field = self.class.item_field_class[item.class].new(ast_node, item, variables, context)
+        field_class = Registry.fetch(self.class.item_class[item.class])
+
+        field = field_class.new(ast_node, item, variables, context)
         field.value
       end
     end

data/lib/gql/config.rb

@@ -1,17 +1,11 @@
-require 'active_support/core_ext/class/subclasses'
-
 module GQL
   class Config
-    def root_field_class
-      @@root_field_class ||= nil
+    def root_class
+      @@root_class ||= nil
     end
 
-    def root_field_class=(value)
-      unless value.nil? || value <= Field
-        raise Errors::InvalidFieldClass.new(value, Field)
-      end
-
-      @@root_field_class = value
+    def root_class=(value)
+      @@root_class = value
     end
 
     def root_target_proc
@@ -24,12 +18,12 @@ module GQL
 
     def field_types
       @@field_types ||= {
-        array:      Array,
-        boolean:    Boolean,
-        connection: Connection,
-        number:     Number,
-        object:     Object,
-        string:     String
+        array:      'GQL::Array',
+        boolean:    'GQL::Boolean',
+        connection: 'GQL::Connection',
+        number:     'GQL::Number',
+        object:     'GQL::Object',
+        string:     'GQL::String'
       }
     end
 
@@ -37,16 +31,12 @@ module GQL
       @@field_types = value
     end
 
-    def default_list_field_class
-      @@default_list_field_class ||= Field
+    def default_list_class
+      @@default_list_class ||= 'GQL::Field'
     end
 
-    def default_list_field_class=(value)
-      unless value.nil? || value <= Field
-        raise Errors::InvalidFieldClass.new(value, Field)
-      end
-
-      @@default_list_field_class = value
+    def default_list_class=(value)
+      @@default_list_class = value
     end
 
     def default_field_proc
@@ -77,6 +67,8 @@ module GQL
     def debug=(value)
       value = !!value
 
+      @@debug = nil unless defined?(@@debug)
+
       return if value == @@debug
 
       value ? switch_debug_on : switch_debug_off
@@ -86,39 +78,13 @@ module GQL
 
     private
       def switch_debug_on
-        switch_on_type_field
-        switch_on_execution_context
-      end
-
-      def switch_debug_off
-        switch_off_type_field
-        switch_off_execution_context
-      end
-
-      def switch_on_type_field
-        return if Field.has_field? :__type__
-
-        type_field_class = Field.object :__type__, -> { field_class }, field_class: Schema::Field
-
-        Field.descendants.each do |field_class|
-          field_class.fields[:__type__] = type_field_class
-        end
-      end
-
-      def switch_off_type_field
-        return unless Field.has_field? :__type__
-
-        [Field, *Field.descendants].each do |field_class|
-          field_class.remove_field :__type__
-        end
-      end
-
-      def switch_on_execution_context
+        Field.object :__type__, -> { field_class }, class: Schema::Field
         Field.send :remove_const, :ExecutionContext if Field.const_defined?(:ExecutionContext)
         Field.const_set :ExecutionContext, Field::ExecutionContextDebug
       end
 
-      def switch_off_execution_context
+      def switch_debug_off
+        Field.remove_field :__type__
         Field.send :remove_const, :ExecutionContext if Field.const_defined?(:ExecutionContext)
         Field.const_set :ExecutionContext, Field::ExecutionContextNoDebug
       end

data/lib/gql/connection.rb

@@ -1,16 +1,12 @@
-require 'active_support/core_ext/class/attribute'
-
 module GQL
   class Connection < Field
     class << self
       def build_class(id, proc, options = {})
-        list_field_class = options.delete(:list_field_class) || GQL.default_list_field_class
-        item_field_class = options.delete(:item_field_class)
-
-        Field.validate_is_subclass! list_field_class, 'list_field_class'
+        list_class = options.delete(:list_class) || GQL.default_list_class
+        item_class = options.delete(:item_class)
 
-        list_field_class.build_class(id, proc, options).tap do |field_class|
-          field_class.array :edges, -> { target }, item_field_class: item_field_class
+        Registry.fetch(list_class).build_class(id, proc, options).tap do |field_class|
+          field_class.array :edges, -> { target }, item_class: item_class
         end
       end
     end

data/lib/gql/errors.rb

@@ -64,7 +64,7 @@ module GQL
     class RootClassNotSet < Error
       def initialize
         msg =  "GQL root field class is not set. "
-        msg << "Set it with `GQL.root_field_class = MyRootField'."
+        msg << "Set it with `GQL.root_class = MyRootField'."
 
         super(msg, 121)
       end

data/lib/gql/executor.rb

@@ -8,7 +8,7 @@ module GQL
     end
 
     def execute(context = {}, vars = {})
-      field_class = GQL.root_field_class
+      field_class = GQL.root_class
 
       raise Errors::RootClassNotSet if field_class.nil?
 
@@ -16,7 +16,7 @@ module GQL
 
       target = GQL.root_target_proc.call(context)
 
-      field = field_class.new(ast_root, target, variables, context)
+      field = Registry.fetch(field_class).new(ast_root, target, variables, context)
       field.value
     end
   end

data/lib/gql/field.rb

@@ -1,7 +1,8 @@
 require 'active_support/core_ext/class/attribute'
 
-require 'gql/has_calls'
-require 'gql/has_fields'
+require 'gql/mixins/common'
+require 'gql/mixins/has_calls'
+require 'gql/mixins/has_fields'
 
 module GQL
   class Field
@@ -14,20 +15,11 @@ module GQL
           field_class.proc = proc
         end
       end
-
-      def validate_is_subclass!(subclass, name)
-        if subclass.nil?
-          raise Errors::FieldClassNotSet.new(self, name)
-        end
-
-        unless subclass <= self
-          raise Errors::InvalidFieldClass.new(subclass, self)
-        end
-      end
     end
 
-    include HasCalls
-    include HasFields
+    extend Mixins::Common
+    include Mixins::HasCalls
+    include Mixins::HasFields
 
     attr_reader :ast_node, :target, :variables, :context
 

data/lib/gql/lazy.rb

@@ -0,0 +1,31 @@
+require 'active_support/core_ext/class/attribute'
+
+module GQL
+  class Lazy < Field
+    class_attribute :owner, :type, :options, instance_accessor: false, instance_predicate: false
+
+    class << self
+      def build_class(id, proc, options)
+        Class.new(self).tap do |field_class|
+          field_class.owner = options.delete(:owner)
+          field_class.type = options.delete(:type)
+          field_class.id = id
+          field_class.proc = proc
+          field_class.options = options
+        end
+      end
+
+      def resolve
+        owner.remove_field id
+        owner.add_field id, proc, options.merge(type: Registry.fetch(type))
+      end
+    end
+
+    def value
+      field_class = self.class.resolve
+
+      field = field_class.new(ast_node, target, variables, context)
+      field.value
+    end
+  end
+end

data/lib/gql/mixins/common.rb

@@ -0,0 +1,31 @@
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+module GQL
+  module Mixins
+    module Common
+      def propagate(type, id, klass)
+        const_name = send("const_name_for_#{type}", id)
+        accessor   = type.to_s.pluralize
+
+        const_set const_name, klass
+
+        [self, *descendants].each do |c|
+          c.send "#{accessor}=", c.send(accessor).merge(id => klass)
+        end
+      end
+
+      def shutdown(type, id)
+        const_name = send("const_name_for_#{type}", id)
+        accessor   = type.to_s.pluralize
+
+        [self, *descendants].each do |c|
+          next unless c.send("has_#{type}?", id)
+
+          c.send :remove_const, const_name if c.const_defined?(const_name, false)
+          c.send(accessor).delete id
+        end
+      end
+    end
+  end
+end

data/lib/gql/mixins/has_calls.rb

@@ -0,0 +1,120 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/class/subclasses'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/string/inflections'
+
+module GQL
+  module Mixins
+    module HasCalls
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :calls, :call_proc, instance_accessor: false, instance_predicate: false
+        self.calls = {}
+      end
+
+      module ClassMethods
+        def add_call(id, *args, &block)
+          remove_call id
+
+          id            = id.to_sym
+          options       = args.extract_options!
+          call_spec     = args.shift || block || proc_for_call(id)
+          result_spec   = options[:returns] || call_spec.try(:result_class)
+          result_class  = result_class_from_spec(result_spec)
+
+          build_call_class(call_spec, id, result_class).tap do |call_class|
+            propagate :call, id, call_class
+          end
+        end
+
+        alias :call :add_call
+
+        def remove_call(id)
+          shutdown :call, id.to_sym
+        end
+
+        def has_call?(id)
+          calls.has_key? id.to_sym
+        end
+
+        private
+          def build_call_class(spec, id, result_class)
+            call_class_from_spec(spec).tap do |call_class|
+              call_class.id = id
+              call_class.result_class = result_class
+
+              if result_class && result_class.name.nil?
+                call_class.const_set :Result, result_class
+              end
+            end
+          end
+
+          def call_class_from_spec(spec)
+            return Class.new(spec) unless spec.is_a?(Proc)
+
+            Class.new(Call).tap do |call_class|
+              call_class.class_eval do
+                self.proc = spec
+
+                def execute(*args)
+                  instance_exec(*args, &self.class.proc)
+                end
+              end
+            end
+          end
+
+          def const_name_for_call(id)
+            :"#{id.to_s.camelize}Call"
+          end
+
+          def proc_for_call(id)
+            instance_exec id, &(call_proc || GQL.default_call_proc)
+          end
+
+          def result_class_from_spec(spec)
+            result_class =
+              case spec
+              when ::Array
+                result_class_from_connection_spec spec.dup
+              when ::Hash
+                result_class_from_mapping_spec spec.dup
+              else
+                spec
+              end
+
+            result_class && Registry.fetch(result_class)
+          end
+
+          def result_class_from_connection_spec(spec)
+            if spec.size == 1
+              spec.unshift GQL.default_list_class
+            end
+
+            options = {
+              list_class: spec.first,
+              item_class: spec.last
+            }
+
+            Connection.build_class :result, nil, options
+          end
+
+          def result_class_from_mapping_spec(spec)
+            Object.build_class :result, nil, class: spec
+          end
+      end
+
+      private
+        def value_of_call(ast_call)
+          call_class = call_class_for_id(ast_call.id)
+          call_class.execute(self.class, ast_call, target, variables, context)
+        end
+
+        def call_class_for_id(id)
+          self.class.calls[id] or raise Errors::CallNotFound.new(id, self.class)
+        end
+    end
+  end
+end

data/lib/gql/mixins/has_fields.rb

@@ -0,0 +1,138 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/class/subclasses'
+require 'active_support/core_ext/string/inflections'
+
+module GQL
+  module Mixins
+    module HasFields
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :fields, :field_proc, instance_accessor: false, instance_predicate: false
+        self.fields = {}
+      end
+
+      module ClassMethods
+        def add_field(id, *args, &block)
+          remove_field id
+
+          id      = id.to_sym
+          options = args.extract_options!
+          type    = options.delete(:type) || Field
+          proc    = args.shift || block || proc_for_field(id)
+
+          build_field_class(type, id, proc, options).tap do |field_class|
+            propagate :field, id, field_class
+          end
+        end
+
+        alias :field :add_field
+
+        def remove_field(id)
+          shutdown :field, id.to_sym
+        end
+
+        def has_field?(id)
+          fields.has_key? id.to_sym
+        end
+
+        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
+
+          add_field :cursor, proc, type: Scalar
+        end
+
+        def respond_to?(method, *args)
+          super || GQL.field_types.has_key?(method)
+        end
+
+        def method_missing(method, *args, &block)
+          if type = GQL.field_types[method]
+            define_field_method method, type
+            send method, *args, &block
+          else
+            super
+          end
+        rescue NoMethodError => exc
+          raise Errors::NoMethodError.new(self, method, exc)
+        end
+
+        private
+          def build_field_class(type, id, proc, options)
+            if type.is_a? ::String
+              Lazy.build_class id, proc, options.merge(owner: self, type: type)
+            else
+              Registry.fetch(type).build_class id, proc, options
+            end
+          end
+
+          def const_name_for_field(id)
+            prefix = id == :__type__ ? 'Schema_Type' : id.to_s.camelize
+            :"#{prefix}Field"
+          end
+
+          def proc_for_field(id)
+            instance_exec id, &(field_proc || GQL.default_field_proc)
+          end
+
+          def define_field_method(name, type)
+            Field.define_singleton_method name do |*args, &block|
+              options = args.extract_options!.merge(type: type)
+              args = args.push(options)
+
+              add_field(*args, &block)
+            end
+          end
+      end
+
+      private
+        def value_of_fields(ast_fields)
+          ast_fields.reduce({}) do |result, ast_field|
+            key = ast_field.alias_id || ast_field.id
+
+            result.merge key => value_of_field(ast_field)
+          end
+        end
+
+        def value_of_field(ast_field)
+          if ast_field.id == :node
+            field = self.class.new(ast_field, target, variables, context)
+            field.value
+          else
+            field_class = field_class_for_id(ast_field.id)
+            next_target = target_for_field(target, field_class.proc)
+
+            field = field_class.new(ast_field, next_target, variables, context)
+            field.value
+          end
+        end
+
+        def field_class_for_id(id)
+          self.class.fields[id] or raise Errors::FieldNotFound.new(id, self.class)
+        end
+
+        def target_for_field(current_target, proc)
+          args = [current_target, context]
+          args.push self.class if GQL.debug
+
+          method = self.class.const_get(:ExecutionContext).new(*args)
+          method.execute proc
+        end
+
+        class ExecutionContextNoDebug < Struct.new(:target, :context)
+          def execute(method, args = [])
+            instance_exec(*args, &method)
+          end
+        end
+
+        class ExecutionContextDebug < Struct.new(:target, :context, :field_class)
+          def execute(method, args = [])
+            instance_exec(*args, &method)
+          end
+        end
+    end
+  end
+end

data/lib/gql/object.rb

@@ -2,14 +2,26 @@ require 'active_support/core_ext/class/attribute'
 
 module GQL
   class Object < Field
+    class_attribute :object_class, instance_accessor: false, instance_predicate: false
+
     class << self
       def build_class(id, proc, options = {})
-        field_class = options.delete(:field_class)
-
-        Field.validate_is_subclass! field_class, 'field_class'
+        object_class = options.delete(:class) || options.delete(:as)
+        object_class = ::Hash.new(object_class) unless object_class.is_a?(::Hash)
 
-        field_class.build_class id, proc, options
+        Class.new(self).tap do |klass|
+          klass.id = id
+          klass.proc = proc
+          klass.object_class = object_class
+        end
       end
     end
+
+    def value
+      field_class = Registry.fetch(self.class.object_class[target.class])
+
+      field = field_class.new(ast_node, target, variables, context)
+      field.value
+    end
   end
 end

data/lib/gql/registry.rb

@@ -0,0 +1,39 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_support/per_thread_registry'
+
+module GQL
+  class Registry
+    extend ActiveSupport::PerThreadRegistry
+
+    attr_reader :cache
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @cache = {}
+    end
+
+    def fetch(key, baseclass = Field)
+      cache[key] || begin
+        raise Errors::FieldClassNotSet.new(baseclass, 'TODO') if key.nil?
+
+        const, name =
+          if key.instance_of? ::Class
+            [key, key.name]
+          else
+            [key.constantize, key]
+          end
+
+        raise Errors::InvalidFieldClass.new(const, baseclass) unless const <= baseclass
+
+        cache.update name => const, const => const
+
+        cache[key]
+      end
+    end
+
+    alias_method :[], :fetch
+  end
+end

data/lib/gql/schema/call.rb

@@ -5,8 +5,8 @@ module GQL
 
       string  :id
       string  :name
-      object  :result_class, -> { target.result_class || CallerClass }, field_class: Field
-      array   :parameters,   -> { (target.proc || target.instance_method(:execute)).parameters }, item_field_class: Parameter
+      object  :result_class, -> { target.result_class || CallerClass }, class: Field
+      array   :parameters,   -> { (target.proc || target.instance_method(:execute)).parameters }, item_class: Parameter
 
       def scalar_value
         target.name

data/lib/gql/schema/field.rb

@@ -5,8 +5,8 @@ module GQL
 
       string      :id
       string      :name
-      connection  :calls,  -> { target.calls.values  }, list_field_class: List, item_field_class: Call
-      connection  :fields, -> { target.fields.values }, list_field_class: List, item_field_class: Field
+      connection  :calls,  -> { target.calls.values  }, list_class: List, item_class: Call
+      connection  :fields, -> { target.fields.values }, list_class: List, item_class: Field
 
       def scalar_value
         target.name

data/lib/gql/version.rb

@@ -1,3 +1,3 @@
 module GQL
-  VERSION = '0.0.19'
+  VERSION = '0.0.20'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gql
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Martin Andert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2015-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: minitest-perf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -112,11 +126,14 @@ files:
 - lib/gql/errors.rb
 - lib/gql/executor.rb
 - lib/gql/field.rb
-- lib/gql/has_calls.rb
-- lib/gql/has_fields.rb
+- lib/gql/lazy.rb
+- lib/gql/mixins/common.rb
+- lib/gql/mixins/has_calls.rb
+- lib/gql/mixins/has_fields.rb
 - lib/gql/number.rb
 - lib/gql/object.rb
 - lib/gql/parser.rb
+- lib/gql/registry.rb
 - lib/gql/scalar.rb
 - lib/gql/schema/call.rb
 - lib/gql/schema/caller_class.rb
@@ -124,7 +141,6 @@ files:
 - lib/gql/schema/list.rb
 - lib/gql/schema/parameter.rb
 - lib/gql/string.rb
-- lib/gql/test_case.rb
 - lib/gql/tokenizer.rb
 - lib/gql/version.rb
 homepage: https://github.com/martinandert/gql

data/lib/gql/has_calls.rb

@@ -1,104 +0,0 @@
-require 'active_support/concern'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/try'
-
-module GQL
-  module HasCalls
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :calls, :call_proc, instance_accessor: false, instance_predicate: false
-      self.calls = {}
-    end
-
-    module ClassMethods
-      def add_call(id, *args, &block)
-        options = args.extract_options!
-
-        call_spec = args.shift || block || proc_for_call(id)
-        result_spec = options[:returns] || call_spec.try(:result_class)
-        result_class = result_class_from_spec(result_spec)
-
-        Field.validate_is_subclass! result_class, 'result_class' if result_class
-
-        call_class = call_class_from_spec(call_spec)
-        call_class.id = id.to_s
-        call_class.result_class = result_class
-
-        if result_class && result_class.name.nil?
-          call_class.const_set :Result, result_class
-        end
-
-        self.const_set const_name_for_call(id), call_class
-        self.calls = calls.merge(id.to_sym => call_class)
-      end
-
-      alias :call :add_call
-
-      def remove_call(id)
-        const_name = const_name_for_call(id)
-
-        send :remove_const, const_name if const_defined?(const_name)
-        calls.delete id
-      end
-
-      def has_call?(id)
-        calls.has_key? id
-      end
-
-      private
-        def const_name_for_call(id)
-          :"#{id.to_s.camelize}Call"
-        end
-
-        def proc_for_call(id)
-          instance_exec id, &(call_proc || GQL.default_call_proc)
-        end
-
-        def result_class_from_spec(spec)
-          return spec unless spec.is_a? ::Array
-
-          result_class_from_connection_spec spec.dup
-        end
-
-        def result_class_from_connection_spec(spec)
-          if spec.size == 1
-            spec.unshift GQL.default_list_field_class
-          end
-
-          options = {
-            list_field_class: spec.first,
-            item_field_class: spec.last
-          }
-
-          Connection.build_class :result, nil, options
-        end
-
-        def call_class_from_spec(spec)
-          return Class.new(spec) unless spec.is_a?(Proc)
-
-          Class.new(Call).tap do |call_class|
-            call_class.class_eval do
-              self.proc = spec
-
-              def execute(*args)
-                instance_exec(*args, &self.class.proc)
-              end
-            end
-          end
-        end
-    end
-
-    private
-      def value_of_call(ast_call)
-        call_class = call_class_for_id(ast_call.id)
-        call_class.execute(self.class, ast_call, target, variables, context)
-      end
-
-      def call_class_for_id(id)
-        self.class.calls[id] or raise Errors::CallNotFound.new(id, self.class)
-      end
-  end
-end

data/lib/gql/has_fields.rb

@@ -1,132 +0,0 @@
-require 'active_support/concern'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/string/inflections'
-
-module GQL
-  module HasFields
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :fields, :field_proc, instance_accessor: false, instance_predicate: false
-      self.fields = {}
-    end
-
-    module ClassMethods
-      def add_field(id, *args, &block)
-        options = args.extract_options!
-        type = options.delete(:type) || Field
-        proc = args.shift || block || proc_for_field(id)
-
-        Field.validate_is_subclass! type, 'type'
-
-        type.build_class(id, proc, options).tap do |field_class|
-          const_name = const_name_for_field(id)
-
-          const_set const_name, field_class unless const_defined?(const_name)
-          self.fields = fields.merge(id.to_sym => field_class)
-        end
-      end
-
-      alias :field :add_field
-
-      def remove_field(id)
-        const_name = const_name_for_field(id)
-
-        send :remove_const, const_name if const_defined?(const_name)
-        fields.delete id
-      end
-
-      def has_field?(id)
-        fields.has_key? id
-      end
-
-      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
-
-        add_field :cursor, proc, type: Scalar
-      end
-
-      def respond_to?(method, *args)
-        super || GQL.field_types.has_key?(method)
-      end
-
-      def method_missing(method, *args, &block)
-        if type = GQL.field_types[method]
-          define_field_method method, type
-          send method, *args, &block
-        else
-          super
-        end
-      rescue NoMethodError => exc
-        raise Errors::NoMethodError.new(self, method, exc)
-      end
-
-      private
-        def const_name_for_field(id)
-          prefix = id == :__type__ ? 'Schema_Type' : id.to_s.camelize
-          :"#{prefix}Field"
-        end
-
-        def proc_for_field(id)
-          instance_exec id, &(field_proc || GQL.default_field_proc)
-        end
-
-        def define_field_method(name, type)
-          Field.define_singleton_method name do |*args, &block|
-            options = args.extract_options!.merge(type: type)
-            args = args.push(options)
-
-            add_field(*args, &block)
-          end
-        end
-    end
-
-    private
-      def value_of_fields(ast_fields)
-        ast_fields.reduce({}) do |result, ast_field|
-          key = ast_field.alias_id || ast_field.id
-
-          result.merge key => value_of_field(ast_field)
-        end
-      end
-
-      def value_of_field(ast_field)
-        if ast_field.id == :node
-          field = self.class.new(ast_field, target, variables, context)
-          field.value
-        else
-          field_class = field_class_for_id(ast_field.id)
-          next_target = target_for_field(target, field_class.proc)
-
-          field = field_class.new(ast_field, next_target, variables, context)
-          field.value
-        end
-      end
-
-      def field_class_for_id(id)
-        self.class.fields[id] or raise Errors::FieldNotFound.new(id, self.class)
-      end
-
-      def target_for_field(current_target, proc)
-        args = [current_target, context]
-        args.push self.class if GQL.debug
-
-        method = self.class.const_get(:ExecutionContext).new(*args)
-        method.execute proc
-      end
-
-      class ExecutionContextNoDebug < Struct.new(:target, :context)
-        def execute(method, args = [])
-          instance_exec(*args, &method)
-        end
-      end
-
-      class ExecutionContextDebug < Struct.new(:target, :context, :field_class)
-        def execute(method, args = [])
-          instance_exec(*args, &method)
-        end
-      end
-  end
-end

data/lib/gql/test_case.rb

@@ -1,4 +0,0 @@
-module GQL
-  class TestCase < ActiveSupport::TestCase
-  end
-end