batch-loader-active-record 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21895ec7eb240edbb662157510b7c1f2e0e09ece
-  data.tar.gz: 73a9d404f37d37432b74dc34156614f591cfd4c5
+  metadata.gz: 20d915e2884c4153776b3acac5c148360e66209b
+  data.tar.gz: 7580228d4074580c688d5561ad4a3c69e599738e
 SHA512:
-  metadata.gz: 5917a41861fd8b5bced3f6b22f5d981028615fb7e6a4a0f674fde403261d6d29da4dbb8d2327a873cae3eb750f5ffee034d819507ca004e67b44d3d4f2b9ebeb
-  data.tar.gz: d03ff1d186f23a10d3f65766ab8ac57555e91b0bd2e7647751e3d3f0ece000c221a5313050abc2a9633f79a460056e4b2564e023053bd5fb9ce824a3fc85404b
+  metadata.gz: 923e068adecf32ee7df60441628672ec324898ba36d5c29f866042d8ec4e6af692b19a0fa9b8c483dfdeee04066d7cf455f22c279023dd10adc997a8fa867e40
+  data.tar.gz: f505bc5a8cfff63725a04b756f8f022c6bc95543ae734a6c8fe49e86169fb6ec18655122954cef56b5724b4ae5fe8a3079bbebc13e10bc5732bcd6cfc2fec8d7

data/CHANGELOG.md

@@ -2,7 +2,11 @@
 
 Unreleased
 
-* nothing yet
+* none
+
+v0.3.1
+
+* allow to decouple declaring the assocation with Active Record DSL and generate a lazy association accessor with `association_accessor`
 
 v0.3.0
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    batch-loader-active-record (0.3.0)
+    batch-loader-active-record (0.3.1)
       activerecord (>= 4.2.0, < 5.2.0)
       activesupport (>= 4.2.0, < 5.2.0)
       batch-loader (~> 1.2.0)

data/README.md

@@ -12,19 +12,25 @@ It is not intended to be used for all associations though, but only where necess
 
 ## Description
 
