datasource 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c4654c0cc97e0cba3fd8ce3d9b99a520d590afa
-  data.tar.gz: a37d72813c8e2d0a6ef6430a380115126f28dfad
+  metadata.gz: acadf2996a54023f7ea9ec464ae0b82ad0c57dc9
+  data.tar.gz: 7f1759d99758a076f66787bb152c147cbb0ba714
 SHA512:
-  metadata.gz: 6d68a095c8b8af62be19f3fbb7048b634b5d0fb5d113f3e81d6e1430959d69bc9f93cce68d02977066ff782361c7915b0a3cab0a9003b85598caa019a5bb5c7e
-  data.tar.gz: 4cf182d351a3bfc21f6dfcd2062eb97f21f36dd39ccf9ef4bfaf6cca418aea7b7fc9105fe613936f95f19a4a32d74714e51b27ebccfc15fa9de9a7b716f25dab
+  metadata.gz: a8d565d3e8d3e2e44ee7c3c22f27f8e776b10f3b301c6f252a996b9130d1a39c15da04e92530d1a5eb81b892815d7377b61d2aaadeadd1841c22df1c5199a0ab
+  data.tar.gz: c40d2192fcdaf926b25f4ece6f8378a763e63459d1ff5a673d06a14e32fbe2183c26b43de1a3f49955b5c73eb9ab6a18bfbc6c6e03b3f78dbefa0d6930a83d5f

data/README.md

@@ -1,10 +1,10 @@
 # Datasource
 
