advanced_ar 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a06ad08bb39f4bce6113d3211ae70ee0f121389c0c6ed94794bc1528894979c4
-  data.tar.gz: 8e7ca779b294e2c3d0bbe657dc6043294e4598766fa1ea6127af6091f3939e0e
+  metadata.gz: 4635f5a6d31cb307162adc165155a6ca6dae23c37d9ad406b12fe5d6b3192b5e
+  data.tar.gz: f4693daf2c847e2ce6743d2afcf1fa11716c45682dd580346c580d30b88047d4
 SHA512:
-  metadata.gz: 964468ac25c780441ddfeeea1bd89a78294060db049e506930c0f4e7f70b82dc4a81bb0340c264c4faaf509f3a97753155e1366c71610637da1347aad0408c74
-  data.tar.gz: 387abf85153e0f202d0f5865cfe1589cd60b07a454aaa128e01c8b02b067d30dcf1b2a4f18981a2ef65156fe53c9e2214f7d45848f417ba782fd2a59ac8e2287
+  metadata.gz: 44d3d78df56df26cb0e8273cc1bedfa66a711bca449db6078d56811382d2ef0b0ccfd78fb686a81c234ff4a183c0cbf8b7c6522de1f640cd6882794572b8c903
+  data.tar.gz: a57ec87822bc24078b85df731ad733a7612d0e24acd02c00a4f44891ff3ff1239b02df953ab88b82de8c2a54427fa18bdf3ac0b5b7c5613500e4553f14759aff

data/lib/advanced_ar.rb

@@ -1,5 +1,5 @@
 
-Dir[File.dirname(__FILE__) +  "/advanced_ar/*.rb"].each { |file| require file }
+Dir[File.dirname(__FILE__) + "/advanced_ar/*.rb"].each { |file| require file }
 
 module AdvancedAR
 

data/lib/advanced_ar/arbitrary_prefetch.rb

@@ -14,147 +14,149 @@
 #     2. Duplicates the relevant snippets from Goldiloader into this module. See Goldiloader::AutoIncludeContext
 #   The current Goldiloader implementation uses Option 1 internally, but also makes the relations lazy - even
 #     if you define a prefetch, it won't actually be loaded until you attempt to access it on one of the models.
-module AdvancedAR::ArbitraryPrefetch
-  class PrefetcherContext
-    attr_accessor :model, :target_attribute
-    attr_reader :options
-
-    def initialize(model, opts)
-      @options = opts
-      @model = model
-      @source_key = opts[:relation]
-      @target_attribute = opts[:attribute]
-      @queryset = opts[:queryset]
-      @models = []
-    end
+module AdvancedAR
+  module ArbitraryPrefetch
+    class PrefetcherContext
+      attr_accessor :model, :target_attribute
+      attr_reader :options
+
+      def initialize(model, opts)
+        @options = opts
+        @model = model
+        @source_key = opts[:relation]
+        @target_attribute = opts[:attribute]
+        @queryset = opts[:queryset]
+        @models = []
+      end
 
-    def link_models(models)
-      Array(models).each do |m|
-        @models << m
+      def link_models(models)
+        Array(models).each do |m|
+          @models << m
 
-        # assoc = PrefetchAssociation.new(m, self, reflection)
-        assoc = reflection.association_class.new(m, reflection)
-        m.send(:association_instance_set, target_attribute, assoc)
+          # assoc = PrefetchAssociation.new(m, self, reflection)
+          assoc = reflection.association_class.new(m, reflection)
+          m.send(:association_instance_set, target_attribute, assoc)
 