-This is a very simple gem which is basically a mixin containg replacement macros for the 3 active record association macros (refer to the [CHANGELOG](https://github.com/mathieul/batch-loader-active-record/blob/master/CHANGELOG.md) to know what is supported and what is not):
+This gem has a very simple implementation and delegates all batch loading responsibilities (used to avoid N+1 calls to the database) to the [batch-loader gem](https://github.com/exAspArk/batch-loader). It allows to generate a lazy association accessor with a simple statement: `association_accessor :association_name`.
+
+Note that it doesn't yet support all cases handled by Active Record associations, refer to the [CHANGELOG](https://github.com/mathieul/batch-loader-active-record/blob/master/CHANGELOG.md) to know what is supported and what is not.
+
+It is also possible to use one of the macros below in replacement of the original Active Record macro to both declare the association and trigger a lazy association accessort in a single statement.
 
 * `belongs_to_lazy`
 * `has_one_lazy`
 * `has_many_lazy`
 
-Those are intended to use in replacement of the original Active Record class methods when you also want to generate a method to avoid N+1 calls to the database when accessed for the elements of a collection. For more details on why N+1 queries are common when fetching associations read [the batch-loader gem README](https://github.com/exAspArk/batch-loader/#why).
+As soon as your lazy association accessor needs to do more than fetch all records of an association (using a scope or not), you're going to want to directly use the batch-loader gem. For more details on N+1 queries read the [batch-loader gem README](https://github.com/exAspArk/batch-loader/#why).
 
 For example let's imagine a post which can have many comments:
 
 ```ruby
 class Post < ActiveRecord::Base
-  has_many_lazy :comments
+  include BatchLoaderActiveRecord
+  has_many :comments
+  association_accessor :comments
 end
 
 class Comment < ActiveRecord::Base

data/lib/batch_loader_active_record.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require "batch_loader_active_record/version"
 require "batch-loader"
+require "batch_loader_active_record/version"
+require "batch_loader_active_record/association_manager"
 
 module BatchLoaderActiveRecord
   def self.included(base)
@@ -11,130 +12,42 @@ module BatchLoaderActiveRecord
   module ClassMethods
     def belongs_to_lazy(*args)
       belongs_to(*args).tap do |reflections|
-        reflect = reflections.values.last
-        assert_not_polymorphic(reflect)
-        batch_key = [table_name, reflect.name]
-        define_method(:"#{reflect.name}_lazy") do
-          assoc_scope = if reflect.scope.nil?
-            reflect.klass
-          else
-            reflect.klass.instance_eval(&reflect.scope)
-          end
-          foreign_key_value = send(reflect.foreign_key) or return nil
-          BatchLoader.for(foreign_key_value).batch(key: batch_key) do |foreign_key_values, loader|
-            assoc_scope.where(id: foreign_key_values).each { |instance| loader.call(instance.id, instance) }
-          end
+        manager = AssociationManager.new(model: self, reflection: reflections.values.last)
+        define_method(manager.accessor_name) { manager.belongs_to_batch_loader(self) }
+      end
+    end
+
+    def association_accessor(name)
+      reflection = reflect_on_association(name) or raise "Can't find association #{name.inspect}"
+      manager = AssociationManager.new(model: self, reflection: reflection)
+      case reflection.macro
+      when :belongs_to
+        define_method(manager.accessor_name) { manager.belongs_to_batch_loader(self) }
+      when :has_one
+        define_method(manager.accessor_name) { manager.has_one_to_batch_loader(self) }
+      when :has_many
+        define_method(manager.accessor_name) do |instance_scope = nil|
+          manager.has_many_to_batch_loader(self, instance_scope)
         end
+      else
+        raise NotImplementedError, "association kind #{reflection.macro.inspect} is not yet supported"
       end
     end
 
     def has_one_lazy(*args)
       has_one(*args).tap do |reflections|
-        reflect = reflections.values.last
-        assert_not_polymorphic(reflect)
-        batch_key = [table_name, reflect.name]
-        define_method(:"#{reflect.name}_lazy") do
-          assoc_scope = if reflect.scope.nil?
-            reflect.klass
-          else
-            reflect.klass.instance_eval(&reflect.scope)
-          end
-          BatchLoader.for(id).batch(key: batch_key) do |model_ids, loader|
-            assoc_scope.where(reflect.foreign_key => model_ids).each do |instance|
-              loader.call(instance.public_send(reflect.foreign_key), instance)
-            end
-          end
-        end
+        manager = AssociationManager.new(model: self, reflection: reflections.values.last)
+        define_method(manager.accessor_name) { manager.has_one_to_batch_loader(self) }
       end
     end
 
     def has_many_lazy(*args)
       has_many(*args).tap do |reflections|
-        reflect = reflections.values.last
-        assert_not_polymorphic(reflect)
-        base_key = [table_name, reflect.name]
-        define_method(:"#{reflect.name}_lazy") do |instance_scope = nil|
-          batch_key = base_key
-          batch_key += [instance_scope.to_sql.hash] unless instance_scope.nil?
-          assoc_scope = if reflect.scope.nil?
-            reflect.klass
-          else
-            reflect.klass.instance_eval(&reflect.scope)
-          end
-          BatchLoader.for(id).batch(default_value: [], key: batch_key) do |model_ids, loader|
-            relation = if instance_scope.nil?
-              assoc_scope
-            else
-              assoc_scope.instance_eval { instance_scope }
-            end
-            if reflect.through_reflection?
-              instances = self.class.fetch_for_model_ids(model_ids, relation: relation, reflection: reflect)
-              instances.each do |instance|
-                loader.call(instance.public_send(:_instance_id)) { |value| value << instance }
-              end
-            else
-              relation.where(reflect.foreign_key => model_ids).each do |instance|
-                loader.call(instance.public_send(reflect.foreign_key)) { |value| value << instance }
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def fetch_for_model_ids(ids, relation:, reflection:)
-      instance_id_path = "#{reflection.active_record.table_name}.#{reflection.active_record.primary_key}"
-      model_class = reflection.active_record
-      reflections = reflection_chain(reflection)
-      join_strings = [reflection_join(reflections.first, relation)]
-      reflections.each_cons(2) do |previous, current|
-        join_strings << reflection_join(current, previous.active_record)
-      end
-      select_relation = join_strings.reduce(relation) do |select_relation, join_string|
-        select_relation.joins(join_string)
-      end
-      select_relation
-        .where("#{model_class.table_name}.#{model_class.primary_key} IN (?)", ids)
-        .select("#{relation.table_name}.*, #{instance_id_path} AS _instance_id")
-    end
-
-    private
-
-    def assert_not_polymorphic(reflection)
-      if reflection.polymorphic? || reflection.options.has_key?(:as) || reflection.options.has_key?(:source_type)
-        raise NotImplementedError, "polymorphic associations are not yet supported (#{reflection.name})"
-      end
-    end
-
-    def reflection_chain(reflection)
-      reflections = [reflection]
-      begin
-        previous   = reflection
-        reflection = previous.source_reflection
-        if reflection && reflection != previous
-          reflections << reflection
-        else
-          reflection = nil
+        manager = AssociationManager.new(model: self, reflection: reflections.values.last)
+        define_method(manager.accessor_name) do |instance_scope = nil|
+          manager.has_many_to_batch_loader(self, instance_scope)
         end
-      end while reflection
-      reflections.reverse
-    end
-
-    def reflection_join(orig_reflection, model_class)
-      reflection = orig_reflection.through_reflection? ? orig_reflection.through_reflection : orig_reflection
-      id_path = id_path_for(reflection, model_class)
-      table_name = reflection.active_record.table_name
-      id_column = reflection.belongs_to? ? reflection.foreign_key : reflection.active_record.primary_key
-      "INNER JOIN #{table_name} ON #{table_name}.#{id_column} = #{id_path}"
-    end
-
-    def id_path_for(reflection, model_class)
-      id_column = if reflection.belongs_to?
-        model_class.primary_key
-      else
-        reflection.foreign_key
       end
-      "#{model_class.table_name}.#{id_column}"
     end
   end
 end

data/lib/batch_loader_active_record/association_manager.rb

@@ -0,0 +1,119 @@
+module BatchLoaderActiveRecord
+  class AssociationManager
+    attr_reader :model, :reflection
+
+    def initialize(model:, reflection:)
+      @model = model
+      @reflection = reflection
+      assert_not_polymorphic
+    end
+
+    def accessor_name
+      :"#{reflection.name}_lazy"
+    end
+
+    def belongs_to_batch_loader(instance)
+      foreign_key_value = instance.send(reflection.foreign_key) or return nil
+      BatchLoader.for(foreign_key_value).batch(key: batch_key) do |foreign_key_values, loader|
+        target_scope.where(id: foreign_key_values).each { |instance| loader.call(instance.id, instance) }
+      end
+    end
+
+    def has_one_to_batch_loader(instance)
+      BatchLoader.for(instance.id).batch(key: batch_key) do |model_ids, loader|
+        target_scope.where(reflection.foreign_key => model_ids).each do |instance|
+          loader.call(instance.public_send(reflection.foreign_key), instance)
+        end
+      end
+    end
+
+    def has_many_to_batch_loader(instance, instance_scope)
+      custom_key = batch_key
+      custom_key += [instance_scope.to_sql.hash] unless instance_scope.nil?
+      BatchLoader.for(instance.id).batch(default_value: [], key: custom_key) do |model_ids, loader|
+        relation = if instance_scope.nil?
+          target_scope
+        else
+          target_scope.instance_eval { instance_scope }
+        end
+        if reflection.through_reflection?
+          instances = fetch_for_model_ids(model_ids, relation: relation)
+          instances.each do |instance|
+            loader.call(instance.public_send(:_instance_id)) { |value| value << instance }
+          end
+        else
+          relation.where(reflection.foreign_key => model_ids).each do |instance|
+            loader.call(instance.public_send(reflection.foreign_key)) { |value| value << instance }
+          end
+        end
+      end
+    end
+
+    private
+
+    def target_scope
+      @target_scope ||= if reflection.scope.nil?
+        reflection.klass
+      else
+        reflection.klass.instance_eval(&reflection.scope)
+      end
+    end
+
+    def batch_key
+      @batch_key ||= [model.table_name, reflection.name].freeze
+    end
+
+    def assert_not_polymorphic
+      if reflection.polymorphic? || reflection.options.has_key?(:as) || reflection.options.has_key?(:source_type)
+        raise NotImplementedError, "polymorphic associations are not yet supported (#{reflection.name})"
+      end
+    end
+
+    def fetch_for_model_ids(ids, relation:)
+      instance_id_path = "#{reflection.active_record.table_name}.#{reflection.active_record.primary_key}"
+      model_class = reflection.active_record
+      reflections = reflection_chain(reflection)
+      join_strings = [reflection_join(reflections.first, relation)]
+      reflections.each_cons(2) do |previous, current|
+        join_strings << reflection_join(current, previous.active_record)
+      end
+      select_relation = join_strings.reduce(relation) do |select_relation, join_string|
+        select_relation.joins(join_string)
+      end
+      select_relation
+        .where("#{model_class.table_name}.#{model_class.primary_key} IN (?)", ids)
+        .select("#{relation.table_name}.*, #{instance_id_path} AS _instance_id")
+    end
+
+    def reflection_chain(reflection)
+      reflections = [reflection]
+      begin
+        previous   = reflection
+        reflection = previous.source_reflection
+        if reflection && reflection != previous
+          reflections << reflection
+        else
+          reflection = nil
+        end
+      end while reflection
+      reflections.reverse
+    end
+
+    def reflection_join(orig_reflection, model_class)
+      reflection = orig_reflection.through_reflection? ? orig_reflection.through_reflection : orig_reflection
+      id_path = id_path_for(reflection, model_class)
+      table_name = reflection.active_record.table_name
+      id_column = reflection.belongs_to? ? reflection.foreign_key : reflection.active_record.primary_key
+      "INNER JOIN #{table_name} ON #{table_name}.#{id_column} = #{id_path}"
+    end
+
+    def id_path_for(reflection, model_class)
+      id_column = if reflection.belongs_to?
+        model_class.primary_key
+      else
+        reflection.foreign_key
+      end
+      "#{model_class.table_name}.#{id_column}"
+    end
+  end
+end

data/lib/batch_loader_active_record/version.rb

@@ -1,3 +1,3 @@
 module BatchLoaderActiveRecord
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: batch-loader-active-record
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - mathieul
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-24 00:00:00.000000000 Z
+date: 2017-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: batch-loader
@@ -157,6 +157,7 @@ files:
 - bin/setup
 - lib/batch-loader-active-record.rb
 - lib/batch_loader_active_record.rb
+- lib/batch_loader_active_record/association_manager.rb
 - lib/batch_loader_active_record/version.rb
 homepage: https://github.com/mathieul/batch-loader-active-record
 licenses: