active_loaders 0.0.1

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/active_loaders.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_loaders/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_loaders"
+  spec.version       = ActiveLoaders::VERSION
+  spec.authors       = ["Jan Berdajs"]
+  spec.email         = ["mrbrdo@gmail.com"]
+  spec.summary       = %q{Ruby library to automatically preload data for your Active Model Serializers}
+  spec.homepage      = "https://github.com/kundi/active_loaders"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'active_model_serializers', '~> 0.9'
+  spec.add_dependency 'datasource', '~> 0.3'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'activerecord', '~> 4'
+  spec.add_development_dependency 'pry', '~> 0.9'
+  spec.add_development_dependency 'sequel', '~> 4.17'
+  spec.add_development_dependency 'database_cleaner', '~> 1.3'
+end

data/lib/active_loaders.rb

@@ -0,0 +1,6 @@
+require "active_loaders/version"
+require "active_loaders/datasource_adapter"
+
+module ActiveLoaders
+
+end

data/lib/active_loaders/datasource_adapter.rb

@@ -0,0 +1,216 @@
+require "active_model/serializer"
+require "datasource"
+
+module ActiveLoaders
+  module Adapters
+    module ActiveModelSerializers
+      module ArraySerializer
+        def initialize_with_loaders(objects, options = {})
+          datasource_class = options.delete(:datasource)
+          adapter = Datasource.orm_adapters.find { |a| a.is_scope?(objects) }
+          if adapter && !adapter.scope_loaded?(objects)
+            scope = begin
+              objects
+              .for_serializer(options[:serializer])
+              .datasource_params(*[options[:loader_params]].compact)
+            rescue NameError
+              if options[:serializer].nil?
+                return initialize_without_loaders(objects, options)
+              else
+                raise
+              end
+            end
+
+            if datasource_class
+              scope = scope.with_datasource(datasource_class)
+            end
+
+            records = adapter.scope_to_records(scope)
+
+            # if we are loading an association proxy, we should set the target
+            # especially because AMS will resolve it twice, which would do 2 queries
+            if objects.respond_to?(:proxy_association)
+              objects.proxy_association.target = records
+            end
+
+            initialize_without_loaders(records, options)
+          else
+            initialize_without_loaders(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, datasource = nil)
+        adapter ||= Datasource::Base.default_adapter
+        serializer ||= get_serializer_for(klass, serializer_assoc)
+        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.loaders_context.select)
+        if serializer.loaders_context.skip_select.empty?
+          result.unshift("*")
+        else
+          datasource_class = if datasource
+            datasource.class
+          else
+            serializer.use_datasource || klass.default_datasource
+          end
+          result.concat(datasource_class._column_attribute_names -
+            serializer.loaders_context.skip_select.map(&:to_s))
+        end
+        result_assocs = serializer.loaders_context.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
+
+module SerializerClassMethods
+  class SerializerDatasourceContext
+    def initialize(serializer)
+      @serializer = serializer
+    end
+
+    def select(*args)
+      @datasource_select ||= []
+      @datasource_select.concat(args)
+
+      @datasource_select
+    end
+
+    def skip_select(*args)
+      @datasource_skip_select ||= []
+      @datasource_skip_select.concat(args)
+
+      @datasource_skip_select
+    end
+
+    def includes(*args)
+      @datasource_includes ||= {}
+
+      args.each do |arg|
+        @datasource_includes.deep_merge!(datasource_includes_to_select(arg))
+      end
+
+      @datasource_includes
+    end
+
+    def use_datasource(*args)
+      @serializer.use_datasource(*args)
+    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
+
+  def inherited(base)
+    select_values = loaders_context.select.deep_dup
+    skip_select_values = loaders_context.skip_select.deep_dup
+    includes_values = loaders_context.includes.deep_dup
+    base.loaders do
+      select(*select_values)
+      skip_select(*skip_select_values)
+      includes(*includes_values)
+    end
+    base.use_datasource(use_datasource)
+
+    super
+  end
+
+  def loaders_context
+    @loaders_context ||= SerializerDatasourceContext.new(self)
+  end
+
+  def loaders(&block)
+    loaders_context.instance_eval(&block)
+  end
+
+  # required by datasource gem
+  def datasource_adapter
+    ActiveLoaders::Adapters::ActiveModelSerializers
+  end
+
+  # required by datasource gem
+  def use_datasource(*args)
+    @use_datasource = args.first unless args.empty?
+    @use_datasource
+  end
+end
+
+module SerializerInstanceMethods
+  def initialize(object, options={}, *args)
+    if object && object.respond_to?(:for_serializer)
+      # single record
+      datasource_class = options.delete(:datasource)
+      record = object.for_serializer(self.class, datasource_class) do |scope|
+        scope.datasource_params(*[options[:loader_params]].compact)
+      end
+      super(record, options, *args)
+    else
+      super
+    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_loaders, :initialize
+  include ActiveLoaders::Adapters::ActiveModelSerializers::ArraySerializer
+  def initialize(*args)
+    initialize_with_loaders(*args)
+  end
+end
+
+ActiveModel::Serializer.singleton_class.send :prepend, SerializerClassMethods
+ActiveModel::Serializer.send :prepend, SerializerInstanceMethods
+Datasource::Base.default_consumer_adapter ||= ActiveLoaders::Adapters::ActiveModelSerializers

data/lib/active_loaders/test.rb

@@ -0,0 +1,100 @@
+require 'set'
+
+module ActiveLoaders
+  module Test
+    Error = Class.new(StandardError)
+    def test_serializer_queries(serializer_klass, model_klass, ignore_columns: [], skip_columns_check: false, allow_queries_per_record: 0)
+      records = get_all_records(model_klass, serializer_klass)
+      fail "Not enough records to test #{serializer_klass}. Create at least 1 #{model_klass}." unless records.size > 0
+
+      records.each do |record|
+        queries = get_executed_queries do
+          serializer_klass.new(record).as_json
+        end
+
+        unless queries.size == allow_queries_per_record
+          fail Error, "unexpected queries\n\nRecord:\n#{record.inspect}\n\nQueries:\n#{queries.join("\n")}"
+        end
+      end
+
+      # just for good measure
+      queries = get_executed_queries do
+        ActiveModel::ArraySerializer.new(records, each_serializer: serializer_klass).as_json
+      end
+      unless queries.size == (records.size * allow_queries_per_record)
+        fail Error, "unexpected queries when using ArraySerializer\n\nModel:\n#{model_klass}\n\nQueries:\n#{queries.join("\n")}"
+      end
+
+      # select values (if supported)
+      # TODO: Sequel?
+      unless skip_columns_check
+        if defined?(ActiveRecord::Base) && model_klass.ancestors.include?(ActiveRecord::Base)
+          if records.first.respond_to?(:accessed_fields)
+            accessed_fields = Set.new
+            records.each { |record| accessed_fields.merge(record.accessed_fields) }
+
+            unaccessed_columns = model_klass.column_names - accessed_fields.to_a - ignore_columns.map(&:to_s)
+
+            unless unaccessed_columns.empty?
+              unaccessed_columns_str = unaccessed_columns.join(", ")
+              unaccessed_columns_syms = unaccessed_columns.map { |c| ":#{c}" }.join(", ")
+              all_unaccessed_columns_syms = (ignore_columns.map(&:to_s) + unaccessed_columns).map { |c| ":#{c}" }.join(", ")
+              fail Error, "unnecessary select for #{model_klass} columns: #{unaccessed_columns_str}\n\nAdd to #{serializer_klass} loaders block:\n  skip_select #{unaccessed_columns_syms}\n\nOr ignore this error with:\n  test_serializer_queries(#{serializer_klass}, #{model_klass}, ignore_columns: [#{all_unaccessed_columns_syms}])\n\nOr skip this columns check entirely:\n  test_serializer_queries(#{serializer_klass}, #{model_klass}, skip_columns_check: true)"
+            end
+          end
+        end
+      end
+
+      (@active_loaders_tested_serializers ||= Set.new).add(serializer_klass)
+    end
+
+    def assert_all_serializers_tested(namespace = nil)
+      descendants =
+        ObjectSpace.each_object(Class)
+        .select { |klass| klass < ActiveModel::Serializer }
+        .select { |klass| (namespace.nil? && !klass.name.include?("::")) || klass.name.starts_with?("#{namespace}::") }
+        .reject { |klass| Array(@active_loaders_tested_serializers).include?(klass) }
+
+      unless descendants.empty?
+        fail Error, "serializers not tested: #{descendants.map(&:name).join(", ")}"
+      end
+    end
+
+  private
+    def get_all_records(model_klass, serializer_klass)
+      if defined?(ActiveRecord::Base) && model_klass.ancestors.include?(ActiveRecord::Base)
+        model_klass.for_serializer(serializer_klass).to_a
+      elsif defined?(Sequel::Model) && model_klass.ancestors.include?(Sequel::Model)
+        model_klass.for_serializer(serializer_klass).all
+      else
+        fail "Unknown model #{model_klass} of type #{model_klass.superclass}."
+      end
+    end
+
+    def get_executed_queries
+      logger_io = StringIO.new
+      logger = Logger.new(logger_io)
+      logger.formatter = ->(severity, datetime, progname, msg) { "#{msg}\n" }
+      if defined?(ActiveRecord::Base)
+        ar_old_logger = ActiveRecord::Base.logger
+        ActiveRecord::Base.logger = logger
+      end
+      if defined?(Sequel::Model)
+        Sequel::Model.db.loggers << logger
+      end
+
+      begin
+        yield
+      ensure
+        if defined?(ActiveRecord::Base)
+          ActiveRecord::Base.logger = ar_old_logger
+        end
+        if defined?(Sequel::Model)
+          Sequel::Model.db.loggers.delete(logger)
+        end
+      end
+
+      logger_io.string.lines.reject { |line| line.strip == "" }
+    end
+  end
+end

data/lib/active_loaders/version.rb

@@ -0,0 +1,3 @@
+module ActiveLoaders
+  VERSION = "0.0.1"
+end

