jit_preloader 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e859fc3b5826b985e1b51721bb6d05dc215b2434b250e553f85606ffba196ce3
-  data.tar.gz: d3637cf1b4cf27da79db1ad6dea4be978d9091ae96278abc2cbd02d5c2256076
+  metadata.gz: a2439886049ccbcd7845882f8fa47524e500ffc96d8b9620711288853c47c131
+  data.tar.gz: 189adc93418cf777c6eb33617934d92426cfbdc105a05a10c639f9dd387736f8
 SHA512:
-  metadata.gz: a2d6a3f714be0c14a0f026d4b824f0c4f2176818af5338e94af11f5fe83af41b81181368e32ea42ad0cf00b5a78de598fd8010b77afe36b8ee01745ac9dca236
-  data.tar.gz: fc80b435fa33b15f6686ca061943f050497f6485edd4b63d0a7c505403cfb8fe6019b85615f195b6d6b02fd09cf325970f93e1b3e8c7503bd42ec37f1df5f2c6
+  metadata.gz: 932327300aea76f21906abf912ba85d655fbeb04b6cf940c1c650e21d39a72682d4fb55d529c389897ed7d5b45d9a41cec411a5c7eb932f2216df03b91fef47e
+  data.tar.gz: 591bc82f9d763b963a78d6869da2f6346c7c3d49b044e48d0a12529fd61c94b104c3e0cc8e7e08a8a8fd9f4feee4ce73e66fbc72cf36ef11477852949d012802

data/lib/jit_preloader/active_record/base.rb

@@ -1,74 +1,70 @@
 module JitPreloadExtension
+  attr_accessor :jit_preloader
+  attr_accessor :jit_n_plus_one_tracking
+  attr_accessor :jit_preload_aggregates
 
-  extend ActiveSupport::Concern
-
-  included do
-    attr_accessor :jit_preloader
-    attr_accessor :jit_n_plus_one_tracking
-    attr_accessor :jit_preload_aggregates
-
-    def reload(*args)
-      clear_jit_preloader!
-      super
-    end
+  def reload(*args)
+    clear_jit_preloader!
+    super
+  end
 
-    def clear_jit_preloader!
-      self.jit_preload_aggregates = {}
-      if jit_preloader
-        jit_preloader.records.delete(self)
-        self.jit_preloader = nil
-      end
+  def clear_jit_preloader!
+    self.jit_preload_aggregates = {}
+    if jit_preloader
+      jit_preloader.records.delete(self)
+      self.jit_preloader = nil
     end
-
   end
 
-  class_methods do
-    delegate :jit_preload, to: :all
+  def self.prepended(base)
+    class << base
+      delegate :jit_preload, to: :all
 
-    def has_many_aggregate(assoc, name, aggregate, field, default: 0)
-      method_name = "#{assoc}_#{name}"
+      def has_many_aggregate(assoc, name, aggregate, field, default: 0)
+        method_name = "#{assoc}_#{name}"
 
-      define_method(method_name) do |conditions={}|
-        self.jit_preload_aggregates ||= {}
+        define_method(method_name) do |conditions={}|
+          self.jit_preload_aggregates ||= {}
 
-        key = "#{method_name}|#{conditions.sort.hash}"
-        return jit_preload_aggregates[key] if jit_preload_aggregates.key?(key)
-        if jit_preloader
-          reflection = association(assoc).reflection
-          primary_ids = jit_preloader.records.collect{|r| r[reflection.active_record_primary_key] }
-          klass = reflection.klass
+          key = "#{method_name}|#{conditions.sort.hash}"
+          return jit_preload_aggregates[key] if jit_preload_aggregates.key?(key)
+          if jit_preloader
+            reflection = association(assoc).reflection
+            primary_ids = jit_preloader.records.collect{|r| r[reflection.active_record_primary_key] }
+            klass = reflection.klass
 
-          aggregate_association = reflection
-          while aggregate_association.through_reflection
-            aggregate_association = aggregate_association.through_reflection
-          end
+            aggregate_association = reflection
+            while aggregate_association.through_reflection
+              aggregate_association = aggregate_association.through_reflection
+            end
 
