nested_select 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7df4328a84a6701ef2081be1b647cd9f1c07442b6dfd48c580126daa369ef80
-  data.tar.gz: 17fd02a9b6f0bf767b55bae9243534030a4ccd7d524ff0c72cd3f62ab4e7b46c
+  metadata.gz: b07e539c2e4dd0ab26ae3991c3af0cf5943601dae0c538774cff62ac9709db21
+  data.tar.gz: af8cdda70c7dfff3b6fe1feba72d39b5c8bcf372c285ef6110d4f45fa471fbee
 SHA512:
-  metadata.gz: 413915e07ba1daa75689c3863f8b6084aaaacace89afe075aaf115a61b6c34245acee01c4eae87ec9509bf7ce0d0b38e9f4fa4a6e17d341177a71d1cb5e31d42
-  data.tar.gz: d955c8d791e58df7025998c69a43bf459c03897384c2c68658e03600ba63158678012c90fded55f35fb8acc64fa652d255381d7164077dbe9c01febddf23d1e8
+  metadata.gz: ebbc597b3ecf57cb80da6cff33852a7dff935cb8b8fcd30d2d5223dcfb54b31c415b80df0c05bb48a46ea6bd4f54d158e1a68c3516d3014622b3fc3ebaf81744
+  data.tar.gz: 0aebc50d2cb3dcd2363dd6167f30dc479f0c415e6b5cc1786e623c0cb8be3544df9c4aae2426f77ed5c5fe335b1c2986a8587d5910ba7d8e30fe6cbb516ceb5d

data/.idea/nested_select.iml

