miscellany 0.1.19 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e919c60e03780d5fab1a21ae6d528482db21d5a4fcfbc176b4808cc1d9acdc77
-  data.tar.gz: c9ecbbbb69e28e8fbef7aa9efe93db1cab9576634ede5ad2dc698180c1743dda
+  metadata.gz: 31028be35ab95451d190d0a669321bd265bc82230f8c07ddab8c52a4e526fcf0
+  data.tar.gz: ee7c51e33f2147ab49e05f3c0783dd5a8f938a931a33468d1289214233b34a4e
 SHA512:
-  metadata.gz: 7468e0d150c79e5ebfb5760648e97699c7b88340c68b7eaa530c58e512ee982eb1d2b44c2599b374a7348a5b9cefe7d7037603a98aa5a8a895f18bac6d4efe84
-  data.tar.gz: 0a7dfb9250e3f686d88f7c2932cbd1a8b07f0a38ae4d3e491e98ee4c14a22126bcf3defd58227130fe3a43f8cd7d0b5dbaf002f6ded24fd187706b445fcce28e
+  metadata.gz: 9f94c830dc69bf00eb3b0c9e423741ce5d70caac4f7cad67e85e4df9c9b929fc60ad2034516ed9924c2f37ce2dab6cbb56f92d02a45b7cd6179b753479f278d8
+  data.tar.gz: 7cfdc3d21e2c648c9031ce061a59529db42236734b50a00bfc058fafde17039ef7660def4f8e8a8775d4a0b65cf30317fc4bbd87a01900b61d6866823904ba19

data/lib/miscellany/active_record/arbitrary_prefetch.rb

@@ -47,146 +47,186 @@ module Miscellany
             qs = qs.merge(source_refl.scope_for(model.unscoped)) if source_refl.scope
             qs
           }
+          pass_opts = source_refl.options.merge(
+            class_name: source_refl.class_name,
+            inverse_of: nil,
+            arbitrary_source_reflection: source_refl,
+          )
+          if source_refl.is_a?(ActiveRecord::Reflection::ThroughReflection)
+            pass_opts[:source] = source_refl.source_reflection_name
+          end
           ActiveRecord::Reflection.create(
             options[:type],
             @target_attribute,
             scope,
-            source_refl.options.merge(
-              class_name: source_refl.class_name,
-              inverse_of: nil
-            ),
+            pass_opts,
             model
           )
         end
       end
     end
 
-    module ActiveRecordBasePatch
-      extend ActiveSupport::Concern
+    module ActiveRecordPatches
+      module BasePatch
+        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 RelationPatch
+        def exec_queries
+          return super if loaded?
+
+          records = super
+          (@values[:prefetches] || {}).each do |_key, opts|
+            pfc = PrefetcherContext.new(model, opts)
+            pfc.link_models(records)
+
+            unless defined?(Goldiloader) && Goldiloader.enabled?
+              if PRE_RAILS_6_2
+                ::ActiveRecord::Associations::Preloader.new.preload(records, [opts[:attribute]])
+              else
+                ::ActiveRecord::Associations::Preloader.new(records: records, associations: [opts[:attribute]]).call
+              end
+            end
+          end
+          records
+        end
 
-        records = super
-        (@values[:prefetches] || {}).each do |_key, opts|
-          pfc = PrefetcherContext.new(model, opts)
-          pfc.link_models(records)
+        def prefetch(**kwargs)
+          spawn.add_prefetches!(kwargs)
+        end
 
-          unless defined?(Goldiloader) && Goldiloader.enabled?
-            if PRE_RAILS_6_2
-              ::ActiveRecord::Associations::Preloader.new.preload(records, [opts[:attribute]])
-            else
-              ::ActiveRecord::Associations::Preloader.new(records: records, associations: [opts[:attribute]]).call
-            end
+        def add_prefetches!(kwargs)
+          return unless kwargs.present?
+
+          assert_mutability!
+          @values[:prefetches] ||= {}
+          kwargs.each do |attr, opts|
+            @values[:prefetches][attr] = normalize_prefetch_options(attr, opts)
           end
+          self
         end
-        records
-      end
 