-- Automatically preload associations for your serializers
-- Specify custom SQL snippets for virtual attributes (Query attributes)
-- Write custom preloading logic in a reusable way
+**Please see gem [active_loaders](https://github.com/kundi/active_loaders)
+documentation for now, it includes all the necessary information**
 
-** Note: the API of this gem is still unstable and may change a lot between versions! This project uses semantic versioning (until version 1.0.0, minor version changes may include API changes, but patch version will not) **
+Documentation for datasource will be updated later. Active Model Serializer support
+was extracted into the active_loaders gem.
 
 #### Install
 
@@ -32,237 +32,6 @@ rails g datasource:install
 - ActiveRecord
 - Sequel
 
-#### Serializer support
-
-- active_model_serializers
-
-### Associations
-
-The most noticable magic effect of using Datasource is that associations will
-automatically be preloaded using a single query.
-
-```ruby
-class PostSerializer < ActiveModel::Serializer
-  attributes :id, :title
-end
-
-class UserSerializer < ActiveModel::Serializer
-  attributes :id
-  has_many :posts
-end
-```
-```sql
-SELECT users.* FROM users
-SELECT posts.* FROM posts WHERE id IN (?)
-```
-
-This means you **do not** need to call `includes` yourself. It will be done
-automatically by Datasource.
-
-### Show action
-
-If you use the more advanced features like Loaded, you will probably want to
-reuse the same loading logic in your show action.
-You will need to call `for_serializer` on the scope before you call `find`.
-You can optionally give it the serializer class as an argument.
-
-```ruby
-class PostsController < ApplicationController
-  def show
-    post = Post.for_serializer.find(params[:id])
-    # more explicit:
-    # post = Post.for_serializer(PostSerializer).find(params[:id])
-
-    render json: post
-  end
-end
-```
-
-You can also use it on an existing record, but doing it this way may result in
-an additional SQL query (for example if you use query attributes).
-
-```ruby
-class UsersController < ApplicationController
-  def show
-    user = current_user.for_serializer
-
-    render json: user
-  end
-end
-```
-
-### Query attribute
-
-You can specify a SQL fragment for `SELECT` and use that as an attribute on your
-model. As a simple example you can concatenate 2 strings together in SQL:
-
-```ruby
-class User < ActiveRecord::Base
-  datasource_module do
-    query :full_name do
-      "users.first_name || ' ' || users.last_name"
-    end
-  end
-end
-
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :full_name
-end
-```
-
-```sql
-SELECT users.*, (users.first_name || ' ' || users.last_name) AS full_name FROM users
-```
-
-Note: If you need data from another table, use a join in a loaded value (see below).
-
-### Standalone Datasource class
-
-If you are going to have more complex preloading logic (like using Loaded below),
-then it might be better to put Datasource code into its own class. This is pretty
-easy, just create a directory `app/datasources` (or whatever you like), and create
-a file depending on your model name, for example for a `Post` model, create
-`post_datasource.rb`. The name is important for auto-magic reasons. Example file:
-
-```ruby
-class PostDatasource < Datasource::From(Post)
-  query(:full_name) { "users.first_name || ' ' || users.last_name" }
-end
-```
-
-### Loaded
-
-You might want to have some more complex preloading logic. In that case you can
-use a method to load values for all the records at once (e.g. with a custom query
-or even from a cache). The loading methods are only executed if you use the values,
-otherwise they will be skipped.
-
-First just declare that you want to have a loaded attribute (the parameters will be explained shortly):
-
-```ruby
-class UserDatasource < Datasource::From(User)
-  loaded :post_count, from: :array, default: 0
-end
-```
-
-By default, datasource will look for a method named `load_<name>` for loading
-the values, in this case `load_newest_comment`. It needs to be defined in the
-collection block, which has methods to access information about the collection (posts)
-that are being loaded. These methods are `scope`, `models`, `model_ids`,
-`datasource`, `datasource_class` and `params`.
-
-```ruby
-class UserDatasource < Datasource::From(User)
-  loaded :post_count, from: :array, default: 0
-
-  collection do
-    def load_post_count
-      Post.where(user_id: model_ids)
-      .group(:user_id)
-      .pluck("user_id, COUNT(id)")
-    end
-  end
-end
-```
-
-In this case `load_post_count` returns an array of pairs.
-For example: `[[1, 10], [2, 5]]`. Datasource can understand this because of
-`from: :array`. This would result in the following:
-
-```ruby
-post_id_1.post_count # => 10
-post_id_2.post_count # => 5
-# other posts will have the default value or nil if no default value was given
-other_post.post_count # => 0
-```
-
-Besides `default` and `from: :array`, you can also specify `group_by`, `one`
-and `source`. Source is just the name of the load method.
-
-The other two are explained in the following example.
-
-```ruby
-class PostDatasource < Datasource::From(Post)
-  loaded :newest_comment, group_by: :post_id, one: true, source: :load_newest_comment
-
-  collection do
-    def load_newest_comment
-      Comment.for_serializer.where(post_id: model_ids)
-        .group("post_id")
-        .having("id = MAX(id)")
-    end
-  end
-end
-```
-
-In this case the load method returns an ActiveRecord relation, which for our purposes
-acts the same as an Array (so we could also return an Array if we wanted).
-Using `group_by: :post_id` in the `loaded` call tells datasource to group the
-results in this array by that attribute (or key if it's an array of hashes instead
-of model objects). `one: true` means that we only want a single value instead of
-an array of values (we might want multiple, e.g. `newest_10_comments`).
-So in this case, if we had a Post with id 1, `post.newest_comment` would be a
-Comment from the array that has `post_id` equal to 1.
-
-In this case, in the load method, we also used `for_serializer`, which will load
-the `Comment`s according to the `CommentSerializer`.
-
-Note that it's perfectly fine (even good) to already have a method with the same
-name in your model.
-If you use that method outside of serializers/datasource, it will work just as
-it should. But when using datasource, it will be overwritten by the datasource
-version. Counts is a good example:
-
-```ruby
-class User < ActiveRecord::Base
-  has_many :posts
-
-  def post_count
-    posts.count
-  end
-end
-
-class UserDatasource < Datasource::From(User)
-  loaded :post_count, from: :array, default: 0
-
-  collection do
-    def load_post_count
-      Post.where(user_id: model_ids)
-        .group(:user_id)
-        .pluck("user_id, COUNT(id)")
-    end
-  end
-end
-
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :post_count # <- post_count will be read from load_post_count
-end
-
-User.first.post_count # <- your model method will be called
-```
-
-### Params
-
-You can also specify params that can be read from collection methods. The params
-can be specified when you call `render`:
-
-```ruby
-# controller
-  render json: posts,
-    datasource_params: { include_newest_comments: true }
-
-# datasource
-  loaded :newest_comments, default: []
-
-  collection do
-    def load_newest_comments
-      if params[:include_newest_comments]
-        # ...
-      end
-    end
-  end
-```
-
 ### Debugging and logging
 
 Datasource outputs some useful logs that you can use debugging. By default the log level is
@@ -270,11 +39,11 @@ set to warnings only, but you can change it. You can add the following line to y
 `config/initializers/datasource.rb`:
 
 ```ruby
-Datasource.logger.level = Logger::INFO
+Datasource.logger.level = Logger::INFO unless Rails.env.production?
 ```
 
 You can also set it to `DEBUG` for more output. The logger outputs to `stdout` by default. It
-is not recommended to have this enabled in production.
+is not recommended to have this enabled in production (simply for performance reasons).
 
 ## Getting Help
 

data/lib/datasource.rb

@@ -9,9 +9,7 @@ module Datasource
   AdapterPaths = {
     activerecord: 'datasource/adapters/active_record',
     active_record: :activerecord,
-    sequel: 'datasource/adapters/sequel',
-    ams: 'datasource/consumer_adapters/active_model_serializers',
-    active_model_serializers: :ams
+    sequel: 'datasource/adapters/sequel'
   }
 
 module_function
@@ -26,10 +24,11 @@ module_function
 
     yield(config)
 
-    config.adapters.each do |adapter|
-      adapter = AdapterPaths[adapter]
-      adapter = AdapterPaths[adapter] if adapter.is_a?(Symbol)
-      require adapter
+    config.adapters.each do |adapter_name|
+      adapter_path = AdapterPaths[adapter_name]
+      adapter_path = AdapterPaths[adapter_path] if adapter_path.is_a?(Symbol)
+      fail "Unknown Datasource adapter '#{adapter_name}'." unless adapter_path
+      require adapter_path
     end
   end
 

data/lib/datasource/adapters/active_record.rb

@@ -11,6 +11,10 @@ module Datasource
           end
         end
 
+        def datasource_get(key)
+          @datasource_info[key]
+        end
+
         def datasource_set(hash)
           @datasource_info.merge!(hash)
           self
@@ -33,7 +37,7 @@ module Datasource
           datasource.params(*@datasource_info[:params])
           if @datasource_info[:serializer_class]
             select = []
-            Datasource::Base.consumer_adapter.to_datasource_select(select, klass.orm_klass, @datasource_info[:serializer_class], nil, datasource.adapter)
+            @datasource_info[:serializer_class].datasource_adapter.to_datasource_select(select, klass.orm_klass, @datasource_info[:serializer_class], nil, datasource.adapter, datasource)
 
             datasource.select(*select)
           end
@@ -63,31 +67,19 @@ module Datasource
           attr_accessor :_datasource_loaded, :_datasource_instance
         end
 
-        def for_serializer(serializer = nil)
-          datasource_class = self.class.default_datasource
-          pk = datasource_class.primary_key.to_sym
-
-          scope = self.class
-          .with_datasource(datasource_class)
-          .for_serializer(serializer)
-          .where(pk => send(pk))
-
-          scope = yield(scope) if block_given?
-
-          datasource = scope.get_datasource
-          if datasource.can_upgrade?(self)
-            datasource.upgrade_records(self).first
-          else
-            scope.first
-          end
+        def for_serializer(serializer_class = nil, datasource_class = nil)
+          self.class.upgrade_for_serializer([self], serializer_class, datasource_class).first
         end
 
         module ClassMethods
           def for_serializer(serializer_class = nil)
-            scope = scope_with_datasource_ext
+            if Datasource::Base.default_consumer_adapter.nil?
+              fail Datasource::Error, "No serializer adapter loaded, see the active_loaders gem."
+            end
             serializer_class ||=
-              Datasource::Base.consumer_adapter.get_serializer_for(
-                Adapters::ActiveRecord.scope_to_class(scope))
+              Datasource::Base.default_consumer_adapter.get_serializer_for(
+                Adapters::ActiveRecord.scope_to_class(all))
+            scope = scope_with_datasource_ext(serializer_class.use_datasource)
             scope.datasource_set(serializer_class: serializer_class)
           end
 
@@ -95,6 +87,25 @@ module Datasource
             scope_with_datasource_ext(datasource_class)
           end
 
+          def upgrade_for_serializer(records, serializer_class = nil, datasource_class = nil)
+            scope = with_datasource(datasource_class).for_serializer(serializer_class)
+            records = Array(records)
+
+            pk = scope.datasource_get(:datasource_class).primary_key.to_sym
+            if primary_keys = records.map(&pk)
+              scope = scope.where(pk => primary_keys.compact)
+            end
+
+            scope = yield(scope) if block_given?
+
+            datasource = scope.get_datasource
+            if datasource.can_upgrade?(records)
+              datasource.upgrade_records(records)
+            else
+              scope.to_a
+            end
+          end
+
           def default_datasource
             @default_datasource ||= begin
               "#{name}Datasource".constantize
@@ -110,7 +121,11 @@ module Datasource
         private
           def scope_with_datasource_ext(datasource_class = nil)
             if all.respond_to?(:datasource_set)
-              all
+              if datasource_class
+                all.datasource_set(datasource_class: datasource_class)
+              else
+                all
+              end
             else
               datasource_class ||= default_datasource
 

data/lib/datasource/adapters/sequel.rb

@@ -10,6 +10,10 @@ module Datasource
           end
         end
 
+        def datasource_get(key)
+          @datasource_info[key]
+        end
+
         def datasource_set(hash)
           @datasource_info.merge!(hash)
           self
@@ -32,7 +36,7 @@ module Datasource
           datasource.params(*@datasource_info[:params])
           if @datasource_info[:serializer_class]
             select = []
-            Datasource::Base.consumer_adapter.to_datasource_select(select, klass.orm_klass, @datasource_info[:serializer_class], nil, datasource.adapter)
+            @datasource_info[:serializer_class].datasource_adapter.to_datasource_select(select, klass.orm_klass, @datasource_info[:serializer_class], nil, datasource.adapter, datasource)
 
             datasource.select(*select)
           end
@@ -58,10 +62,10 @@ module Datasource
 
           dataset_module do
             def for_serializer(serializer_class = nil)
-              scope = scope_with_datasource_ext
               serializer_class ||=
-                Datasource::Base.consumer_adapter
-                .get_serializer_for(Adapters::Sequel.scope_to_class(scope))
+                Datasource::Base.default_consumer_adapter
+                .get_serializer_for(Adapters::Sequel.scope_to_class(self))
+              scope = scope_with_datasource_ext(serializer_class.use_datasource)
               scope.datasource_set(serializer_class: serializer_class)
             end
 
@@ -72,7 +76,11 @@ module Datasource
           private
             def scope_with_datasource_ext(datasource_class = nil)
               if respond_to?(:datasource_set)
-                self
+                if datasource_class
+                  datasource_set(datasource_class: datasource_class)
+                else
+                  self
+                end
               else
                 datasource_class ||= Adapters::Sequel.scope_to_class(self).default_datasource
 
@@ -83,23 +91,8 @@ module Datasource
           end
         end
 
-        def for_serializer(serializer = nil)
-          datasource_class = self.class.default_datasource
-          pk = datasource_class.primary_key.to_sym
-
-          scope = self.class
-          .with_datasource(datasource_class)
-          .for_serializer(serializer)
-          .where(pk => send(pk))
-
-          scope = yield(scope) if block_given?
-
-          datasource = scope.get_datasource
-          if datasource.can_upgrade?(self)
-            datasource.upgrade_records(self).first
-          else
-            scope.first
-          end
+        def for_serializer(serializer_class = nil, datasource_class = nil)
+          self.class.upgrade_for_serializer([self], serializer_class, datasource_class).first
         end
 
         module ClassMethods
@@ -110,6 +103,28 @@ module Datasource
           def datasource_module(&block)
             default_datasource.instance_exec(&block)
           end
+
+          def upgrade_for_serializer(records, serializer_class = nil, datasource_class = nil)
+            # must use filter to get a new scope
+            scope = filter.with_datasource(datasource_class).for_serializer(serializer_class)
+            records = Array(records)
+
+            binding.pry if scope.datasource_get(:datasource_class).nil?
+
+            pk = scope.datasource_get(:datasource_class).primary_key.to_sym
+            if primary_keys = records.map(&pk)
+              scope = scope.where(pk => primary_keys.compact)
+            end
+
+            scope = yield(scope) if block_given?
+
+            datasource = scope.get_datasource
+            if datasource.can_upgrade?(records)
+              datasource.upgrade_records(records)
+            else
+              scope.all
+            end
+          end
         end
       end
 
@@ -193,7 +208,11 @@ module Datasource
 
       def upgrade_records(ds, records)
         Datasource.logger.debug { "Upgrading records #{records.map(&:class).map(&:name).join(', ')}" }
-        get_final_scope(ds).send :post_load, records
+        # NOTE: this does not guarantee assocs are loaded, there might be a better way
+        assocs_loaded = records.all? { |record|
+          record._datasource_instance
+        }
+        get_final_scope(ds).send :post_load, records unless assocs_loaded
         ds.results(records)
       end
 

data/lib/datasource/base.rb

@@ -3,6 +3,8 @@ module Datasource
     class << self
       attr_accessor :_attributes, :_associations, :_update_scope, :_loaders, :_loader_order, :_collection_context
       attr_writer :orm_klass
+      # Should be set by consumer adapter library (e.g. for ActiveModelSerializers)
+      attr_accessor :default_consumer_adapter
 
       def inherited(base)
         base._attributes = (_attributes || {}).dup
@@ -18,10 +20,6 @@ module Datasource
         end
       end
 
-      def consumer_adapter
-        @consumer_adapter = Datasource::ConsumerAdapters::ActiveModelSerializers
-      end
-
       def orm_klass
         fail Datasource::Error, "Model class not set for #{name}. You should define it:\nclass YourDatasource\n  @orm_klass = MyModelClass\nend"
       end
@@ -45,6 +43,12 @@ module Datasource
         _collection_context.class_exec(&block)
       end
 
+      def _column_attribute_names
+        column_attributes = _attributes.values.select { |att|
+          att[:klass].nil?
+        }.map { |att| att[:name] }
+      end
+
     private
       def attributes(*attrs)
         attrs.each { |name| attribute(name) }
@@ -108,10 +112,7 @@ module Datasource
     end
 
     def select_all_columns
-      column_attributes = self.class._attributes.values.select do |att|
-        att[:klass].nil?
-      end
-      columns = column_attributes.map { |att| att[:name] }
+      columns = self.class._column_attribute_names
       select(*columns)
       @select_all_columns = true
 
@@ -156,7 +157,7 @@ module Datasource
         end
       end
       update_dependencies(newly_exposed_attributes) unless newly_exposed_attributes.empty?
-      fail_missing_attributes(missing_attributes) unless Datasource.config.simple_mode || missing_attributes.empty?
+      fail_missing_attributes(missing_attributes) if Datasource.config.raise_error_on_unknown_attribute_select && !missing_attributes.empty?
       self
     end
 

data/lib/datasource/configuration.rb

@@ -5,7 +5,7 @@ module Datasource
 
     included do |base|
       base.config.adapters = Configuration.default_adapters
-      base.config.simple_mode = false
+      base.config.raise_error_on_unknown_attribute_select = false
     end
 
     def self.default_adapters

data/lib/generators/datasource/templates/initializer.rb

@@ -1,10 +1,5 @@
 Datasource.setup do |config|
   # Adapters to load
   # Available ORM adapters: activerecord, sequel
-  # Available Serializer adapters: active_model_serializers
-  config.adapters = [:activerecord, :active_model_serializers]
-
-  # Enable simple mode, which will always select all model database columns,
-  # making Datasource easier to use. See documentation for details.
-  config.simple_mode = true
+  config.adapters = [:activerecord]
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: datasource
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jan Berdajs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-24 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: active_model_serializers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.8'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -141,7 +127,6 @@ files:
 - lib/datasource/base.rb
 - lib/datasource/collection_context.rb
 - lib/datasource/configuration.rb
-- lib/datasource/consumer_adapters/active_model_serializers.rb
 - lib/generators/datasource/install_generator.rb
 - lib/generators/datasource/templates/initializer.rb
 homepage: https://github.com/kundi/datasource

data/lib/datasource/consumer_adapters/active_model_serializers.rb

@@ -1,138 +0,0 @@
-require "active_model/serializer"
-
-module Datasource
-  module ConsumerAdapters
-    module ActiveModelSerializers
-      module ArraySerializer
-        def initialize_with_datasource(objects, options = {})
-          datasource_class = options.delete(:datasource)
-          adapter = Datasource.orm_adapters.find { |a| a.is_scope?(objects) }
-          if adapter && !adapter.scope_loaded?(objects)
-            datasource_class ||= adapter.scope_to_class(objects).default_datasource
-
-            scope = begin
-              objects
-              .with_datasource(datasource_class)
-              .for_serializer(options[:serializer])
-              .datasource_params(*[options[:datasource_params]].compact)
-            rescue NameError
-              if options[:serializer].nil?
-                return initialize_without_datasource(objects, options)
-              else
-                raise
-              end
-            end
-
-            records = adapter.scope_to_records(scope)
-
-            initialize_without_datasource(records, options)
-          else
-            initialize_without_datasource(objects, options)
-          end
-        end
-      end
-
-    module_function
-      def get_serializer_for(klass, serializer_assoc = nil)
-        serializer = if serializer_assoc
-          if serializer_assoc.kind_of?(Hash)
-            serializer_assoc[:options].try(:[], :serializer)
-          else
-            serializer_assoc.options[:serializer]
-          end
-        end
-        serializer || "#{klass.name}Serializer".constantize
-      end
-
-      def to_datasource_select(result, klass, serializer = nil, serializer_assoc = nil, adapter = nil)
-        adapter ||= Datasource::Base.default_adapter
-        serializer ||= get_serializer_for(klass, serializer_assoc)
-        result.unshift("*") if Datasource.config.simple_mode
-        if serializer._attributes.respond_to?(:keys)  # AMS 0.8
-          result.concat(serializer._attributes.keys)
-        else                                          # AMS 0.9
-          result.concat(serializer._attributes)
-        end
-        result.concat(serializer.datasource_select)
-        result_assocs = serializer.datasource_includes.dup
-        result.push(result_assocs)
-
-        serializer._associations.each_pair do |name, serializer_assoc|
-          # TODO: what if assoc is renamed in serializer?
-          reflection = adapter.association_reflection(klass, name.to_sym)
-          assoc_class = reflection[:klass]
-
-          name = name.to_s
-          result_assocs[name] = []
-          to_datasource_select(result_assocs[name], assoc_class, nil, serializer_assoc, adapter)
-        end
-      rescue Exception => ex
-        if ex.is_a?(SystemStackError) || ex.is_a?(Datasource::RecursionError)
-          fail Datasource::RecursionError, "recursive association (involving #{klass.name})"
-        else
-          raise
-        end
-      end
-    end
-  end
-end
-
-array_serializer_class = if defined?(ActiveModel::Serializer::ArraySerializer)
-  ActiveModel::Serializer::ArraySerializer
-else
-  ActiveModel::ArraySerializer
-end
-
-array_serializer_class.class_exec do
-  alias_method :initialize_without_datasource, :initialize
-  include Datasource::ConsumerAdapters::ActiveModelSerializers::ArraySerializer
-  def initialize(*args)
-    initialize_with_datasource(*args)
-  end
-end
-
-module SerializerClassMethods
-  def inherited(base)
-    base.datasource_select(*datasource_select.deep_dup)
-    base.datasource_includes(*datasource_includes.deep_dup)
-
-    super
-  end
-
-  def datasource_select(*args)
-    @datasource_select ||= []
-    @datasource_select.concat(args)
-
-    @datasource_select
-  end
-
-  def datasource_includes(*args)
-    @datasource_includes ||= {}
-
-    args.each do |arg|
-      @datasource_includes.deep_merge!(datasource_includes_to_select(arg))
-    end
-
-    @datasource_includes
-  end
-
-private
-  def datasource_includes_to_select(arg)
-    if arg.kind_of?(Hash)
-      arg.keys.inject({}) do |memo, key|
-        memo[key.to_sym] = ["*", datasource_includes_to_select(arg[key])]
-        memo
-      end
-    elsif arg.kind_of?(Array)
-      arg.inject({}) do |memo, element|
-        memo.deep_merge!(datasource_includes_to_select(element))
-      end
-    elsif arg.respond_to?(:to_sym)
-      { arg.to_sym => ["*"] }
-    else
-      fail Datasource::Error, "unknown includes value type #{arg.class}"
-    end
-  end
-end
-
-ActiveModel::Serializer.singleton_class.send :prepend, SerializerClassMethods