@@ -59,6 +59,7 @@
     <orderEntry type="library" scope="PROVIDED" name="reline (v0.6.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rubocop (v1.70.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rubocop-ast (v1.37.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop-shopify (v2.15.1, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="ruby-progressbar (v1.13.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="securerandom (v0.4.1, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="sqlite3 (v2.5.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
@@ -77,21 +78,21 @@
     <option name="myRootTask">
       <RakeTaskImpl id="rake">
         <subtasks>
-          <RakeTaskImpl description="Build nested_select-0.2.0.gem into the pkg directory" fullCommand="build" id="build" />
+          <RakeTaskImpl description="Build nested_select-0.3.0.gem into the pkg directory" fullCommand="build" id="build" />
           <RakeTaskImpl id="build">
             <subtasks>
-              <RakeTaskImpl description="Generate SHA512 checksum of nested_select-0.2.0.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
+              <RakeTaskImpl description="Generate SHA512 checksum of nested_select-0.3.0.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
             </subtasks>
           </RakeTaskImpl>
           <RakeTaskImpl description="Remove any temporary products" fullCommand="clean" id="clean" />
           <RakeTaskImpl description="Remove any generated files" fullCommand="clobber" id="clobber" />
-          <RakeTaskImpl description="Build and install nested_select-0.2.0.gem into system gems" fullCommand="install" id="install" />
+          <RakeTaskImpl description="Build and install nested_select-0.3.0.gem into system gems" fullCommand="install" id="install" />
           <RakeTaskImpl id="install">
             <subtasks>
-              <RakeTaskImpl description="Build and install nested_select-0.2.0.gem into system gems without network access" fullCommand="install:local" id="local" />
+              <RakeTaskImpl description="Build and install nested_select-0.3.0.gem into system gems without network access" fullCommand="install:local" id="local" />
             </subtasks>
           </RakeTaskImpl>
-          <RakeTaskImpl description="Create tag v0.2.0 and build and push nested_select-0.2.0.gem to https://rubygems.org" fullCommand="release[remote]" id="release[remote]" />
+          <RakeTaskImpl description="Create tag v0.3.0 and build and push nested_select-0.3.0.gem to https://rubygems.org" fullCommand="release[remote]" id="release[remote]" />
           <RakeTaskImpl description="Run RuboCop" fullCommand="rubocop" id="rubocop" />
           <RakeTaskImpl id="rubocop">
             <subtasks>

data/README.md

@@ -1,6 +1,7 @@
 # WIP disclaimer
 The gem is under active development now. 
-Use in prod with caution only if you are properly covered by your CI. Read **Safety** and **Limitations** sections before.
+Use in prod with caution only if you are properly covered by your CI. 
+Read **Safety** and **Limitations** sections before.
 
 # Nested select -- 7 times faster and 33 times less RAM on preloading relations with heavy columns!
 nested_select allows the partial selection of the relations attributes during preloading process, leading to less RAM and CPU usage.
@@ -22,9 +23,10 @@ nested_select  0.096008   0.002876   0.098884 (  0.466985)
 simple includes  0.209188   0.058340   0.267528 (  0.903893)                                                       
                                                                                                                    
 ----------------- Memory comparison, for root_collection_size: 1 ---------                                         
-
+# partial selection
 D, [2025-01-12T19:08:36.163282 #503] DEBUG -- :   Topic Load (4.1ms)  SELECT "topics"."id", "topics"."position", "topics"."title", "topics"."course_id" FROM "topics" WHERE "topics"."deleted_at" IS NULL AND "topics"."course_id" = $1  [["course_id", 1624]]                                                                 
 D, [2025-01-12T19:08:36.168803 #503] DEBUG -- :   Lesson Load (3.9ms)  SELECT "lessons"."id", "lessons"."title", "lessons"."topic_id", "lessons"."position", "lessons"."topic_id" FROM "lessons" WHERE "lessons"."deleted_at" IS NULL AND "lessons"."topic_id" = $1  [["topic_id", 7297]]                                      
+# includes in full 
 D, [2025-01-12T19:08:37.220379 #503] DEBUG -- :   Topic Load (4.2ms)  SELECT "topics"."id", "topics"."position", "topics"."title", "topics"."course_id" FROM "topics" WHERE "topics"."deleted_at" IS NULL AND "topics"."course_id" = $1  [["course_id", 1624]]                                                                 
 D, [2025-01-12T19:08:37.247484 #503] DEBUG -- :   Lesson Load (25.7ms)  SELECT "lessons".* FROM "lessons" WHERE "lessons"."deleted_at" IS NULL AND "lessons"."topic_id" = $1  [["topic_id", 7297]]
 
@@ -48,7 +50,7 @@ irb(main):280:0> compare_nested_select(ids, 100)
 ------- CPU comparison, for root_collection_size: 100 ----
                     user     system      total        real           
 nested_select    1.571095   0.021778   1.592873 (  2.263369)
-simple includes  5.374909   1.704284   7.079193 ( 15.488579)
+simple includes  5.374909   1.704284   7.079193 ( 15.488579) 
                                                         
 ----------------- Memory comparison, for root_collection_size: 100 ---------
 ------ Nested Select memory consumption for root_collection_size: 100 ------
@@ -62,9 +64,12 @@ Total allocated: 33.05 MB (38332 objects)
 Total retained:  32.00 MB (24057 objects)               
 RAM ratio improvements x15.57707431190517 on retain objects
 RAM ratio improvements x11.836000856510193 on total_allocated objects
-
 ```
 
+Despite this little click bait it's pretty obvious that it might not be even the biggest numbers, 
+if you have heavy relations instantiation for heavy views or reports generation, 
+and you want it to be less demanding in RAM and CPU -- you should try nested_select
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -76,6 +81,8 @@ If bundler is not being used to manage dependencies, install the gem by executin
     $ gem install nested_select
 
 ## Usage
+
+### Specify which attributes to load in preloading models   
 Assume you have a relation users <- profile, and you want to preview users in a paginated feed, 
 and you need only :photo_url attribute of a profile, with nested_select you can do it like this:  
 
@@ -95,19 +102,85 @@ end
 User.includes(:profile).select(profile: :photo_url).limit(10)
 ```
 
-## Safety
+### Partial through relations preloading
+Whenever you are using through relations between models rails will fully load all intermediate objects under the hood,
+that is definitely wastes lots of RAM, CPU including those on the DB side. 
+You can limit through objects only to relation columns. 
+Ex:
+
+```ruby
+class User
+  has_one :user_profile, inverse_of: :user
+  has_many :avatars, through: :user_profile, inverse_of: :user
+end
+
+  # pay attention user_profile relation, wasn't included explicitly, 
+  # but still rails needed to be preloaded to match and preload avatars here
+  user = User.includes(:avatars)
+             .select(avatars: [:img_url, { user_profile: [:zip_code] }]).first
+  
+  # Now user - loaded fully
+  # avatars - foreign and primary keys needed to establish relations + img_url
+  # user_profile - foreign and primary keys + zip_code
+```
+**REM:** Through preloading happens in reverse, so to nest their selection 
+you must start from the latest, in this case avatar, and go to the previous ones in this case its a user_profile
+
+If you want intermediate models to be completely skinny, you should select like this:
+
+```ruby
+class User
+  has_one :user_profile, inverse_of: :user
+  has_many :avatars, through: :user_profile, inverse_of: :user
+  has_many :through_avatar_images, through: :avatars, class_name: :Image, source: :images
+end
+
+  # only through_avatar_images is matter here, and we want everything 
+  user = User.includes(:through_avatar_images)
+             .select(through_avatar_images: ["images.*", avatars: [user_profile: [:id]]]).first
+  
+  # through_avatar_images -- loaded in full
+  # avatars, user_profile -- only relations columns id, user_profile_id e.t.c
+```
+**REM** As for version 0.4.0 for the earliest relation in a through chain you need to select something, 
+otherwise nested_select will select everything ))
+
+# Safety
 How safe is the partial model loading? Earlier version of rails and activerecord would return nil in the case, 
 when attribute wasn't selected from a DB, but rails 6 started to raise a ActiveModel::MissingAttributeError. 
 So the major problem is already solved -- your code will not operate based on falsy blank values, it will raise an exception. 
 
+But if you are working with attributes directly ( which you should not btw ), you will see nil, without any exception. 
+Using as_json on such models will also deliver json without exception and without skipped attributes. 
+
+## Partial selection in multiple preloading branches
+If you are doing some strange or narrow cases whenever you preloading same objects via different preloading branches, 
+including the most common case through relations, which rails preloads in full, then you must be very accurate 
+with nested selection, cause rails loads and attach associations only once, if it was partial
+than you might get yourself into trouble. BUT nested_select will check and raise an exception 
+if you are trying to re-instantiate with a different set of attributes. Ex:
+
+```
+ActiveModel::MissingAttributeError: Reflection 'avatars' already loaded with a different set of basic attributes.
+expected: ["img_url", "user_profile_id", "id"], already loaded with: ["created_at", "user_profile_id", "id"]
+Hint: ensure that you are using same set of attributes for entrance of same relation
+      on nesting selection tree including reverse through relations
+```
+
+# Limitations
+
 ## belongs_to foreign keys limitations 
-Rails preloading happens from loaded record to their reflection step by step. 
-That's makes pretty easy to include foreign keys for has_* relations, and very hard for belongs_to, 
+Rails preloading happens from loaded records to their reflections step by step. 
+That's makes it pretty easy to include foreign keys for has_* relations, and very hard for belongs_to, 
 to work this out you need to analyze includes based on the already loaded records, analyze and traverse their relations.
-This needs a lot of monkey patching, and for now I decided not to gow this way.
+This needs a lot of monkey patching, and for now I decided not to go this way.
 That means in case when nesting selects based on belongs_to reflections, 
 you'll need to select their foreign keys **EXPLICITLY!** 
 
+## will not work with ar_lazy_preload
+Right now it will not work with ar_lazy_preload gem. nested_select relies on the includes_values definition 
+of a relation. If you are doing it in a lazy way, there weren't any explicit includes, that means it will not extract any nested selection.
+
 ```ruby
 class Avatar < ApplicationRecord
   belongs_to user
@@ -118,16 +191,15 @@ class Image < ApplicationRecord
   belongs_to :avatar
 end
 
-Image.includes(avatar: :user).select(avatar: [:id, :size, { user: [:email] }]).load # <--- will raise a Missing Attribute exception 
+Image.includes(avatar: :user).select(avatar: [:size, { user: [:email] }]).load # <--- will raise a Missing Attribute exception 
 
 #> ActiveModel::MissingAttributeError: Parent reflection avatar was missing foreign key user_id in nested selection
 #> while trying to preload belongs_to reflection named user.
 #> Hint: didn't you forgot to add user_id inside [:id, :size]?
 
-Image.includes(avatar: :user).select(avatar: [:id, :size, :user_id, { user: [:email] }]).load
+Image.includes(avatar: :user).select(avatar: [:size, :user_id, { user: [:email] }]).load
 ```
 
-
 ## Testing
 
 ```bash
@@ -135,15 +207,16 @@ docker compose run test
 ```
 
 ## TODO
-- [ ] Cover all relation combinations and add missing functionality
+- [x] Cover all relation combinations and add missing functionality
   - [x] Ensure relations foreign keys are present on the selection
   - [x] Ensure primary key will be added
-  - [-] Ensure belongs_to will add a foreign_key column
-- [ ] Optimize through relations ( since they loading a whole set of attributes )
+  - [-] Ensure belongs_to will add a foreign_key column (Too hard to manage :(, its definitely not a low hanging fruit)
+- [x] Optimize through relations ( since they loading a whole set of attributes )
 - [ ] Separated rails version testing
 - [x] Merge multiple nested selections 
 - [x] Don't apply any selection if blank ( allows to limit only part of subselection tree)
 - [x] Allows to use custom attributes
+- [ ] Eager loading? 
 
 ## Development
 

data/lib/nested_select/deep_merger.rb

@@ -7,12 +7,22 @@ module NestedSelect
         merge!(other.except(*keys))
         merge!(other.slice(*keys).map{ |key, value| [key, [self[key], value].flatten.deep_combine_elements]}.to_h )
       end
+
+      def relation_nesting_depth
+        1 + [*values.grep(Hash), *values.grep(Array)].map(&:relation_nesting_depth).max.to_i
+      end
     end
 
     refine Array do
       def deep_combine_elements
         [*grep_v(Hash), grep(Hash).inject(&:deep_combine)].uniq.compact
       end
+      # in terms of relation/selection nesting every array node
+      # should not add +1 to depth, that mean that array nesting
+      # does not count as nesting [[[]]] has depth equal 0.
+      def relation_nesting_depth
+        [*grep(Hash), *grep(Array)].map(&:relation_nesting_depth).max.to_i
+      end
     end
   end
 end

data/lib/nested_select/preloader/association.rb

@@ -4,12 +4,46 @@ module NestedSelect
       attr_reader :nested_select_values
 
       def build_scope
-        nested_select_values.blank? ? super : super.select(*nested_select_values)
+        nested_select_values.blank? ? super :
+          super.select(*nested_select_values.grep_v(Hash).map{_1.try(:to_s) }.uniq)
       end
 
       def apply_nested_select_values(partial_select_values)
         foreign_key = reflection.foreign_key unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-        @nested_select_values = [*partial_select_values, *foreign_key, *reflection.klass.primary_key].uniq
+        @nested_select_values = [*partial_select_values, *foreign_key, *reflection.klass.primary_key]
+        ensure_nesting_selection_integrity!
+      end
+
+      def ensure_nesting_selection_integrity!
+        single_owner = owners.first
+        # do nothing unless not yet loaded
+        return unless single_owner.association(reflection.name).loaded?
+
+        single_reflection_record = single_owner.send(reflection.name)
+        return if single_reflection_record.blank?
+
+        single_reflection_record = single_reflection_record.first if single_reflection_record.is_a?(Enumerable)
+
+        attributes_loaded = single_reflection_record.attributes.keys.map(&:to_s)
+        current_selection = @nested_select_values.grep_v(Hash).map(&:to_s)
+
+        basic_attributes_matched = (attributes_loaded & reflection.klass.column_names).tally ==
+                                   (current_selection & reflection.klass.column_names).tally
+
+        # this is not a 100% safe verification, but it will match cases with custom attributes selection for example:
+        # "(SELECT COUNT(*) FROM images) as IMG_count" =~ /img_count/
+        custom_attributes_matched = (attributes_loaded - reflection.klass.column_names).all? do |loaded_attr|
+          (current_selection - reflection.klass.column_names).any? do |upcoming_custom_attr|
+            upcoming_custom_attr =~ /#{loaded_attr}/i
+          end
+        end
+
+        raise ActiveModel::MissingAttributeError, <<~ERR if !basic_attributes_matched || !custom_attributes_matched
+          Reflection '#{reflection.name}' already loaded with a different set of basic attributes.
+          expected: #{current_selection}, already loaded with: #{attributes_loaded}
+          Hint: ensure that you are using same set of attributes for entrance of same relation
+                on nesting selection tree including reverse through relations
+        ERR
       end
     end
   end

data/lib/nested_select/preloader/branch.rb

@@ -7,6 +7,7 @@ module NestedSelect
         prevent_belongs_to_foreign_key_absence!(reflection)
 
         super.tap do |ldrs|
+          # nested_select_values contains current level selection + nested relation selections
           ldrs.each{ _1.apply_nested_select_values(nested_select_values) } if nested_select_values.present?
         end
       end
@@ -17,7 +18,8 @@ module NestedSelect
 
         # ActiveRecord will not raise in case its missing, so we should prevent silent error here
         if parent.nested_select_values.present? &&
-          !parent.nested_select_values.map(&:to_sym).include?( reflection.foreign_key.to_sym )
+          !parent.nested_select_values.grep_v(Hash)
+                 .map(&:to_sym).include?(reflection.foreign_key.to_sym)
 
           raise ActiveModel::MissingAttributeError, <<~ERR
             Parent reflection #{parent.association} was missing foreign key #{reflection.foreign_key} in nested selection,
@@ -26,7 +28,6 @@ module NestedSelect
           ERR
         end
       end
-
     end
   end
 end

data/lib/nested_select/preloader/through_association.rb

@@ -1,22 +1,84 @@
 module NestedSelect
   module Preloader
     module ThroughAssociation
+      # this preloader root will preload intermediate records, so here we should apply 'through'
+      # selection limitation AS A BASIC nested selection and it wuold be either __minimize_through_selection sym OR
+      # nested_selection tree
+      # def source_preloaders
+      #   @source_preloaders ||= ActiveRecord::Associations::Preloader.new(
+      #     records: middle_records,
+      #     associations: source_reflection.name,
+      #     scope: scope,
+      #     associate_by_default: false
+      #   ).tap {
+      #     byebug
+      #     _1.apply_nested_select_values([*@limit_through_selection])
+      #   }.loaders
+      # end
       def through_preloaders
         @through_preloaders ||= ActiveRecord::Associations::Preloader.new(
           records: owners,
           associations: through_reflection.name,
           scope: through_scope,
           associate_by_default: false,
-          ).tap { _1.apply_nested_select_values(nested_select_values) }.loaders
+          ).tap do
+          _1.apply_nested_select_values(nested_select_values.grep(Hash))
+        end.loaders
       end
 
-      def apply_nested_select_values( partial_select_values )
-        return super unless reflection.parent_reflection.is_a?( ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+      # def through_scope
+      #   if @limit_through_selection.present?
+      #     # through_selection is either __minimize_through_selection symbol, or an array
+      #     through_selection = [*@limit_through_selection]
+      #     through_selection = [*through_selection.grep_v(Hash),
+      #                          *through_selection.grep(Hash).first&.dig(through_reflection.source_reflection_name)]
+      #     through_selection << through_reflection.foreign_key
+      #     through_selection << through_reflection.klass.primary_key
+      #     super.select(through_selection)
+      #   else
+      #     super
+      #   end
+      # end
 
-        # when parent reflection is a HasAndBelongsToManyReflection,
-        # then we don't need foreign_key to be included, as it does in super
-        @nested_select_values = partial_select_values
+      # def through_scope
+      #   if @limit_through_selection.present?
+      #     super.select(through_reflection.foreign_key.to_sym, through_reflection.klass.primary_key.to_sym)
+      #   else
+      #     super
+      #   end
+      # end
+      # def through_selection_nesting
+      #   return if @limit_through_selection.blank?
+      #   through_limit_selection = [through_reflection.foreign_key.to_sym, through_reflection.klass.primary_key.to_sym]
+      #   through_limit_selection << :__minimize_through_selection if through_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      #   through_limit_selection
+      # end
+
+      def apply_nested_select_values(partial_select_values)
+
+        if reflection.parent_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          # when parent reflection is a HasAndBelongsToManyReflection,
+          # then we don't need foreign_key to be included, as it does in super
+          @nested_select_values = partial_select_values
+        else
+          @limit_through_selection = partial_select_values.delete(:__minimize_through_selection)
+          super(partial_select_values)
+        end
       end
+      # def exract_through_selections(partial_select_values)
+      #   # __minimize_through_selection: [ :user_id, user_profile: [] ]
+      #   # there should not be more than one such limitation definition
+      #   through_selection_rules, cleaned_partial_select_values = partial_select_values&.partition do
+      #     _1 == :__minimize_through_selection || _1.is_a?(Hash) && _1[:__minimize_through_selection].present?
+      #   end
+      #   @limit_through_selection = through_selection_rules.map do
+      #     _1.is_a?(Hash) && _1[:__minimize_through_selection] || _1
+      #   end.first
+      #
+      #   byebug
+      #   cleaned_partial_select_values
+      # end
+
     end
   end
 end

data/lib/nested_select/preloader.rb

@@ -12,20 +12,36 @@ module NestedSelect
       ActiveRecord::Associations::Preloader::ThroughAssociation.prepend(ThroughAssociation)
       ActiveRecord::Associations::Preloader::Association.prepend(Association)
     end
+
+    # first one will start from the roots [included_1: [{}], included_2: [{}] ]
     def apply_nested_select_values(nested_select_values)
       distribute_nested_select_over_loading_tree(@tree, nested_select_values)
     end
 
+    # this one either subtree roots only when its first, OR current branch selection root
+    # + its branches in array
+    # 1) [:__minimize_through_selection, ...]
+    # 2) []
+    # Логика следующая:
+    #  если мы передаем __minimize_through_selection как символ, то его надо пробросить до всех бранчей, они с этим разберутся, там где надо
+    #  если у нас там хеш, то его надо оставить на текущем уровне и дальше если это through, то оно превратит это в нестед селект для вложенных
     def distribute_nested_select_over_loading_tree(sub_tree, nested_select_values)
       #  nested_select_values = [:id, :title, comments: [:id, :body], cover: [:id, img: [:url]]]
       return if nested_select_values.blank?
 
-      sub_tree.nested_select_values = nested_select_values.grep_v(Hash)
+      sub_tree.nested_select_values = [*nested_select_values.grep_v(Hash)]
       # sub_nested_select_values = { comments: [:id, :body], cover: [:id, img: [:url]] }
-      sub_nested_select_values = nested_select_values.grep(Hash).inject(&:merge)&.symbolize_keys
+      sub_nested_select_values = nested_select_values.grep(Hash).inject({}, &:merge)&.symbolize_keys
+
       # it could be a case when selection tree is not that deep than Branch tree.
       return if sub_nested_select_values.blank?
 
+      # its possible to subselect in reverse direction for through relation's
+      # in that case includes are implicit, but we need to add that reverse tree into nested select
+      reverse_nested_selections = sub_nested_select_values.except(*sub_tree.children.map(&:association))
+      # this is for reverse selection of through models
+      sub_tree.nested_select_values << reverse_nested_selections if reverse_nested_selections.present?
+
       sub_tree.children.each do |chld_brnch|
         distribute_nested_select_over_loading_tree(chld_brnch, sub_nested_select_values[chld_brnch.association])
       end

data/lib/nested_select/relation.rb

@@ -9,17 +9,30 @@ module NestedSelect
     def select(*fields)
       # {user_profile: [:zip_code]} + {user_profile: [:bio]} -> { user_profile: [:zip_code, :bio] }
       @nested_select_values = [*@nested_select_values, *fields.grep(Hash)].deep_combine_elements
+      # returning self means -- there was only nesting selection,
+      # and we should not interfere with default selection
       fields.grep_v(Hash).present? ? super(*fields.grep_v(Hash)) : self
     end
 
+    # # when nested_select interferes the 'through' selection, its doing this in reverse
+    # # in this case the first one preload wins a selection scope,
+    # # so we need to make them all the same across all selection trees
+    # # ( except for the cases when traversing ends up in same place using different path,
+    # # this case is out of the normal sense )
+    # def combine_reverse_selection_sub_trees
+    #   @nested_select_values.permutation.each do |left, right|
+    #
+    #   end
+    # end
+
     def preload_associations(records) # :nodoc:
       preload = preload_values
       preload += includes_values unless eager_loading?
       scope = strict_loading_value ? StrictLoadingScope : nil
       preload.each do |associations|
         ActiveRecord::Associations::Preloader.new(records:, associations:, scope:)
-                                             .tap{ _1.apply_nested_select_values(nested_select_values) } # <-- Patching code
-                                             .call
+          .tap{_1.apply_nested_select_values(nested_select_values) } # <-- Patching code
+          .call
       end
     end
   end

data/lib/nested_select/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NestedSelect
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/test_habtm_reflections.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class TestHabtmReflections < ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+
+  self.use_instantiated_fixtures = true
+
+
+  test "select allows nesting attribute selection" do
+    item = Item.includes(users: [user_profile: :avatars])
+               .select("items.*", users: [:id, :name, user_profile: [:id, :bio, avatars: [:img_url]]])
+               .find(identify(:mug))
+
+    user = item.users.first
+    assert_equal(user.name, "Frodo")
+    assert_raises(ActiveModel::MissingAttributeError) { user.membership }
+    assert_equal(user.reload.membership, "basic")
+
+    assert_includes(user.user_profile.avatars.map(&:img_url), avatars(:frodo_avatar).img_url)
+  end
+
+  test "works fine with inverse_of basic reflection" do
+    user = User.includes(user_profile: :avatars)
+               .select("users.*", user_profile: [:id, :user_id, avatars: [:id, :user_profile_id]])
+               .find(identify(:frodo))
+
+    # NestedSelect::Preloader::Branch#preloaders_for_reflection
+    assert_equal(user.user_profile.user.object_id, user.object_id)
+    assert_equal(user.user_profile.object_id, user.user_profile.avatars.first.user_profile.object_id)
+  end
+
+  test "works fine with through reflection" do
+    user = User.includes(:avatars)
+               .select("users.*", avatars: [:id, :user_profile_id])
+               .find(identify(:frodo))
+
+    assert_raises(ActiveModel::MissingAttributeError) { user.avatars.first.img_url }
+    assert_equal(user.avatars, [avatars(:frodo_avatar)])
+    assert_equal(user.avatars.first.reload.img_url, "https://api.rubyonrails.org/")
+  end
+
+  test "partial selection always includes foreign keys" do
+    user = User.includes(user_profile: :avatars)
+               .select("users.*", user_profile: [:id, :bio])
+               .find(identify(:frodo))
+
+    assert_equal(user.user_profile.user_id, user.id)
+  end
+
+  test "partial selection always includes foreign keys also for through reflection bb" do
+    user = User.includes(:avatars)
+               .select("users.*", avatars: [:id, :img_url])
+               .find(identify(:frodo))
+
+    assert_equal(user.avatars, [avatars(:frodo_avatar)])
+    assert_not_nil(user.avatars.first.user_profile_id)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested_select
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-01 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -210,6 +210,7 @@ files:
 - lib/nested_select/relation.rb
 - lib/nested_select/version.rb
 - sig/nested_select.rbs
+- test_habtm_reflections.rb
 homepage: https://github.com/alekseyl/nested_select
 licenses:
 - MIT