-        m.instance_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{target_attribute}
-            association(:#{target_attribute}).reader
-          end
-        CODE
+          m.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{target_attribute}
+              association(:#{target_attribute}).reader
+            end
+          CODE
+        end
       end
-    end
 
-    def reflection
-      @reflection ||= begin
-        queryset = @queryset
-        source_refl = model.reflections[@source_key.to_s]
-        scope = lambda { |*_args|
-          qs = queryset
-          qs = qs.merge(source_refl.scope_for(model.unscoped)) if source_refl.scope
-          qs
-        }
-        ActiveRecord::Reflection.create(
-          options[:type],
-          @target_attribute,
-          scope,
-          source_refl.options.merge(
-            class_name: source_refl.class_name,
-            inverse_of: nil
-          ),
-          model
-        )
+      def reflection
+        @reflection ||= begin
+          queryset = @queryset
+          source_refl = model.reflections[@source_key.to_s]
+          scope = lambda { |*_args|
+            qs = queryset
+            qs = qs.merge(source_refl.scope_for(model.unscoped)) if source_refl.scope
+            qs
+          }
+          ActiveRecord::Reflection.create(
+            options[:type],
+            @target_attribute,
+            scope,
+            source_refl.options.merge(
+              class_name: source_refl.class_name,
+              inverse_of: nil
+            ),
+            model
+          )
+        end
       end
     end
-  end
 
-  module ActiveRecordBasePatch
-    extend ActiveSupport::Concern
+    module ActiveRecordBasePatch
+      extend ActiveSupport::Concern
 
-    included do
-      class << self
-        delegate :prefetch, to: :all
+      included do
+        class << self
+          delegate :prefetch, to: :all
+        end
       end
     end
-  end
 
-  module ActiveRecordRelationPatch
-    def exec_queries
-      return super if loaded?
+    module ActiveRecordRelationPatch
+      def exec_queries
+        return super if loaded?
 
-      records = super
-      preloader = nil
-      (@values[:prefetches] || {}).each do |_key, opts|
-        pfc = PrefetcherContext.new(model, opts)
-        pfc.link_models(records)
+        records = super
+        preloader = nil
+        (@values[:prefetches] || {}).each do |_key, opts|
+          pfc = PrefetcherContext.new(model, opts)
+          pfc.link_models(records)
 
-        unless defined?(Goldiloader)
-          preloader ||= build_preloader
-          preloader.preload(records, opts[:attribute])
+          unless defined?(Goldiloader)
+            preloader ||= build_preloader
+            preloader.preload(records, opts[:attribute])
+          end
         end
+        records
       end
-      records
-    end
 
-    def prefetch(**kwargs)
-      spawn.add_prefetches!(kwargs)
-    end
+      def prefetch(**kwargs)
+        spawn.add_prefetches!(kwargs)
+      end
 
-    def add_prefetches!(kwargs)
-      return unless kwargs.present?
+      def add_prefetches!(kwargs)
+        return unless kwargs.present?
 
-      assert_mutability!
-      @values[:prefetches] ||= {}
-      kwargs.each do |attr, opts|
-        @values[:prefetches][attr] = normalize_options(attr, opts)
+        assert_mutability!
+        @values[:prefetches] ||= {}
+        kwargs.each do |attr, opts|
+          @values[:prefetches][attr] = normalize_options(attr, opts)
+        end
+        self
       end
-      self
-    end
 
-    def normalize_options(attr, opts)
-      norm = if opts.is_a?(Array)
-          { relation: opts[0], queryset: opts[1] }
-        elsif opts.is_a?(ActiveRecord::Relation)
-          rel_name = opts.model.name.underscore
-          rel = (model.reflections[rel_name] || model.reflections[rel_name.pluralize])&.name
-          { relation: rel, queryset: opts }
-        else
-          opts
-      end
+      def normalize_options(attr, opts)
+        norm = if opts.is_a?(Array)
+            { relation: opts[0], queryset: opts[1] }
+          elsif opts.is_a?(ActiveRecord::Relation)
+            rel_name = opts.model.name.underscore
+            rel = (model.reflections[rel_name] || model.reflections[rel_name.pluralize])&.name
+            { relation: rel, queryset: opts }
+          else
+            opts
+        end
 
-      norm[:attribute] = attr
-      norm[:type] ||= (attr.to_s.pluralize == attr.to_s) ? :has_many : :has_one
+        norm[:attribute] = attr
+        norm[:type] ||= (attr.to_s.pluralize == attr.to_s) ? :has_many : :has_one
 
-      norm
+        norm
+      end
     end
-  end
 
-  module ActiveRecordMergerPatch
-    def merge
-      super.tap do
-        merge_prefetches
+    module ActiveRecordMergerPatch
+      def merge
+        super.tap do
+          merge_prefetches
+        end
       end
-    end
 
-    private
+      private
 
-    def merge_prefetches
-      relation.add_prefetches!(other.values[:prefetches])
+      def merge_prefetches
+        relation.add_prefetches!(other.values[:prefetches])
+      end
     end
-  end
 
-  def self.install
-    ::ActiveRecord::Base.include(ActiveRecordBasePatch)
-    ::ActiveRecord::Relation.prepend(ActiveRecordRelationPatch)
-    ::ActiveRecord::Relation::Merger.prepend(ActiveRecordMergerPatch)
+    def self.install
+      ::ActiveRecord::Base.include(ActiveRecordBasePatch)
+      ::ActiveRecord::Relation.prepend(ActiveRecordRelationPatch)
+      ::ActiveRecord::Relation::Merger.prepend(ActiveRecordMergerPatch)
 
-    return unless defined? ::Goldiloader
+      return unless defined? ::Goldiloader
 
-    ::Goldiloader::AssociationLoader.module_eval do
-      def self.has_association?(model, association_name) # rubocop:disable Naming/PredicateName
-        model.association(association_name)
-        true
-      rescue ::ActiveRecord::AssociationNotFoundError => _err
-        false
+      ::Goldiloader::AssociationLoader.module_eval do
+        def self.has_association?(model, association_name) # rubocop:disable Naming/PredicateName
+          model.association(association_name)
+          true
+        rescue ::ActiveRecord::AssociationNotFoundError => _err
+          false
+        end
       end
     end
   end

data/lib/advanced_ar/batched_destruction.rb

@@ -1,94 +1,96 @@
-module AdvancedAR::BatchedDestruction
-  extend ActiveSupport::Concern
+module AdvancedAR
+  module BatchedDestruction
+    extend ActiveSupport::Concern
 
-  included do
-    define_model_callbacks :bulk_destroy
-    define_model_callbacks :destroy_batch
+    included do
+      define_model_callbacks :bulk_destroy
+      define_model_callbacks :destroy_batch
 
-    before_destroy_batch do
-      # TODO Delete Dependant Relations
-      model_class.reflections.each do |name, reflection|
-        options = reflection.options
+      before_destroy_batch do
+        # TODO Delete Dependant Relations
+        model_class.reflections.each do |name, reflection|
+          options = reflection.options
+        end
       end
     end
-  end
 
-  class_methods do
-    def bulk_destroy(**kwargs)
-      return to_sql
-      bulk_destroy_internal(self, **kwargs)
-    end
+    class_methods do
+      def bulk_destroy(**kwargs)
+        return to_sql
+        bulk_destroy_internal(self, **kwargs)
+      end
 
-    # Hook for performing the actual deletion of items, may be used to facilitate soft-deletion.
-    # Must not call destroy().
-    # Default implementation is to delete the batch using delete_all(id: batch_ids).
-    def destroy_bulk_batch(batch, options)
-      delete_ids = batch.map(&:id)
-      where(id: delete_ids).delete_all()
-    end
+      # Hook for performing the actual deletion of items, may be used to facilitate soft-deletion.
+      # Must not call destroy().
+      # Default implementation is to delete the batch using delete_all(id: batch_ids).
+      def destroy_bulk_batch(batch, options)
+        delete_ids = batch.map(&:id)
+        where(id: delete_ids).delete_all()
+      end
 
-    private
+      private
 
-    def bulk_destroy_internal(items, **kwargs)
-      options = {}
-      options.merge!(kwargs)
-      ClassCallbackExector.run_callbacks(model_class, :bulk_destroy, options: options) do
-        if items.respond_to?(:find_in_batches)
-          items.find_in_batches do |batch|
-            _destroy_batch(batch, options)
+      def bulk_destroy_internal(items, **kwargs)
+        options = {}
+        options.merge!(kwargs)
+        ClassCallbackExector.run_callbacks(model_class, :bulk_destroy, options: options) do
+          if items.respond_to?(:find_in_batches)
+            items.find_in_batches do |batch|
+              _destroy_batch(batch, options)
+            end
+          else
+            _destroy_batch(items, options)
           end
-        else
-          _destroy_batch(items, options)
         end
       end
-    end
 
-    def _destroy_batch(batch, options)
-      ClassCallbackExector.run_callbacks(model_class, :destroy_batch, {
-        model_class: model_class,
-        batch: batch,
-      }) do
-        model_class.destroy_bulk_batch(batch, options)
+      def _destroy_batch(batch, options)
+        ClassCallbackExector.run_callbacks(model_class, :destroy_batch, {
+          model_class: model_class,
+          batch: batch,
+        }) do
+          model_class.destroy_bulk_batch(batch, options)
+        end
       end
-    end
 
-    private
+      private
 
-    def model_class
-      try(:model) || self
+      def model_class
+        try(:model) || self
+      end
     end
-  end
 
-  def destroy(*args, legacy: false, **kwargs)
-    if legacy
-      super(*args)
-    else
-      self.class.send(:bulk_destroy_internal, [self], **kwargs)
+    def destroy(*args, legacy: false, **kwargs)
+      if legacy
+        super(*args)
+      else
+        self.class.send(:bulk_destroy_internal, [self], **kwargs)
+      end
     end
-  end
 
-  private
+    private
 
-  # These classes are some Hackery to allow us to use callbacks against the Model classes instead of Model instances
-  class ClassCallbackExector
-    include ActiveSupport::Callbacks
+    # These classes are some Hackery to allow us to use callbacks against the Model classes instead of Model instances
+    class ClassCallbackExector
+      include ActiveSupport::Callbacks
 
-    attr_reader :callback_class
-    delegate :__callbacks, to: :callback_class
-    delegate_missing_to :callback_class
+      attr_reader :callback_class
+      delegate :__callbacks, to: :callback_class
+      delegate_missing_to :callback_class
 
-    def initialize(cls, env)
-      @callback_class = cls
-      env.keys.each do |k|
-        define_singleton_method(k) do
-          env[k]
+      def initialize(cls, env)
+        @callback_class = cls
+        env.keys.each do |k|
+          define_singleton_method(k) do
+            env[k]
+          end
         end
+        @options = options
       end
-      @options = options
-    end
 
-    def self.run_callbacks(cls, callback, env={}, &blk)
-      new(cls, env).run_callbacks(callback, &blk)
+      def self.run_callbacks(cls, callback, env={}, &blk)
+        new(cls, env).run_callbacks(callback, &blk)
+      end
     end
   end
 end

data/lib/advanced_ar/custom_preloaders.rb

@@ -29,29 +29,31 @@
 #   end
 # end
 #
-module AdvancedAR::CustomPreloaders
-  module AssociationBuilderExtension
-    def self.build(model, reflection); end
+module AdvancedAR
+  module CustomPreloaders
+    module AssociationBuilderExtension
+      def self.build(model, reflection); end
 
-    def self.valid_options
-      [:preloader]
+      def self.valid_options
+        [:preloader]
+      end
     end
-  end
 
-  module PreloaderExtension
-    def preloader_for(reflection, owners)
-      cust_preloader = reflection.options[:preloader]
-      if cust_preloader.present?
-        cust_preloader = cust_preloader.constantize if cust_preloader.is_a?(String)
-        cust_preloader
-      else
-        super
+    module PreloaderExtension
+      def preloader_for(reflection, owners)
+        cust_preloader = reflection.options[:preloader]
+        if cust_preloader.present?
+          cust_preloader = cust_preloader.constantize if cust_preloader.is_a?(String)
+          cust_preloader
+        else
+          super
+        end
       end
     end
-  end
 
-  def self.install
-    ActiveRecord::Associations::Builder::Association.extensions << AssociationBuilderExtension
-    ActiveRecord::Associations::Preloader.prepend(CustomPreloaders::PreloaderExtension)
+    def self.install
+      ActiveRecord::Associations::Builder::Association.extensions << AssociationBuilderExtension
+      ActiveRecord::Associations::Preloader.prepend(CustomPreloaders::PreloaderExtension)
+    end
   end
 end

data/lib/advanced_ar/version.rb

@@ -1,3 +1,3 @@
 module AdvancedAR
-  VERSION = "0.1.4".freeze
+  VERSION = "0.1.5".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: advanced_ar
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Ethan Knapp