-      def prefetch(**kwargs)
-        spawn.add_prefetches!(kwargs)
-      end
+        def normalize_prefetch_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 add_prefetches!(kwargs)
-        return unless kwargs.present?
+          norm[:attribute] = attr
+          norm[:type] ||= (attr.to_s.pluralize == attr.to_s) ? :has_many : :has_one
 
-        assert_mutability!
-        @values[:prefetches] ||= {}
-        kwargs.each do |attr, opts|
-          @values[:prefetches][attr] = normalize_prefetch_options(attr, opts)
+          norm
         end
-        self
       end
 
-      def normalize_prefetch_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
+      module Relation
+        module MergerPatch
+          def merge
+            super.tap do
+              merge_prefetches
+            end
+          end
 
-        norm[:attribute] = attr
-        norm[:type] ||= (attr.to_s.pluralize == attr.to_s) ? :has_many : :has_one
+          private
 
-        norm
+          def merge_prefetches
+            relation.add_prefetches!(other.values[:prefetches])
+          end
+        end
       end
-    end
 
-    module ActiveRecordMergerPatch
-      def merge
-        super.tap do
-          merge_prefetches
+      module Associations
+        if ACTIVE_RECORD_VERSION >= ::Gem::Version.new('7.0.0')
+          module Preloader
+            module BranchPatch
+              def grouped_records
+                h = {}
+                polymorphic_parent = !root? && parent.polymorphic?
+                source_records.each do |record|
+                  next unless record
+                  reflection = record.class._reflect_on_association(association)
+                  reflection ||= record.association(association)&.reflection rescue nil
+                  next if polymorphic_parent && !reflection || !record.association(association).klass
+                  (h[reflection] ||= []) << record
+                end
+                h
+              end
+            end
+          end
+        elsif ACTIVE_RECORD_VERSION >= ::Gem::Version.new('6.0.0')
+          module PreloaderPatch
+            def grouped_records(association, records, polymorphic_parent)
+              h = {}
+              records.each do |record|
+                next unless record
+                reflection = record.class._reflect_on_association(association)
+                reflection ||= record.association(association)&.reflection rescue nil
+                next if polymorphic_parent && !reflection || !record.association(association).klass
+                (h[reflection] ||= []) << record
+              end
+              h
+            end
+          end
         end
       end
 
-      private
+      module Reflection
+        module AssociationReflectionPatch
+          def check_preloadable!
+            return if scope && scope.arity < 0
+            super
+          end
+        end
 
-      def merge_prefetches
-        relation.add_prefetches!(other.values[:prefetches])
+        module ThroughReflectionPatch
+          def check_validity!
+            return if options[:arbitrary_source_reflection] # Rails already checked the base relation, we're good
+            super
+          end
+        end
       end
     end
 
-    module ActiveRecordPreloaderPatch
-      def grouped_records(association, records, polymorphic_parent)
-        h = {}
-        records.each do |record|
-          next unless record
-          reflection = record.class._reflect_on_association(association)
-          reflection ||= record.association(association)&.reflection rescue nil
-          next if polymorphic_parent && !reflection || !record.association(association).klass
-          (h[reflection] ||= []) << record
+    def self.apply_patches(mod, install_base, base_module: nil)
+      return unless mod.is_a?(Module)
+
+      base_module ||= mod
+
+      if mod.name.ends_with? "Patch"
+        base_full_name = base_module.to_s
+        mod_full_name = mod.to_s
+        mod_rel_name = mod_full_name.sub(base_full_name, '')
+        mod_rel_bits = mod_rel_name.split('::').select(&:present?).map do |bit|
+          bit.ends_with?('Patch') ? bit[0..-6] : bit
         end
-        h
-      end
-    end
+        final_mod_name = [install_base, *mod_rel_bits].select(&:present?).join("::")
+        install_mod = final_mod_name.constantize
 
-    module ActiveRecordPreloaderBranchPatch
-      def grouped_records
-        h = {}
-        polymorphic_parent = !root? && parent.polymorphic?
-        source_records.each do |record|
-          next unless record
-          reflection = record.class._reflect_on_association(association)
-          reflection ||= record.association(association)&.reflection rescue nil
-          next if polymorphic_parent && !reflection || !record.association(association).klass
-          (h[reflection] ||= []) << record
+        if mod.is_a?(ActiveSupport::Concern)
+          install_mod.include(mod)
+        else
+          install_mod.prepend(mod)
         end