-          association_scope = klass.all.merge(association(assoc).scope).unscope(where: aggregate_association.foreign_key)
-          association_scope = association_scope.instance_exec(&reflection.scope).reorder(nil) if reflection.scope
+            association_scope = klass.all.merge(association(assoc).scope).unscope(where: aggregate_association.foreign_key)
+            association_scope = association_scope.instance_exec(&reflection.scope).reorder(nil) if reflection.scope
 
-          conditions[aggregate_association.table_name] = { aggregate_association.foreign_key => primary_ids }
-          if reflection.type.present?
-            conditions[reflection.type] = self.class.name
-          end
-          group_by = "#{aggregate_association.table_name}.#{aggregate_association.foreign_key}"
+            conditions[aggregate_association.table_name] = { aggregate_association.foreign_key => primary_ids }
+            if reflection.type.present?
+              conditions[reflection.type] = self.class.name
+            end
+            group_by = "#{aggregate_association.table_name}.#{aggregate_association.foreign_key}"
 
-          preloaded_data = Hash[association_scope
-            .where(conditions)
-            .group(group_by)
-            .send(aggregate, field)
-          ]
+            preloaded_data = Hash[association_scope
+              .where(conditions)
+              .group(group_by)
+              .send(aggregate, field)
+            ]
 
-          jit_preloader.records.each do |record|
-            record.jit_preload_aggregates ||= {}
-            record.jit_preload_aggregates[key] = preloaded_data[record.id] || default
+            jit_preloader.records.each do |record|
+              record.jit_preload_aggregates ||= {}
+              record.jit_preload_aggregates[key] = preloaded_data[record.id] || default
+            end
+          else
+            self.jit_preload_aggregates[key] = send(assoc).where(conditions).send(aggregate, field) || default
           end
-        else
-          self.jit_preload_aggregates[key] = send(assoc).where(conditions).send(aggregate, field) || default
+          jit_preload_aggregates[key]
         end
-        jit_preload_aggregates[key]
       end
     end
   end
 end
 
-ActiveRecord::Base.send(:include, JitPreloadExtension)
+ActiveRecord::Base.send(:prepend, JitPreloadExtension)

data/lib/jit_preloader/version.rb

@@ -1,3 +1,3 @@
 module JitPreloader
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jit_preloader
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Kyle d'Oliveira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2019-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -148,7 +148,6 @@ files:
 - lib/jit_preloader.rb
 - lib/jit_preloader/active_record/associations/collection_association.rb
 - lib/jit_preloader/active_record/associations/preloader/association.rb
-- lib/jit_preloader/active_record/associations/preloader/association.rb~
 - lib/jit_preloader/active_record/associations/preloader/collection_association.rb
 - lib/jit_preloader/active_record/associations/preloader/singular_association.rb
 - lib/jit_preloader/active_record/associations/singular_association.rb

data/lib/jit_preloader/active_record/associations/preloader/association.rb~

@@ -1,34 +0,0 @@
-class ActiveRecord::Associations::Preloader::Association
-  private
-  # A monkey patch to ActiveRecord. The old method looked like the snippet
-  # below. Our changes here are that we remove records that are already
-  # part of the target, then attach all of the records to a new jit preloader.
-  #
-  # def preload(preloader)
-  #   associated_records_by_owner(preloader).each do |owner, records|
-  #     association = owner.association(reflection.name)
-  #     association.loaded!
-  #     association.target.concat(records)
-  #     records.each { |record| association.set_inverse_instance(record) }
-  #   end
-  # end
-
-  def preload(preloader)
-    return unless (reflection.scope.nil? || reflection.scope.arity == 0) && klass.ancestors.include?(ActiveRecord::Base)
-    all_records = []
-    associated_records_by_owner(preloader).each do |owner, records|
-      association = owner.association(reflection.name)
-      association.loaded!
-      # It is possible that some of the records are loaded already.
-      # We don't want to duplicate them, but we also want to preserve
-      # the original copy so that we don't blow away in-memory changes.
-      new_records = association.target.any? ? records - association.target : records
-
-      association.target.concat(new_records)
-      new_records.each { |record| association.set_inverse_instance(record) }
-
-      all_records.concat(records) if owner.jit_preloader || JitPreloader.globally_enabled?
-    end
-    JitPreloader::Preloader.attach(all_records) if all_records.any?
-  end
-end