data/spec/sequel_serializer_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module SequelSerializerSpec
+  describe "Serializer (Sequel)", :sequel do
+    class Comment < Sequel::Model
+      many_to_one :post
+    end
+
+    class Post < Sequel::Model
+      many_to_one :blog
+      one_to_many :comments
+
+      datasource_module do
+        query :author_name do
+          "posts.author_first_name || ' ' || posts.author_last_name"
+        end
+      end
+    end
+
+    class Blog < Sequel::Model
+      one_to_many :posts
+    end
+
+    class CommentSerializer < ActiveModel::Serializer
+      attributes :id, :comment
+    end
+
+    class PostSerializer < ActiveModel::Serializer
+      attributes :id, :title, :author_name
+      has_many :comments, each_serializer: CommentSerializer
+
+      def author_name
+        object.values[:author_name]
+      end
+    end
+
+    class BlogSerializer < ActiveModel::Serializer
+      attributes :id, :title
+
+      has_many :posts, each_serializer: PostSerializer
+    end
+
+    it "returns serialized hash" do
+      blog = Blog.create title: "Blog 1"
+      post = Post.create blog_id: blog.id, title: "Post 1", author_first_name: "John", author_last_name: "Doe"
+      Comment.create(post_id: post.id, comment: "Comment 1")
+      post = Post.create blog_id: blog.id, title: "Post 2", author_first_name: "Maria", author_last_name: "Doe"
+      Comment.create(post_id: post.id, comment: "Comment 2")
+      blog = Blog.create title: "Blog 2"
+
+      expected_result = [
+        {:id =>1, :title =>"Blog 1", :posts =>[
+          {:id =>1, :title =>"Post 1", :author_name =>"John Doe", comments: [{:id =>1, :comment =>"Comment 1"}]},
+          {:id =>2, :title =>"Post 2", :author_name =>"Maria Doe", comments: [{:id =>2, :comment =>"Comment 2"}]}
+        ]},
+        {:id =>2, :title =>"Blog 2", :posts =>[]}
+      ]
+
+      expect_query_count(3) do
+        serializer = ActiveModel::ArraySerializer.new(Blog.where, each_serializer: BlogSerializer)
+        expect(expected_result).to eq(serializer.as_json)
+      end
+    end
+  end
+end

data/spec/sequel_skip_select_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module SequelSkipSelectSpec
+  describe "skip_select (Sequel)", :sequel do
+    class Comment < Sequel::Model
+      many_to_one :post
+    end
+
+    class Post < Sequel::Model
+      many_to_one :blog
+      one_to_many :comments
+
+      datasource_module do
+        query :author_name do
+          "posts.author_first_name || ' ' || posts.author_last_name"
+        end
+      end
+    end
+
+    class Blog < Sequel::Model
+      one_to_many :posts
+    end
+
+    class CommentSerializer < ActiveModel::Serializer
+      attributes :id, :comment
+    end
+
+    class PostSerializer < ActiveModel::Serializer
+      attributes :id, :title, :author_name
+      has_many :comments, each_serializer: CommentSerializer
+
+      loaders do
+        skip_select :author_first_name, :author_last_name
+      end
+
+      def author_name
+        object.values[:author_name]
+      end
+    end
+
+    class BlogSerializer < ActiveModel::Serializer
+      attributes :id, :title
+
+      has_many :posts, each_serializer: PostSerializer
+    end
+
+    it "returns serialized hash" do
+      blog = Blog.create title: "Blog 1"
+      post = Post.create blog_id: blog.id, title: "Post 1", author_first_name: "John", author_last_name: "Doe"
+      Comment.create(post_id: post.id, comment: "Comment 1")
+      post = Post.create blog_id: blog.id, title: "Post 2", author_first_name: "Maria", author_last_name: "Doe"
+      Comment.create(post_id: post.id, comment: "Comment 2")
+      blog = Blog.create title: "Blog 2"
+
+      expected_result = [
+        {:id =>1, :title =>"Blog 1", :posts =>[
+          {:id =>1, :title =>"Post 1", :author_name =>"John Doe", comments: [{:id =>1, :comment =>"Comment 1"}]},
+          {:id =>2, :title =>"Post 2", :author_name =>"Maria Doe", comments: [{:id =>2, :comment =>"Comment 2"}]}
+        ]},
+        {:id =>2, :title =>"Blog 2", :posts =>[]}
+      ]
+
+      expect_query_count(3) do |logger|
+        serializer = ActiveModel::ArraySerializer.new(Blog.where, each_serializer: BlogSerializer)
+        expect(expected_result).to eq(serializer.as_json)
+        expect(logger.string.lines[0]).to include("blogs.*")
+        expect(logger.string.lines[1]).to_not include("posts.*")
+        expect(logger.string.lines[1]).to_not include("posts.author_first_name,")
+        expect(logger.string.lines[1]).to_not include("posts.author_last_name,")
+        expect(logger.string.lines[1]).to include("posts.id")
+        expect(logger.string.lines[1]).to include("posts.title")
+        expect(logger.string.lines[1]).to include("posts.blog_id")
+        expect(logger.string.lines[2]).to include("comments.*")
+      end
+    end
+  end
+end