-        h
       end
-    end
 
-    module ActiveRecordReflectionPatch
-      def check_preloadable!
-        return if scope && scope.arity < 0
-        super
+      mod.constants.map {|const| mod.const_get(const) }.each do |const|
+        apply_patches(const, install_base, base_module: base_module || mod)
       end
     end
 
     def self.install
-      ::ActiveRecord::Base.include(ActiveRecordBasePatch)
-
-      ::ActiveRecord::Relation.prepend(ActiveRecordRelationPatch)
-      ::ActiveRecord::Relation::Merger.prepend(ActiveRecordMergerPatch)
-
-      if ACTIVE_RECORD_VERSION >= ::Gem::Version.new('7.0.0')
-        ::ActiveRecord::Associations::Preloader::Branch.prepend(ActiveRecordPreloaderBranchPatch)
-      elsif ACTIVE_RECORD_VERSION >= ::Gem::Version.new('6.0.0')
-        ::ActiveRecord::Associations::Preloader.prepend(ActiveRecordPreloaderPatch)
-      end
-
-      ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecordReflectionPatch)
+      apply_patches(ActiveRecordPatches, ::ActiveRecord)
 
       return unless defined? ::Goldiloader
 

data/lib/miscellany/active_record/complex_query.rb

@@ -47,6 +47,7 @@ module Miscellany
       end
       psql += " LIMIT #{length} OFFSET #{start}"
       records = ActiveRecord::Base.connection.exec_query(psql).to_a
+      records.map!(&:with_indifferent_access)
       augment_batch(records)
       records
     end
@@ -62,6 +63,7 @@ module Miscellany
         batch = ActiveRecord::Base.connection.exec_query(
           "SELECT * FROM #{tbl} LIMIT #{of} OFFSET #{offset}",
         )
+        batch.map!(&:with_indifferent_access)
         augment_batch(batch)
         yield batch
         offset += of

data/lib/miscellany/controller/sliced_response.rb

@@ -187,6 +187,7 @@ module Miscellany
       def sliced_items
         @sliced_items ||= begin
           if items.is_a?(Array)
+            # TODO Can we apply sorting?
             start, finish = slice_bounds
             if start && finish
               items[start...finish]
@@ -194,6 +195,7 @@ module Miscellany
               items
             end
           elsif items.is_a?(Proc)
+            # TODO Can we apply sorting?
             items.call(self)
           elsif items.is_a?(ActiveRecord::Relation)
             offset, limit = slice_bounds
@@ -218,8 +220,7 @@ module Miscellany
       end
 
       def sort_sql
-        sorts = [ *Array(self.sort) ]
-        sorts.push(*options[:sort_parser]&.default_sorts)
+        sorts = [ *Array(self.sort), *options[:sort_parser]&.default_sorts]
         sorts.compact!
 
         return nil unless sorts.present?

data/lib/miscellany/version.rb

@@ -1,3 +1,3 @@
 module Miscellany
-  VERSION = "0.1.19".freeze
+  VERSION = "0.1.20".freeze
 end

data/spec/miscellany/arbitrary_prefetch_spec.rb

@@ -2,84 +2,139 @@
 require 'spec_helper'
 
 describe Miscellany::ArbitraryPrefetch do
-  with_model :Post do
-    table do |t|
-      t.string :title
-      t.timestamps null: false
+  shared_examples "general specs" do
+    it 'generally works' do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+      expect(posts.count).to eq 10
+      expect(posts[0].favorite_comment).to be
     end
 
-    model do
-      has_many :comments
+    it 'works with Goldiloader active' do
+      Goldiloader.enabled do
+        posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+        expect(posts.count).to eq 10
+        expect(posts[0].favorite_comment).to be
+      end
     end
-  end
 
-  with_model :Comment do
-    table do |t|
-      t.belongs_to :post
-      t.string :title
-      t.boolean :favorite
-      t.timestamps null: false
+    it 'works with Goldiloader disabled' do
+      Goldiloader.disabled do
+        posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+        expect(posts.count).to eq 10
+        expect(posts[0].favorite_comment).to be
+      end
     end
 
-    model do
-      belongs_to :post
+    context 'prefetch is singluar' do
+      it 'returns a single object' do
+        posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+        expect(posts[0].favorite_comment).to be_a Comment
+      end
+
+      it 'with multiple items returns a single object' do
+        posts = Post.prefetch(favorite_comment: Comment.where(favorite: nil))
+        expect(posts[0].favorite_comment).to be_a Comment
+      end
     end
-  end
 
-  let!(:posts) { 10.times.map{|i| Post.create!(title: "Post #{i}") } }
+    context 'prefetch is plural' do
+      it 'returns an Array' do
+        posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: nil))
+        expect(posts[0].non_favorite_comments).to respond_to :[]
+        expect(posts[0].non_favorite_comments.length).to eq 4
+      end
 
-  before :each do
-    posts.each do |p|
-      5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
-      p.comments.last.update!(favorite: true)
+      it 'with 1 item returns an Array' do
+        posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: true))
+        expect(posts[0].non_favorite_comments).to respond_to :[]
+        expect(posts[0].non_favorite_comments.length).to eq 1
+      end
     end
   end
 
-  it 'generally works' do
-    posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
-    expect(posts.count).to eq 10
-    expect(posts[0].favorite_comment).to be
-  end
+  context "normal association" do
+    with_model :Post do
+      table do |t|
+        t.string :title
+        t.timestamps null: false
+      end
 
-  it 'works with Goldiloader active' do
-    Goldiloader.enabled do
-      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
-      expect(posts.count).to eq 10
-      expect(posts[0].favorite_comment).to be
+      model do
+        has_many :comments
+      end
     end
-  end
 
-  it 'works with Goldiloader disabled' do
-    Goldiloader.disabled do
-      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
-      expect(posts.count).to eq 10
-      expect(posts[0].favorite_comment).to be
+    with_model :Comment do
+      table do |t|
+        t.belongs_to :post
+        t.string :title
+        t.boolean :favorite
+        t.timestamps null: false
+      end
+
+      model do
+        belongs_to :post
+      end
     end
+
+    let!(:posts) { 10.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+    before :each do
+      posts.each do |p|
+        5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
+        p.comments.last.update!(favorite: true)
+      end
+    end
+
+    include_examples "general specs"
   end
 
-  context 'prefetch is singluar' do
-    it 'returns a single object' do
-      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
-      expect(posts[0].favorite_comment).to be_a Comment
+  context "through: association" do
+    with_model :Post do
+      table do |t|
+        t.string :title
+        t.timestamps null: false
+      end
+
+      model do
+        has_many :interims
+        has_many :comments, through: :interims
+      end
     end
 
-    it 'with multiple items returns a single object' do
-      posts = Post.prefetch(favorite_comment: Comment.where(favorite: nil))
-      expect(posts[0].favorite_comment).to be_a Comment
+    with_model :Interim do
+      table do |t|
+        t.belongs_to :post
+        t.belongs_to :comment
+        t.timestamps null: false
+      end
+
+      model do
+        belongs_to :post
+        belongs_to :comment
+      end
     end
-  end
 
-  context 'prefetch is plural' do
-    it 'returns an Array' do
-      posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: nil))
-      expect(posts[0].non_favorite_comments).to respond_to :[]
-      expect(posts[0].non_favorite_comments.length).to eq 4
+    with_model :Comment do
+      table do |t|
+        t.string :title
+        t.boolean :favorite
+        t.timestamps null: false
+      end
+
+      model do
+      end
     end
 
-    it 'with 1 item returns an Array' do
-      posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: true))
-      expect(posts[0].non_favorite_comments).to respond_to :[]
-      expect(posts[0].non_favorite_comments.length).to eq 1
+    let!(:posts) { 10.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+    before :each do
+      posts.each do |p|
+        5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
+        p.comments.last.update!(favorite: true)
+      end
     end
+
+    include_examples "general specs"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: miscellany
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.20
 platform: ruby
 authors:
 - Ethan Knapp
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2023-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -114,7 +114,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
+description: 
 email:
 - eknapp@instructure.com
 executables: []
@@ -154,7 +154,7 @@ files:
 homepage: https://instructure.com
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -170,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Gem for a bunch of random, re-usable Rails Concerns & Helpers
 test_files: